Stop expanding type aliases during name resolution

Type aliases now persist as TK_TYPEALIASREF nodes throughout the compiler
pipeline instead of being expanded inline during name resolution. The
type system, reach subsystem, and codegen unfold aliases on demand at
each dispatch point.

This preserves alias identity in the AST, enabling LSP features like
go-to-definition on alias names and laying the groundwork for finite
recursive type aliases.

Closes #745
Design: #5007

Author: SeanTAllen

src/libponyc/CMakeLists.txt

@@ -89,6 +89,7 @@ add_library(libponyc STATIC
     type/safeto.c
     type/sanitise.c
     type/subtype.c
+    type/typealias.c
     type/typeparam.c
     type/viewpoint.c
     verify/call.c

src/libponyc/ast/ast.c

@@ -1844,6 +1844,31 @@ static void print_type(printbuf_t* buffer, ast_t* type, bool print_cap)
       break;
     }
 
+    case TK_TYPEALIASREF:
+    {
+      AST_GET_CHILDREN(type, id, typeargs, cap, ephemeral);
+
+      ast_t* def = (ast_t*)ast_data(type);
+      if(def != NULL)
+        id = ast_child(def);
+
+      printbuf(buffer, "%s", ast_nice_name(id));
+
+      if(ast_id(typeargs) != TK_NONE)
+        print_typeexpr(buffer, typeargs, ", ", true, true);
+
+      if(print_cap)
+      {
+        if(ast_id(cap) != TK_NONE)
+          printbuf(buffer, " %s", token_print(cap->t));
+
+        if(ast_id(ephemeral) != TK_NONE)
+          printbuf(buffer, "%s", token_print(ephemeral->t));
+      }
+
+      break;
+    }
+
     case TK_ARROW:
     {
       AST_GET_CHILDREN(type, left, right);
@@ -2230,6 +2255,7 @@ static void ast_serialise_trace_data(pony_ctx_t* ctx, ast_t* ast)
     case TK_FUN:
     case TK_TYPEPARAM:
     case TK_TYPEPARAMREF:
+    case TK_TYPEALIASREF:
     case TK_REFERENCE:
     case TK_PACKAGEREF:
     case TK_TYPEREF:
@@ -2286,6 +2312,7 @@ static void ast_serialise_data(pony_ctx_t* ctx, ast_t* ast, ast_t* dst)
     case TK_FUN:
     case TK_TYPEPARAM:
     case TK_TYPEPARAMREF:
+    case TK_TYPEALIASREF:
     case TK_REFERENCE:
     case TK_PACKAGEREF:
     case TK_TYPEREF:
@@ -2336,6 +2363,7 @@ static void ast_deserialise_data(pony_ctx_t* ctx, ast_t* ast)
     case TK_FUN:
     case TK_TYPEPARAM:
     case TK_TYPEPARAMREF:
+    case TK_TYPEALIASREF:
     case TK_REFERENCE:
     case TK_PACKAGEREF:
     case TK_TYPEREF:

src/libponyc/ast/lexer.c

@@ -288,6 +288,7 @@ static const lextoken_t abstract[] =
   { "packageref", TK_PACKAGEREF },
   { "typeref", TK_TYPEREF },
   { "typeparamref", TK_TYPEPARAMREF },
+  { "typealiasref", TK_TYPEALIASREF },
   { "newref", TK_NEWREF },
   { "newberef", TK_NEWBEREF },
   { "beref", TK_BEREF },

src/libponyc/ast/token.h

@@ -238,6 +238,7 @@ typedef enum token_id
   TK_PACKAGEREF,
   TK_TYPEREF,
   TK_TYPEPARAMREF,
+  TK_TYPEALIASREF,
   TK_NEWREF,
   TK_NEWBEREF,
   TK_BEREF,

src/libponyc/ast/treecheckdef.h

@@ -488,8 +488,9 @@ RULE(param_ref,
 
 GROUP(type,
   type_infix, type_tuple, type_arrow, type_this, cap, nominal,
-  type_param_ref, dontcare_type, fun_type, error_type, infer_type, lambda_type,
-  barelambda_type, literal_type, opliteral_type, control_type);
+  type_param_ref, type_alias_ref, dontcare_type, fun_type, error_type,
+  infer_type, lambda_type, barelambda_type, literal_type, opliteral_type,
+  control_type);
 
 RULE(type_infix, ONE_OR_MORE(type), TK_UNIONTYPE, TK_ISECTTYPE);
 
@@ -548,6 +549,14 @@ RULE(type_param_ref,
   CHILD(aliased, ephemeral, none),
   TK_TYPEPARAMREF);
 
+RULE(type_alias_ref,
+  HAS_DATA  // Definition of referred type alias (TK_TYPE)
+  CHILD(id)
+  CHILD(type_args, none)
+  CHILD(cap, gencap, none)
+  CHILD(aliased, ephemeral, none),
+  TK_TYPEALIASREF);
+
 RULE(at, LEAF, TK_AT);
 RULE(bool_literal, HAS_TYPE(type), TK_TRUE, TK_FALSE);
 RULE(aliased, LEAF, TK_ALIASED);

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: {}
   }