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.
1454 lines
37 KiB
Plaintext
1454 lines
37 KiB
Plaintext
// Tuple arc layout SSoT (user-ratified): the tuple
|
|
// SLOT layout (str/slice = 24B header, everything else one 8B eightbyte;
|
|
// tagged = roundup8(size(elem))) is the single source of truth the checker
|
|
// size, the cgen cursor transports, and the t.N read walk all agree on.
|
|
// Migrated from test/wcc/941_tuple_slot_layout_run.c — the value rows become
|
|
// @test fns here (T1 `ww test` runs the runtime asserts; T2 test-lang-byteid
|
|
// keeps cs==ww); the reject rows become fold-3 //ww:error carriers under
|
|
// test/wcc/data/tslot_*/. Never-taken match arms / failure-checks that were
|
|
// `return K` become assert(false) / assert(!(COND)).
|
|
//
|
|
// Helper fns and types are suffixed with the row label to keep each migrated
|
|
// `package main` row's decls collision-free at this single file scope.
|
|
|
|
package tuple_slot_layout_test;
|
|
|
|
fn f_letcall_packed() (u32, u32) = {
|
|
return (3, 4);
|
|
};
|
|
|
|
@test fn letcall_packed() void = {
|
|
let t: (u32, u32) = f_letcall_packed();
|
|
assert(!(t.0 != 3));
|
|
assert(!(t.1 != 4));
|
|
};
|
|
|
|
fn f_letcall_float_packed() (u32, f64) = {
|
|
let a: u32 = 9;
|
|
let x: f64 = 2.5;
|
|
return (a, x);
|
|
};
|
|
|
|
@test fn letcall_float_packed() void = {
|
|
let t: (u32, f64) = f_letcall_float_packed();
|
|
assert(!(t.0 != 9));
|
|
assert(!(t.1 != 2.5));
|
|
};
|
|
|
|
fn f_letcall_signed_packed() (i32, i32) = {
|
|
let a: i32 = -5;
|
|
let b: i32 = -6;
|
|
return (a, b);
|
|
};
|
|
|
|
@test fn letcall_signed_packed() void = {
|
|
let t: (i32, i32) = f_letcall_signed_packed();
|
|
assert(!(t.0 != -5));
|
|
assert(!(t.1 != -6));
|
|
assert(!(t.0 + t.1 != -11));
|
|
};
|
|
|
|
fn f_letcall_mixed_packed() (u32, str) = {
|
|
let a: u32 = 7;
|
|
let s: str = "hello";
|
|
return (a, s);
|
|
};
|
|
|
|
@test fn letcall_mixed_packed() void = {
|
|
let t: (u32, str) = f_letcall_mixed_packed();
|
|
assert(!(t.0 != 7));
|
|
assert(!(len(t.1) != 5));
|
|
};
|
|
|
|
fn f_letcall_16_neutral() (i64, i64) = {
|
|
return (41, 17);
|
|
};
|
|
|
|
@test fn letcall_16_neutral() void = {
|
|
let t: (i64, i64) = f_letcall_16_neutral();
|
|
assert(!(t.0 != 41));
|
|
assert(!(t.1 != 17));
|
|
};
|
|
|
|
fn f_letcall_32_neutral() (i64, str) = {
|
|
let a: i64 = 12;
|
|
let s: str = "wxyz";
|
|
return (a, s);
|
|
};
|
|
|
|
@test fn letcall_32_neutral() void = {
|
|
let t: (i64, str) = f_letcall_32_neutral();
|
|
assert(!(t.0 != 12));
|
|
assert(!(len(t.1) != 4));
|
|
};
|
|
|
|
fn f_mlet_packed_neutral() (u32, u32) = {
|
|
return (3, 4);
|
|
};
|
|
|
|
@test fn mlet_packed_neutral() void = {
|
|
let (a, b) = f_mlet_packed_neutral();
|
|
assert(!(a != 3));
|
|
assert(!(b != 4));
|
|
};
|
|
|
|
@test fn c0_sizefold_slot() void = {
|
|
assert(!(size((u32, u32)) != 16));
|
|
assert(!(size((size, size)) != 16));
|
|
assert(!(size((u32, str)) != 32));
|
|
assert(!(size((str, str)) != 48));
|
|
assert(!(align((u32, u32)) != 4));
|
|
};
|
|
|
|
type holder_c0_sizefold_recursive = struct { t: (u32, u32), x: i64 };
|
|
|
|
@test fn c0_sizefold_recursive() void = {
|
|
assert(!(size(holder_c0_sizefold_recursive) != 24));
|
|
assert(!(size([4](u32, u32)) != 64));
|
|
};
|
|
|
|
@test fn t22_sizefold_tagged() void = {
|
|
assert(!(size(((void | size), size)) != 24));
|
|
assert(!(size((size, (void | size))) != 24));
|
|
assert(!(size(((void | size), (void | size), size)) != 40));
|
|
assert(!(align(((void | size), size)) != 8));
|
|
assert(!(size((u64, void)) != 8));
|
|
};
|
|
|
|
fn mk_t22_roundtrip() ((void | size), size) = {
|
|
let mn: (void | size) = 5: size;
|
|
return (mn, 4);
|
|
};
|
|
|
|
fn mk2_t22_roundtrip() (size, (void | size)) = {
|
|
let mx: (void | size) = 7: size;
|
|
return (9, mx);
|
|
};
|
|
|
|
fn mkv_t22_roundtrip() ((void | size), size) = {
|
|
let mn: (void | size) = void;
|
|
return (mn, 3);
|
|
};
|
|
|
|
@test fn t22_roundtrip() void = {
|
|
let t = mk_t22_roundtrip();
|
|
assert(!(!(t.0 is size)));
|
|
assert(!(t.0 as size != 5));
|
|
assert(!(t.1 != 4));
|
|
let u = mk2_t22_roundtrip();
|
|
assert(!(u.0 != 9));
|
|
assert(!(!(u.1 is size)));
|
|
assert(!(u.1 as size != 7));
|
|
let v = mkv_t22_roundtrip();
|
|
assert(!(!(v.0 is void)));
|
|
assert(!(v.1 != 3));
|
|
let (a, b) = mk_t22_roundtrip();
|
|
assert(!(!(a is size)));
|
|
assert(!(a as size != 5));
|
|
assert(!(b != 4));
|
|
let mn: (void | size) = 6: size;
|
|
let w: ((void | size), size) = (mn, 2);
|
|
assert(!(!(w.0 is size)));
|
|
assert(!(w.0 as size != 6));
|
|
assert(!(w.1 != 2));
|
|
};
|
|
|
|
fn mk_t22_float_mix() (f64, (void | size), i64) = {
|
|
let mn: (void | size) = 6: size;
|
|
return (2.5, mn, 9);
|
|
};
|
|
|
|
@test fn t22_float_mix() void = {
|
|
let t = mk_t22_float_mix();
|
|
assert(!(t.0 != 2.5));
|
|
assert(!(!(t.1 is size)));
|
|
assert(!(t.1 as size != 6));
|
|
assert(!(t.2 != 9));
|
|
let (x, y, z) = mk_t22_float_mix();
|
|
assert(!(x != 2.5));
|
|
assert(!(!(y is size)));
|
|
assert(!(y as size != 6));
|
|
assert(!(z != 9));
|
|
};
|
|
|
|
fn mk_t22_two_tagged() ((void | u32), (void | i64)) = {
|
|
let a: (void | u32) = 9: u32;
|
|
let b: (void | i64) = -5: i64;
|
|
return (a, b);
|
|
};
|
|
|
|
fn mkv_t22_two_tagged() ((void | u32), (void | i64)) = {
|
|
let a: (void | u32) = void;
|
|
let b: (void | i64) = -41: i64;
|
|
return (a, b);
|
|
};
|
|
|
|
@test fn t22_two_tagged() void = {
|
|
let t = mk_t22_two_tagged();
|
|
assert(!(!(t.0 is u32)));
|
|
assert(!(t.0 as u32 != 9));
|
|
assert(!(!(t.1 is i64)));
|
|
assert(!(t.1 as i64 != -5));
|
|
let v = mkv_t22_two_tagged();
|
|
assert(!(!(v.0 is void)));
|
|
assert(!(v.1 as i64 != -41));
|
|
let (a, b) = mk_t22_two_tagged();
|
|
assert(!(a as u32 != 9));
|
|
assert(!(b as i64 != -5));
|
|
};
|
|
|
|
fn mk_t22_float_mix_rev() ((void | size), f64) = {
|
|
let mn: (void | size) = 6: size;
|
|
return (mn, 0.25);
|
|
};
|
|
|
|
@test fn t22_float_mix_rev() void = {
|
|
let t = mk_t22_float_mix_rev();
|
|
assert(!(!(t.0 is size)));
|
|
assert(!(t.0 as size != 6));
|
|
assert(!(t.1 != 0.25));
|
|
let (y, z) = mk_t22_float_mix_rev();
|
|
assert(!(y as size != 6));
|
|
assert(!(z != 0.25));
|
|
};
|
|
|
|
fn takes_t22_elem_arg(v: (void | size)) size = {
|
|
if (v is size) { return v as size; };
|
|
return 0;
|
|
};
|
|
|
|
@test fn t22_elem_arg() void = {
|
|
let mn: (void | size) = 5: size;
|
|
let t: ((void | size), size) = (mn, 4);
|
|
assert(!(takes_t22_elem_arg(t.0) != 5));
|
|
assert(!(takes_t22_elem_arg(t.0) + t.1 != 9));
|
|
};
|
|
|
|
fn pr_b22_parse_repetition() ((void | size), (void | size), size) = {
|
|
let mn: (void | size) = void;
|
|
let mx: (void | size) = 5: size;
|
|
mn = 3: size;
|
|
return (mn, mx, 9);
|
|
};
|
|
|
|
@test fn b22_parse_repetition() void = {
|
|
let t = pr_b22_parse_repetition();
|
|
assert(!(!(t.0 is size)));
|
|
assert(!(t.0 as size != 3));
|
|
assert(!(!(t.1 is size)));
|
|
assert(!(t.1 as size != 5));
|
|
assert(!(t.2 != 9));
|
|
let (a, b, n) = pr_b22_parse_repetition();
|
|
assert(!(a as size != 3));
|
|
assert(!(b as size != 5));
|
|
assert(!(n != 9));
|
|
let a2: (void | size) = void;
|
|
let b2: (void | size) = void;
|
|
let n2: size = 0;
|
|
a2, b2, n2 = pr_b22_parse_repetition();
|
|
assert(!(a2 as size != 3));
|
|
assert(!(b2 as size != 5));
|
|
assert(!(n2 != 9));
|
|
};
|
|
|
|
fn ph_b22_head_mid_tail() ((void | size), size, size, size, size) = {
|
|
let a: (void | size) = 11: size;
|
|
return (a, 1, 2, 3, 4);
|
|
};
|
|
|
|
fn pm_b22_head_mid_tail() (size, size, (void | size), size, size) = {
|
|
let a: (void | size) = 12: size;
|
|
return (1, 2, a, 3, 4);
|
|
};
|
|
|
|
fn pt_b22_head_mid_tail() (size, size, size, size, (void | size)) = {
|
|
let a: (void | size) = 13: size;
|
|
return (1, 2, 3, 4, a);
|
|
};
|
|
|
|
fn pv_b22_head_mid_tail() ((void | size), (void | size), size) = {
|
|
let a: (void | size) = void;
|
|
let b: (void | size) = void;
|
|
return (a, b, 9);
|
|
};
|
|
|
|
@test fn b22_head_mid_tail() void = {
|
|
let h = ph_b22_head_mid_tail();
|
|
assert(!(h.0 as size != 11));
|
|
assert(!(h.4 != 4));
|
|
let m = pm_b22_head_mid_tail();
|
|
assert(!(m.0 != 1));
|
|
assert(!(m.2 as size != 12));
|
|
assert(!(m.4 != 4));
|
|
let t = pt_b22_head_mid_tail();
|
|
assert(!(t.3 != 4));
|
|
assert(!(t.4 as size != 13));
|
|
let v = pv_b22_head_mid_tail();
|
|
assert(!(!(v.0 is void)));
|
|
assert(!(!(v.1 is void)));
|
|
assert(!(v.2 != 9));
|
|
let (x, y, z) = v;
|
|
assert(!(!(x is void)));
|
|
assert(!(!(y is void)));
|
|
assert(!(z != 9));
|
|
};
|
|
|
|
fn pr_b22_str_tagged_mix() (str, (void | size), size, size) = {
|
|
let mid: (void | size) = 4: size;
|
|
return ("hello", mid, 6, 7);
|
|
};
|
|
|
|
@test fn b22_str_tagged_mix() void = {
|
|
let t = pr_b22_str_tagged_mix();
|
|
assert(!(t.0.len != 5));
|
|
assert(!(t.1 as size != 4));
|
|
assert(!(t.2 != 6));
|
|
assert(!(t.3 != 7));
|
|
};
|
|
|
|
fn pr_b22_sse_mix() ((void | size), f64, f64, f64) = {
|
|
let a: (void | size) = 6: size;
|
|
return (a, 1.5, 2.5, 3.5);
|
|
};
|
|
|
|
@test fn b22_sse_mix() void = {
|
|
let t = pr_b22_sse_mix();
|
|
assert(!(t.0 as size != 6));
|
|
assert(!(t.1 != 1.5));
|
|
assert(!(t.2 != 2.5));
|
|
assert(!(t.3 != 3.5));
|
|
let (a, x, y, z) = pr_b22_sse_mix();
|
|
assert(!(a as size != 6));
|
|
assert(!(x != 1.5));
|
|
assert(!(y != 2.5));
|
|
assert(!(z != 3.5));
|
|
};
|
|
|
|
fn pr_b22_underscore_skip() ((void | size), (void | size), size) = {
|
|
let mn: (void | size) = 3: size;
|
|
let mx: (void | size) = 5: size;
|
|
return (mn, mx, 9);
|
|
};
|
|
|
|
@test fn b22_underscore_skip() void = {
|
|
let a: (void | size) = void;
|
|
let n: size = 0;
|
|
a, _, n = pr_b22_underscore_skip();
|
|
assert(!(a as size != 3));
|
|
assert(!(n != 9));
|
|
let (q, _, r) = pr_b22_underscore_skip();
|
|
assert(!(q as size != 3));
|
|
assert(!(r != 9));
|
|
};
|
|
|
|
type four_c37_big_box_t0_read = struct { a: u64, b: u64, c: u64, d: u64, };
|
|
|
|
fn g_c37_big_box_t0_read() (void | four_c37_big_box_t0_read) = {
|
|
let v: four_c37_big_box_t0_read = four_c37_big_box_t0_read{a=1u64, b=2u64, c=3u64, d=4u64};
|
|
return v;
|
|
};
|
|
|
|
fn pr_c37_big_box_t0_read() ((void | four_c37_big_box_t0_read), size) = {
|
|
let e: (void | four_c37_big_box_t0_read) = g_c37_big_box_t0_read();
|
|
return (e, 7);
|
|
};
|
|
|
|
@test fn c37_big_box_t0_read() void = {
|
|
let t = pr_c37_big_box_t0_read();
|
|
assert(!(t.1 != 7));
|
|
assert(!(!(t.0 is four_c37_big_box_t0_read)));
|
|
match (t.0) {
|
|
case let f: four_c37_big_box_t0_read => {
|
|
assert(!(f.a != 1));
|
|
assert(!(f.b != 2));
|
|
assert(!(f.c != 3));
|
|
assert(!(f.d != 4));
|
|
};
|
|
case void => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type inst_lit_c37_idx_match_56 = rune;
|
|
type inst_repeat_c37_idx_match_56 = struct {
|
|
id: size,
|
|
origin: size,
|
|
min: (void | size),
|
|
max: (void | size),
|
|
};
|
|
type inst_c37_idx_match_56 = (inst_lit_c37_idx_match_56 | inst_repeat_c37_idx_match_56);
|
|
|
|
@test fn c37_idx_match_56() void = {
|
|
let insts: []inst_c37_idx_match_56 = [];
|
|
let r = inst_repeat_c37_idx_match_56{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
|
|
append(insts, r);
|
|
append(insts, ('A': inst_lit_c37_idx_match_56));
|
|
let pc: size = 0;
|
|
match (insts[pc]) {
|
|
case let ir: inst_repeat_c37_idx_match_56 => {
|
|
assert(!(ir.id != 7));
|
|
assert(!(ir.origin != 3));
|
|
assert(!(!(ir.min is size)));
|
|
assert(!(ir.min as size != 11));
|
|
assert(!(!(ir.max is size)));
|
|
assert(!(ir.max as size != 22));
|
|
};
|
|
case let l: inst_lit_c37_idx_match_56 => { assert(false); };
|
|
};
|
|
match (insts[1]) {
|
|
case let l: inst_lit_c37_idx_match_56 => {
|
|
assert(!(l != 'A'));
|
|
};
|
|
case let ir: inst_repeat_c37_idx_match_56 => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type lit2_c37_idx_match_str_nested = rune;
|
|
type rep2_c37_idx_match_str_nested = struct {
|
|
name: str,
|
|
min: (void | size),
|
|
max: (void | size),
|
|
};
|
|
type in2_c37_idx_match_str_nested = (lit2_c37_idx_match_str_nested | rep2_c37_idx_match_str_nested);
|
|
|
|
@test fn c37_idx_match_str_nested() void = {
|
|
let xs: []in2_c37_idx_match_str_nested = [];
|
|
let r = rep2_c37_idx_match_str_nested{name="deadbeef", min=(2: size), max=(5: size)};
|
|
append(xs, r);
|
|
match (xs[0]) {
|
|
case let v: rep2_c37_idx_match_str_nested => {
|
|
assert(!(v.name.len != 8));
|
|
assert(!(v.name[0] != 'd'));
|
|
assert(!(v.name[7] != 'f'));
|
|
assert(!(!(v.min is size)));
|
|
assert(!(v.min as size != 2));
|
|
assert(!(v.max as size != 5));
|
|
};
|
|
case let l: lit2_c37_idx_match_str_nested => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type inst_lit_c37_idx_let_is_assign = rune;
|
|
type inst_repeat_c37_idx_let_is_assign = struct {
|
|
id: size,
|
|
origin: size,
|
|
min: (void | size),
|
|
max: (void | size),
|
|
};
|
|
type inst_c37_idx_let_is_assign = (inst_lit_c37_idx_let_is_assign | inst_repeat_c37_idx_let_is_assign);
|
|
|
|
@test fn c37_idx_let_is_assign() void = {
|
|
let insts: []inst_c37_idx_let_is_assign = [];
|
|
let r = inst_repeat_c37_idx_let_is_assign{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
|
|
append(insts, r);
|
|
append(insts, ('A': inst_lit_c37_idx_let_is_assign));
|
|
assert(!(!(insts[0] is inst_repeat_c37_idx_let_is_assign)));
|
|
assert(!(insts[0] is inst_lit_c37_idx_let_is_assign));
|
|
let w = insts[0];
|
|
match (w) {
|
|
case let ir: inst_repeat_c37_idx_let_is_assign => {
|
|
assert(!(ir.max as size != 22));
|
|
};
|
|
case let l: inst_lit_c37_idx_let_is_assign => { assert(false); };
|
|
};
|
|
w = insts[1];
|
|
assert(!(!(w is inst_lit_c37_idx_let_is_assign)));
|
|
w = insts[0];
|
|
match (w) {
|
|
case let ir: inst_repeat_c37_idx_let_is_assign => {
|
|
assert(!(ir.min as size != 11));
|
|
};
|
|
case let l: inst_lit_c37_idx_let_is_assign => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type inst_lit_c37_idx_return = rune;
|
|
type inst_repeat_c37_idx_return = struct {
|
|
id: size,
|
|
origin: size,
|
|
min: (void | size),
|
|
max: (void | size),
|
|
};
|
|
type inst_c37_idx_return = (inst_lit_c37_idx_return | inst_repeat_c37_idx_return);
|
|
|
|
fn pick_c37_idx_return(insts: []inst_c37_idx_return, pc: size) inst_c37_idx_return = {
|
|
return insts[pc];
|
|
};
|
|
|
|
@test fn c37_idx_return() void = {
|
|
let insts: []inst_c37_idx_return = [];
|
|
let r = inst_repeat_c37_idx_return{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
|
|
append(insts, r);
|
|
let w = pick_c37_idx_return(insts, 0);
|
|
match (w) {
|
|
case let ir: inst_repeat_c37_idx_return => {
|
|
assert(!(ir.id != 7));
|
|
assert(!(ir.min as size != 11));
|
|
};
|
|
case let l: inst_lit_c37_idx_return => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type inst_lit_c37_widen_and_memarg = rune;
|
|
type inst_repeat_c37_widen_and_memarg = struct {
|
|
id: size,
|
|
origin: size,
|
|
min: (void | size),
|
|
max: (void | size),
|
|
};
|
|
type inst_c37_widen_and_memarg = (inst_lit_c37_widen_and_memarg | inst_repeat_c37_widen_and_memarg);
|
|
type wide_c37_widen_and_memarg = (inst_lit_c37_widen_and_memarg | inst_repeat_c37_widen_and_memarg | str);
|
|
|
|
fn idof_c37_widen_and_memarg(i: inst_c37_widen_and_memarg) size = {
|
|
match (i) {
|
|
case let ir: inst_repeat_c37_widen_and_memarg => { return ir.id; };
|
|
case let l: inst_lit_c37_widen_and_memarg => { return 999; };
|
|
};
|
|
return 998;
|
|
};
|
|
|
|
@test fn c37_widen_and_memarg() void = {
|
|
let insts: []inst_c37_widen_and_memarg = [];
|
|
let r = inst_repeat_c37_widen_and_memarg{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
|
|
append(insts, r);
|
|
let w: wide_c37_widen_and_memarg = insts[0];
|
|
match (w) {
|
|
case let ir: inst_repeat_c37_widen_and_memarg => {
|
|
assert(!(ir.max as size != 22));
|
|
};
|
|
case let l: inst_lit_c37_widen_and_memarg => { assert(false); };
|
|
case let s2: str => { assert(false); };
|
|
};
|
|
assert(!(idof_c37_widen_and_memarg(insts[0]) != 7));
|
|
};
|
|
|
|
type inst_lit_c37_widen_remap = rune;
|
|
type inst_repeat_c37_widen_remap = struct {
|
|
id: size,
|
|
origin: size,
|
|
min: (void | size),
|
|
max: (void | size),
|
|
};
|
|
type rev_c37_widen_remap = (inst_repeat_c37_widen_remap | inst_lit_c37_widen_remap);
|
|
type wide_c37_widen_remap = (inst_lit_c37_widen_remap | inst_repeat_c37_widen_remap | str);
|
|
|
|
@test fn c37_widen_remap() void = {
|
|
let xs: []rev_c37_widen_remap = [];
|
|
let r = inst_repeat_c37_widen_remap{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
|
|
append(xs, r);
|
|
let w: wide_c37_widen_remap = xs[0];
|
|
match (w) {
|
|
case let ir: inst_repeat_c37_widen_remap => {
|
|
assert(!(ir.id != 7));
|
|
assert(!(!(ir.max is size)));
|
|
assert(!(ir.max as size != 22));
|
|
};
|
|
case let l: inst_lit_c37_widen_remap => { assert(false); };
|
|
case let s2: str => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type st_c37_x1_compose = struct { a: size, m: (void | size), };
|
|
|
|
fn pr_c37_x1_compose() ((void | st_c37_x1_compose), size, size) = {
|
|
let e: (void | st_c37_x1_compose) = st_c37_x1_compose{a=4: size, m=(2: size)};
|
|
return (e, 5, 6);
|
|
};
|
|
|
|
@test fn c37_x1_compose() void = {
|
|
let t = pr_c37_x1_compose();
|
|
assert(!(!(t.0 is st_c37_x1_compose)));
|
|
match (t.0) {
|
|
case let v: st_c37_x1_compose => {
|
|
assert(!(v.a != 4));
|
|
assert(!(!(v.m is size)));
|
|
assert(!(v.m as size != 2));
|
|
};
|
|
case void => { assert(false); };
|
|
};
|
|
assert(!(t.1 != 5));
|
|
assert(!(t.2 != 6));
|
|
};
|
|
|
|
type box_c37_idx_at_cap = (void | str);
|
|
|
|
@test fn c37_idx_at_cap() void = {
|
|
let bs: []box_c37_idx_at_cap = [];
|
|
let s: str = "abcdefgh";
|
|
append(bs, s);
|
|
match (bs[0]) {
|
|
case let v: str => {
|
|
assert(!(v.len != 8));
|
|
};
|
|
case void => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type inst_lit_c37_ptr_field_match = rune;
|
|
type inst_repeat_c37_ptr_field_match = struct {
|
|
id: size,
|
|
origin: size,
|
|
min: (void | size),
|
|
max: (void | size),
|
|
};
|
|
type inst_c37_ptr_field_match = (inst_lit_c37_ptr_field_match | inst_repeat_c37_ptr_field_match);
|
|
type holder_c37_ptr_field_match = struct { pre: size, f: inst_c37_ptr_field_match, };
|
|
|
|
@test fn c37_ptr_field_match() void = {
|
|
let g = holder_c37_ptr_field_match{pre=9: size, f=inst_repeat_c37_ptr_field_match{id=7: size, origin=3: size, min=(11: size), max=(55: size)}};
|
|
let p = &g;
|
|
assert(!(!(p.f is inst_repeat_c37_ptr_field_match)));
|
|
match (p.f) {
|
|
case let ir: inst_repeat_c37_ptr_field_match => {
|
|
assert(!(ir.id != 7));
|
|
assert(!(ir.max as size != 55));
|
|
};
|
|
case let l: inst_lit_c37_ptr_field_match => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type inst_lit_c37_deref_idx_match = rune;
|
|
type inst_repeat_c37_deref_idx_match = struct {
|
|
id: size,
|
|
origin: size,
|
|
min: (void | size),
|
|
max: (void | size),
|
|
};
|
|
type inst_c37_deref_idx_match = (inst_lit_c37_deref_idx_match | inst_repeat_c37_deref_idx_match);
|
|
|
|
@test fn c37_deref_idx_match() void = {
|
|
let insts: []inst_c37_deref_idx_match = [];
|
|
let r = inst_repeat_c37_deref_idx_match{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
|
|
append(insts, r);
|
|
let p = &insts;
|
|
match ((*p)[0]) {
|
|
case let ir: inst_repeat_c37_deref_idx_match => {
|
|
assert(!(ir.id != 7));
|
|
assert(!(ir.max as size != 22));
|
|
};
|
|
case let l: inst_lit_c37_deref_idx_match => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type inst_lit_fc_deref_56_slice_let = rune;
|
|
type inst_repeat_fc_deref_56_slice_let = struct {
|
|
id: size,
|
|
origin: size,
|
|
min: (void | size),
|
|
max: (void | size),
|
|
};
|
|
type inst_fc_deref_56_slice_let = (inst_lit_fc_deref_56_slice_let | inst_repeat_fc_deref_56_slice_let);
|
|
|
|
@test fn fc_deref_56_slice_let() void = {
|
|
let insts: []inst_fc_deref_56_slice_let = [];
|
|
let r = inst_repeat_fc_deref_56_slice_let{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
|
|
append(insts, r);
|
|
let p = &insts[0];
|
|
let w = *p;
|
|
assert(!(!(w is inst_repeat_fc_deref_56_slice_let)));
|
|
match (w) {
|
|
case let ir: inst_repeat_fc_deref_56_slice_let => {
|
|
assert(!(ir.id != 7 || ir.origin != 3));
|
|
assert(!((ir.min as size) != 11));
|
|
assert(!((ir.max as size) != 22));
|
|
};
|
|
case let l: inst_lit_fc_deref_56_slice_let => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type inst_lit_fc_deref_56_slice_match = rune;
|
|
type inst_repeat_fc_deref_56_slice_match = struct {
|
|
id: size,
|
|
origin: size,
|
|
min: (void | size),
|
|
max: (void | size),
|
|
};
|
|
type inst_fc_deref_56_slice_match = (inst_lit_fc_deref_56_slice_match | inst_repeat_fc_deref_56_slice_match);
|
|
|
|
@test fn fc_deref_56_slice_match() void = {
|
|
let insts: []inst_fc_deref_56_slice_match = [];
|
|
let r = inst_repeat_fc_deref_56_slice_match{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
|
|
append(insts, r);
|
|
let p = &insts[0];
|
|
match (*p) {
|
|
case let ir: inst_repeat_fc_deref_56_slice_match => {
|
|
assert(!(ir.id != 7));
|
|
assert(!(!(ir.min is size)));
|
|
assert(!((ir.max as size) != 22));
|
|
};
|
|
case let l: inst_lit_fc_deref_56_slice_match => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type four_b22_big_box_mlet = struct { a: u64, b: u64, c: u64, d: u64, };
|
|
|
|
fn g_b22_big_box_mlet() (void | four_b22_big_box_mlet) = {
|
|
let v: four_b22_big_box_mlet = four_b22_big_box_mlet{a=1u64, b=2u64, c=3u64, d=4u64};
|
|
return v;
|
|
};
|
|
|
|
fn pr_b22_big_box_mlet() ((void | four_b22_big_box_mlet), size) = {
|
|
let e: (void | four_b22_big_box_mlet) = g_b22_big_box_mlet();
|
|
return (e, 7);
|
|
};
|
|
|
|
@test fn b22_big_box_mlet() void = {
|
|
let e2 = g_b22_big_box_mlet();
|
|
assert(!(!(e2 is four_b22_big_box_mlet)));
|
|
let (e, n) = pr_b22_big_box_mlet();
|
|
assert(!(n != 7));
|
|
assert(!(!(e is four_b22_big_box_mlet)));
|
|
};
|
|
|
|
fn mk_b22_void_elem_k4() (void, size, size, size, size, size) = {
|
|
return (void, 1, 2, 3, 4, 5);
|
|
};
|
|
|
|
@test fn b22_void_elem_k4() void = {
|
|
let (v, a, b, c, d, e) = mk_b22_void_elem_k4();
|
|
assert(!(a != 1));
|
|
assert(!(b != 2));
|
|
assert(!(c != 3));
|
|
assert(!(d != 4));
|
|
assert(!(e != 5));
|
|
};
|
|
|
|
fn mk_b22_k5_box_at_cap() ((void | str), size, size) = {
|
|
let m: (void | str) = "boundary";
|
|
return (m, 5, 6);
|
|
};
|
|
|
|
@test fn b22_k5_box_at_cap() void = {
|
|
let t = mk_b22_k5_box_at_cap();
|
|
assert(!(!(t.0 is str)));
|
|
match (t.0) {
|
|
case let s: str => {
|
|
assert(!(s.len != 8));
|
|
};
|
|
case void => { assert(false); };
|
|
};
|
|
assert(!(t.1 != 5));
|
|
assert(!(t.2 != 6));
|
|
};
|
|
|
|
fn pr_b22_both_tagged_2elem() ((void | str), (void | size)) = {
|
|
let a: (void | str) = "boundary";
|
|
let b: (void | size) = 7: size;
|
|
return (a, b);
|
|
};
|
|
|
|
@test fn b22_both_tagged_2elem() void = {
|
|
let t = pr_b22_both_tagged_2elem();
|
|
assert(!(!(t.0 is str)));
|
|
match (t.0) {
|
|
case let s: str => { assert(!(s.len != 8)); };
|
|
case void => { assert(false); };
|
|
};
|
|
assert(!(!(t.1 is size)));
|
|
assert(!(t.1 as size != 7));
|
|
let (x, y) = pr_b22_both_tagged_2elem();
|
|
assert(!(!(x is str)));
|
|
assert(!(y as size != 7));
|
|
};
|
|
|
|
fn g_b22_chained_sret() ((void | size), (void | size), size) = {
|
|
let mn: (void | size) = 3: size;
|
|
let mx: (void | size) = 5: size;
|
|
return (mn, mx, 9);
|
|
};
|
|
|
|
fn h_b22_chained_sret() ((void | size), (void | size), size) = {
|
|
let (a, b, n) = g_b22_chained_sret();
|
|
return (a, b, n + 1);
|
|
};
|
|
|
|
@test fn b22_chained_sret() void = {
|
|
let t = h_b22_chained_sret();
|
|
assert(!(t.0 as size != 3));
|
|
assert(!(t.1 as size != 5));
|
|
assert(!(t.2 != 10));
|
|
};
|
|
|
|
fn f_sret_narrow_mix_let() (str, u32, str) = {
|
|
let a: str = "abc";
|
|
let b: u32 = 7;
|
|
let c: str = "wxyz";
|
|
return (a, b, c);
|
|
};
|
|
|
|
@test fn sret_narrow_mix_let() void = {
|
|
let t = f_sret_narrow_mix_let();
|
|
assert(!(len(t.0) != 3));
|
|
assert(!(t.1 != 7));
|
|
assert(!(len(t.2) != 4));
|
|
};
|
|
|
|
fn f_sret_narrow_mix_mlet() (str, u32, str) = {
|
|
let a: str = "abc";
|
|
let b: u32 = 7;
|
|
let c: str = "wxyz";
|
|
return (a, b, c);
|
|
};
|
|
|
|
@test fn sret_narrow_mix_mlet() void = {
|
|
let (a, b, c) = f_sret_narrow_mix_mlet();
|
|
assert(!(len(a) != 3));
|
|
assert(!(b != 7));
|
|
assert(!(len(c) != 4));
|
|
};
|
|
|
|
fn f_sret_narrow_mix_massign() (str, u32, str) = {
|
|
let a: str = "abc";
|
|
let b: u32 = 7;
|
|
let c: str = "wxyz";
|
|
return (a, b, c);
|
|
};
|
|
|
|
@test fn sret_narrow_mix_massign() void = {
|
|
let a: str = "";
|
|
let b: u32 = 0;
|
|
let c: str = "";
|
|
a, b, c = f_sret_narrow_mix_massign();
|
|
assert(!(len(a) != 3));
|
|
assert(!(b != 7));
|
|
assert(!(len(c) != 4));
|
|
};
|
|
|
|
fn second_t1_lit_packed() u32 = {
|
|
let t: (u32, u32) = (3, 4);
|
|
if (t.0 != 3) { return 99; };
|
|
return t.1;
|
|
};
|
|
|
|
@test fn t1_lit_packed() void = {
|
|
assert(!(second_t1_lit_packed() != 4));
|
|
};
|
|
|
|
@test fn t1_lit_16() void = {
|
|
let t: (i64, i64) = (3, 4);
|
|
assert(!(t.0 != 3));
|
|
assert(!(t.1 != 4));
|
|
};
|
|
|
|
@test fn t1_lit_mixed() void = {
|
|
let t: (i64, str) = (12, "wxyz");
|
|
assert(!(t.0 != 12));
|
|
assert(!(len(t.1) != 4));
|
|
};
|
|
|
|
fn second_t1_lit_3scalar() i64 = {
|
|
let t: (i64, i64, i64) = (3, 4, 5);
|
|
if (t.0 != 3) { return -1; };
|
|
if (t.1 != 4) { return -2; };
|
|
return t.2;
|
|
};
|
|
|
|
@test fn t1_lit_3scalar() void = {
|
|
assert(!(second_t1_lit_3scalar() != 5));
|
|
};
|
|
|
|
fn f_t1_call_3scalar() (i64, i64, i64) = {
|
|
return (7, 8, 9);
|
|
};
|
|
|
|
@test fn t1_call_3scalar() void = {
|
|
let t: (i64, i64, i64) = f_t1_call_3scalar();
|
|
assert(!(t.0 != 7));
|
|
assert(!(t.1 != 8));
|
|
assert(!(t.2 != 9));
|
|
};
|
|
|
|
fn f_t1_call_noannot_neutral() (i64, i64) = {
|
|
return (3, 4);
|
|
};
|
|
|
|
@test fn t1_call_noannot_neutral() void = {
|
|
let t = f_t1_call_noannot_neutral();
|
|
assert(!(t.0 != 3));
|
|
assert(!(t.1 != 4));
|
|
};
|
|
|
|
fn pick_t2_param_packed(t: (u32, u32), k: i32) u32 = {
|
|
if (k == 0) { return t.0; };
|
|
return t.1;
|
|
};
|
|
|
|
@test fn t2_param_packed() void = {
|
|
let t: (u32, u32) = (41, 17);
|
|
assert(!(pick_t2_param_packed(t, 0) != 41));
|
|
assert(!(pick_t2_param_packed(t, 1) != 17));
|
|
};
|
|
|
|
fn pick_t2_param_16(t: (i64, i64), k: i32) i64 = {
|
|
if (k == 0) { return t.0; };
|
|
return t.1;
|
|
};
|
|
|
|
@test fn t2_param_16() void = {
|
|
let t: (i64, i64) = (41, 17);
|
|
assert(!(pick_t2_param_16(t, 0) != 41));
|
|
assert(!(pick_t2_param_16(t, 1) != 17));
|
|
};
|
|
|
|
fn g_t2_mixed_order(a: i64, t: (u32, u32), b: i64) i64 = {
|
|
return a*1000 + (t.0: i64)*100 + (t.1: i64)*10 + b;
|
|
};
|
|
|
|
fn h_t2_mixed_order(t: (i64, i64), s: str, k: i64) i64 = {
|
|
return t.0 + t.1 + (len(s): i64) + k;
|
|
};
|
|
|
|
@test fn t2_mixed_order() void = {
|
|
let t: (u32, u32) = (3, 4);
|
|
assert(!(g_t2_mixed_order(1, t, 2) != 1342));
|
|
let u: (i64, i64) = (10, 20);
|
|
assert(!(h_t2_mixed_order(u, "abc", 7) != 40));
|
|
};
|
|
|
|
fn pick_t2_lit_arg(t: (i64, i64), k: i32) i64 = {
|
|
if (k == 0) { return t.0; };
|
|
return t.1;
|
|
};
|
|
|
|
@test fn t2_lit_arg() void = {
|
|
assert(!(pick_t2_lit_arg((41, 17), 0) != 41));
|
|
assert(!(pick_t2_lit_arg((41, 17), 1) != 17));
|
|
};
|
|
|
|
fn fsum_t2_float_param(t: (f64, i64)) f64 = {
|
|
return t.0 + (t.1: f64);
|
|
};
|
|
|
|
@test fn t2_float_param() void = {
|
|
let t: (f64, i64) = (2.5, 4);
|
|
assert(!(fsum_t2_float_param(t) != 6.5));
|
|
};
|
|
|
|
fn mk_t2_unwrap_arg() ((i64, i64) | nomem) = {
|
|
let a: i64 = 5;
|
|
let b: i64 = 6;
|
|
return (a, b);
|
|
};
|
|
|
|
fn sum_t2_unwrap_arg(t: (i64, i64)) i64 = {
|
|
return t.0 + t.1;
|
|
};
|
|
|
|
@test fn t2_unwrap_arg() void = {
|
|
assert(!(sum_t2_unwrap_arg(mk_t2_unwrap_arg()!) != 11));
|
|
};
|
|
|
|
fn f_t2_gp_pressure(a: i64, b: i64, c: i64, d: i64, t: (i64, i64), e: i64) i64 = {
|
|
if (e != 60) { return -1; };
|
|
if (a != 1 || b != 2 || c != 3 || d != 4) { return -2; };
|
|
return t.0 * 100 + t.1;
|
|
};
|
|
|
|
@test fn t2_gp_pressure() void = {
|
|
let t: (i64, i64) = (7, 9);
|
|
assert(!(f_t2_gp_pressure(1, 2, 3, 4, t, 60) != 709));
|
|
};
|
|
|
|
fn g_t2_variadic_after_tuple(t: (i64, i64), xs: i64...) i64 = {
|
|
let s: i64 = t.0 + t.1;
|
|
for (let x .. xs) { s += x; };
|
|
return s;
|
|
};
|
|
|
|
@test fn t2_variadic_after_tuple() void = {
|
|
let t: (i64, i64) = (3, 4);
|
|
assert(!(g_t2_variadic_after_tuple(t, 1, 2) != 10));
|
|
};
|
|
|
|
fn first_t2_variadic_of_tuples(ts: (i64, i64)...) i64 = {
|
|
if (len(ts) == 0) { return -1; };
|
|
return ts[0].0;
|
|
};
|
|
|
|
@test fn t2_variadic_of_tuples() void = {
|
|
let t: (i64, i64) = (3, 4);
|
|
assert(!(first_t2_variadic_of_tuples(t) != 3));
|
|
};
|
|
|
|
let g_t3_global_elem: (str, i64) = ("hello", 9);
|
|
let h_t3_global_elem: (u32, u32) = (5, 6);
|
|
|
|
@test fn t3_global_elem() void = {
|
|
assert(!(len(g_t3_global_elem.0) != 5));
|
|
assert(!(g_t3_global_elem.1 != 9));
|
|
assert(!(h_t3_global_elem.0 != 5));
|
|
assert(!(h_t3_global_elem.1 != 6));
|
|
};
|
|
|
|
fn take_fc_arg_deref_16(e: (void | size)) size = {
|
|
if (!(e is size)) { return 99; };
|
|
return e as size;
|
|
};
|
|
|
|
@test fn fc_arg_deref_16() void = {
|
|
let v: (void | size) = 7: size;
|
|
let p: *(void | size) = &v;
|
|
assert(!(take_fc_arg_deref_16(*p) != 7));
|
|
};
|
|
|
|
type un16_fc_deref_let_match_16 = (void | size);
|
|
|
|
@test fn fc_deref_let_match_16() void = {
|
|
let v: un16_fc_deref_let_match_16 = 5: size;
|
|
let p: *un16_fc_deref_let_match_16 = &v;
|
|
let w = *p;
|
|
assert(!(!(w is size)));
|
|
match (*p) {
|
|
case let s: size => { assert(!(s != 5)); };
|
|
case void => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type un32_fc_deref_let_match_32str = (void | str);
|
|
|
|
@test fn fc_deref_let_match_32str() void = {
|
|
let v: un32_fc_deref_let_match_32str = "atcap";
|
|
let p: *un32_fc_deref_let_match_32str = &v;
|
|
let w = *p;
|
|
assert(!(!(w is str)));
|
|
match (*p) {
|
|
case let s: str => { assert(!(s.len != 5)); };
|
|
case void => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type un16_fc_deref_asg_16 = (void | size);
|
|
|
|
@test fn fc_deref_asg_16() void = {
|
|
let v: un16_fc_deref_asg_16 = 5: size;
|
|
let p: *un16_fc_deref_asg_16 = &v;
|
|
let w: un16_fc_deref_asg_16 = void;
|
|
w = *p;
|
|
assert(!(!(w is size)));
|
|
assert(!((w as size) != 5));
|
|
};
|
|
|
|
type un16_fc_deref_ret_16 = (void | size);
|
|
|
|
fn get_fc_deref_ret_16(p: *un16_fc_deref_ret_16) un16_fc_deref_ret_16 = {
|
|
return *p;
|
|
};
|
|
|
|
@test fn fc_deref_ret_16() void = {
|
|
let v: un16_fc_deref_ret_16 = 5: size;
|
|
let w = get_fc_deref_ret_16(&v);
|
|
assert(!(!(w is size)));
|
|
assert(!((w as size) != 5));
|
|
};
|
|
|
|
type un16_fc_deref_is_as_16 = (void | size);
|
|
|
|
@test fn fc_deref_is_as_16() void = {
|
|
let v: un16_fc_deref_is_as_16 = 5: size;
|
|
let p: *un16_fc_deref_is_as_16 = &v;
|
|
assert(!(!((*p) is size)));
|
|
assert(!(((*p) as size) != 5));
|
|
};
|
|
|
|
type un32_fc_deref_as_32str = (void | str);
|
|
|
|
@test fn fc_deref_as_32str() void = {
|
|
let v: un32_fc_deref_as_32str = "atcap";
|
|
let p: *un32_fc_deref_as_32str = &v;
|
|
let s = (*p) as str;
|
|
assert(!(s.len != 5));
|
|
};
|
|
|
|
type un32_fc_deref_arg_32str = (void | str);
|
|
|
|
fn take_fc_deref_arg_32str(e: un32_fc_deref_arg_32str) i32 = {
|
|
if (!(e is str)) { return 99; };
|
|
let s = e as str;
|
|
if (s.len != 5) { return 98; };
|
|
return 0;
|
|
};
|
|
|
|
@test fn fc_deref_arg_32str() void = {
|
|
let v: un32_fc_deref_arg_32str = "atcap";
|
|
let p: *un32_fc_deref_arg_32str = &v;
|
|
assert(!(take_fc_deref_arg_32str(*p) != 0));
|
|
};
|
|
|
|
type un16_fc_deref_widen_16to24 = (void | size);
|
|
type un3_fc_deref_widen_16to24 = (void | size | str);
|
|
|
|
@test fn fc_deref_widen_16to24() void = {
|
|
let v: un16_fc_deref_widen_16to24 = 5: size;
|
|
let p: *un16_fc_deref_widen_16to24 = &v;
|
|
let w: un3_fc_deref_widen_16to24 = *p;
|
|
assert(!(!(w is size)));
|
|
assert(!((w as size) != 5));
|
|
};
|
|
|
|
type s2_fc_deref_struct24_neighbor = struct { a: size, b: size };
|
|
type un24_fc_deref_struct24_neighbor = (void | s2_fc_deref_struct24_neighbor);
|
|
|
|
@test fn fc_deref_struct24_neighbor() void = {
|
|
let lo: size = 111;
|
|
let v: un24_fc_deref_struct24_neighbor = s2_fc_deref_struct24_neighbor { a = 5, b = 6 };
|
|
let hi: size = 222;
|
|
let p: *un24_fc_deref_struct24_neighbor = &v;
|
|
let w = *p;
|
|
assert(!(!(w is s2_fc_deref_struct24_neighbor)));
|
|
match (w) {
|
|
case let s: s2_fc_deref_struct24_neighbor => { assert(!(s.a != 5 || s.b != 6)); };
|
|
case void => { assert(false); };
|
|
};
|
|
assert(!(lo != 111));
|
|
assert(!(hi != 222));
|
|
};
|
|
|
|
type big_fc_deref_56_memread = struct { a: u64, b: u64, c: u64, d: u64, e: u64, f: u64 };
|
|
type un56_fc_deref_56_memread = (void | big_fc_deref_56_memread);
|
|
|
|
@test fn fc_deref_56_memread() void = {
|
|
let v: un56_fc_deref_56_memread = big_fc_deref_56_memread { a = 1u64, b = 2u64, c = 3u64, d = 4u64, e = 5u64, f = 6u64 };
|
|
let p: *un56_fc_deref_56_memread = &v;
|
|
let w = *p;
|
|
assert(!(!(w is big_fc_deref_56_memread)));
|
|
match (*p) {
|
|
case let s: big_fc_deref_56_memread => { assert(!(s.a != 1u64 || s.f != 6u64)); };
|
|
case void => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type un16_fc_cast_ident_arg = (void | size);
|
|
|
|
fn take_fc_cast_ident_arg(e: un16_fc_cast_ident_arg) size = {
|
|
if (!(e is size)) { return 99; };
|
|
return e as size;
|
|
};
|
|
|
|
@test fn fc_cast_ident_arg() void = {
|
|
let v: un16_fc_cast_ident_arg = 7: size;
|
|
assert(!(take_fc_cast_ident_arg((v: un16_fc_cast_ident_arg)) != 7));
|
|
};
|
|
|
|
type un16_fc_cast_widen_let = (void | size);
|
|
type un3_fc_cast_widen_let = (void | size | str);
|
|
|
|
@test fn fc_cast_widen_let() void = {
|
|
let v: un16_fc_cast_widen_let = 5: size;
|
|
let w: un3_fc_cast_widen_let = (v: un3_fc_cast_widen_let);
|
|
assert(!(!(w is size)));
|
|
assert(!((w as size) != 5));
|
|
};
|
|
|
|
type un16_fc_unwrap_tagged_let = (void | size);
|
|
type err_fc_unwrap_tagged_let = !void;
|
|
|
|
fn get_fc_unwrap_tagged_let() (un16_fc_unwrap_tagged_let | err_fc_unwrap_tagged_let) = {
|
|
let v: un16_fc_unwrap_tagged_let = 7: size;
|
|
return v;
|
|
};
|
|
|
|
fn use_fc_unwrap_tagged_let() (size | err_fc_unwrap_tagged_let) = {
|
|
let w = get_fc_unwrap_tagged_let()?;
|
|
if (!(w is size)) { return 99; };
|
|
return w as size;
|
|
};
|
|
|
|
@test fn fc_unwrap_tagged_let() void = {
|
|
match (use_fc_unwrap_tagged_let()) {
|
|
case let s: size => { assert(!(s != 7)); };
|
|
case err_fc_unwrap_tagged_let => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type err_fc_unwrap_ident = !void;
|
|
|
|
fn use_fc_unwrap_ident(v: (size | err_fc_unwrap_ident)) (size | err_fc_unwrap_ident) = {
|
|
let w = v?;
|
|
return w: size;
|
|
};
|
|
|
|
@test fn fc_unwrap_ident() void = {
|
|
let v: (size | err_fc_unwrap_ident) = 7: size;
|
|
match (use_fc_unwrap_ident(v)) {
|
|
case let s: size => { assert(!(s != 7)); };
|
|
case err_fc_unwrap_ident => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type err_fc_unwrap_deref = !void;
|
|
|
|
fn use_fc_unwrap_deref(p: *(size | err_fc_unwrap_deref)) (size | err_fc_unwrap_deref) = {
|
|
let x = (*p)?;
|
|
return x: size;
|
|
};
|
|
|
|
@test fn fc_unwrap_deref() void = {
|
|
let v: (size | err_fc_unwrap_deref) = 7: size;
|
|
match (use_fc_unwrap_deref(&v)) {
|
|
case let s: size => { assert(!(s != 7)); };
|
|
case err_fc_unwrap_deref => { assert(false); };
|
|
};
|
|
};
|
|
|
|
type un16_fc_cast_deref_arg = (void | size);
|
|
|
|
fn take_fc_cast_deref_arg(e: un16_fc_cast_deref_arg) size = {
|
|
if (!(e is size)) { return 99; };
|
|
return e as size;
|
|
};
|
|
|
|
@test fn fc_cast_deref_arg() void = {
|
|
let v: un16_fc_cast_deref_arg = 7: size;
|
|
let p: *un16_fc_cast_deref_arg = &v;
|
|
assert(!(take_fc_cast_deref_arg(((*p): un16_fc_cast_deref_arg)) != 7));
|
|
};
|
|
|
|
type un16_fc_deref_void_16 = (void | size);
|
|
|
|
@test fn fc_deref_void_16() void = {
|
|
let v: un16_fc_deref_void_16 = void;
|
|
let p: *un16_fc_deref_void_16 = &v;
|
|
match (*p) {
|
|
case let s: size => { assert(false); };
|
|
case void => { };
|
|
};
|
|
assert(!((*p) is size));
|
|
let w = *p;
|
|
assert(!(!(w is void)));
|
|
};
|
|
|
|
type un16_fc_deref_slice_elem_16 = (void | size);
|
|
|
|
@test fn fc_deref_slice_elem_16() void = {
|
|
let xs: []un16_fc_deref_slice_elem_16 = [];
|
|
append(xs, 11: size);
|
|
append(xs, void);
|
|
let p: *un16_fc_deref_slice_elem_16 = &xs[0];
|
|
match (*p) {
|
|
case let s: size => { assert(!(s != 11)); };
|
|
case void => { assert(false); };
|
|
};
|
|
let q: *un16_fc_deref_slice_elem_16 = &xs[1];
|
|
assert(!(!((*q) is void)));
|
|
};
|
|
|
|
type big4_fc_deref_arg_40 = struct { a: u64, b: u64, c: u64, d: u64 };
|
|
type un40_fc_deref_arg_40 = (void | big4_fc_deref_arg_40);
|
|
|
|
fn take_fc_deref_arg_40(e: un40_fc_deref_arg_40) u64 = {
|
|
match (e) {
|
|
case let g: big4_fc_deref_arg_40 => {
|
|
if (g.b != 2u64 || g.c != 3u64) { return 90u64; };
|
|
return g.a + g.d;
|
|
};
|
|
case void => { return 0u64; };
|
|
};
|
|
};
|
|
|
|
@test fn fc_deref_arg_40() void = {
|
|
let v: un40_fc_deref_arg_40 = big4_fc_deref_arg_40 { a = 30u64, b = 2u64, c = 3u64, d = 12u64 };
|
|
let p: *un40_fc_deref_arg_40 = &v;
|
|
assert(!(take_fc_deref_arg_40(*p) != 42u64));
|
|
};
|
|
|
|
type big_fc_deref_arg_56 = struct { a: u64, b: u64, c: u64, d: u64, e: u64, f: u64 };
|
|
type un56_fc_deref_arg_56 = (void | big_fc_deref_arg_56);
|
|
|
|
fn take_fc_deref_arg_56(e: un56_fc_deref_arg_56) u64 = {
|
|
match (e) {
|
|
case let g: big_fc_deref_arg_56 => {
|
|
if (g.b != 2u64 || g.e != 5u64) { return 90u64; };
|
|
return g.a + g.f;
|
|
};
|
|
case void => { return 0u64; };
|
|
};
|
|
};
|
|
|
|
@test fn fc_deref_arg_56() void = {
|
|
let v: un56_fc_deref_arg_56 = big_fc_deref_arg_56 { a = 30u64, b = 2u64, c = 3u64, d = 4u64, e = 5u64, f = 12u64 };
|
|
let p: *un56_fc_deref_arg_56 = &v;
|
|
assert(!(take_fc_deref_arg_56(*p) != 42u64));
|
|
};
|
|
|
|
type un16_fc_arg_balance_multi = (void | size);
|
|
|
|
fn take_fc_arg_balance_multi(a: size, e: un16_fc_arg_balance_multi, b: size) size = {
|
|
if (a != 100) { return 90; };
|
|
if (!(e is size)) { return 91; };
|
|
if ((e as size) != 7) { return 92; };
|
|
if (b != 200) { return 93; };
|
|
return a + (e as size) + b;
|
|
};
|
|
|
|
@test fn fc_arg_balance_multi() void = {
|
|
let v: un16_fc_arg_balance_multi = 7: size;
|
|
let p: *un16_fc_arg_balance_multi = &v;
|
|
assert(!(take_fc_arg_balance_multi(100, *p, 200) != 307));
|
|
assert(!(take_fc_arg_balance_multi(100, *p, 200) != 307));
|
|
};
|
|
|
|
@test fn t44_inferred_let_cast() void = {
|
|
let t = (4: size, 2: size);
|
|
assert(!(t.0 != 4));
|
|
assert(!(t.1 != 2));
|
|
};
|
|
|
|
@test fn t44_inferred_let_bare() void = {
|
|
let t = (4, 2);
|
|
assert(!(t.0 != 4));
|
|
assert(!(t.1 != 2));
|
|
};
|
|
|
|
@test fn t44_inferred_let_mixed3() void = {
|
|
let t = (4: size, 2, 36: size);
|
|
assert(!(t.0 + t.2 != 40));
|
|
assert(!(t.1 != 2));
|
|
};
|
|
|
|
@test fn t44_inferred_let_float() void = {
|
|
let t = (1.5, 2.5);
|
|
assert(!(t.0 + t.1 != 4.0));
|
|
};
|
|
|
|
@test fn t44_inferred_destructure() void = {
|
|
let t = (40: size, 2: size);
|
|
let (a, b) = t;
|
|
assert(!(a + b != 42));
|
|
};
|
|
|
|
fn add_t44_inferred_arg(t: (size, size)) size = {
|
|
return t.0 + t.1;
|
|
};
|
|
|
|
@test fn t44_inferred_arg() void = {
|
|
let t = (40: size, 2: size);
|
|
assert(!(add_t44_inferred_arg(t) != 42));
|
|
};
|
|
|
|
type un16_t57_ret_cast_elem = (void | size);
|
|
|
|
fn mk_t57_ret_cast_elem() (un16_t57_ret_cast_elem, size) = {
|
|
return (5: size, 9);
|
|
};
|
|
|
|
@test fn t57_ret_cast_elem() void = {
|
|
let t = mk_t57_ret_cast_elem();
|
|
assert(!(t.1 != 9));
|
|
let (a, b) = mk_t57_ret_cast_elem();
|
|
assert(!(!(a is size)));
|
|
assert(!(a as size != 5));
|
|
assert(!(b != 9));
|
|
};
|
|
|
|
fn mk_t57_ret_inline_union() ((void | size), size) = {
|
|
return (5: size, 9);
|
|
};
|
|
|
|
@test fn t57_ret_inline_union() void = {
|
|
let (a, b) = mk_t57_ret_inline_union();
|
|
assert(!(!(a is size)));
|
|
assert(!(b != 9));
|
|
assert(!(a as size != 5));
|
|
};
|
|
|
|
type un16_t57_let_literal = (void | size);
|
|
|
|
@test fn t57_let_literal() void = {
|
|
let t: (un16_t57_let_literal, size) = (5: size, 9);
|
|
assert(!(t.1 != 9));
|
|
assert(!(!(t.0 is size)));
|
|
assert(!(t.0 as size != 5));
|
|
};
|
|
|
|
type un16_t57_tagged_second_elem = (void | size);
|
|
|
|
fn mk2_t57_tagged_second_elem() (size, un16_t57_tagged_second_elem) = {
|
|
return (3, 7: size);
|
|
};
|
|
|
|
@test fn t57_tagged_second_elem() void = {
|
|
let (a, b) = mk2_t57_tagged_second_elem();
|
|
assert(!(a != 3));
|
|
assert(!(!(b is size)));
|
|
assert(!(b as size != 7));
|
|
};
|
|
|
|
type unf_t57_float_payload = (void | f64);
|
|
|
|
fn mkf_t57_float_payload() (unf_t57_float_payload, size) = {
|
|
return (1.5, 9);
|
|
};
|
|
|
|
@test fn t57_float_payload() void = {
|
|
let (a, b) = mkf_t57_float_payload();
|
|
assert(!(b != 9));
|
|
assert(!(!(a is f64)));
|
|
assert(!(a as f64 != 1.5));
|
|
};
|
|
|
|
type un_t57_tagged_mid_elem = (void | size);
|
|
|
|
fn mk3_t57_tagged_mid_elem() (size, un_t57_tagged_mid_elem, size) = {
|
|
return (1, 5: size, 9);
|
|
};
|
|
|
|
@test fn t57_tagged_mid_elem() void = {
|
|
let (a, b, c) = mk3_t57_tagged_mid_elem();
|
|
assert(!(a != 1));
|
|
assert(!(!(b is size)));
|
|
assert(!(b as size != 5));
|
|
assert(!(c != 9));
|
|
};
|
|
|
|
type un_t57_two_tagged_void_elem = (void | size);
|
|
|
|
fn mk_t57_two_tagged_void_elem() (un_t57_two_tagged_void_elem, un_t57_two_tagged_void_elem) = {
|
|
return (5: size, void);
|
|
};
|
|
|
|
@test fn t57_two_tagged_void_elem() void = {
|
|
let t = mk_t57_two_tagged_void_elem();
|
|
assert(!(!(t.0 is size)));
|
|
assert(!(t.0 as size != 5));
|
|
assert(!(!(t.1 is void)));
|
|
};
|
|
|
|
type un_t57_sse_coexist = (void | size);
|
|
|
|
fn mk_t57_sse_coexist() (f64, un_t57_sse_coexist) = {
|
|
return (0.5, 7: size);
|
|
};
|
|
|
|
@test fn t57_sse_coexist() void = {
|
|
let (x, e) = mk_t57_sse_coexist();
|
|
assert(!(x * 4.0 != 2.0));
|
|
assert(!(!(e is size)));
|
|
assert(!(e as size != 7));
|
|
};
|
|
|
|
type un16_t57_bare_untyped_payload = (void | size);
|
|
|
|
fn mkb_t57_bare_untyped_payload() (un16_t57_bare_untyped_payload, size) = {
|
|
return (5, 9);
|
|
};
|
|
|
|
@test fn t57_bare_untyped_payload() void = {
|
|
let (a, b) = mkb_t57_bare_untyped_payload();
|
|
assert(!(!(a is size)));
|
|
assert(!(a as size != 5));
|
|
assert(!(b != 9));
|
|
};
|
|
|
|
type un16_t57_ident_no_regress = (void | size);
|
|
|
|
fn mk_t57_ident_no_regress() (un16_t57_ident_no_regress, size) = {
|
|
let e: un16_t57_ident_no_regress = 5: size;
|
|
return (e, 9);
|
|
};
|
|
|
|
@test fn t57_ident_no_regress() void = {
|
|
let t = mk_t57_ident_no_regress();
|
|
assert(!(t.1 != 9));
|
|
assert(!(!(t.0 is size)));
|
|
assert(!(t.0 as size != 5));
|
|
};
|