lab/sx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

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

Browse Source 
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.
This commit is contained in:
agra
2026-05-29 20:07:41 +03:00
parent d7ecf02d7a
commit 72731f97ee
4 changed files with 58 additions and 5 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
src/ir/lower.zig
View File

@@ -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 (!tt.isBuiltin()) {
const tinfo = self.module.types.get(tt);
if (tinfo == .tuple and tinfo.tuple.fields.len == tl.elements.len) {
target_fields = tinfo.tuple.fields;
if (!has_spread) {
if (self.target_type) |tt| {
if (!tt.isBuiltin()) {
const tinfo = self.module.types.get(tt);
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);