lang 2.3: tuple materialization from a pack — (..xs) / (..xs.method)

A `spread_expr` element inside a tuple literal now expands the pack into the
tuple's fields: `(..xs.get)` ≈ `(xs[0].get(), …, xs[N-1].get())` (Decision 2 —
a pack is stored by materializing a tuple). lowerTupleLiteral detects a
pack-spread element via packSpreadRefs and splices the per-element Refs as
fields (typed via getRefType); for Box(T) the materialized tuple is
heterogeneous. A spread whose operand isn't a pack falls through to the
existing spread_expr diagnostic (tuple-value spread not yet handled).

When any element is a spread, field-count ≠ element-count, so the contextual
target-tuple alignment is skipped (field types inferred from the expanded refs).
examples/198-pack-tuple-materialize.sx.

examples/198-pack-tuple-materialize.sx

@@ -0,0 +1,25 @@
+// Feature 1 — materialize a tuple from a pack via `(..xs.method)` (Decision 2:
+// a pack is stored by materializing a tuple). `(..xs.get)` projects `get` over
+// the pack and collects the results into a real tuple value, which can then be
+// stored, indexed, and (for `Box(T)`) is heterogeneous per position.
+
+#import "modules/std.sx";
+
+Box :: protocol(T: Type) {
+    get :: () -> T;
+}
+IntCell :: struct { v: s64; }
+StrCell :: struct { s: string; }
+impl Box(s64) for IntCell { get :: (self: *IntCell) -> s64 => self.v; }
+impl Box(string) for StrCell { get :: (self: *StrCell) -> string => self.s; }
+
+snapshot :: (..xs: Box) -> void {
+    t := (..xs.get);                 // tuple (s64, string) materialized from the pack
+    print("0={} 1={}\n", t.0, t.1);
+}
+
+main :: () -> s32 {
+    snapshot(IntCell.{ v = 42 }, StrCell.{ s = "hi" });
+    snapshot(StrCell.{ s = "x" }, IntCell.{ v = 7 });   // order swapped → (string, s64)
+    0;
+}

src/ir/lower.zig

@@ -4703,18 +4703,43 @@ pub const Lowering = struct {
         // ambient scalar `target_type` (e.g. the enclosing fn's int return
         // type) can't narrow an element below its field width. Otherwise each
         // element's type is inferred independently.
+        // A pack-spread element `(..xs)` / `(..xs.method)` expands to N fields,
+        // so element-count ≠ field-count and a contextual target tuple can't be
+        // aligned by index — infer field types from the expanded refs instead.
+        var has_spread = false;
+        for (tl.elements) |elem| {
+            if (elem.value.data == .spread_expr) has_spread = true;
+        }
+
         var target_fields: ?[]const TypeId = null;
-        if (self.target_type) |tt| {
+        if (!has_spread) {
-            if (!tt.isBuiltin()) {
+            if (self.target_type) |tt| {
-                const tinfo = self.module.types.get(tt);
+                if (!tt.isBuiltin()) {
-                if (tinfo == .tuple and tinfo.tuple.fields.len == tl.elements.len) {
+                    const tinfo = self.module.types.get(tt);
-                    target_fields = tinfo.tuple.fields;
+                    if (tinfo == .tuple and tinfo.tuple.fields.len == tl.elements.len) {
+                        target_fields = tinfo.tuple.fields;
+                    }
                 }
             }
         }
 
         const saved_target = self.target_type;
         for (tl.elements, 0..) |elem, i| {
+            // Pack-spread element → splice its per-element values as fields.
+            if (elem.value.data == .spread_expr) {
+                if (self.packSpreadRefs(elem.value.data.spread_expr.operand, elem.value.span)) |refs| {
+                    defer self.alloc.free(refs);
+                    for (refs) |r| {
+                        elems.append(self.alloc, r) catch unreachable;
+                        field_type_ids.append(self.alloc, self.builder.getRefType(r)) catch unreachable;
+                        name_ids.append(self.alloc, self.module.types.internString("")) catch unreachable;
+                    }
+                    continue;
+                }
+                // Not a pack spread (e.g. tuple-value spread) — not yet handled.
+                _ = self.lowerExpr(elem.value); // surfaces the spread_expr diagnostic
+                continue;
+            }
             const field_ty = if (target_fields) |tf| tf[i] else self.inferExprType(elem.value);
             self.target_type = field_ty;
             var val = self.lowerExpr(elem.value);

tests/expected/198-pack-tuple-materialize.exit

@@ -0,0 +1 @@
+0

tests/expected/198-pack-tuple-materialize.txt

@@ -0,0 +1,2 @@
+0=42 1=hi
+0=x 1=7