// slice_global_arg_test — module-global slice/array constants, two folded
// concerns that share these globals:
//
//   #148 (D2): a module-global slice passed BY VALUE as a slice arg must arrive
//   with a real header, not garbage. Migrated from test/wcc/953_globalslice_arg_run.c.
//   Pre-fix the slice-ident call-arg fast path emitted BP-relative pushes for a
//   global (localfind→0), reading saved-BP/RIP garbage instead of the global's
//   header at name(SB). The fix mirrors the N_SLICE arm's isglobal dispatch.
//
//   #28: wwstage's checker REJECTED a module-level `const/let []T = [..]`
//   ("let: not assignable") while cstage accepted — the slice-from-arrlit
//   admission was gated local-only. const dotdot/dot/g/d below are the exact
//   shape (ref/hare/path/stack.ha:30 `const dotdot: []u8 = ['.', '.'];`). This
//   file was a `_runonly` (cstage-only) carrier until that fix; promoting it
//   drops the suffix and re-arms the cs==ww byte-id net over the slice globals.
//
// The element values discriminate a real header from garbage; u32_global pins
// the path element-width-agnostic; the const/let/[_] table-driven readbacks pin
// the #28 admission across const, mutable let, and the inferred-array form.

package slice_global_arg_test;

type my64 = i64;
type my64b = my64;

const dotdot: []u8 = ['.', '.'];
const dot: []u8 = ['.'];
const g: []u32 = [7u32, 8u32, 9u32];
const d: []u32 = [11u32, 22u32];

// #28: a wider-element slice global, and a 2-level-alias element type — both
// converged from cstage-only (was test/wcc/944 Group A slc_plain_ctl / slc_2lvl,
// where wwstage rejected at the let checker) to cs==ww byte-id once the
// module-scope slice-from-arrlit admission landed.
let gi64: []i64 = [5, 6, 7];
let galias: []my64b = [5, 6, 7];

// #28: a MUTABLE `let` slice global must be accepted identically to `const`
// (shared decl path; the pre-fix error said "let:" even for const).
let lu8: []u8 = [10u8, 20u8, 30u8];

// #28 subtlety 2: rune-lit elements coerce into u8 via the SAME per-element
// path; `[_]u8` is the inferred-length ARRAY form, not a slice.
const carr: [_]u8 = ['a', 'b'];

fn seen_u8(bs: []u8) i32 = {
	return bs.len: i32 * 1000 + bs[0]: i32;
};

fn seen_u32(xs: []u32) i32 = {
	return xs.len: i32 * 100 + xs[0]: i32 + xs[2]: i32;
};

@test fn u8_dotdot() void = {
	assert(seen_u8(dotdot) == 2046);
};

@test fn u8_dot() void = {
	assert(seen_u8(dot) == 1046);
};

@test fn u32_global() void = {
	assert(seen_u32(g) == 316);
};

@test fn direct_read() void = {
	assert(d.len: i32 * 100 + d[0]: i32 + d[1]: i32 == 233);
};

@test fn u8_local_arg() void = {
	let a: [2]u8 = ['.', '.'];
	let s: []u8 = a[0:2];
	assert(seen_u8(s) == 2046);
};

// #28: const []u8 element readback, table-driven over the declared elements.
@test fn const_slice_elems() void = {
	let want: [2]u8 = [46u8, 46u8];
	assert(dotdot.len == 2);
	let i: i32 = 0;
	for (i < dotdot.len: i32) {
		assert(dotdot[i] == want[i]);
		i += 1;
	};
};

// #28: mutable `let []u8` global — accept + element readback.
@test fn let_slice_elems() void = {
	let want: [3]u8 = [10u8, 20u8, 30u8];
	assert(lu8.len == 3);
	let i: i32 = 0;
	for (i < lu8.len: i32) {
		assert(lu8[i] == want[i]);
		i += 1;
	};
};

// #28: const [_]u8 rune-lit array form — accept + element readback.
@test fn const_array_elems() void = {
	let want: [2]u8 = [97u8, 98u8];
	assert(carr.len == 2);
	let i: i32 = 0;
	for (i < carr.len: i32) {
		assert(carr[i] == want[i]);
		i += 1;
	};
};

// #28: wider-element ([]i64) and 2-level-alias-element ([]my64b) slice globals
// (ex test/wcc/944 Group A) — accept + element readback.
@test fn wide_and_alias_slice() void = {
	assert(gi64.len == 3);
	assert(gi64[0] + gi64[1] + gi64[2] == 18);
	assert(galias.len == 3);
	assert(galias[0] + galias[1] + galias[2] == 18);
};