Fix match exhaustiveness for tuples of aliased unions (#5193)

PR #5145 stopped expanding type aliases during name resolution, so a
type alias now persists as TK_TYPEALIASREF in places where it used to
be replaced by its underlying form. Every subtype dispatch site was
updated to unfold TK_TYPEALIASREF on demand, except for
expand_type_alternatives, which is how tuple-of-union subtype checks
distribute a tuple over its element unions for match exhaustiveness.

Without the unfold, a tuple element that is a type alias was treated
as a single opaque alternative instead of the union it wraps, so
(PRF, PRF) over a four-case match (where PRF is (String | U64)) no
longer looked exhaustive. Add the TK_TYPEALIASREF case to
expand_type_alternatives and a regression test pair covering both
the exhaustive and non-exhaustive shapes.

This is a regression against unreleased code, so no changelog or
release notes entry.

Author: SeanTAllen

src/libponyc/type/subtype.c

@@ -556,6 +556,7 @@ static bool is_x_sub_isect(ast_t* sub, ast_t* super, check_cap_t check_cap,
 //
 // For TK_UNIONTYPE: collects alternatives from all members.
 // For TK_TUPLETYPE: computes the cross-product of each element's alternatives.
+// For TK_TYPEALIASREF: unfolds the alias and recurses.
 // For anything else: returns a 1-element union containing a copy of the type.
 static ast_t* expand_type_alternatives(ast_t* type, size_t max_alternatives)
 {
@@ -644,6 +645,22 @@ static ast_t* expand_type_alternatives(ast_t* type, size_t max_alternatives)
       return result;
     }
 
+    case TK_TYPEALIASREF:
+    {
+      ast_t* unfolded = typealias_unfold(type);
+
+      if(unfolded == NULL)
+      {
+        ast_t* result = ast_from(type, TK_UNIONTYPE);
+        ast_append(result, ast_dup(type));
+        return result;
+      }
+
+      ast_t* result = expand_type_alternatives(unfolded, max_alternatives);
+      ast_free_unattached(unfolded);
+      return result;
+    }
+
     default:
     {
       ast_t* result = ast_from(type, TK_UNIONTYPE);

test/libponyc/sugar_expr.cc

@@ -755,6 +755,51 @@ TEST_F(SugarExprTest, MatchExhaustiveAllCasesIncludingDontCareAndTuple)
 }
 
 
+TEST_F(SugarExprTest, MatchExhaustiveTupleOverAliasedUnion)
+{
+  // Regression test for the interaction with PR #5145, which stopped
+  // expanding type aliases during name resolution. Tuple match exhaustiveness
+  // distributes the tuple over its element unions by computing a cross-
+  // product of the element alternatives, and must unfold TK_TYPEALIASREF
+  // elements to see the underlying union. Without the unfold, each element
+  // is treated as a single opaque alternative and the cases do not look
+  // exhaustive. This mirrors the failing pattern in corral's
+  // CompareVersions._compare_pr_Fields.
+  const char* src =
+    "type PRF is (String | U64)\n"
+
+    "primitive Foo\n"
+    "  fun apply(p1: PRF, p2: PRF): Bool =>\n"
+    "    match (p1, p2)\n"
+    "    | (let u1: U64, let s2: String) => true\n"
+    "    | (let s1: String, let u2: U64) => false\n"
+    "    | (let u1: U64, let u2: U64) => true\n"
+    "    | (let s1: String, let s2: String) => false\n"
+    "    end";
+
+  TEST_COMPILE(src);
+}
+
+
+TEST_F(SugarExprTest, MatchNonExhaustiveTupleOverAliasedUnion)
+{
+  // Paired negative for MatchExhaustiveTupleOverAliasedUnion: dropping one
+  // cross-product case must still be detected as non-exhaustive after the
+  // TK_TYPEALIASREF unfold in expand_type_alternatives.
+  const char* src =
+    "type PRF is (String | U64)\n"
+
+    "primitive Foo\n"
+    "  fun apply(p1: PRF, p2: PRF): Bool =>\n"
+    "    match (p1, p2)\n"
+    "    | (let u1: U64, let s2: String) => true\n"
+    "    | (let s1: String, let u2: U64) => false\n"
+    "    | (let u1: U64, let u2: U64) => true\n"
+    "    end";
+
+  TEST_ERRORS_1(src, "function body isn't the result type");
+}
+
 
 TEST_F(SugarExprTest, MatchNonExhaustiveSomeTupleCaseElementsMatchOnValue)
 {