Stop expanding type aliases during name resolution (Phase 2)

names_typealias() now creates TK_TYPEALIASREF nodes instead of expanding
aliases inline. The alias identity is preserved throughout the compiler
pipeline — type system, reach, and codegen unfold on demand at each
dispatch point.

All 1423 C++ compiler tests pass. All tools (pony-lsp, pony-lint,
pony-doc) and the full-program test runner build successfully.

Key changes across 24 files:

Names pass:
- names_typealias() creates TK_TYPEALIASREF via REPLACE instead of
  reify+applycap+replace (names_applycap removed as dead code)

Expression pass:
- pass_expr handles TK_TYPEALIASREF constraint checking
- expr_nominal keeps TK_TYPEALIASREF in place (no unfold)
- find_infer_type unfolds aliases for tuple destructuring inference
- entity_access unfolds aliases for tuple element access (._1, ._2)
- check_auto_recover_newref unfolds aliases for auto-recovery eligibility

Refer pass:
- is_constructed_from unfolds aliases for "let x: Alias = x.create()"

Type system:
- subtype.c: is_literal unfolds TK_TYPEALIASREF so is_machine_word,
  is_pointer, etc. correctly identify aliased builtin types
- viewpoint.c: unfold-and-redispatch in viewpoint_type/upper/lower
- cap.c: unfold in cap_dispatch and modified_cap
- safeto.c: unfold in safe_field_move, safe_to_autorecover, safe_to_move
- typeparam.c: unfold in cap_from_constraint, apply_cap, constraint_cap;
  TK_TUPLETYPE fallback for invalid tuple constraints exposed by unfolding
- reify.c: unfold in check_constraints for struct-as-typearg detection
- alias.c: unfold in sendable() only (other alias.c functions keep Phase 1
  behavior — compound alias cap handling deferred to follow-up)

Flatten pass:
- constraint_contains_tuple passes unfolded type as both constraint and
  scan to fix union member iteration

Lambda/object:
- find_possible_fun_defs: don't free unfolded AST (caller stores pointers)
- catch_up_provides: unfold TK_TYPE alias definitions for ast_passes_type

Array:
- find_possible_element_types and iterator variant: don't free unfolded
  AST (caller stores element type pointers)

Reach:
- add_type: unfold-and-redispatch
- trace_kind_append: unfold-and-redispatch
- set_method_types: unfold for param cap extraction

Codegen:
- genname.c, gentrace.c, genmatch.c, gencall.c, genexpr.c: unfold at
  all TK_TYPEALIASREF dispatch points
- gentrace.c: unfold in TRACE_MACHINE_WORD case for correct boxed/unboxed
  decision on aliased primitive types

Design: #5007

Author: SeanTAllen

src/libponyc/codegen/gencall.c

@@ -10,6 +10,7 @@
 #include "../pkg/platformfuns.h"
 #include "../type/cap.h"
 #include "../type/subtype.h"
+#include "../type/typealias.h"
 #include "../ast/stringtab.h"
 #include "../pass/expr.h"
 #include "../../libponyrt/mem/pool.h"
@@ -651,6 +652,16 @@ static bool contains_boxable(ast_t* type)
       return false;
     }
 
+    case TK_TYPEALIASREF:
+    {
+      ast_t* unfolded = typealias_unfold(type);
+      pony_assert(unfolded != NULL);
+
+      bool ok = contains_boxable(unfolded);
+      ast_free_unattached(unfolded);
+      return ok;
+    }
+
     default:
       pony_assert(0);
       return false;

src/libponyc/codegen/genexpr.c

@@ -9,6 +9,7 @@
 #include "genoperator.h"
 #include "genreference.h"
 #include "../type/subtype.h"
+#include "../type/typealias.h"
 #include "../../libponyrt/mem/pool.h"
 #include "ponyassert.h"
 
@@ -313,6 +314,19 @@ LLVMValueRef gen_assign_cast(compile_t* c, LLVMTypeRef l_type,
 
   pony_assert(r_value != GEN_NOTNEEDED);
 
+  // Unfold type aliases so downstream dispatch sees concrete types.
+  if(ast_id(type) == TK_TYPEALIASREF)
+  {
+    ast_t* unfolded = typealias_unfold(type);
+
+    if(unfolded != NULL)
+    {
+      LLVMValueRef result = gen_assign_cast(c, l_type, r_value, unfolded);
+      ast_free_unattached(unfolded);
+      return result;
+    }
+  }
+
   LLVMTypeRef r_type = LLVMTypeOf(r_value);
 
   if(r_type == l_type)

src/libponyc/codegen/genident.c

@@ -7,6 +7,7 @@
 #include "genopt.h"
 #include "../reach/subtype.h"
 #include "../type/subtype.h"
+#include "../type/typealias.h"
 #include "../../libponyrt/mem/pool.h"
 #include "ponyassert.h"
 #include <string.h>
@@ -21,6 +22,22 @@ static LLVMValueRef gen_is_value(compile_t* c, ast_t* left_type,
 static LLVMValueRef tuple_is(compile_t* c, ast_t* left_type, ast_t* right_type,
   LLVMValueRef l_value, LLVMValueRef r_value)
 {
+  // Unfold type aliases to get the actual tuple types.
+  ast_t* unfolded_l = NULL;
+  ast_t* unfolded_r = NULL;
+
+  if(ast_id(left_type) == TK_TYPEALIASREF)
+  {
+    unfolded_l = typealias_unfold(left_type);
+    if(unfolded_l != NULL) left_type = unfolded_l;
+  }
+
+  if(ast_id(right_type) == TK_TYPEALIASREF)
+  {
+    unfolded_r = typealias_unfold(right_type);
+    if(unfolded_r != NULL) right_type = unfolded_r;
+  }
+
   pony_assert(ast_id(left_type) == TK_TUPLETYPE);
   pony_assert(ast_id(right_type) == TK_TUPLETYPE);
   pony_assert(ast_childcount(left_type) == ast_childcount(right_type));
@@ -229,13 +246,28 @@ static LLVMValueRef tuple_is_box_element(compile_t* c, ast_t* l_field_type,
   LLVMValueRef l_field, LLVMValueRef r_fields, LLVMValueRef r_desc,
   unsigned int field_index)
 {
+  // Unfold type alias to determine field kind.
+  ast_t* check_field = l_field_type;
+  ast_t* field_unfolded = NULL;
+
+  if(ast_id(check_field) == TK_TYPEALIASREF)
+  {
+    field_unfolded = typealias_unfold(check_field);
+
+    if(field_unfolded != NULL)
+      check_field = field_unfolded;
+  }
+
   int field_kind = SUBTYPE_KIND_UNBOXED;
 
-  if((ast_id(l_field_type) == TK_TUPLETYPE))
+  if((ast_id(check_field) == TK_TUPLETYPE))
     field_kind = SUBTYPE_KIND_TUPLE;
-  else if(is_machine_word(l_field_type))
+  else if(is_machine_word(check_field))
     field_kind = SUBTYPE_KIND_NUMERIC;
 
+  if(field_unfolded != NULL)
+    ast_free_unattached(field_unfolded);
+
   LLVMValueRef r_field_info = gendesc_fieldinfo(c, r_desc, field_index);
   LLVMValueRef r_field_ptr = gendesc_fieldptr(c, r_fields, r_field_info);
   LLVMValueRef r_field_desc = gendesc_fielddesc(c, r_field_info);
@@ -297,6 +329,17 @@ static LLVMValueRef tuple_is_box(compile_t* c, ast_t* left_type,
   pony_assert(LLVMGetTypeKind(LLVMTypeOf(l_value)) == LLVMStructTypeKind);
   pony_assert(LLVMGetTypeKind(LLVMTypeOf(r_value)) == LLVMPointerTypeKind);
 
+  // Unfold type aliases to get the actual tuple type.
+  ast_t* unfolded_left = NULL;
+
+  if(ast_id(left_type) == TK_TYPEALIASREF)
+  {
+    unfolded_left = typealias_unfold(left_type);
+
+    if(unfolded_left != NULL)
+      left_type = unfolded_left;
+  }
+
   size_t cardinality = ast_childcount(left_type);
 
   // If check_cardinality is false, trust the caller and don't do the check.

src/libponyc/codegen/genmatch.c

@@ -10,6 +10,7 @@
 #include "../type/subtype.h"
 #include "../type/matchtype.h"
 #include "../type/alias.h"
+#include "../type/typealias.h"
 #include "../type/viewpoint.h"
 #include "../type/lookup.h"
 #include "ponyassert.h"
@@ -214,6 +215,16 @@ static bool check_type(compile_t* c, LLVMValueRef ptr, LLVMValueRef desc,
       return check_type(c, ptr, desc, ast_childidx(pattern_type, 1),
         next_block, weight);
 
+    case TK_TYPEALIASREF:
+    {
+      ast_t* unfolded = typealias_unfold(pattern_type);
+      pony_assert(unfolded != NULL);
+
+      bool ok = check_type(c, ptr, desc, unfolded, next_block, weight);
+      ast_free_unattached(unfolded);
+      return ok;
+    }
+
     default: {}
   }
 
@@ -593,6 +604,16 @@ static bool static_tuple(compile_t* c, LLVMValueRef value, ast_t* type,
       return static_tuple(c, value, ast_childidx(type, 1), pattern,
         next_block);
 
+    case TK_TYPEALIASREF:
+    {
+      ast_t* unfolded = typealias_unfold(type);
+      pony_assert(unfolded != NULL);
+
+      bool ok = static_tuple(c, value, unfolded, pattern, next_block);
+      ast_free_unattached(unfolded);
+      return ok;
+    }
+
     default: {}
   }
 

src/libponyc/codegen/genname.c

@@ -1,5 +1,6 @@
 #include "genname.h"
 #include "../pkg/package.h"
+#include "../type/typealias.h"
 #include "../ast/stringtab.h"
 #include "../ast/lexer.h"
 #include "../../libponyrt/mem/pool.h"
@@ -57,6 +58,16 @@ static void type_append(printbuf_t* buf, ast_t* type, bool first)
       return;
     }
 
+    case TK_TYPEALIASREF:
+    {
+      ast_t* unfolded = typealias_unfold(type);
+      pony_assert(unfolded != NULL);
+
+      type_append(buf, unfolded, first);
+      ast_free_unattached(unfolded);
+      return;
+    }
+
     default: {}
   }
 

src/libponyc/codegen/genoperator.c

@@ -6,6 +6,7 @@
 #include "gentype.h"
 #include "../pkg/platformfuns.h"
 #include "../type/subtype.h"
+#include "../type/typealias.h"
 #include "ponyassert.h"
 
 typedef LLVMValueRef (*build_binop)(LLVMBuilderRef builder, LLVMValueRef left,
@@ -348,9 +349,21 @@ static LLVMValueRef assign_field(compile_t* c, LLVMValueRef l_value,
 static bool assign_tuple(compile_t* c, ast_t* left, ast_t* r_type,
   LLVMValueRef r_value)
 {
+  // Unfold type aliases to get the actual tuple element types.
+  ast_t* iter_type = r_type;
+  ast_t* unfolded = NULL;
+
+  if(ast_id(r_type) == TK_TYPEALIASREF)
+  {
+    unfolded = typealias_unfold(r_type);
+
+    if(unfolded != NULL)
+      iter_type = unfolded;
+  }
+
   // Handle assignment for each component.
   ast_t* child = ast_child(left);
-  ast_t* rtype_child = ast_child(r_type);
+  ast_t* rtype_child = ast_child(iter_type);
   int i = 0;
 
   while(child != NULL)
@@ -395,6 +408,10 @@ static bool assign_tuple(compile_t* c, ast_t* left, ast_t* r_type,
   }
 
   pony_assert(rtype_child == NULL);
+
+  if(unfolded != NULL)
+    ast_free_unattached(unfolded);
+
   return true;
 }
 

src/libponyc/codegen/genreference.c

@@ -11,6 +11,7 @@
 #include "../reach/subtype.h"
 #include "../type/cap.h"
 #include "../type/subtype.h"
+#include "../type/typealias.h"
 #include "../type/viewpoint.h"
 #include "../../libponyrt/mem/pool.h"
 #include "ponyassert.h"
@@ -435,9 +436,21 @@ static LLVMValueRef gen_digestof_value(compile_t* c, ast_t* type,
 
     case LLVMStructTypeKind:
     {
+      // Unfold type aliases to get the actual tuple element types.
+      ast_t* iter_type = type;
+      ast_t* unfolded = NULL;
+
+      if(ast_id(type) == TK_TYPEALIASREF)
+      {
+        unfolded = typealias_unfold(type);
+
+        if(unfolded != NULL)
+          iter_type = unfolded;
+      }
+
       uint32_t count = LLVMCountStructElementTypes(impl_type);
       LLVMValueRef result = LLVMConstInt(c->intptr, 0, false);
-      ast_t* child = ast_child(type);
+      ast_t* child = ast_child(iter_type);
 
       for(uint32_t i = 0; i < count; i++)
       {
@@ -449,6 +462,9 @@ static LLVMValueRef gen_digestof_value(compile_t* c, ast_t* type,
 
       pony_assert(child == NULL);
 
+      if(unfolded != NULL)
+        ast_free_unattached(unfolded);
+
       return result;
     }