Hojun-Cho
83f5956df2
Every section banner dies (103 -> 0) across test/lang, the observer suites, the C carriers, and the five comment-heavy corpus fixtures; banner provenance (#N cites, carrier numbers, repair-cluster labels) folded into headers or adjacent WHY comments. Narration deleted; row provenance, ref cites, divergence pins, and layout contracts kept (fwd-ref decl-order guards and bootstrap-gate corpus rationale restored where the sweep over-cut). Comment-only proven: all 3742 wwbuild workdir .s byte-identical before/after; test-commit and test-byteid (161 lang + 1399 data, 0 pinned-divergent) green.
110 lines
4.3 KiB
Plaintext
110 lines
4.3 KiB
Plaintext
// #17: an array VARIABLE coerced into the SLICE
|
|
// success variant of a tagged union (`let a:[N]i32; ... ([]i32|e)`) silently
|
|
// dropped .len/.cap (and .ptr) — a both-stage miscompile the byte-id gate is
|
|
// BLIND to (cstage and wwstage agreed and were BOTH wrong).
|
|
//
|
|
// Root cause was in the CHECKER, not cgen: desugar_arrayslice — the single
|
|
// #258 [N]T->[]T borrow lowering that rewrites the array source to a full
|
|
// slice `a[0:len(a)]` so the existing slice cgen builds the {ptr,len,cap}
|
|
// header — no-op'd when the borrow target chased to a tagged union (it gated
|
|
// `du->kind == TY_SLICE` only). The bare array source then reached cgen's
|
|
// scalar union-widen arm, which loaded the array's first 8 bytes as a single
|
|
// payload word and zeroed len/cap. The fix chases a TY_TAGGED dst to its slice
|
|
// success variant before lowering (the exact #13 reject_arrlit_borrow chase,
|
|
// applied to a LEGAL array-variable borrow rather than a reject) — closing the
|
|
// class by construction at the one shared choke-point, so RETURN / LET-init /
|
|
// ASSIGN / CALL-ARG all lower identically.
|
|
//
|
|
// Both stages emit identically-wrong asm pre-fix, so byte-id is blind — these
|
|
// VALUE asserts are the sole tooth: len, cap (the dropped words) AND first/last
|
|
// elements (proving .ptr too). Reverting either stage's desugar chase reverts
|
|
// to the scalar-widen drop and reddens.
|
|
//
|
|
// DISTINCT from #13/#18: those REJECT an illegal array-LITERAL temp borrowed
|
|
// into a union slice variant (a temp has no outliving backing). #17 is the
|
|
// opposite — an array VARIABLE HAS storage, so the borrow is legal and must
|
|
// WORK. A typed array literal here still loud-rejects (reject_arrlit_borrow
|
|
// runs first); only the variable desugars.
|
|
//
|
|
// multi_variant_form pins the variant SELECTION: `[4]i32` into a MULTI-slice
|
|
// union ([]u8|[]i32|e) must chase to the []i32 member by ELEMENT equality, not
|
|
// merely the first slice ([]u8). A naive first-N_TSLICE chase would pick []u8,
|
|
// fail the main desugar gate's element-eq guard, and no-op straight back to the
|
|
// len/cap drop. Faithful to harec tagged_select_subtype (types.c:702 — a UNIQUE
|
|
// assignable member; an array is element-eq to at most one slice variant).
|
|
//
|
|
// Inline @test fns, not a row-table: the cases vary in the COERCION-CONTEXT
|
|
// place shape (return / let-init / assign / call-arg), not in data values over
|
|
// one operation, so a row-array `[](in,exp){}` can't express them — and that
|
|
// form is itself blocked by cgen #111. Mirrors global_chained_unwrap_test's
|
|
// #16 pins.
|
|
|
|
package arrvar_union_slice_test;
|
|
|
|
type e = !i32;
|
|
|
|
fn mk() ([]i32 | e) = { // RETURN: array var -> union slice
|
|
let a: [4]i32 = [11, 22, 33, 44];
|
|
return a;
|
|
};
|
|
|
|
fn use_slice(s: ([]i32 | e)) i32 = { // receives the CALL-ARG widen
|
|
let v = s!;
|
|
return len(v): i32 + v.cap: i32 + v[0] + v[3];
|
|
};
|
|
|
|
@test fn ret_form() void = {
|
|
let s = mk()!;
|
|
assert(len(s) == 4); // .len tooth
|
|
assert(s.cap == 4); // .cap tooth
|
|
assert(s[0] == 11); // .ptr teeth
|
|
assert(s[1] == 22);
|
|
assert(s[2] == 33);
|
|
assert(s[3] == 44);
|
|
};
|
|
|
|
@test fn let_form() void = { // LET-init: `let r:([]i32|e) = a;`
|
|
let a: [3]i32 = [7, 8, 9];
|
|
let r: ([]i32 | e) = a;
|
|
let s = r!;
|
|
assert(len(s) == 3);
|
|
assert(s.cap == 3);
|
|
assert(s[0] == 7);
|
|
assert(s[2] == 9);
|
|
};
|
|
|
|
@test fn assign_form() void = { // ASSIGN: `r = a;` into a union
|
|
let a0: [2]i32 = [1, 1];
|
|
let r: ([]i32 | e) = a0;
|
|
let a: [2]i32 = [5, 6];
|
|
r = a;
|
|
let s = r!;
|
|
assert(len(s) == 2);
|
|
assert(s.cap == 2);
|
|
assert(s[0] == 5);
|
|
assert(s[1] == 6);
|
|
};
|
|
|
|
@test fn callarg_form() void = { // CALL-ARG: `f(a)` where f takes union
|
|
let a: [4]i32 = [11, 22, 33, 44];
|
|
assert(use_slice(a) == 4 + 4 + 11 + 44);
|
|
};
|
|
|
|
fn mk_multi() ([]u8 | []i32 | e) = { // MULTI-slice union: must pick []i32, not leading []u8
|
|
let a: [4]i32 = [11, 22, 33, 44];
|
|
return a;
|
|
};
|
|
|
|
@test fn multi_variant_form() void = { // element-eq chase selects the RIGHT slice variant
|
|
let got: i32 = 0;
|
|
match (mk_multi()) {
|
|
case let s: []i32 =>
|
|
got = len(s): i32 + s.cap: i32 + s[0] + s[3];
|
|
case let b: []u8 =>
|
|
got = -1; // wrong: chase mis-picked the leading slice
|
|
case let er: e =>
|
|
got = -2; // wrong: chase fell through to the no-op drop
|
|
};
|
|
assert(got == 4 + 4 + 11 + 44);
|
|
};
|