Hojun-Cho
1a57de6ffe
local_zeroinit_test.ww takes the 840/944 zero-init seam (dirty-frame prime and probe share one @test because the runtime forks per test); alias_cgen_b6, alloc_nested_field, array_static_init, and strarray_static gain the rows their retired wrappers held; the remaining files re-point reject-row citations at the r788_* and stage-matrix fixtures.
276 lines
6.2 KiB
Plaintext
276 lines
6.2 KiB
Plaintext
// alias_cgen_b6_test — #5 alias arc F2b (B6 train): the cgen.c cgexpr/cgstmt
|
|
// INLINE single-peel sweep through type_chase_named, by consumer family —
|
|
// c1 assign/reassign, c2 call-arg, c3 addr-of/field-walk/index spine,
|
|
// c4 cast/is/try, c5 reads/len/globals. Every K_RUN row was a cs-side
|
|
// single-peel that left a 2-level alias TY_NAMED (or ww the alias-blind side
|
|
// at the c3 index/field gates, graduated by W2 #102): silent-wrong store
|
|
// width, wrong stride, alias-blind field offset. Migrated from
|
|
// test/wcc/944_alias_cgen_b6_run.c (#5-C3).
|
|
//
|
|
// The 3 K_BUILDERR/loud rows (fsarg0_loud_ctl, fsarg2_bound, try_loud_38b)
|
|
// live elsewhere — value rows only here. Per-row type/global/fn families are
|
|
// prefixed to dedup the source's reused {ms,st,fs,u,big,S,my32,...} spellings
|
|
// at module scope (ww forbids local `type`); forward-ref decl order is
|
|
// irrelevant to value semantics here so families are declared base-first.
|
|
|
|
package alias_cgen_b6_test;
|
|
|
|
// ---- c1: assign/reassign family
|
|
|
|
type c1sr_ms0 = str;
|
|
type c1sr_ms = c1sr_ms0;
|
|
|
|
@test fn streassign_2lvl() void = {
|
|
let a: c1sr_ms = "hello";
|
|
let b: c1sr_ms = "x";
|
|
b = a;
|
|
assert(len(b) == 5);
|
|
};
|
|
|
|
type c1ra_st0 = struct { a: i64, b: i64, c: i64 };
|
|
type c1ra_st = c1ra_st0;
|
|
|
|
@test fn sreassign_2lvl() void = {
|
|
let x: c1ra_st; x.a = 1; x.b = 2; x.c = 3;
|
|
let y: c1ra_st; y.a = 0; y.b = 0; y.c = 0;
|
|
y = x;
|
|
assert(y.c == 3 && y.b == 2);
|
|
};
|
|
|
|
type c1da_st0 = struct { a: i64, b: i64 };
|
|
type c1da_st = c1da_st0;
|
|
|
|
@test fn dassign_2lvl() void = {
|
|
let x: c1da_st; x.a = 1; x.b = 2;
|
|
let p: *c1da_st = &x;
|
|
(*p).b = 9;
|
|
assert(x.b == 9);
|
|
};
|
|
|
|
// ---- c2: call-arg family
|
|
|
|
type c2fi_fs0 = struct { x: f64 };
|
|
type c2fi_fs = c2fi_fs0;
|
|
|
|
fn c2fi_mk() c2fi_fs0 = {
|
|
let s: c2fi_fs0; s.x = 2.5;
|
|
return s;
|
|
};
|
|
|
|
fn c2fi_g(p: c2fi_fs) f64 = { return p.x; };
|
|
|
|
@test fn fsarg_ident_ctl() void = {
|
|
let v: c2fi_fs = c2fi_mk();
|
|
assert(c2fi_g(v) == 2.5);
|
|
};
|
|
|
|
type c2sa_big0 = struct { a: i64, b: i64, c: i64 };
|
|
type c2sa_big = c2sa_big0;
|
|
|
|
fn c2sa_g(p: c2sa_big) i64 = { return p.a + p.c; };
|
|
|
|
@test fn sarg_2lvl() void = {
|
|
let s: c2sa_big; s.a = 4; s.b = 5; s.c = 9;
|
|
assert(c2sa_g(s) == 13);
|
|
};
|
|
|
|
type c2st_ms0 = str;
|
|
type c2st_ms = c2st_ms0;
|
|
|
|
fn c2st_g(s: c2st_ms) i64 = { return len(s): i64; };
|
|
|
|
@test fn strarg_2lvl() void = {
|
|
let a: c2st_ms = "hello";
|
|
assert(c2st_g(a) == 5);
|
|
};
|
|
|
|
// ---- c3: addr-of/field-walk/index spine
|
|
|
|
type c3if_el0 = struct { a: i64, b: i64 };
|
|
type c3if_el = c3if_el0;
|
|
|
|
// graduated: #102 (W2)
|
|
@test fn idxf_2lvl() void = {
|
|
let xs: [2]c3if_el;
|
|
xs[0].a = 1; xs[0].b = 2;
|
|
xs[1].a = 3; xs[1].b = 4;
|
|
assert(xs[1].b == 4 && xs[0].b == 2);
|
|
};
|
|
|
|
type c3ifp_el0 = struct { a: i64, b: i64 };
|
|
|
|
@test fn idxf_plain_ctl() void = {
|
|
let xs: [2]c3ifp_el0;
|
|
xs[0].a = 1; xs[0].b = 2;
|
|
xs[1].a = 3; xs[1].b = 4;
|
|
assert(xs[1].b == 4 && xs[0].b == 2);
|
|
};
|
|
|
|
type c3af_st0 = struct { a: i64, b: i64 };
|
|
type c3af_st = c3af_st0;
|
|
|
|
// graduated: #102 (W2)
|
|
@test fn ampf_2lvl() void = {
|
|
let x: c3af_st; x.a = 1; x.b = 2;
|
|
let p: *c3af_st = &x;
|
|
let q: *i64 = &p.b;
|
|
*q = 9;
|
|
assert(x.b == 9);
|
|
};
|
|
|
|
type c3afp_st0 = struct { a: i64, b: i64 };
|
|
|
|
@test fn ampf_plain_ctl() void = {
|
|
let x: c3afp_st0; x.a = 1; x.b = 2;
|
|
let p: *c3afp_st0 = &x;
|
|
let q: *i64 = &p.b;
|
|
*q = 9;
|
|
assert(x.b == 9);
|
|
};
|
|
|
|
type c3av_st0 = struct { a: i64, b: i64 };
|
|
type c3av_st = c3av_st0;
|
|
|
|
// amendment: #102 (W2)
|
|
@test fn ampv_2lvl() void = {
|
|
let x: c3av_st; x.a = 1; x.b = 2;
|
|
let q: *i64 = &x.b;
|
|
*q = 9;
|
|
assert(x.b == 9);
|
|
};
|
|
|
|
type c3avp_st0 = struct { a: i64, b: i64 };
|
|
|
|
@test fn ampv_plain_ctl() void = {
|
|
let x: c3avp_st0; x.a = 1; x.b = 2;
|
|
let q: *i64 = &x.b;
|
|
*q = 9;
|
|
assert(x.b == 9);
|
|
};
|
|
|
|
type c3cd_in0 = struct { v: i64 };
|
|
type c3cd_in1 = c3cd_in0;
|
|
type c3cd_out0 = struct { inner: c3cd_in1, n: i64 };
|
|
type c3cd_out1 = c3cd_out0;
|
|
|
|
@test fn chdot_2lvl() void = {
|
|
let s: c3cd_out1; s.inner.v = 7; s.n = 3;
|
|
let p: *c3cd_out1 = &s;
|
|
assert(p.inner.v == 7);
|
|
};
|
|
|
|
type c3es_my32 = u32;
|
|
type c3es_my32b = c3es_my32;
|
|
|
|
@test fn esub_2lvl() void = {
|
|
let xs: [3]c3es_my32b;
|
|
xs[0] = 5; xs[1] = 6; xs[2] = 7;
|
|
assert(xs[0]: i64 + xs[1]: i64 + xs[2]: i64 == 18);
|
|
};
|
|
|
|
type c3kw_my32 = u32;
|
|
type c3kw_my32b = c3kw_my32;
|
|
type c3kw_S = struct { arr: [3]c3kw_my32b, tail: int };
|
|
|
|
@test fn kw1_101() void = {
|
|
let s = c3kw_S { arr = [10u32, 20u32, 30u32], tail = 77 };
|
|
assert(size(c3kw_my32b) == 4);
|
|
assert(s.arr[0] == 10u32);
|
|
assert(s.arr[1] == 20u32);
|
|
assert(s.arr[2] == 30u32);
|
|
assert(s.tail == 77);
|
|
};
|
|
|
|
type c3kc_my16 = u16;
|
|
type c3kc_S2 = struct { arr: [4]c3kc_my16, n: int };
|
|
|
|
@test fn kw1_ctl16() void = {
|
|
let s = c3kc_S2 { arr = [1u16, 2u16, 3u16, 4u16], n = 9 };
|
|
assert(s.arr[0] + s.arr[1] + s.arr[2] + s.arr[3] == 10u16);
|
|
assert(s.n == 9);
|
|
};
|
|
|
|
// ---- c4: cast/is/try family
|
|
|
|
type c4sc_ms0 = str;
|
|
type c4sc_ms = c4sc_ms0;
|
|
|
|
@test fn strcast_2lvl() void = {
|
|
let a: c4sc_ms = "hey";
|
|
let b: []u8 = a: []u8;
|
|
assert(len(b) == 3);
|
|
assert(b[0] == 'h');
|
|
};
|
|
|
|
type c4ic_u0 = (void | i64);
|
|
type c4ic_u = c4ic_u0;
|
|
|
|
@test fn idcast_2lvl() void = {
|
|
let v: c4ic_u = 42i64;
|
|
let w: c4ic_u = (v: c4ic_u);
|
|
match (w) {
|
|
case let n: i64 => { assert(n == 42); };
|
|
case void => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type c4is_u0 = (void | i64);
|
|
type c4is_u = c4is_u0;
|
|
|
|
@test fn is_2lvl() void = {
|
|
let v: c4is_u = 42i64;
|
|
assert(v is i64);
|
|
assert(!(v is void));
|
|
};
|
|
|
|
// ---- c5: reads/len/globals family
|
|
|
|
type c5tf_u0 = (void | i64);
|
|
type c5tf_u = c5tf_u0;
|
|
type c5tf_st0 = struct { f: c5tf_u, n: i64 };
|
|
type c5tf_st = c5tf_st0;
|
|
|
|
@test fn tfread_2lvl() void = {
|
|
let s: c5tf_st;
|
|
s.f = 42i64;
|
|
s.n = 3;
|
|
assert(s.f is i64);
|
|
let p: *c5tf_st = &s;
|
|
assert(p.f is i64);
|
|
};
|
|
|
|
type c5ln_ms0 = str;
|
|
type c5ln_ms = c5ln_ms0;
|
|
type c5ln_ar0 = [4]i64;
|
|
type c5ln_ar = c5ln_ar0;
|
|
|
|
@test fn len_2lvl() void = {
|
|
let a: c5ln_ms = "hello";
|
|
assert(len(a) == 5);
|
|
let xs: c5ln_ar = [1, 2, 3, 4];
|
|
assert(len(xs) == 4);
|
|
};
|
|
|
|
type c5gr_my64 = i64;
|
|
type c5gr_my64b = c5gr_my64;
|
|
let c5gr_G: c5gr_my64b = 7;
|
|
|
|
@test fn gref_2lvl() void = {
|
|
assert(c5gr_G == 7);
|
|
};
|
|
|
|
type c5mr_big = struct { a: i64, b: i64, c: i64, d: i64, e: i64 };
|
|
type c5mr_m0 = (void | c5mr_big);
|
|
type c5mr_m = c5mr_m0;
|
|
|
|
@test fn memread_40b() void = {
|
|
let s: c5mr_big;
|
|
s.a = 1; s.b = 2; s.c = 3; s.d = 4; s.e = 55;
|
|
let v: c5mr_m = s;
|
|
assert(v is c5mr_big);
|
|
match (v) {
|
|
case let w: c5mr_big => { assert(w.e == 55); };
|
|
case void => { assert(false); };
|
|
};
|
|
};
|