Hojun-Cho/ww
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

wcc: stamp for-range tuple-binds and massign blank via shared helper

Browse Source 
For-range tuple-destructure binders (for (let (k,v) .. s)) and the tuple
massign discard _ were left nil-typed: the for-range binders are N_IDENT
use-sites and the _ slot, though unbound, has a real element type. Add a
shared stamptuplebinds helper — one lockstep walk distributing an N_TTUPLE's
per-element types onto a binder chain — refactoring the existing N_MLET
destructure loop into it (behavior identical) and adding N_FORRANGE and
N_MASSIGN call-sites. _ is STAMPED with its slot's element type (unbound is
not untyped), not exempted. Mirrors harec create_unpack_bindings
(ref/harec/src/check.c:1354-1419), the routine harec shares between let-unpack
and the for-each header (:2308-2317).

A prerequisite for arming the wwstage asserttyped bail. byte-id holds (cgen
derives binder/elem widths structurally, never off type_; 990-997 green).
Extends the 901 gap-corpus with 901_forrange_tuple.ww + 901_massign_blank.ww.
This commit is contained in:
Hojun-Cho
2026-05-28 09:06:54 +09:00
parent 3252bd1709
commit f892a91223
6 changed files with 317 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

107
selfhost/cmd/w6c/main.combined.ww
View File

@@ -10261,6 +10261,56 @@ fn installdecl(c: *checker, file: *node, d: *node) void = {
if (k == nkind.N_LET) { scopedefineinmodule(c.top, nm, mod, skind.SK_VAR, nil, d); return; };
};
// stamptuplebinds — distribute a tuple's per-element types onto a
// destructure binding chain, walked in lockstep with the resolved
// N_TTUPLE element chain (each `elems` link carries its element type on
// .lhs). Mirror of harec's create_unpack_bindings
// (ref/harec/src/check.c:1354-1419), which harec shares between
// let-unpack (check_expr_binding) and the for-each loop header
// (ref/harec/src/check.c:2308-2317) — the one shape behind ww's
// `let (a,b) = f()`, `for (let (a,b) .. s)`, and the ww-extension
// multi-assign `a, _ = f()`.
//
// `define` (the binding contexts: let-unpack + for-range) installs each
// named binder as a fresh SK_VAR and back-fills its declared type onto
// .lhs so use sites resolve through the N_IDENT exprtype path. Multi-
// assign targets are pre-declared lvalues, so it passes false: .lhs is
// left untouched (an N_INDEX/N_DOT target carries a live operand there)
// and only the type_ stamp fires on the still-untyped slots.
//
// Each binder/target node's own type_ is stamped from its element type so
// the asserttyped gate sees a typed node. This covers the discard `_` (an
// empty-str N_IDENT with no decl to read a type back from): harec drops
// `_` yet still advances the tuple slot, so that slot's element type is
// the honest type to stamp — `_` is UNBOUND, not UNTYPED.
fn stamptuplebinds(c: *checker, binds: *node, elems: *node,
define: bool, what: str) void = {
let b: *node = binds;
let pt: *node = elems;
for (b != nil) {
let et: *node = nil;
if (pt != nil) { et = pt.lhs; };
if (define) {
if (b.lhs == nil) { b.lhs = et; };
let bnm: str = b.str;
if (bnm.len > 0) {
checkmoduleshadow(c, bnm, what);
scopedefine(c.cur, bnm, skind.SK_VAR, nil, b);
};
};
if (b.type_ == nil) {
let src: *node = b.lhs;
if (src == nil) { src = et; };
if (src != nil) {
let ti: *tinfo = tinfofornode(c, src);
if (ti != nil) { b.type_ = ti: *void; };
};
};
b = b.next;
if (pt != nil) { pt = pt.next; };
};
};
// resolvewalk — recursive AST walk that, for every nkind.N_IDENT and
// nkind.N_TNAME seen, looks up the name and bumps the resolved/unresolved
// counters. Local lets are installed in the current scope as soon as
@@ -10354,15 +10404,22 @@ fn resolvewalk(c: *checker, n: *node) void = {
if (k == nkind.N_FORRANGE) {
if (n.lhs != nil) { resolvewalk(c, n.lhs); };
if (n.list != nil) {
let m: *node = n.list;
for (m != nil) {
let bnm: str = m.str;
if (bnm.len > 0) {
checkmoduleshadow(c, bnm, "binding");
scopedefine(c.cur, bnm, skind.SK_VAR, nil, m);
};
m = m.next;
// Tuple destructure `for (let (a,b) .. xs)`: peel the
// iterable's element type and distribute its tuple
// element types onto the binders, the same lockstep walk
// harec runs for the for-each header
// (ref/harec/src/check.c:2308-2317 → create_unpack_bindings).
let elems: *node = nil;
let it: *node = exprtype(c, n.lhs, nil);
if (it != nil) {
let et: *node = nil;
if (it.kind == nkind.N_TSLICE) { et = it.lhs; };
if (it.kind == nkind.N_TARRAY) { et = it.lhs; };
if (et != nil) { if (et.kind == nkind.N_TTUPLE) {
elems = et.list;
}; };
};
stamptuplebinds(c, n.list, elems, true, "binding");
} else {
let bnm: str = n.str;
if (bnm.len > 0) {
@@ -10452,19 +10509,29 @@ fn resolvewalk(c: *checker, n: *node) void = {
pt = rty.list;
}; };
}; };
stamptuplebinds(c, n.list, pt, true, "let");
return;
};
// `a, _ = call();` — tuple multi-assign (a retained ww extension over
// Hare; harec has no statement-position unpack-assign). Targets are
// pre-declared lvalues, resolved by the per-target resolvewalk below
// before the distribution; stamptuplebinds(define=false) only stamps
// still-nil slots, which is exactly the discard `_` (no decl, so the
// N_IDENT exprtype path leaves it untyped). Distribution mirrors the
// N_MLET/N_FORRANGE binders; see stamptuplebinds.
if (k == nkind.N_MASSIGN) {
if (n.rhs != nil) { resolvewalk(c, n.rhs); };
let pt: *node = nil;
if (n.rhs != nil) { if (n.rhs.kind == nkind.N_CALL) {
let rty: *node = exprtype(c, n.rhs, nil);
if (rty != nil) { if (rty.kind == nkind.N_TTUPLE) {
pt = rty.list;
}; };
}; };
let l: *node = n.list;
for (l != nil) {
if (l.lhs == nil) {
if (pt != nil) { l.lhs = pt.lhs; };
};
let bnm: str = l.str;
if (bnm.len > 0) {
checkmoduleshadow(c, bnm, "let");
scopedefine(c.cur, bnm, skind.SK_VAR, nil, l);
};
l = l.next;
if (pt != nil) { pt = pt.next; };
};
for (l != nil) { resolvewalk(c, l); l = l.next; };
stamptuplebinds(c, n.list, pt, false, "");
return;
};

107
selfhost/cmd/wcc/check.ww
View File

@@ -231,6 +231,56 @@ fn installdecl(c: *checker, file: *node, d: *node) void = {
if (k == nkind.N_LET) { scopedefineinmodule(c.top, nm, mod, skind.SK_VAR, nil, d); return; };
};
// stamptuplebinds — distribute a tuple's per-element types onto a
// destructure binding chain, walked in lockstep with the resolved
// N_TTUPLE element chain (each `elems` link carries its element type on
// .lhs). Mirror of harec's create_unpack_bindings
// (ref/harec/src/check.c:1354-1419), which harec shares between
// let-unpack (check_expr_binding) and the for-each loop header
// (ref/harec/src/check.c:2308-2317) — the one shape behind ww's
// `let (a,b) = f()`, `for (let (a,b) .. s)`, and the ww-extension
// multi-assign `a, _ = f()`.
//
// `define` (the binding contexts: let-unpack + for-range) installs each
// named binder as a fresh SK_VAR and back-fills its declared type onto
// .lhs so use sites resolve through the N_IDENT exprtype path. Multi-
// assign targets are pre-declared lvalues, so it passes false: .lhs is
// left untouched (an N_INDEX/N_DOT target carries a live operand there)
// and only the type_ stamp fires on the still-untyped slots.
//
// Each binder/target node's own type_ is stamped from its element type so
// the asserttyped gate sees a typed node. This covers the discard `_` (an
// empty-str N_IDENT with no decl to read a type back from): harec drops
// `_` yet still advances the tuple slot, so that slot's element type is
// the honest type to stamp — `_` is UNBOUND, not UNTYPED.
fn stamptuplebinds(c: *checker, binds: *node, elems: *node,
define: bool, what: str) void = {
let b: *node = binds;
let pt: *node = elems;
for (b != nil) {
let et: *node = nil;
if (pt != nil) { et = pt.lhs; };
if (define) {
if (b.lhs == nil) { b.lhs = et; };
let bnm: str = b.str;
if (bnm.len > 0) {
checkmoduleshadow(c, bnm, what);
scopedefine(c.cur, bnm, skind.SK_VAR, nil, b);
};
};
if (b.type_ == nil) {
let src: *node = b.lhs;
if (src == nil) { src = et; };
if (src != nil) {
let ti: *tinfo = tinfofornode(c, src);
if (ti != nil) { b.type_ = ti: *void; };
};
};
b = b.next;
if (pt != nil) { pt = pt.next; };
};
};
// resolvewalk — recursive AST walk that, for every nkind.N_IDENT and
// nkind.N_TNAME seen, looks up the name and bumps the resolved/unresolved
// counters. Local lets are installed in the current scope as soon as
@@ -324,15 +374,22 @@ fn resolvewalk(c: *checker, n: *node) void = {
if (k == nkind.N_FORRANGE) {
if (n.lhs != nil) { resolvewalk(c, n.lhs); };
if (n.list != nil) {
let m: *node = n.list;
for (m != nil) {
let bnm: str = m.str;
if (bnm.len > 0) {
checkmoduleshadow(c, bnm, "binding");
scopedefine(c.cur, bnm, skind.SK_VAR, nil, m);
};
m = m.next;
// Tuple destructure `for (let (a,b) .. xs)`: peel the
// iterable's element type and distribute its tuple
// element types onto the binders, the same lockstep walk
// harec runs for the for-each header
// (ref/harec/src/check.c:2308-2317 → create_unpack_bindings).
let elems: *node = nil;
let it: *node = exprtype(c, n.lhs, nil);
if (it != nil) {
let et: *node = nil;
if (it.kind == nkind.N_TSLICE) { et = it.lhs; };
if (it.kind == nkind.N_TARRAY) { et = it.lhs; };
if (et != nil) { if (et.kind == nkind.N_TTUPLE) {
elems = et.list;
}; };
};
stamptuplebinds(c, n.list, elems, true, "binding");
} else {
let bnm: str = n.str;
if (bnm.len > 0) {
@@ -422,19 +479,29 @@ fn resolvewalk(c: *checker, n: *node) void = {
pt = rty.list;
}; };
}; };
stamptuplebinds(c, n.list, pt, true, "let");
return;
};
// `a, _ = call();` — tuple multi-assign (a retained ww extension over
// Hare; harec has no statement-position unpack-assign). Targets are
// pre-declared lvalues, resolved by the per-target resolvewalk below
// before the distribution; stamptuplebinds(define=false) only stamps
// still-nil slots, which is exactly the discard `_` (no decl, so the
// N_IDENT exprtype path leaves it untyped). Distribution mirrors the
// N_MLET/N_FORRANGE binders; see stamptuplebinds.
if (k == nkind.N_MASSIGN) {
if (n.rhs != nil) { resolvewalk(c, n.rhs); };
let pt: *node = nil;
if (n.rhs != nil) { if (n.rhs.kind == nkind.N_CALL) {
let rty: *node = exprtype(c, n.rhs, nil);
if (rty != nil) { if (rty.kind == nkind.N_TTUPLE) {
pt = rty.list;
}; };
}; };
let l: *node = n.list;
for (l != nil) {
if (l.lhs == nil) {
if (pt != nil) { l.lhs = pt.lhs; };
};
let bnm: str = l.str;
if (bnm.len > 0) {
checkmoduleshadow(c, bnm, "let");
scopedefine(c.cur, bnm, skind.SK_VAR, nil, l);
};
l = l.next;
if (pt != nil) { pt = pt.next; };
};
for (l != nil) { resolvewalk(c, l); l = l.next; };
stamptuplebinds(c, n.list, pt, false, "");
return;
};

107
selfhost/cmd/wwdump/main.combined.ww
View File

@@ -10261,6 +10261,56 @@ fn installdecl(c: *checker, file: *node, d: *node) void = {
if (k == nkind.N_LET) { scopedefineinmodule(c.top, nm, mod, skind.SK_VAR, nil, d); return; };
};
// stamptuplebinds — distribute a tuple's per-element types onto a
// destructure binding chain, walked in lockstep with the resolved
// N_TTUPLE element chain (each `elems` link carries its element type on
// .lhs). Mirror of harec's create_unpack_bindings
// (ref/harec/src/check.c:1354-1419), which harec shares between
// let-unpack (check_expr_binding) and the for-each loop header
// (ref/harec/src/check.c:2308-2317) — the one shape behind ww's
// `let (a,b) = f()`, `for (let (a,b) .. s)`, and the ww-extension
// multi-assign `a, _ = f()`.
//
// `define` (the binding contexts: let-unpack + for-range) installs each
// named binder as a fresh SK_VAR and back-fills its declared type onto
// .lhs so use sites resolve through the N_IDENT exprtype path. Multi-
// assign targets are pre-declared lvalues, so it passes false: .lhs is
// left untouched (an N_INDEX/N_DOT target carries a live operand there)
// and only the type_ stamp fires on the still-untyped slots.
//
// Each binder/target node's own type_ is stamped from its element type so
// the asserttyped gate sees a typed node. This covers the discard `_` (an
// empty-str N_IDENT with no decl to read a type back from): harec drops
// `_` yet still advances the tuple slot, so that slot's element type is
// the honest type to stamp — `_` is UNBOUND, not UNTYPED.
fn stamptuplebinds(c: *checker, binds: *node, elems: *node,
define: bool, what: str) void = {
let b: *node = binds;
let pt: *node = elems;
for (b != nil) {
let et: *node = nil;
if (pt != nil) { et = pt.lhs; };
if (define) {
if (b.lhs == nil) { b.lhs = et; };
let bnm: str = b.str;
if (bnm.len > 0) {
checkmoduleshadow(c, bnm, what);
scopedefine(c.cur, bnm, skind.SK_VAR, nil, b);
};
};
if (b.type_ == nil) {
let src: *node = b.lhs;
if (src == nil) { src = et; };
if (src != nil) {
let ti: *tinfo = tinfofornode(c, src);
if (ti != nil) { b.type_ = ti: *void; };
};
};
b = b.next;
if (pt != nil) { pt = pt.next; };
};
};
// resolvewalk — recursive AST walk that, for every nkind.N_IDENT and
// nkind.N_TNAME seen, looks up the name and bumps the resolved/unresolved
// counters. Local lets are installed in the current scope as soon as
@@ -10354,15 +10404,22 @@ fn resolvewalk(c: *checker, n: *node) void = {
if (k == nkind.N_FORRANGE) {
if (n.lhs != nil) { resolvewalk(c, n.lhs); };
if (n.list != nil) {
let m: *node = n.list;
for (m != nil) {
let bnm: str = m.str;
if (bnm.len > 0) {
checkmoduleshadow(c, bnm, "binding");
scopedefine(c.cur, bnm, skind.SK_VAR, nil, m);
};
m = m.next;
// Tuple destructure `for (let (a,b) .. xs)`: peel the
// iterable's element type and distribute its tuple
// element types onto the binders, the same lockstep walk
// harec runs for the for-each header
// (ref/harec/src/check.c:2308-2317 → create_unpack_bindings).
let elems: *node = nil;
let it: *node = exprtype(c, n.lhs, nil);
if (it != nil) {
let et: *node = nil;
if (it.kind == nkind.N_TSLICE) { et = it.lhs; };
if (it.kind == nkind.N_TARRAY) { et = it.lhs; };
if (et != nil) { if (et.kind == nkind.N_TTUPLE) {
elems = et.list;
}; };
};
stamptuplebinds(c, n.list, elems, true, "binding");
} else {
let bnm: str = n.str;
if (bnm.len > 0) {
@@ -10452,19 +10509,29 @@ fn resolvewalk(c: *checker, n: *node) void = {
pt = rty.list;
}; };
}; };
stamptuplebinds(c, n.list, pt, true, "let");
return;
};
// `a, _ = call();` — tuple multi-assign (a retained ww extension over
// Hare; harec has no statement-position unpack-assign). Targets are
// pre-declared lvalues, resolved by the per-target resolvewalk below
// before the distribution; stamptuplebinds(define=false) only stamps
// still-nil slots, which is exactly the discard `_` (no decl, so the
// N_IDENT exprtype path leaves it untyped). Distribution mirrors the
// N_MLET/N_FORRANGE binders; see stamptuplebinds.
if (k == nkind.N_MASSIGN) {
if (n.rhs != nil) { resolvewalk(c, n.rhs); };
let pt: *node = nil;
if (n.rhs != nil) { if (n.rhs.kind == nkind.N_CALL) {
let rty: *node = exprtype(c, n.rhs, nil);
if (rty != nil) { if (rty.kind == nkind.N_TTUPLE) {
pt = rty.list;
}; };
}; };
let l: *node = n.list;
for (l != nil) {
if (l.lhs == nil) {
if (pt != nil) { l.lhs = pt.lhs; };
};
let bnm: str = l.str;
if (bnm.len > 0) {
checkmoduleshadow(c, bnm, "let");
scopedefine(c.cur, bnm, skind.SK_VAR, nil, l);
};
l = l.next;
if (pt != nil) { pt = pt.next; };
};
for (l != nil) { resolvewalk(c, l); l = l.next; };
stamptuplebinds(c, n.list, pt, false, "");
return;
};

8
test/wcc/901_asserttyped_gap.c
View File

@@ -26,6 +26,8 @@
* D module-leaf == type/fn name fnmatch 0 (closed)
* D module-leaf == type/fn name random 0 (closed)
* E computed enum-member value-expr enum_corpus 0 (closed)
* F for-range tuple-destructure bind forrange_tuple 0 (closed)
* G tuple multi-assign discard `_` massign_blank 0 (closed)
*
* Exit code of wwdump_ww is intentionally not gated: the diagnostics
* land on stderr regardless of the run's success, and arming the bail
@@ -119,6 +121,10 @@ main(void)
"D module-leaf == type/fn name", 0 },
{ "test/wcc/901_enum_corpus.ww",
"E computed enum-member value-expr", 0 },
{ "test/wcc/901_forrange_tuple.ww",
"F for-range tuple-destructure bind", 0 },
{ "test/wcc/901_massign_blank.ww",
"G tuple multi-assign discard `_`", 0 },
{ NULL, NULL, 0 },
};
@@ -154,6 +160,6 @@ main(void)
return 1;
}
printf("asserttyped_gap: ww-stage checker warn set matches manifest "
"on %d gap-corpus fixtures (C pinned, A+B+D+E closed)\n", n);
"on %d gap-corpus fixtures (C pinned, A+B+D+E+F+G closed)\n", n);
return 0;
}

24
test/wcc/901_forrange_tuple.ww Normal file
View File

@@ -0,0 +1,24 @@
// 901_forrange_tuple — for-range tuple-destructure binder gap fixture
// for the 901 asserttyped net (class F). `for (let (k, v) .. s)` over a
// `[](i64, i64)` left both binders — and every body use site of them,
// plus the N_BIN wrapping them — type_=nil: the N_FORRANGE handler
// installed the binders as SK_VAR but never back-filled their element
// type, so the N_IDENT exprtype path read a nil decl type. stamptuplebinds
// (the shared binder distributor, harec create_unpack_bindings) now peels
// the iterable element tuple and stamps each binder, so this reads 0.
package main;
export fn main() i32 = {
let buf: [2]i64;
buf[0] = 1i64;
buf[1] = 2i64;
let s: [](i64, i64);
s.ptr = buf.ptr: *(i64, i64);
s.len = 1;
s.cap = 1;
let total: i64 = 0i64;
for (let (k, v) .. s) {
total += k + v;
};
return total: i32;
};

25
test/wcc/901_massign_blank.ww Normal file
View File

@@ -0,0 +1,25 @@
// 901_massign_blank — tuple multi-assign discard `_` gap fixture for the
// 901 asserttyped net (class G). In `_, a = f()` the blank `_` parses to
// an empty-str N_IDENT with no decl, so the generic N_IDENT exprtype path
// left it type_=nil (945's own comment documents the gap). The `_` is a
// GAP, not an exemption — the slot has a real element type ([]u8 here), so
// stamptuplebinds(define=false) stamps it with that element type (harec
// drops `_` but still advances the tuple slot). a is pre-declared and
// resolves the normal way; this reads 0.
package main;
fn mk() ([]u8, i64) = {
let b: str = "hi";
let p: []u8;
p.ptr = b.ptr;
p.len = 2;
p.cap = 5;
return (p, 7i64);
};
export fn main() i32 = {
let a: i64 = 0i64;
_, a = mk();
if (a != 7) { return 1; };
return 0;
};