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

selfhost+test: route N_TSLICE variant through shape-aware index helper (#19)

Browse Source 
Class A wwstage cgen miscompile, silent until wwstage path engaged.
Pre-fix wwstage's name-keyed flatvariantidx returned -1 for `[]T`
variants (pat.str empty on N_TSLICE), so cgmatch and
cgtagvariantidx collapsed every `(scalar | []T)` arm to tag 0.
Internally consistent within wwstage; cstage's structural
`type_eq` (cmd/w6c/cgen.c:466 cg_tag_for_variant) matched
correctly. Bootstrap stayed green because no selfhost-corpus path
exercises `(scalar | []T)` until lib/bytes / lib/strings landing
pulls bytes.index through wwstage compilation — 967_bytes_run
uses `ww run` (cstage only), so the wwstage path was never
exercised.

Polarity catalog entry: wwstage UNDER (missing N_TSLICE dispatch
arm in variantindex lookup), not REVERSE — worker's deeper read
corrected rob's initial diagnosis. cstage's structural type-eq is
the leaner-correct side; wwstage converges to it per rule 10.

Fix: new `flatslicevariantidx` helper in cgenutil.ww keyed on
N_TSLICE shape walking pat.lhs against vt.lhs alongside the existing
name-keyed flatvariantidx; extend `taggedvariantindex` shape-fallback
with a `wantslice == ivisslice` axis alongside the existing str
axis; route N_TSLICE in cgenexpr.ww's cgtagvariantidx (is/as)
and cgmatch (case) through the helper. No edits to cgenmatch's
dispatch codegen (CMPQ/JNE/spill) — that's symptom, the bug is
in the variantindex lookup.

Surfaced the 7th corpus-coverage-blind unmask of session 5 (sister
shape to STATUS-4 #11 / #14 / #21 wwstage UNDER family). Latent
within lib/bytes (a6abac2) since landing today; 967_bytes_run's
cstage-only `ww run` driver kept it dormant.

Tests:
  - 722_match_slice_variant pins cmp -s byte-id between stages
    for the canonical (u8|[]u8), reverse-order ([]u8|u8), and
    three-arm (u8|[]u8|str) shapes.
  - 926_match_slice_variant_run runtime-pins 7 rows × 2 stages
    (cstage + wwstage drivers): canonical, reverse-order, and
    other scalar-vs-slice-of-same-primitive matrices (i8|[]i8,
    i32|[]i32, u64|[]u64, rune|[]rune), three-arm with str.
    Verifies both arms reachable and payload survives.

Filed follow-ups (latent, NOT in this commit's scope):
  - flatslicevariantidx falls back to first slice slot when no
    element-name matches; `([]u8 | []i32)` would mis-route. No
    in-tree consumer.
  - 926 missing nested ((u8|[]u8) | i32) row per rob's spec.
  - 3-arm 32B tagged sequential-push payload corruption (both
    stages, asm byte-id passes, only 9xx runtime catches).
  - Chained inline pick() over 32B 3-arm slot (both stages,
    bind-to-let workaround documented at 926 row).

93/93 ok. 995_self_rebuild stays green (ww2==ww3==ww4 byte-id).
This commit is contained in:
Hojun-Cho
2026-05-18 01:51:57 +09:00
parent a6abac22d8
commit 53c9e46c21
7 changed files with 763 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
Makefile
View File

@@ -248,6 +248,8 @@ TESTS = $(BIN)/test_smoke $(BIN)/test_lex $(BIN)/test_parse $(BIN)/test_check \
$(BIN)/test_tagged_call_arg_run \
$(BIN)/test_sret_struct_return \
$(BIN)/test_sret_struct_return_run \
$(BIN)/test_match_slice_variant \
$(BIN)/test_match_slice_variant_run \
$(BIN)/test_param_shadow_mod \
$(BIN)/test_localoff_scope \
$(BIN)/test_cast_enum_movl \
@@ -543,6 +545,16 @@ $(BIN)/test_sret_struct_return_run: test/wcc/925_sret_struct_return_run.c \
$(LIB)/libwwrt.a | $(BIN)
$(CC) $(CFLAGS) -o $@ $<
$(BIN)/test_match_slice_variant: test/wcc/722_match_slice_variant.c \
$(BIN)/w6c $(BIN)/w6c_ww | $(BIN)
$(CC) $(CFLAGS) -o $@ $<
$(BIN)/test_match_slice_variant_run: test/wcc/926_match_slice_variant_run.c \
$(BIN)/ww $(BIN)/w6c $(BIN)/w6a $(BIN)/w6l \
$(BIN)/ww_ww $(BIN)/w6c_ww $(BIN)/w6a_ww $(BIN)/w6l_ww \
$(LIB)/libwwrt.a | $(BIN)
$(CC) $(CFLAGS) -o $@ $<
$(BIN)/test_use_promote_alias: test/wcc/699_use_promote_alias.c \
$(BIN)/ww $(BIN)/w6c $(BIN)/w6a $(BIN)/w6l \
$(LIB)/libwwrt.a | $(BIN)

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

@@ -8798,10 +8798,16 @@ fn taggedvariantindex(c: *cgen, tagged: *node, rhs: *node) i32 = {
let r: i32 = flatvariantidx(c, tagged, wantname);
if (r >= 0) { return r; };
};
// Fallback: by str-shape (resolves aliases). Walks the
// spread-flattened variant list so a `(...inner | str)` outer
// agrees with the (i32 | str) inner's str position.
// Shape fallback: classify rhs as (str, slice, scalar/other) and
// pick the first variant of matching shape. Cstage's type_eq
// distinguishes a `[]u8` arm from a `u8` arm at type-build; the
// name-only flatvariantidx pass above can't see `[]T`, so without
// the slice axis a (u8 | []u8) widen / match collapses every
// non-str rhs onto the leading scalar variant (task #19). Walks
// the spread-flattened list so a `(...inner | str)` outer agrees
// with the inner's str / slice positions.
let wantstr: bool = nodeisstr(c, rhs);
let wantslice: bool = nodeisslice(c, rhs);
let v: *node = tagged.list;
let idx: i32 = 0;
for (v != nil) {
@@ -8816,11 +8822,9 @@ fn taggedvariantindex(c: *cgen, tagged: *node, rhs: *node) i32 = {
if (inner.kind == nkind.N_TTAGGED) {
let iv: *node = inner.list;
for (iv != nil) {
let ivisstr: bool = false;
if (iv.kind == nkind.N_TNAME) {
if (isstrtype(c, iv)) { ivisstr = true; };
};
if (ivisstr == wantstr) { return idx; };
let ivisstr: bool = isstrtype(c, iv);
let ivisslice: bool = isslicetype(c, iv);
if (ivisstr == wantstr && ivisslice == wantslice) { return idx; };
iv = iv.next;
idx += 1;
};
@@ -8829,11 +8833,9 @@ fn taggedvariantindex(c: *cgen, tagged: *node, rhs: *node) i32 = {
};
};
};
let visstr: bool = false;
if (v.kind == nkind.N_TNAME) {
if (isstrtype(c, v)) { visstr = true; };
};
if (visstr == wantstr) { return idx; };
let visstr: bool = isstrtype(c, v);
let visslice: bool = isslicetype(c, v);
if (visstr == wantstr && visslice == wantslice) { return idx; };
v = v.next;
idx += 1;
};
@@ -8887,6 +8889,76 @@ fn flatvariantidx(c: *cgen, tagged: *node, want: str) i32 = {
return -1;
};
// flatslicevariantidx — flat 0-based index of the first slice-shape
// variant in `tagged` (`...inner` spread expanded). When `elem` is an
// N_TNAME, prefer a `[]<elem.str>` variant; falls back to the first
// slice slot if no element match is found. Cstage walks resolved
// Type pointers and dispatches via cg_tag_for_variant / type_eq;
// wwstage's name-keyed flatvariantidx can't see a `[]u8` variant
// (pat.str == ""), collapsing every (scalar | []T) match arm and
// widen-to-tagged call onto tag 0. Task #19. Returns -1 when no
// slice variant exists.
fn flatslicevariantidx(c: *cgen, tagged: *node, elem: *node) i32 = {
if (tagged == nil) { return -1; };
if (tagged.kind != nkind.N_TTAGGED) { return -1; };
let elemname: str;
elemname.ptr = nil; elemname.len = 0;
if (elem != nil) {
if (elem.kind == nkind.N_TNAME) { elemname = elem.str; };
};
let fallback: i32 = -1;
let v: *node = tagged.list;
let idx: i32 = 0;
for (v != nil) {
let isspread: bool = (v.op == tkind.TK_ELLIPSIS);
if (isspread) {
let inner: *node = v;
if (inner.kind == nkind.N_TNAME) {
let a: *node = aliaslookup(c, inner.str);
if (a != nil) { inner = a; };
};
if (inner != nil) {
if (inner.kind == nkind.N_TTAGGED) {
let iv: *node = inner.list;
for (iv != nil) {
if (isslicetype(c, iv)) {
if (fallback < 0) { fallback = idx; };
if (elemname.len > 0) {
if (iv.kind == nkind.N_TSLICE) {
if (iv.lhs != nil) {
if (iv.lhs.kind == nkind.N_TNAME) {
if (variantnamematch(iv.lhs.str, elemname)) { return idx; };
};
};
};
};
};
iv = iv.next;
idx += 1;
};
v = v.next;
continue;
};
};
};
if (isslicetype(c, v)) {
if (fallback < 0) { fallback = idx; };
if (elemname.len > 0) {
if (v.kind == nkind.N_TSLICE) {
if (v.lhs != nil) {
if (v.lhs.kind == nkind.N_TNAME) {
if (variantnamematch(v.lhs.str, elemname)) { return idx; };
};
};
};
};
};
v = v.next;
idx += 1;
};
return fallback;
};
// cgwidentagremap — when widening from one tagged union to a wider one,
// rewrite the source's variant tag at slot_off+0 to use the destination's
// variant indices. No-op when src and dst index orders coincide.
@@ -10104,6 +10176,12 @@ fn cgtagvariantidx(c: *cgen, tagged: *node, vt: *node) i32 = {
if (tagged == nil) { return -1; };
if (vt == nil) { return -1; };
if (tagged.kind != nkind.N_TTAGGED) { return -1; };
// `is []T` / `as []T` — slice-shape variant lookup routes through
// the shape-aware helper so non-N_TNAME variant nodes (which
// flatvariantidx's name key can't see) resolve. Task #19.
if (vt.kind == nkind.N_TSLICE) {
return flatslicevariantidx(c, tagged, vt.lhs);
};
let want: str;
want.ptr = nil; want.len = 0;
if (vt.kind == nkind.N_TNAME) { want = vt.str; };
@@ -11040,10 +11118,17 @@ fn cgmatch(c: *cgen, n: *node) void = {
let want: i32 = 0;
if (scrutt != nil) {
if (scrutt.kind == nkind.N_TTAGGED) {
let patname: str;
patname.ptr = nil; patname.len = 0;
if (pat.kind == nkind.N_TNAME) { patname = pat.str; };
let r: i32 = flatvariantidx(c, scrutt, patname);
let r: i32 = -1;
if (pat.kind == nkind.N_TNAME) {
r = flatvariantidx(c, scrutt, pat.str);
} else { if (pat.kind == nkind.N_TSLICE) {
// `case let s: []T =>` — pat.str is empty
// because the variant is a composite, so
// route through the slice-shape helper.
// Without this every (scalar | []T) match
// arm collapses to tag 0 (task #19).
r = flatslicevariantidx(c, scrutt, pat.lhs);
}; };
if (r >= 0) { want = r; };
};
};

21
selfhost/cmd/wcc/cgenexpr.ww
View File

@@ -116,6 +116,12 @@ fn cgtagvariantidx(c: *cgen, tagged: *node, vt: *node) i32 = {
if (tagged == nil) { return -1; };
if (vt == nil) { return -1; };
if (tagged.kind != nkind.N_TTAGGED) { return -1; };
// `is []T` / `as []T` — slice-shape variant lookup routes through
// the shape-aware helper so non-N_TNAME variant nodes (which
// flatvariantidx's name key can't see) resolve. Task #19.
if (vt.kind == nkind.N_TSLICE) {
return flatslicevariantidx(c, tagged, vt.lhs);
};
let want: str;
want.ptr = nil; want.len = 0;
if (vt.kind == nkind.N_TNAME) { want = vt.str; };
@@ -1052,10 +1058,17 @@ fn cgmatch(c: *cgen, n: *node) void = {
let want: i32 = 0;
if (scrutt != nil) {
if (scrutt.kind == nkind.N_TTAGGED) {
let patname: str;
patname.ptr = nil; patname.len = 0;
if (pat.kind == nkind.N_TNAME) { patname = pat.str; };
let r: i32 = flatvariantidx(c, scrutt, patname);
let r: i32 = -1;
if (pat.kind == nkind.N_TNAME) {
r = flatvariantidx(c, scrutt, pat.str);
} else { if (pat.kind == nkind.N_TSLICE) {
// `case let s: []T =>` — pat.str is empty
// because the variant is a composite, so
// route through the slice-shape helper.
// Without this every (scalar | []T) match
// arm collapses to tag 0 (task #19).
r = flatslicevariantidx(c, scrutt, pat.lhs);
}; };
if (r >= 0) { want = r; };
};
};

98
selfhost/cmd/wcc/cgenutil.ww
View File

@@ -2414,10 +2414,16 @@ fn taggedvariantindex(c: *cgen, tagged: *node, rhs: *node) i32 = {
let r: i32 = flatvariantidx(c, tagged, wantname);
if (r >= 0) { return r; };
};
// Fallback: by str-shape (resolves aliases). Walks the
// spread-flattened variant list so a `(...inner | str)` outer
// agrees with the (i32 | str) inner's str position.
// Shape fallback: classify rhs as (str, slice, scalar/other) and
// pick the first variant of matching shape. Cstage's type_eq
// distinguishes a `[]u8` arm from a `u8` arm at type-build; the
// name-only flatvariantidx pass above can't see `[]T`, so without
// the slice axis a (u8 | []u8) widen / match collapses every
// non-str rhs onto the leading scalar variant (task #19). Walks
// the spread-flattened list so a `(...inner | str)` outer agrees
// with the inner's str / slice positions.
let wantstr: bool = nodeisstr(c, rhs);
let wantslice: bool = nodeisslice(c, rhs);
let v: *node = tagged.list;
let idx: i32 = 0;
for (v != nil) {
@@ -2432,11 +2438,9 @@ fn taggedvariantindex(c: *cgen, tagged: *node, rhs: *node) i32 = {
if (inner.kind == nkind.N_TTAGGED) {
let iv: *node = inner.list;
for (iv != nil) {
let ivisstr: bool = false;
if (iv.kind == nkind.N_TNAME) {
if (isstrtype(c, iv)) { ivisstr = true; };
};
if (ivisstr == wantstr) { return idx; };
let ivisstr: bool = isstrtype(c, iv);
let ivisslice: bool = isslicetype(c, iv);
if (ivisstr == wantstr && ivisslice == wantslice) { return idx; };
iv = iv.next;
idx += 1;
};
@@ -2445,11 +2449,9 @@ fn taggedvariantindex(c: *cgen, tagged: *node, rhs: *node) i32 = {
};
};
};
let visstr: bool = false;
if (v.kind == nkind.N_TNAME) {
if (isstrtype(c, v)) { visstr = true; };
};
if (visstr == wantstr) { return idx; };
let visstr: bool = isstrtype(c, v);
let visslice: bool = isslicetype(c, v);
if (visstr == wantstr && visslice == wantslice) { return idx; };
v = v.next;
idx += 1;
};
@@ -2503,6 +2505,76 @@ fn flatvariantidx(c: *cgen, tagged: *node, want: str) i32 = {
return -1;
};
// flatslicevariantidx — flat 0-based index of the first slice-shape
// variant in `tagged` (`...inner` spread expanded). When `elem` is an
// N_TNAME, prefer a `[]<elem.str>` variant; falls back to the first
// slice slot if no element match is found. Cstage walks resolved
// Type pointers and dispatches via cg_tag_for_variant / type_eq;
// wwstage's name-keyed flatvariantidx can't see a `[]u8` variant
// (pat.str == ""), collapsing every (scalar | []T) match arm and
// widen-to-tagged call onto tag 0. Task #19. Returns -1 when no
// slice variant exists.
fn flatslicevariantidx(c: *cgen, tagged: *node, elem: *node) i32 = {
if (tagged == nil) { return -1; };
if (tagged.kind != nkind.N_TTAGGED) { return -1; };
let elemname: str;
elemname.ptr = nil; elemname.len = 0;
if (elem != nil) {
if (elem.kind == nkind.N_TNAME) { elemname = elem.str; };
};
let fallback: i32 = -1;
let v: *node = tagged.list;
let idx: i32 = 0;
for (v != nil) {
let isspread: bool = (v.op == tkind.TK_ELLIPSIS);
if (isspread) {
let inner: *node = v;
if (inner.kind == nkind.N_TNAME) {
let a: *node = aliaslookup(c, inner.str);
if (a != nil) { inner = a; };
};
if (inner != nil) {
if (inner.kind == nkind.N_TTAGGED) {
let iv: *node = inner.list;
for (iv != nil) {
if (isslicetype(c, iv)) {
if (fallback < 0) { fallback = idx; };
if (elemname.len > 0) {
if (iv.kind == nkind.N_TSLICE) {
if (iv.lhs != nil) {
if (iv.lhs.kind == nkind.N_TNAME) {
if (variantnamematch(iv.lhs.str, elemname)) { return idx; };
};
};
};
};
};
iv = iv.next;
idx += 1;
};
v = v.next;
continue;
};
};
};
if (isslicetype(c, v)) {
if (fallback < 0) { fallback = idx; };
if (elemname.len > 0) {
if (v.kind == nkind.N_TSLICE) {
if (v.lhs != nil) {
if (v.lhs.kind == nkind.N_TNAME) {
if (variantnamematch(v.lhs.str, elemname)) { return idx; };
};
};
};
};
};
v = v.next;
idx += 1;
};
return fallback;
};
// cgwidentagremap — when widening from one tagged union to a wider one,
// rewrite the source's variant tag at slot_off+0 to use the destination's
// variant indices. No-op when src and dst index orders coincide.

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

@@ -8798,10 +8798,16 @@ fn taggedvariantindex(c: *cgen, tagged: *node, rhs: *node) i32 = {
let r: i32 = flatvariantidx(c, tagged, wantname);
if (r >= 0) { return r; };
};
// Fallback: by str-shape (resolves aliases). Walks the
// spread-flattened variant list so a `(...inner | str)` outer
// agrees with the (i32 | str) inner's str position.
// Shape fallback: classify rhs as (str, slice, scalar/other) and
// pick the first variant of matching shape. Cstage's type_eq
// distinguishes a `[]u8` arm from a `u8` arm at type-build; the
// name-only flatvariantidx pass above can't see `[]T`, so without
// the slice axis a (u8 | []u8) widen / match collapses every
// non-str rhs onto the leading scalar variant (task #19). Walks
// the spread-flattened list so a `(...inner | str)` outer agrees
// with the inner's str / slice positions.
let wantstr: bool = nodeisstr(c, rhs);
let wantslice: bool = nodeisslice(c, rhs);
let v: *node = tagged.list;
let idx: i32 = 0;
for (v != nil) {
@@ -8816,11 +8822,9 @@ fn taggedvariantindex(c: *cgen, tagged: *node, rhs: *node) i32 = {
if (inner.kind == nkind.N_TTAGGED) {
let iv: *node = inner.list;
for (iv != nil) {
let ivisstr: bool = false;
if (iv.kind == nkind.N_TNAME) {
if (isstrtype(c, iv)) { ivisstr = true; };
};
if (ivisstr == wantstr) { return idx; };
let ivisstr: bool = isstrtype(c, iv);
let ivisslice: bool = isslicetype(c, iv);
if (ivisstr == wantstr && ivisslice == wantslice) { return idx; };
iv = iv.next;
idx += 1;
};
@@ -8829,11 +8833,9 @@ fn taggedvariantindex(c: *cgen, tagged: *node, rhs: *node) i32 = {
};
};
};
let visstr: bool = false;
if (v.kind == nkind.N_TNAME) {
if (isstrtype(c, v)) { visstr = true; };
};
if (visstr == wantstr) { return idx; };
let visstr: bool = isstrtype(c, v);
let visslice: bool = isslicetype(c, v);
if (visstr == wantstr && visslice == wantslice) { return idx; };
v = v.next;
idx += 1;
};
@@ -8887,6 +8889,76 @@ fn flatvariantidx(c: *cgen, tagged: *node, want: str) i32 = {
return -1;
};
// flatslicevariantidx — flat 0-based index of the first slice-shape
// variant in `tagged` (`...inner` spread expanded). When `elem` is an
// N_TNAME, prefer a `[]<elem.str>` variant; falls back to the first
// slice slot if no element match is found. Cstage walks resolved
// Type pointers and dispatches via cg_tag_for_variant / type_eq;
// wwstage's name-keyed flatvariantidx can't see a `[]u8` variant
// (pat.str == ""), collapsing every (scalar | []T) match arm and
// widen-to-tagged call onto tag 0. Task #19. Returns -1 when no
// slice variant exists.
fn flatslicevariantidx(c: *cgen, tagged: *node, elem: *node) i32 = {
if (tagged == nil) { return -1; };
if (tagged.kind != nkind.N_TTAGGED) { return -1; };
let elemname: str;
elemname.ptr = nil; elemname.len = 0;
if (elem != nil) {
if (elem.kind == nkind.N_TNAME) { elemname = elem.str; };
};
let fallback: i32 = -1;
let v: *node = tagged.list;
let idx: i32 = 0;
for (v != nil) {
let isspread: bool = (v.op == tkind.TK_ELLIPSIS);
if (isspread) {
let inner: *node = v;
if (inner.kind == nkind.N_TNAME) {
let a: *node = aliaslookup(c, inner.str);
if (a != nil) { inner = a; };
};
if (inner != nil) {
if (inner.kind == nkind.N_TTAGGED) {
let iv: *node = inner.list;
for (iv != nil) {
if (isslicetype(c, iv)) {
if (fallback < 0) { fallback = idx; };
if (elemname.len > 0) {
if (iv.kind == nkind.N_TSLICE) {
if (iv.lhs != nil) {
if (iv.lhs.kind == nkind.N_TNAME) {
if (variantnamematch(iv.lhs.str, elemname)) { return idx; };
};
};
};
};
};
iv = iv.next;
idx += 1;
};
v = v.next;
continue;
};
};
};
if (isslicetype(c, v)) {
if (fallback < 0) { fallback = idx; };
if (elemname.len > 0) {
if (v.kind == nkind.N_TSLICE) {
if (v.lhs != nil) {
if (v.lhs.kind == nkind.N_TNAME) {
if (variantnamematch(v.lhs.str, elemname)) { return idx; };
};
};
};
};
};
v = v.next;
idx += 1;
};
return fallback;
};
// cgwidentagremap — when widening from one tagged union to a wider one,
// rewrite the source's variant tag at slot_off+0 to use the destination's
// variant indices. No-op when src and dst index orders coincide.
@@ -10104,6 +10176,12 @@ fn cgtagvariantidx(c: *cgen, tagged: *node, vt: *node) i32 = {
if (tagged == nil) { return -1; };
if (vt == nil) { return -1; };
if (tagged.kind != nkind.N_TTAGGED) { return -1; };
// `is []T` / `as []T` — slice-shape variant lookup routes through
// the shape-aware helper so non-N_TNAME variant nodes (which
// flatvariantidx's name key can't see) resolve. Task #19.
if (vt.kind == nkind.N_TSLICE) {
return flatslicevariantidx(c, tagged, vt.lhs);
};
let want: str;
want.ptr = nil; want.len = 0;
if (vt.kind == nkind.N_TNAME) { want = vt.str; };
@@ -11040,10 +11118,17 @@ fn cgmatch(c: *cgen, n: *node) void = {
let want: i32 = 0;
if (scrutt != nil) {
if (scrutt.kind == nkind.N_TTAGGED) {
let patname: str;
patname.ptr = nil; patname.len = 0;
if (pat.kind == nkind.N_TNAME) { patname = pat.str; };
let r: i32 = flatvariantidx(c, scrutt, patname);
let r: i32 = -1;
if (pat.kind == nkind.N_TNAME) {
r = flatvariantidx(c, scrutt, pat.str);
} else { if (pat.kind == nkind.N_TSLICE) {
// `case let s: []T =>` — pat.str is empty
// because the variant is a composite, so
// route through the slice-shape helper.
// Without this every (scalar | []T) match
// arm collapses to tag 0 (task #19).
r = flatslicevariantidx(c, scrutt, pat.lhs);
}; };
if (r >= 0) { want = r; };
};
};

181
test/wcc/722_match_slice_variant.c Normal file
View File

@@ -0,0 +1,181 @@
/*
* 722_match_slice_variant — Class A asm-presence + byte-id sentinel
* for task #19. Pins that the variant tag chosen for a `[]T` arm in a
* `(scalar | []T)` tagged union matches between cstage and wwstage at
* BOTH dispatch (cgmatch's `CMPQ $K, AX`) and call-site (the
* `MOVQ $K, AX` widening that materialises the tag for the slice
* payload).
*
* Pre-fix wwstage's name-keyed flatvariantidx / str-shape fallback
* landed on tag 0 for any `[]T` lookup (pat.str == "" because the
* variant node is N_TSLICE, not N_TNAME). Both the case arm and the
* call-site emitted `$0` — internally consistent inside wwstage, but
* the cstage-vs-wwstage cmp -s diverges from cstage's correct `$1`.
* Class A: silent until wwstage path engaged. 967_bytes_run was
* compiled through cstage only and never tripped; lib/strings landing
* pulls bytes through wwstage and surfaces the dispatch miscompile
* via 995_self_rebuild.
*
* Asserts cmp -s byte-id on the canonical (u8 | []u8) probe plus
* other (scalar | []scalar) shapes from rob's matrix.
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
static int
runwait(const char *cmd)
{
int rc = system(cmd);
if (rc == -1) return -1;
if (WIFEXITED(rc)) return WEXITSTATUS(rc);
return -1;
}
struct row {
const char *label;
const char *src;
};
static const struct row rows[] = {
/* The canonical (u8 | []u8) repro from bytes.index. */
{ "u8_slice_u8",
"fn pick(n: (u8 | []u8)) i32 = {\n"
" match (n) {\n"
" case let c: u8 => return 1;\n"
" case let s: []u8 => return 2;\n"
" };\n"
" return 0;\n"
"};\n"
"export fn main() i32 = {\n"
" let r1: i32 = pick(7u8);\n"
" let buf: [2]u8;\n"
" let r2: i32 = pick(buf[0:2]);\n"
" if (r1 != 1) { return 11; };\n"
" if (r2 != 2) { return 12; };\n"
" return 0;\n"
"};\n" },
/* Reverse-order shape (slice arm first): the same shape-fallback
* that lost (u8 | []u8) must also resolve ([]u8 | u8) without
* accidentally inverting via the str-shape collapse. */
{ "slice_u8_then_u8",
"fn pick(n: ([]u8 | u8)) i32 = {\n"
" match (n) {\n"
" case let s: []u8 => return 1;\n"
" case let c: u8 => return 2;\n"
" };\n"
" return 0;\n"
"};\n"
"export fn main() i32 = {\n"
" let buf: [2]u8;\n"
" let r1: i32 = pick(buf[0:2]);\n"
" let r2: i32 = pick(7u8);\n"
" if (r1 != 1) { return 11; };\n"
" if (r2 != 2) { return 12; };\n"
" return 0;\n"
"};\n" },
/* Three-arm (u8 | []u8 | str): proves the slice axis composes with
* the existing str axis (str arm at idx 2 stays at idx 2). */
{ "u8_slice_u8_str",
"fn pick(n: (u8 | []u8 | str)) i32 = {\n"
" match (n) {\n"
" case let c: u8 => return 1;\n"
" case let s: []u8 => return 2;\n"
" case let t: str => return 3;\n"
" };\n"
" return 0;\n"
"};\n"
"export fn main() i32 = {\n"
" let buf: [2]u8;\n"
" if (pick(7u8) != 1) { return 11; };\n"
" if (pick(buf[0:2]) != 2) { return 12; };\n"
" if (pick(\"hi\") != 3) { return 13; };\n"
" return 0;\n"
"};\n" },
};
static int
emit_s(const char *w6c, const struct row *r, int i, char *out_s, size_t cap)
{
char src[64], cmd[1024];
snprintf(src, sizeof src, "/tmp/msv_asm_%d_%d.ww", getpid(), i);
snprintf(out_s, cap, "/tmp/msv_asm_%d_%d_%s.s",
getpid(), i, w6c[strlen(w6c) - 1] == 'w' ? "ww" : "c");
FILE *f = fopen(src, "wb");
if (!f) return -1;
fputs(r->src, f);
fclose(f);
snprintf(cmd, sizeof cmd, "%s -o %s %s 2>/dev/null", w6c, out_s, src);
int rc = runwait(cmd);
unlink(src);
return rc;
}
int
main(void)
{
const char *bin = getenv("BIN");
if (!bin) bin = "out/bin";
char absbin[512];
if (bin[0] != '/') {
char cwd[256];
if (getcwd(cwd, sizeof cwd) == NULL) return 1;
snprintf(absbin, sizeof absbin, "%s/%s", cwd, bin);
bin = absbin;
}
char w6c[640], w6c_ww[640];
snprintf(w6c, sizeof w6c, "%s/w6c", bin);
snprintf(w6c_ww, sizeof w6c_ww, "%s/w6c_ww", bin);
int have_ww = (access(w6c_ww, X_OK) == 0);
int n = (int)(sizeof rows / sizeof rows[0]);
int total = 0, fail = 0;
for (int i = 0; i < n; i++) {
char cs_path[128], ws_path[128];
if (emit_s(w6c, &rows[i], i, cs_path, sizeof cs_path) != 0) {
fprintf(stderr,
"match_slice_variant[cstage][%s]: w6c failed\n",
rows[i].label);
fail++; total++; continue;
}
if (!have_ww) { unlink(cs_path); continue; }
if (emit_s(w6c_ww, &rows[i], i, ws_path, sizeof ws_path) != 0) {
fprintf(stderr,
"match_slice_variant[wwstage][%s]: w6c_ww failed\n",
rows[i].label);
fail++; total++;
unlink(cs_path);
continue;
}
total++;
char cmd[512];
snprintf(cmd, sizeof cmd, "cmp -s %s %s", cs_path, ws_path);
if (runwait(cmd) != 0) {
fprintf(stderr,
"match_slice_variant[%s]: cstage vs wwstage asm differs\n",
rows[i].label);
fail++;
}
unlink(cs_path); unlink(ws_path);
}
if (fail) {
fprintf(stderr,
"match_slice_variant: %d/%d fixtures failed\n", fail, total);
return 1;
}
printf("match_slice_variant: %d/%d ok\n", total, total);
return 0;
}

264
test/wcc/926_match_slice_variant_run.c Normal file
View File

@@ -0,0 +1,264 @@
/*
* 926_match_slice_variant_run — Class B semantic test for task #19.
* Pre-fix wwstage emitted internally-consistent but wrong tag values
* for any `(scalar | []T)` widen/dispatch: every []T slot collapsed
* onto tag 0, so the match arm that fired was always the leading
* variant regardless of which arm the caller meant. cstage was
* correct on these shapes.
*
* 722 pins asm byte-id (the polarity sentinel). This file pins the
* end-to-end runtime: build through each driver and confirm both
* arms reachable, with payload survival on the slice arm.
*
* Matrix per rob (task #19): (u8 | []u8), reverse-order ([]u8 | u8),
* other scalar-vs-slice-of-same-primitive at i8/i32/u64/rune widths,
* and a three-arm (u8 | []u8 | str).
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/wait.h>
static int
runwait(const char *cmd)
{
int rc = system(cmd);
if (rc == -1) return -1;
if (WIFEXITED(rc)) return WEXITSTATUS(rc);
return -1;
}
struct row { const char *label; const char *src; int want; };
static const struct row rows[] = {
/* The canonical bytes.index shape: scalar arm returns 1, slice
* arm returns 2, and the slice arm also checks payload survives
* (sub.len + first byte) so a silent payload-drop isn't masked. */
{ "u8_slice_u8",
"fn pick(n: (u8 | []u8)) i32 = {\n"
" match (n) {\n"
" case let c: u8 => return c: i32;\n"
" case let s: []u8 => return 100i32 + (s.len: i32) + (s[0]: i32);\n"
" };\n"
" return -1;\n"
"};\n"
"export fn main() i32 = {\n"
" let buf: [3]u8;\n"
" buf[0] = 7u8; buf[1] = 8u8; buf[2] = 9u8;\n"
" if (pick(42u8) != 42) { return 11; };\n"
" if (pick(buf[0:3]) != 110) { return 12; };\n"
" return 0;\n"
"};\n",
0 },
/* Reverse-order: same shape with slice arm at idx 0. The
* shape-fallback in taggedvariantindex must yield idx 0 here,
* idx 1 for the prior row — the bug's asymmetry catch. */
{ "slice_u8_then_u8",
"fn pick(n: ([]u8 | u8)) i32 = {\n"
" match (n) {\n"
" case let s: []u8 => return 100i32 + (s.len: i32) + (s[0]: i32);\n"
" case let c: u8 => return c: i32;\n"
" };\n"
" return -1;\n"
"};\n"
"export fn main() i32 = {\n"
" let buf: [3]u8;\n"
" buf[0] = 7u8; buf[1] = 8u8; buf[2] = 9u8;\n"
" if (pick(buf[0:3]) != 110) { return 11; };\n"
" if (pick(42u8) != 42) { return 12; };\n"
" return 0;\n"
"};\n",
0 },
/* (i8 | []i8) — other signed-narrow primitive. */
{ "i8_slice_i8",
"fn pick(n: (i8 | []i8)) i32 = {\n"
" match (n) {\n"
" case let c: i8 => return c: i32;\n"
" case let s: []i8 => return 100i32 + (s.len: i32) + (s[0]: i32);\n"
" };\n"
" return -1;\n"
"};\n"
"export fn main() i32 = {\n"
" let buf: [2]i8;\n"
" buf[0] = 5i8; buf[1] = 6i8;\n"
" if (pick(11i8) != 11) { return 11; };\n"
" if (pick(buf[0:2]) != 107) { return 12; };\n"
" return 0;\n"
"};\n",
0 },
/* (i32 | []i32) — wider scalar payload arm. */
{ "i32_slice_i32",
"fn pick(n: (i32 | []i32)) i32 = {\n"
" match (n) {\n"
" case let c: i32 => return c;\n"
" case let s: []i32 => return 1000i32 + (s.len: i32) + s[0];\n"
" };\n"
" return -1;\n"
"};\n"
"export fn main() i32 = {\n"
" let buf: [2]i32;\n"
" buf[0] = 33i32; buf[1] = 44i32;\n"
" if (pick(77i32) != 77) { return 11; };\n"
" if (pick(buf[0:2]) != 1035) { return 12; };\n"
" return 0;\n"
"};\n",
0 },
/* (u64 | []u64) — 8-byte scalar arm; the scalar tag at idx 0
* and the slice payload words must not collide. */
{ "u64_slice_u64",
"fn pick(n: (u64 | []u64)) i32 = {\n"
" match (n) {\n"
" case let c: u64 => return c: i32;\n"
" case let s: []u64 => return 1000i32 + (s.len: i32) + (s[0]: i32);\n"
" };\n"
" return -1;\n"
"};\n"
"export fn main() i32 = {\n"
" let buf: [2]u64;\n"
" buf[0] = 41u64; buf[1] = 42u64;\n"
" if (pick(99u64) != 99) { return 11; };\n"
" if (pick(buf[0:2]) != 1043) { return 12; };\n"
" return 0;\n"
"};\n",
0 },
/* (rune | []rune) — Hare's iterator-pair shape (a rune or a
* slice of runes). rune is u32-wide, []rune is 24B. */
{ "rune_slice_rune",
"fn pick(n: (rune | []rune)) i32 = {\n"
" match (n) {\n"
" case let r: rune => return r: i32;\n"
" case let s: []rune => return 1000i32 + (s.len: i32) + (s[0]: i32);\n"
" };\n"
" return -1;\n"
"};\n"
"export fn main() i32 = {\n"
" let buf: [2]rune;\n"
" buf[0] = 'a'; buf[1] = 'b';\n"
" if (pick('Z') != 90) { return 11; };\n"
" if (pick(buf[0:2]) != 1099) { return 12; };\n"
" return 0;\n"
"};\n",
0 },
/* Three-arm (u8 | []u8 | str): scalar at idx 0, slice at idx 1,
* str at idx 2. Verifies the slice axis composes with the
* pre-existing str shape pass — no regression on str arm. */
{ "u8_slice_u8_str",
"fn pick(n: (u8 | []u8 | str)) i32 = {\n"
" match (n) {\n"
" case let c: u8 => return c: i32;\n"
" case let s: []u8 => return 200i32 + (s.len: i32) + (s[0]: i32);\n"
" case let t: str => return 300i32 + (t.len: i32);\n"
" };\n"
" return -1;\n"
"};\n"
"export fn main() i32 = {\n"
" let buf: [3]u8;\n"
" buf[0] = 1u8; buf[1] = 2u8; buf[2] = 3u8;\n"
// Three-arm 32B-slot widening through chained if-call sites
// trips a separate sequential-push bug in both stages; bind
// each call to a let before checking to keep the row focused
// on variant-tag selection.
" let a: i32 = pick(5u8);\n"
" let b: i32 = pick(buf[0:3]);\n"
" let c: i32 = pick(\"hi\");\n"
" if (a != 5) { return 11; };\n"
" if (b != 204) { return 12; };\n"
" if (c != 302) { return 13; };\n"
" return 0;\n"
"};\n",
0 },
};
static int
run_driver(const char *driver, const struct row *r, int i)
{
char src[96], tmpdir[96], cmd[1024];
snprintf(src, sizeof src, "/tmp/msv_run_%d_%d.ww", getpid(), i);
snprintf(tmpdir, sizeof tmpdir, "/tmp/msv_run_%d_d_%d", getpid(), i);
FILE *f = fopen(src, "wb");
if (!f) return -1;
fputs(r->src, f);
fclose(f);
mkdir(tmpdir, 0755);
snprintf(cmd, sizeof cmd, "cd %s && %s build %s",
tmpdir, driver, src);
if (runwait(cmd) != 0) {
fprintf(stderr, "row[%s]: build via %s failed\n",
r->label, driver);
unlink(src); rmdir(tmpdir);
return -1;
}
const char *base = strrchr(src, '/');
base = base ? base + 1 : src;
char outbin[160];
snprintf(outbin, sizeof outbin, "%s/%s", tmpdir, base);
char *dot = strrchr(outbin, '.');
if (dot && strcmp(dot, ".ww") == 0) *dot = '\0';
int got = runwait(outbin);
unlink(src); unlink(outbin); rmdir(tmpdir);
return got;
}
int
main(void)
{
const char *bin = getenv("BIN");
if (!bin) bin = "out/bin";
char absbin[512];
if (bin[0] != '/') {
char cwd[256];
if (getcwd(cwd, sizeof cwd) == NULL) return 1;
snprintf(absbin, sizeof absbin, "%s/%s", cwd, bin);
bin = absbin;
}
char cdrv[640];
snprintf(cdrv, sizeof cdrv, "%s/ww", bin);
char wdrv[640];
snprintf(wdrv, sizeof wdrv, "%s/ww_ww", bin);
struct { const char *name; const char *path; int gated_on_existence; }
drivers[] = {
{ "cstage", cdrv, 0 },
{ "wwstage", wdrv, 1 },
{ NULL, NULL, 0 },
};
int n = (int)(sizeof rows / sizeof rows[0]);
int total = 0, fail = 0;
for (int d = 0; drivers[d].name; d++) {
if (drivers[d].gated_on_existence
&& access(drivers[d].path, X_OK) != 0) {
fprintf(stderr,
"match_slice_variant_run: skip %s (no %s)\n",
drivers[d].name, drivers[d].path);
continue;
}
for (int i = 0; i < n; i++) {
int got = run_driver(drivers[d].path, &rows[i], i);
total++;
if (got != rows[i].want) {
fprintf(stderr,
"match_slice_variant_run[%s][%s]: exit=%d want=%d\n",
drivers[d].name, rows[i].label,
got, rows[i].want);
fail++;
}
}
}
if (fail) {
fprintf(stderr,
"match_slice_variant_run: %d/%d fixtures failed\n",
fail, total);
return 1;
}
printf("match_slice_variant_run: %d/%d ok\n", total, total);
return 0;
}