Hojun-Cho
47c7dbc2c8
fold-2 chunk C1 (drew's Fam8-13 plan): 960_opaque_decl_run.c and 962_opaque_assign_cast_run.c were value-row C drivers. Migrate their 3+3 cases to test/lang/opaque_decl_test.ww and opaque_assign_cast_test.ww as @test row-tables. The test-lang byte-id (LANGBYTEID) gate gives cs==ww automatically -- 960 was cstage-only-run before, so this strengthens it. Both byte-id clean, no cs!=ww carve. Retire the 2 C drivers (LANGBYTEID floor 57->59) and repoint a dead comment ref in lib/sort/sort.ww. 961_opaque_guards (reject/guards) stays in C -- fold-3 territory, not in the Fam12 fold-2 worklist.
110 lines
4.8 KiB
Plaintext
110 lines
4.8 KiB
Plaintext
// opaque_assign_cast_test — runtime proof of #108 sub-fold (c): opaque as a
|
|
// type-erasure sink. Two assignability rules + the reinterpret casts sort's
|
|
// implementation relies on. Migrated from test/wcc/962_opaque_assign_cast_run.c.
|
|
//
|
|
// rule 1 `*T -> *opaque` IMPLICIT (no cast). Any pointer is the universal
|
|
// void-pointer. harec type_is_assignable, pointer arm:
|
|
// ref/harec/src/types.c:1053 (`case STORAGE_OPAQUE: break;` — the
|
|
// referent need not match).
|
|
// rule 2 `[]T -> []opaque` IMPLICIT (no cast). Any slice is the type-erased
|
|
// slice; the {ptr,len,cap} header is normal, the byte stride is
|
|
// supplied at runtime (itemsz). harec slice arm: types.c:1094
|
|
// (`if (to_secondary->storage == STORAGE_OPAQUE) return true;`).
|
|
// casts `[]opaque -> *u8` (slice -> byte ptr; cgexpr leaves the ptr in AX,
|
|
// so the cast naturally takes .ptr) and `*opaque -> *u8` /
|
|
// `*opaque -> *i32` (ptr->ptr reinterpret, a no-op). drew described
|
|
// the Hare idiom as `*[*]u8`; ww has no unbounded-array `[*]`, so the
|
|
// ww-faithful reinterpret target is `*u8` + uintptr stride arithmetic.
|
|
//
|
|
// rules 1 & 2 are CSTAGE-led; the wwstage check.ww isassignable is a
|
|
// resolve-only AST approximation that returns "can't tell, stay quiet"
|
|
// (confident=false) for a ptr/slice whose element it cannot match, so it
|
|
// already ACCEPTS every form here. The casts are validation-free in BOTH stages
|
|
// (N_CAST never checks legality). The T2 byte-id floor (LANGBYTEID) carries the
|
|
// cs==ww rule-10 proof directly — opaque is inert on the selfhost corpus so the
|
|
// 990-997 gates never exercise it.
|
|
//
|
|
// Array->[]opaque (harec's array->slice decay) is deliberately EXCLUDED: ww has
|
|
// no implicit array->slice conversion for any element type (a slice is built
|
|
// only via an explicit `a[0:n]`), so there is no array->slice-header cgen.
|
|
//
|
|
// Call results are bound to locals before each assert (the test/lang idiom),
|
|
// not compared inline. The C original avoided an inline `if (f(x) != k)` shape
|
|
// (arg from a prior uintptr-arith call) that a pre-#116-era cgen bug once
|
|
// mis-compiled; that form now compiles correct + cs==ww on HEAD, so the binding
|
|
// is style, not a live workaround. The opaque feature is exercised in full.
|
|
|
|
package opaque_assign_cast_test;
|
|
|
|
fn readi32(p: *opaque) i32 = { let pi: *i32 = p: *i32; return *pi; };
|
|
fn slen(o: []opaque) i32 = { return o.len: i32; };
|
|
fn first(o: []opaque) i32 = { let p: *opaque = o.ptr; let pi: *i32 = p: *i32; return *pi; };
|
|
|
|
fn elemptr(items: []opaque, i: size, itemsz: size) *opaque = {
|
|
let base: *u8 = items: *u8; // []opaque -> *u8 (takes .ptr)
|
|
let off: uintptr = (i * itemsz): uintptr;
|
|
return ((base: uintptr) + off): *opaque;
|
|
};
|
|
|
|
fn swap(items: []opaque, x: size, y: size, itemsz: size) void = {
|
|
let pa: *u8 = elemptr(items, x, itemsz): *u8;
|
|
let pb: *u8 = elemptr(items, y, itemsz): *u8;
|
|
let k: size = 0;
|
|
for (k < itemsz) {
|
|
let qa: *u8 = ((pa: uintptr) + k: uintptr): *u8;
|
|
let qb: *u8 = ((pb: uintptr) + k: uintptr): *u8;
|
|
let t: u8 = *qa;
|
|
*qa = *qb;
|
|
*qb = t;
|
|
k = k + 1;
|
|
};
|
|
};
|
|
|
|
@test fn rule1_implicit_ptr() void = {
|
|
// rule 1: `*T -> *opaque` IMPLICIT (no cast) at a let-init AND a call-arg.
|
|
// Round-trip a real *i32 through *opaque and back, deref.
|
|
let n: i32 = 42;
|
|
let po: *opaque = &n; // let-init *i32 -> *opaque
|
|
let v: i32 = readi32(po);
|
|
let v2: i32 = readi32(&n); // call-arg *i32 -> *opaque
|
|
assert(v == 42);
|
|
assert(v2 == 42);
|
|
};
|
|
|
|
@test fn rule2_implicit_slice() void = {
|
|
// rule 2: `[]T -> []opaque` IMPLICIT (no cast) at a let-init AND a call-arg.
|
|
// Read .len, round-trip .ptr (a *opaque) back to *i32.
|
|
let a: [4]i32 = [11, 22, 33, 44];
|
|
let s: []i32 = a[0:4];
|
|
let o: []opaque = s; // let-init []i32 -> []opaque
|
|
let n: i32 = slen(o);
|
|
let n2: i32 = slen(s); // call-arg []i32 -> []opaque
|
|
assert(n == 4);
|
|
assert(n2 == 4);
|
|
let f: i32 = first(s);
|
|
assert(f == 11);
|
|
};
|
|
|
|
@test fn sort_pattern() void = {
|
|
// sort's actual usage end-to-end: a `fn(items: []opaque, itemsz: size)`
|
|
// called with a []i32; inside, reinterpret the slice as a byte base
|
|
// (`items: *u8`), uintptr-arith two element addresses, byte-swap them by
|
|
// itemsz. Then read back through the *opaque element path and the original
|
|
// []i32 view — the type erasure round-trips iff both agree.
|
|
let a: [4]i32 = [10, 20, 30, 40];
|
|
let s: []i32 = a[0:4];
|
|
swap(s, 0: size, 3: size, size(i32)); // []i32 -> []opaque call-arg
|
|
assert(a[0] == 40); // erased swap round-trips
|
|
assert(a[3] == 10);
|
|
let p0: *opaque = elemptr(s, 0: size, size(i32));
|
|
let v0: i32 = readi32(p0);
|
|
assert(v0 == 40);
|
|
let nn: i32 = 77;
|
|
let pn: *opaque = &nn; // *i32 -> *opaque let-init
|
|
let vn: i32 = readi32(pn);
|
|
assert(vn == 77);
|
|
let o: []opaque = s;
|
|
let ol: i32 = o.len: i32;
|
|
assert(ol == 4);
|
|
};
|