Fix gentrace assertions when tracing tuples containing type aliases (#5196)

PR #5145 stopped expanding type aliases during name resolution, so a
type alias now persists as TK_TYPEALIASREF through codegen. Every
codegen dispatch site was updated to unfold TK_TYPEALIASREF on demand,
but two sites in gentrace.c were missed. Both only surface when a tuple
is traced dynamically (e.g. as an element of a union), which is why
ponylang/crdt's nightly started failing its build after #5145 landed:
its `_Dot is (ID, U64)` alias wrapping a tuple exercises the first of
these paths.

trace_dynamic_tuple's TRACE_TUPLE branch duplicated the alias ref with
ast_dup and passed it to the recursive trace_dynamic_tuple, which then
iterated the alias ref's TK_ID / typeargs / cap / eph children as if
they were tuple elements and tripped trace_type's default assertion.
Unfold the alias once before the recursion so the callee sees the
concrete TK_TUPLETYPE.

trace_dynamic's TK_TYPEALIASREF case called typealias_unfold (which
always returns a detached subtree) and passed the detached tree into
the recursive trace_dynamic. When the detached subtree contained a
tuple that reached trace_dynamic_tuple with tuple != NULL, the
ast_swap(type, dontcare) at the top of trace_dynamic_tuple asserted on
the NULL parent. Splice the unfolded form into the alias's position in
its parent so downstream ast_swap always sees an attached tree; the
rare detached-alias case is only reachable when tuple == NULL, so the
in_tuple branch is never taken and the missing parent does not matter.

A single regression test under test/full-program-tests exercises both
scenarios: one field with an alias that expands directly to a tuple
(bug 1) and another field with an alias that expands to a union
containing a second alias-to-tuple (bug 2).

Chained type aliases (alias of alias of tuple) are a known gap in the
TRACE_TUPLE fix — typealias_unfold only unfolds one level. Constructing
a test that reaches this site with a chained alias is currently blocked
by other #5145 regressions elsewhere in codegen (the static trace_tuple
path in gentrace.c and gen_digestof_value in genreference.c), which
fire first for every configuration tried. That broader audit of every
typealias_unfold call site is tracked in #5195.

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

Author: SeanTAllen

src/libponyc/codegen/gentrace.c

@@ -814,7 +814,30 @@ static void trace_dynamic_tuple(compile_t* c, LLVMValueRef ctx,
         LLVMPositionBuilderAtEnd(c->builder, trace_block);
 
         // If we are (A, B), turn (_, _) into (A, _).
-        ast_t* swap = ast_dup(child);
+        // If the element is a type alias for a tuple, unfold it once so the
+        // recursive call sees the concrete TK_TUPLETYPE; iterating the alias
+        // ref's children (TK_ID, typeargs, cap, eph) as tuple elements would
+        // trip trace_type's default assertion. typealias_unfold is guaranteed
+        // to succeed here because trace_type already unfolded the same child
+        // to classify it as TRACE_TUPLE; reify is deterministic. Chained
+        // aliases (alias of alias of tuple) are a known gap tracked in
+        // ponylang/ponyc#5195 — typealias_unfold only unfolds one level, so
+        // swap is still a TK_TYPEALIASREF and the recursive call hits the
+        // same assertion. Constructing a test that reaches this site with a
+        // chained alias is currently blocked by other PR #5145 regressions
+        // elsewhere in codegen (the static trace_tuple path in this file and
+        // gen_digestof_value in genreference.c), which fire first for every
+        // configuration tried.
+        ast_t* swap;
+
+        if(ast_id(child) == TK_TYPEALIASREF)
+        {
+          swap = typealias_unfold(child);
+          pony_assert(swap != NULL);
+        } else {
+          swap = ast_dup(child);
+        }
+
         ast_swap(dc_child, swap);
 
         // Get a pointer to the unboxed tuple and its descriptor.
@@ -950,7 +973,29 @@ static void trace_dynamic(compile_t* c, LLVMValueRef ctx, LLVMValueRef object,
 
       if(unfolded != NULL)
       {
-        trace_dynamic(c, ctx, object, unfolded, orig, tuple, next_block);
+        // Splice the unfolded form into the alias's position in its parent.
+        // This keeps the tree attached so that downstream code (e.g.
+        // trace_dynamic_tuple's ast_swap into the enclosing tuple context)
+        // always sees a non-NULL parent.
+        //
+        // If the alias itself has no parent, the only way to get here is
+        // gentrace's own top-level TRACE_DYNAMIC case below, which always
+        // passes tuple == NULL, so trace_dynamic_tuple's in_tuple branch
+        // never runs and the missing parent does not matter. The other
+        // callers of trace_dynamic (trace_dynamic_union_or_isect,
+        // trace_dynamic_tuple's TRACE_MUT/VAL/TAG/DYNAMIC case) always pass
+        // an attached type, and the recursive self-call below preserves
+        // that invariant.
+        if(ast_parent(type) != NULL)
+        {
+          ast_swap(type, unfolded);
+          trace_dynamic(c, ctx, object, unfolded, orig, tuple, next_block);
+          ast_swap(unfolded, type);
+        } else {
+          pony_assert(tuple == NULL);
+          trace_dynamic(c, ctx, object, unfolded, orig, tuple, next_block);
+        }
+
         ast_free_unattached(unfolded);
       }
       break;

test/full-program-tests/type-alias-tuple-trace-union/main.pony

@@ -0,0 +1,24 @@
+// Regression test for type alias elements inside dynamically-traced tuples.
+//
+// Two related scenarios in gentrace's trace_dynamic path:
+//
+// 1. An outer tuple has a child that is a type alias expanding directly to a
+//    tuple. trace_dynamic_tuple's TRACE_TUPLE case used to iterate the alias
+//    ref as if it were a tuple, tripping an assertion on the TK_ID child.
+//
+// 2. An outer tuple has a child that is a type alias expanding to a union
+//    which in turn contains another alias that expands to a tuple.
+//    trace_dynamic's TK_TYPEALIASREF case unfolded the alias into a detached
+//    subtree; when that subtree recursed into trace_dynamic_tuple with
+//    tuple != NULL, ast_swap asserted on the detached type's NULL parent.
+
+type _Pair is (U64, U64)
+type _Wrap is (_Pair | String)
+
+actor Main
+  var _direct: ((String, _Pair) | None) = None
+  var _wrapped: ((String, _Wrap) | None) = None
+
+  new create(env: Env) =>
+    _direct = ("hello", (U64(1), U64(2)))
+    _wrapped = ("world", (U64(3), U64(4)))