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/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/gentrace.c

@@ -7,6 +7,7 @@
 #include "../type/cap.h"
 #include "../type/matchtype.h"
 #include "../type/subtype.h"
+#include "../type/typealias.h"
 #include "ponyassert.h"
 
 // Arranged from most specific to least specific.
@@ -292,7 +293,9 @@ static trace_t trace_type_isect(ast_t* type)
 static trace_t trace_type_nominal(ast_t* type)
 {
   if(is_bare(type))
+  {
     return TRACE_PRIMITIVE;
+  }
 
   ast_t* def = (ast_t*)ast_data(type);
   switch(ast_id(def))
@@ -364,6 +367,16 @@ static trace_t trace_type(ast_t* type)
     case TK_NOMINAL:
       return trace_type_nominal(type);
 
+    case TK_TYPEALIASREF:
+    {
+      ast_t* unfolded = typealias_unfold(type);
+      pony_assert(unfolded != NULL);
+
+      trace_t result = trace_type(unfolded);
+      ast_free_unattached(unfolded);
+      return result;
+    }
+
     default: {}
   }
 
@@ -931,6 +944,18 @@ static void trace_dynamic(compile_t* c, LLVMValueRef ctx, LLVMValueRef object,
       trace_dynamic_nominal(c, ctx, object, type, orig, tuple, next_block);
       break;
 
+    case TK_TYPEALIASREF:
+    {
+      ast_t* unfolded = typealias_unfold(type);
+
+      if(unfolded != NULL)
+      {
+        trace_dynamic(c, ctx, object, unfolded, orig, tuple, next_block);
+        ast_free_unattached(unfolded);
+      }
+      break;
+    }
+
     default: {}
   }
 }
@@ -945,12 +970,31 @@ bool gentrace_needed(compile_t* c, ast_t* src_type, ast_t* dst_type)
 
     case TRACE_MACHINE_WORD:
     {
-      if(ast_id(dst_type) == TK_NOMINAL)
+      ast_t* check_type = dst_type;
+      ast_t* unfolded = NULL;
+
+      if(ast_id(check_type) == TK_TYPEALIASREF)
+      {
+        unfolded = typealias_unfold(check_type);
+        check_type = unfolded;
+      }
+
+      if((check_type != NULL) && (ast_id(check_type) == TK_NOMINAL))
       {
-        ast_t* def = (ast_t*)ast_data(dst_type);
+        ast_t* def = (ast_t*)ast_data(check_type);
+
         if(ast_id(def) == TK_PRIMITIVE)
+        {
+          if(unfolded != NULL)
+            ast_free_unattached(unfolded);
+
           return false;
+        }
       }
+
+      if(unfolded != NULL)
+        ast_free_unattached(unfolded);
+
       return true;
     }
 
@@ -1038,13 +1082,28 @@ void gentrace(compile_t* c, LLVMValueRef ctx, LLVMValueRef src_value,
     case TRACE_MACHINE_WORD:
     {
       bool boxed = true;
-      if(ast_id(dst_type) == TK_NOMINAL)
+
+      ast_t* check_dst = dst_type;
+      ast_t* dst_unfolded = NULL;
+
+      if(ast_id(check_dst) == TK_TYPEALIASREF)
       {
-        ast_t* def = (ast_t*)ast_data(dst_type);
+        dst_unfolded = typealias_unfold(check_dst);
+
+        if(dst_unfolded != NULL)
+          check_dst = dst_unfolded;
+      }
+
+      if(ast_id(check_dst) == TK_NOMINAL)
+      {
+        ast_t* def = (ast_t*)ast_data(check_dst);
         if(ast_id(def) == TK_PRIMITIVE)
           boxed = false;
       }
 
+      if(dst_unfolded != NULL)
+        ast_free_unattached(dst_unfolded);
+
       if(boxed)
         trace_known(c, ctx, dst_value, src_type, PONY_TRACE_IMMUTABLE);
 

src/libponyc/expr/array.c

@@ -192,13 +192,14 @@ static void find_possible_element_types(pass_opt_t* opt, ast_t* ast,
 
     case TK_TYPEALIASREF:
     {
+      // Don't free the unfolded AST: the TK_NOMINAL case stores pointers
+      // into it (ast_child(typeargs) for Array element types) that the
+      // caller uses.
       ast_t* unfolded = typealias_unfold(ast);
 
       if(unfolded != NULL)
-      {
         find_possible_element_types(opt, unfolded, list);
-        ast_free_unattached(unfolded);
-      }
+
       return;
     }
 
@@ -245,13 +246,12 @@ static void find_possible_iterator_element_types(pass_opt_t* opt, ast_t* ast,
 
     case TK_TYPEALIASREF:
     {
+      // Don't free: same reason as find_possible_element_types above.
       ast_t* unfolded = typealias_unfold(ast);
 
       if(unfolded != NULL)
-      {
         find_possible_iterator_element_types(opt, unfolded, list);
-        ast_free_unattached(unfolded);
-      }
+
       return;
     }
 

src/libponyc/expr/call.c

@@ -18,6 +18,7 @@
 #include "../type/safeto.h"
 #include "../type/sanitise.h"
 #include "../type/subtype.h"
+#include "../type/typealias.h"
 #include "../type/viewpoint.h"
 #include "ponyassert.h"
 
@@ -201,7 +202,20 @@ static ast_t* method_receiver_type(ast_t* method);
 bool check_auto_recover_newref(ast_t* dest_type, ast_t* ast)
 {
   // we're not going to try auto-recovering to a complex type
-  if (ast_id(dest_type) != TK_NOMINAL)
+  token_id dest_id = ast_id(dest_type);
+
+  if(dest_id == TK_TYPEALIASREF)
+  {
+    ast_t* unfolded = typealias_unfold(dest_type);
+
+    if(unfolded != NULL)
+    {
+      dest_id = ast_id(unfolded);
+      ast_free_unattached(unfolded);
+    }
+  }
+
+  if(dest_id != TK_NOMINAL)
     return false;
 
   while (ast != NULL && ast_id(ast) != TK_CALL)

src/libponyc/expr/lambda.c

@@ -213,13 +213,13 @@ static void find_possible_fun_defs(pass_opt_t* opt, ast_t* ast,
 
     case TK_TYPEALIASREF:
     {
+      // Don't free the unfolded AST: find_possible_fun_defs stores pointers
+      // into it (the obj_cap at child 3 of the nominal) that the caller uses.
       ast_t* unfolded = typealias_unfold(ast);
 
       if(unfolded != NULL)
-      {
         find_possible_fun_defs(opt, unfolded, fun_defs, obj_caps);
-        ast_free_unattached(unfolded);
-      }
+
       break;
     }
 
@@ -683,6 +683,27 @@ static bool catch_up_provides(pass_opt_t* opt, ast_t* provides, ast_t* obj_ast)
 
     ast_t* def = (ast_t*)ast_data(child);
 
+    // For type aliases, unfold to get the concrete type definition.
+    // ast_data on TK_TYPEALIASREF points to TK_TYPE, not a class/trait.
+    if((def != NULL) && (ast_id(child) == TK_TYPEALIASREF))
+    {
+      ast_t* unfolded = typealias_unfold(child);
+
+      if(unfolded != NULL)
+      {
+        if(ast_id(unfolded) == TK_NOMINAL)
+          def = (ast_t*)ast_data(unfolded);
+        else
+          def = NULL;
+
+        ast_free_unattached(unfolded);
+      }
+      else
+      {
+        def = NULL;
+      }
+    }
+
     if(def != NULL)
     {
       // If the provided type definition is an ancestor of the original object