// selfhost/cmd/wcc/cgenutil.ww — split out of cgen.ww.
//
// General helpers used across cgenexpr / cgenstmt / cgendecl:
//   - pushargsrev: per-call arg pushing
//   - type predicates: isstr*/isslice*/istagged*/nodeis* families
//   - field ops:    fieldloadop, fieldstoreop
//   - index helpers: indexbaseesz, dotinnerstructptr, elemsizeof
//   - slot sizing:  structlookup, primsize, slotsize, fieldsize,
//                   registerstruct, collectstructs
//   - rhs helpers:  rhstargetname, taggedvariantindex
//
// Bundler pulls this in transitively via cgen.ww; consumers don't
// need to `use cgenutil;` directly.

use os;
use mem;
use ast;
use tok;
use typ;
use sym;
use strconv;

// ---- expression cgen -------------------------------------------------

// pushargsrev — recursively walks the arg list, evaluates rightmost
// first, and pushes. str args take two slots (ptr in AX, len in BX);
// the order on the stack so a left-to-right pop into argregs lands
// (ptr, len) correctly is: PUSHQ BX (top), PUSHQ AX (above) — the
// pop sequence then yields AX, then BX.
//
// `param` is the corresponding declared parameter for `arg` (N_PARAM
// node from the callee's signature) or nil. When param's type is a
// tagged union and `arg`'s surface type is a concrete variant of it,
// we materialise (tag, value-words, pad) for the parameter slot before
// pushing — mirrors cmd/w6c/cgen.c's call-arg widening.
fn pushargsrev(c: *cgen, arg: *node, param: *node) i32 = {
	if (arg == nil) { return 0; };
	let nextparam: *node = nil;
	if (param != nil) { nextparam = param.next; };
	let rest: i32 = pushargsrev(c, arg.next, nextparam);
	// Implicit widening from a concrete variant to a tagged-union
	// parameter slot. Skips when the arg is already a tagged local
	// (line 121's slice-or-tagged shortcut handles that).
	let widensz: i32 = 0;
	let widentag: i32 = 0;
	if (param != nil) {
		if (param.kind == nkind.N_PARAM) {
			let ptype: *node = param.lhs;
			if (istaggedtype(c, ptype)) {
				let aistagged: bool = false;
				if (arg.kind == nkind.N_IDENT) {
					let lc: *local = localfindnode(c, arg.str);
					if (lc != nil) {
						aistagged = istaggedtype(c, lc.tnode);
					};
				};
				if (!aistagged) {
					widensz = slotsize(c, ptype);
					let tagged: *node = resolvetagged(c, ptype);
					let t: i32 = taggedvariantindex(c, tagged, arg);
					if (t < 0) { t = 0; };
					widentag = t;
				};
			};
		};
	};
	if (widensz == 8) {
		// Nullable fold: pointer value IS the discriminator. No
		// separate tag word.
		cgexpr(c, arg);
		emitline("\tPUSHQ\tAX\n");
		return rest + 1;
	};
	if (widensz > 0) {
		// Struct-payload widening into a tagged-union param uses
		// @tagscr (zero + cgwidentaggedstore writes fields + tag,
		// then push slot words high → low). Scalar / str go via
		// the direct push fast path below — keeps wwstage's asm
		// byte-identical to cstage for selfhost source.
		let pname: str = rhsstructpayload(c, arg);
		if (pname.len > 0) {
			let ptype: *node = param.lhs;
			let scroff: i32 = localadd(c, "@tagscr", 24, nil);
			emitline("\tXORQ\tAX, AX\n");
			let zz: i32 = 0;
			for (zz < widensz) {
				emitline("\tMOVQ\tAX, ");
				emitoff((scroff + zz): i64);
				emitline("(BP)\n");
				zz += 8;
			};
			cgwidentaggedstore(c, ptype, arg, scroff, widensz);
			let pp: i32 = widensz - 8;
			for (pp >= 0) {
				emitline("\tMOVQ\t");
				emitoff((scroff + pp): i64);
				emitline("(BP), AX\n");
				emitline("\tPUSHQ\tAX\n");
				pp -= 8;
			};
			return rest + widensz / 8;
		};
		cgexpr(c, arg);
		if (nodeisslice(c, arg)) {
			// Slice payload (24B): cgexpr leaves (AX=ptr, BX=len,
			// CX=cap). Slot layout: [+0]=tag, [+8]=ptr, [+16]=len,
			// [+24]=cap. Push high→low so pop drains tag first.
			// Requires widensz >= 32; a smaller slot would mean the
			// destination union doesn't list slice as a variant
			// (caller should have flagged a type error).
			emitline("\tPUSHQ\tCX\n");
			emitline("\tPUSHQ\tBX\n");
			emitline("\tPUSHQ\tAX\n");
			emitline("\tMOVQ\t$");
			emitint(widentag: i64);
			emitline(", AX\n");
			emitline("\tPUSHQ\tAX\n");
		} else { if (nodeisstr(c, arg)) {
			// slot 24: [+0]=tag,[+8]=ptr,[+16]=len. Push high→low
			// so pop drains tag first into arg-reg[0].
			emitline("\tPUSHQ\tBX\n");
			emitline("\tPUSHQ\tAX\n");
			emitline("\tMOVQ\t$");
			emitint(widentag: i64);
			emitline(", AX\n");
			emitline("\tPUSHQ\tAX\n");
		} else {
			// Scalar variant: single value word at +8. Pad a zero
			// high word when slot is 24B (some other variant of
			// the union is 16B-shaped).
			let pp: i32 = widensz - 8;
			for (pp > 8) {
				emitline("\tXORQ\tDX, DX\n");
				emitline("\tPUSHQ\tDX\n");
				pp -= 8;
			};
			emitline("\tPUSHQ\tAX\n");
			emitline("\tMOVQ\t$");
			emitint(widentag: i64);
			emitline(", AX\n");
			emitline("\tPUSHQ\tAX\n");
		};};
		return rest + widensz / 8;
	};
	// nkind.N_SLICE expression as arg: `buf[lo:hi]` builds a slice header
	// on the stack matching C cgen's sequence — push base, push hi,
	// compute lo, pop into BX/CX, derive len/ptr, push (cap, len, ptr).
	if (arg.kind == nkind.N_SLICE) {
		let base: *node = arg.lhs;
		let lo: *node = arg.rhs;
		let hi: *node = arg.cond;
		let baselocal: *local = nil;
		if (base != nil) {
			if (base.kind == nkind.N_IDENT) {
				let bn: str = base.str;
				baselocal = localfindnode(c, bn);
			};
		};
		// base address → push
		if (baselocal != nil) {
			let tn: *node = baselocal.tnode;
			if (tn != nil) {
				if (tn.kind == nkind.N_TARRAY) {
					emitline("\tLEAQ\t");
					emitoff(baselocal.off: i64);
					emitline("(BP), AX\n");
				} else {
					emitline("\tMOVQ\t");
					emitoff(baselocal.off: i64);
					emitline("(BP), AX\n");
				};
			} else {
				emitline("\tMOVQ\t");
				emitoff(baselocal.off: i64);
				emitline("(BP), AX\n");
			};
		} else {
			cgexpr(c, base);
		};
		emitline("\tPUSHQ\tAX\n");
		// hi (default base length) → push
		if (hi != nil) {
			cgexpr(c, hi);
		} else { if (baselocal != nil) {
			let tn: *node = baselocal.tnode;
			if (tn != nil) {
				if (tn.kind == nkind.N_TARRAY) {
					let lenn: *node = tn.rhs;
					if (lenn != nil) {
						if (lenn.kind == nkind.N_INTLIT) {
							emitline("\tMOVQ\t$");
							emituint(lenn.uval);
							emitline(", AX\n");
						};
					};
				} else { if (tn.kind == nkind.N_TSLICE) {
					emitline("\tMOVQ\t");
					emitoff((baselocal.off + 8): i64);
					emitline("(BP), AX\n");
				} else { if (tn.kind == nkind.N_TNAME) {
					if (streq(tn.str, "str")) {
						emitline("\tMOVQ\t");
						emitoff((baselocal.off + 8): i64);
						emitline("(BP), AX\n");
					};
				};};};
			};
		} else {
			emitline("\tMOVQ\t$0, AX\n");
		};};
		emitline("\tPUSHQ\tAX\n");
		// lo (default 0) → AX
		if (lo != nil) { cgexpr(c, lo); }
		else { emitline("\tMOVQ\t$0, AX\n"); };
		emitline("\tPOPQ\tBX\n");           // hi
		emitline("\tPOPQ\tCX\n");           // base
		emitline("\tMOVQ\tBX, DX\n");       // DX = hi
		emitline("\tSUBQ\tAX, DX\n");       // DX = hi - lo = len
		emitline("\tADDQ\tAX, CX\n");       // CX = base + lo = ptr
		emitline("\tPUSHQ\tDX\n");          // cap
		emitline("\tPUSHQ\tDX\n");          // len
		emitline("\tPUSHQ\tCX\n");          // ptr (top)
		return rest + 3;
	};
	// Slice/tagged ident args: emit per-register MOVQ+PUSHQ pairs in
	// reverse order (cap/v1, len/v0, ptr/tag) so a left-to-right pop
	// into argregs lands the canonical (ptr/tag, len/v0, cap/v1).
	// For tagged ident with a >24B slot (slice-payload variant),
	// push a fourth word from off+24.
	if (arg.kind == nkind.N_IDENT) {
		let nm: str = arg.str;
		let lc: *local = localfindnode(c, nm);
		if (lc != nil) {
			let off: i32 = lc.off;
			if (isslicetype(c, lc.tnode) || istaggedtype(c, lc.tnode)) {
				let nwords: i32 = 3;
				if (istaggedtype(c, lc.tnode)) {
					let ssz: i32 = slotsize(c, lc.tnode);
					nwords = ssz / 8;
				};
				let w: i32 = nwords - 1;
				for (w >= 0) {
					emitline("\tMOVQ\t");
					emitoff((off + w*8): i64);
					emitline("(BP), AX\n");
					emitline("\tPUSHQ\tAX\n");
					w -= 1;
				};
				return rest + nwords;
			};
		};
	};
	// Float arg: cgexpr leaves the value in X0. Push 8 bytes from
	// X0 via SUBQ+MOVSD so cgcall's pop side can drain into the
	// XMM stream (X0..X7). f32 still occupies 8B on the stack —
	// the MOVSS load on the pop side touches only the low 4.
	let fk: i32 = exprfloatkind(c, arg);
	if (fk != 0) {
		cgexpr(c, arg);
		let mov: str = "MOVSD";
		if (fk == 1) { mov = "MOVSS"; };
		emitline("\tSUBQ\t$8, SP\n");
		emitline("\t");
		emitline(mov);
		emitline("\tX0, (SP)\n");
		return rest + 1;
	};
	cgexpr(c, arg);
	if (nodeisslice(c, arg)) {
		emitline("\tPUSHQ\tCX\n");
		emitline("\tPUSHQ\tBX\n");
		emitline("\tPUSHQ\tAX\n");
		return rest + 3;
	};
	if (nodeisstr(c, arg)) {
		emitline("\tPUSHQ\tBX\n");
		emitline("\tPUSHQ\tAX\n");
		return rest + 2;
	};
	emitline("\tPUSHQ\tAX\n");
	return rest + 1;
};

fn nodeisslice(c: *cgen, n: *node) bool = {
	if (n == nil) { return false; };
	let k: nkind = n.kind;
	if (k == nkind.N_IDENT) {
		let nm: str = n.str;
		let lc: *local = localfindnode(c, nm);
		if (lc != nil) { return isslicetype(c, lc.tnode); };
		return false;
	};
	if (k == nkind.N_SLICE) { return true; };
	return false;
};

// nodeisstr — best-effort surface check: does this expression
// evaluate to a str value? Used to drive the call-arg push convention
// (str args take two slots: ptr + len).
fn nodeisstr(c: *cgen, n: *node) bool = {
	if (n == nil) { return false; };
	let k: nkind = n.kind;
	if (k == nkind.N_STRLIT) { return true; };
	if (k == nkind.N_IDENT) {
		let nm: str = n.str;
		let lc: *local = localfindnode(c, nm);
		if (lc != nil) {
			// Use isstrtype so `!str` aliases (parserr = !str) and
			// `type foo = str;` chains resolve through. The bare
			// `streq("str", ...)` test missed them and dropped the
			// MOVQ BX,CX shuffle on returns of str-aliased locals.
			if (isstrtype(c, lc.tnode)) { return true; };
		};
		return false;
	};
	if (k == nkind.N_CALL) {
		let callee: *node = n.lhs;
		if (callee != nil) {
			if (callee.kind == nkind.N_IDENT) {
				let cnm: str = callee.str;
				let rt: *node = fnretlookup(c, cnm);
				return isstrtype(c, rt);
			};
		};
		return false;
	};
	if (k == nkind.N_DOT) {
		let base: *node = n.lhs;
		let fld: str = n.str;
		// `<expr>.ptr` is *u8 not str; `<expr>.len` is i32 not str.
		if (streq(fld, "ptr")) { return false; };
		if (streq(fld, "len")) { return false; };
		if (streq(fld, "cap")) { return false; };
		if (base != nil) {
			let sname: str;
			sname.ptr = nil; sname.len = 0;
			if (base.kind == nkind.N_IDENT) {
				let lc: *local = localfindnode(c, base.str);
				if (lc != nil) {
					let tn: *node = lc.tnode;
					let lkind: nkind = nkind.N_NONE;
					if (tn != nil) { lkind = tn.kind; };
					if (lkind == nkind.N_TNAME) { sname = tn.str; };
					if (lkind == nkind.N_TPTR) {
						let inner: *node = tn.lhs;
						if (inner != nil) {
							if (inner.kind == nkind.N_TNAME) { sname = inner.str; };
						};
					};
				};
			};
			// Chained dot (`p.foo.bar`): use dotinnerstructptr
			// to resolve the inner chain to the *struct it lands
			// on, then look up `fld` in that struct.
			if (base.kind == nkind.N_DOT) {
				let innert: *node = dotinnerstructptr(c, base);
				if (innert != nil) {
					if (innert.kind == nkind.N_TNAME) { sname = innert.str; };
				};
			};
			if (sname.len > 0) {
				let si: *structinfo = structlookup(c, sname);
				if (si != nil) {
					let fi: *fieldinfo = si.fields;
					for (fi != nil) {
						let fn_: str = fi.fname;
						if (streq(fn_, fld)) {
							return isstrtype(c, fi.tnode);
						};
						fi = fi.finext;
					};
				};
			};
		};
		return false;
	};
	if (k == nkind.N_CAST) {
		return isstrtype(c, n.rhs);
	};
	return false;
};

// typenameisunsigned — true for u8/u16/u32/u64/uint/uintptr.
fn typenameisunsigned(nm: str) bool = {
	if (streq(nm, "u8"))   { return true; };
	if (streq(nm, "u16"))  { return true; };
	if (streq(nm, "u32"))  { return true; };
	if (streq(nm, "u64"))  { return true; };
	if (streq(nm, "uint")) { return true; };
	if (streq(nm, "uintptr")) { return true; };
	return false;
};

// typenodeisunsigned — recurse through TNAME / TPTR / TSLICE etc.
fn typenodeisunsigned(t: *node) bool = {
	if (t == nil) { return false; };
	if (t.kind == nkind.N_TNAME) { return typenameisunsigned(t.str); };
	return false;
};

// typeis8byteprimitive — does this type take exactly one 8-byte
// slot (pointer / fn-ptr / 64-bit int / chan / scalar primitive
// padded up to 8) rather than a wider aggregate? Used by nkind.N_LET
// zero-init to mirror C cgen's "only zero if sz == 8 at the type
// level" rule. Strings (16), slices (24), tagged unions (>=16),
// tuples (16), structs (varies), arrays — all fall through to
// false here even when their *slot* rounds up to 8.
fn typeis8byteprimitive(c: *cgen, t: *node) bool = {
	if (t == nil) { return false; };
	let k: nkind = t.kind;
	if (k == nkind.N_TPTR)   { return true; };
	if (k == nkind.N_TFN)    { return true; };
	if (k == nkind.N_TCHAN)  { return true; };
	if (k == nkind.N_TSLICE) { return false; };
	if (k == nkind.N_TARRAY) {
		// C cgen (cmd/w6c/cgen.c:3317) zero-inits TY_ARRAY whenever
		// its raw byte size is 8 — e.g. `[8]bool`, `[2]i32`, `[4]i16`,
		// `[1]i64`. Mirror that here so the wwstage matches.
		let lenn: *node = t.rhs;
		let elemn: *node = t.lhs;
		if (lenn == nil) { return false; };
		if (lenn.kind != nkind.N_INTLIT) { return false; };
		let elen: i64 = lenn.uval: i64;
		let esz: i32 = 8;
		if (elemn != nil) {
			if (elemn.kind == nkind.N_TNAME) {
				let ps: i32 = primsize(elemn.str);
				if (ps > 0) { esz = ps; };
			};
		};
		return (esz: i64 * elen) == 8i64;
	};
	if (k == nkind.N_TTUPLE) { return false; };
	if (k == nkind.N_TTAGGED){ return false; };
	if (k == nkind.N_TNAME) {
		let nm: str = t.str;
		if (streq(nm, "str")) { return false; };
		// Struct alias: not a primitive even if the slot is 8B.
		if (structlookup(c, nm) != nil) { return false; };
		// Primitive (i8/u8/.../i64/u64/bool/rune/f32/f64/int/...).
		// All of these get slot-padded to 8 and zero-init in C.
		if (primsize(nm) > 0) { return true; };
		return false;
	};
	return false;
};

// elemissigned — given an indexable type (`*T`, `[]T`, `[N]T`), is
// its element a signed narrow primitive (i8/i16/i32/rune)? Used by
// cgindex to pick MOVSXD vs MOVL at esz=4. Mirrors C cgen's
// `signed_elem` check.
fn elemissigned(t: *node) bool = {
	if (t == nil) { return false; };
	let elem: *node = nil;
	let k: nkind = t.kind;
	if (k == nkind.N_TPTR)   { elem = t.lhs; };
	if (k == nkind.N_TSLICE) { elem = t.lhs; };
	if (k == nkind.N_TARRAY) { elem = t.lhs; };
	if (elem == nil) { return false; };
	if (elem.kind != nkind.N_TNAME) { return false; };
	return typenameissigned(elem.str);
};

// typenameissigned — true for i8/i16/i32/i64/int/rune.
fn typenameissigned(nm: str) bool = {
	if (streq(nm, "i8"))   { return true; };
	if (streq(nm, "i16"))  { return true; };
	if (streq(nm, "i32"))  { return true; };
	if (streq(nm, "i64"))  { return true; };
	if (streq(nm, "int"))  { return true; };
	if (streq(nm, "rune")) { return true; };
	return false;
};

// fieldloadop — pick the load instruction for a non-str struct
// field by its declared size + signedness. Mirrors the C cgen op
// dispatch (MOVZBQ for u8/bool/i8, MOVSXD for i32, MOVL for u32, MOVQ
// for 8-byte). f might be nil for fields outside our struct registry.
fn fieldloadop(f: *fieldinfo) str = {
	if (f == nil) { return "MOVQ"; };
	let sz: i32 = f.fsz;
	if (sz == 1) { return "MOVZBQ"; };
	if (sz == 4) {
		let t: *node = f.tnode;
		if (t != nil) {
			if (t.kind == nkind.N_TNAME) {
				if (typenameissigned(t.str)) { return "MOVSXD"; };
			};
		};
		return "MOVL";
	};
	return "MOVQ";
};

// fieldstoreop — pick the store instruction for a non-str struct
// field by its declared size. MOVB for 1, MOVL for 4, MOVQ for 8.
fn fieldstoreop(f: *fieldinfo) str = {
	if (f == nil) { return "MOVQ"; };
	let sz: i32 = f.fsz;
	if (sz == 1) { return "MOVB"; };
	if (sz == 4) { return "MOVL"; };
	return "MOVQ";
};

// indexbaseesz — element size for `arr[i]` where the base is a
// chained-dot pseudo-field `s.ptr` (s being str/*str/slice/*slice).
// For str the element is one byte; for `[]T` / `*[]T` we drill into
// the slice element type.
fn indexbaseesz(c: *cgen, base: *node) i32 = {
	if (base == nil) { return 8; };
	if (base.kind != nkind.N_DOT) { return 8; };
	let fld: str = base.str;
	let inner: *node = base.lhs;
	if (inner == nil) { return 8; };
	if (inner.kind != nkind.N_IDENT) { return 8; };
	let nm: str = inner.str;
	let lc: *local = localfindnode(c, nm);
	if (lc == nil) { return 8; };
	let tn: *node = lc.tnode;
	if (tn == nil) { return 8; };

	// `.ptr` pseudo-field on str/slice → element of the str/slice.
	if (streq(fld, "ptr")) {
		let innert: *node = tn;
		if (tn.kind == nkind.N_TPTR) { innert = tn.lhs; };
		if (innert == nil) { return 8; };
		if (innert.kind == nkind.N_TNAME) {
			if (streq(innert.str, "str")) { return 1; };
		};
		if (innert.kind == nkind.N_TSLICE) { return elemsizeof(innert); };
		return 8;
	};

	// Generic struct field: if it's *T, element size is T's size.
	let lkind: nkind = tn.kind;
	let sname: str;
	sname.ptr = nil; sname.len = 0;
	if (lkind == nkind.N_TNAME) { sname = tn.str; };
	if (lkind == nkind.N_TPTR) {
		let pinner: *node = tn.lhs;
		if (pinner != nil) {
			if (pinner.kind == nkind.N_TNAME) { sname = pinner.str; };
		};
	};
	if (sname.len == 0) { return 8; };
	let si: *structinfo = structlookup(c, sname);
	if (si == nil) { return 8; };
	let fi: *fieldinfo = si.fields;
	for (fi != nil) {
		let fn_: str = fi.fname;
		if (streq(fn_, fld)) {
			let ft: *node = fi.tnode;
			if (ft == nil) { return 8; };
			if (ft.kind == nkind.N_TPTR) {
				let elem: *node = ft.lhs;
				if (elem != nil) {
					if (elem.kind == nkind.N_TNAME) {
						if (streq(elem.str, "str")) { return 16; };
						let ps: i32 = primsize(elem.str);
						if (ps > 0) { return ps; };
					};
				};
				return 8;
			};
			if (ft.kind == nkind.N_TSLICE) { return elemsizeof(ft); };
			// str-typed field: indexing yields one byte
			// (`n.s[i]` where .s is str — matches C cgen's
			// MOVZBQ for byte indexing).
			if (ft.kind == nkind.N_TNAME) {
				if (streq(ft.str, "str")) { return 1; };
			};
			return 8;
		};
		fi = fi.finext;
	};
	return 8;
};

// dotinnerstructptr — for an nkind.N_DOT whose lhs is a chain of dots
// or an nkind.N_IDENT, walk the chain and return the nkind.N_TNAME tnode of the
// struct that the chain dereferences to (i.e., for `r.sym` where
// .sym is *lsym, return nkind.N_TNAME("lsym")). Returns nil if the chain
// doesn't resolve to a *struct.
//
// Used by the chained-DOT cgen path so `r.sym.val` knows the outer
// is a field of `lsym`.
fn dotinnerstructptr(c: *cgen, n: *node) *node = {
	if (n == nil) { return nil; };
	if (n.kind != nkind.N_DOT) { return nil; };
	let base: *node = n.lhs;
	let fld: str = n.str;
	if (base == nil) { return nil; };

	// Resolve base's struct tnode.
	let baset: *node = nil;
	if (base.kind == nkind.N_IDENT) {
		let lc: *local = localfindnode(c, base.str);
		if (lc == nil) { return nil; };
		let tn: *node = lc.tnode;
		if (tn == nil) { return nil; };
		// base could be either struct-by-value (nkind.N_TNAME) or *struct (nkind.N_TPTR).
		if (tn.kind == nkind.N_TNAME) { baset = tn; };
		if (tn.kind == nkind.N_TPTR)  { baset = tn.lhs; };
	} else { if (base.kind == nkind.N_DOT) {
		baset = dotinnerstructptr(c, base);
	};};
	if (baset == nil) { return nil; };
	if (baset.kind != nkind.N_TNAME) { return nil; };

	// Look up the struct, find the field, return the field's *struct.
	let si: *structinfo = structlookup(c, baset.str);
	if (si == nil) { return nil; };
	let fi: *fieldinfo = si.fields;
	for (fi != nil) {
		if (streq(fi.fname, fld)) {
			let ft: *node = fi.tnode;
			if (ft == nil) { return nil; };
			if (ft.kind != nkind.N_TPTR) { return nil; };
			let inner: *node = ft.lhs;
			if (inner == nil) { return nil; };
			if (inner.kind != nkind.N_TNAME) { return nil; };
			return inner;
		};
		fi = fi.finext;
	};
	return nil;
};

// elemsizeof — given the type node of an indexable (`*T`, `[]T`,
// `[N]T`, `str`), return the byte size of one element (1 for u8/i8/
// bool/str-byte, 8 otherwise — same shape as C cgen's esz fallback).
// For aliased element types (e.g. `[N]formattable`), callers that
// need the resolved slot size should use elemsizeofc(c, t) which
// follows aliases via slotsize.
fn elemsizeof(t: *node) i32 = {
	if (t == nil) { return 1; };
	let k: nkind = t.kind;
	let elem: *node = nil;
	if (k == nkind.N_TPTR)   { elem = t.lhs; };
	if (k == nkind.N_TSLICE) { elem = t.lhs; };
	if (k == nkind.N_TARRAY) { elem = t.lhs; };
	if (k == nkind.N_TNAME) {
		let nm: str = t.str;
		if (streq(nm, "str")) { return 1; };
		// Indexing a primitive name (rare): element size = the prim.
		let ps: i32 = primsize(nm);
		if (ps > 0) { return ps; };
		return 1;
	};
	if (elem == nil) { return 1; };
	if (elem.kind == nkind.N_TNAME) {
		let nm: str = elem.str;
		// str element is 16B (ptr+len). primsize returns 0 for it.
		if (streq(nm, "str")) { return 16; };
		let ps: i32 = primsize(nm);
		if (ps > 0) { return ps; };
	};
	return 8;
};

// elemsizeofc — like elemsizeof but resolves aliased element types
// (struct / tagged / `type foo = bar;`) via slotsize. Used where
// cgindex / cgassign need a correct stride for `[N]Alias` arrays
// whose Alias resolves to a tagged union (e.g. `[N]formattable`).
fn elemsizeofc(c: *cgen, t: *node) i32 = {
	if (t == nil) { return 1; };
	let direct: i32 = elemsizeof(t);
	if (direct != 8) { return direct; };
	let k: nkind = t.kind;
	let elem: *node = nil;
	if (k == nkind.N_TPTR)   { elem = t.lhs; };
	if (k == nkind.N_TSLICE) { elem = t.lhs; };
	if (k == nkind.N_TARRAY) { elem = t.lhs; };
	if (elem == nil) { return direct; };
	if (elem.kind == nkind.N_TNAME) {
		let ps: i32 = primsize(elem.str);
		if (ps > 0) { return ps; };
	};
	return slotsize(c, elem);
};

// nodeisunsigned — best-effort cgen-time inference from the AST. We
// don't have a typed AST yet, so we walk surface nodes:
//   nkind.N_INTLIT      — never marked unsigned (no tsuffix plumbing yet)
//   nkind.N_IDENT       — look up the local's declared type
//   nkind.N_DOT         — look up the field's declared type via struct reg
//   nkind.N_BIN / nkind.N_UN  — recurse: unsigned if either operand is unsigned
//   nkind.N_CAST        — use the cast target type
//
// Conservative: if we can't tell, return false (signed). The cost of
// being wrong here is byte-different asm vs C, not bad runtime.
fn nodeisunsigned(c: *cgen, n: *node) bool = {
	if (n == nil) { return false; };
	let k: nkind = n.kind;
	if (k == nkind.N_IDENT) {
		let nm: str = n.str;
		let lc: *local = localfindnode(c, nm);
		if (lc != nil) { return typenodeisunsigned(lc.tnode); };
		return false;
	};
	if (k == nkind.N_DOT) {
		let base: *node = n.lhs;
		let fld: str = n.str;
		if (base != nil) {
			if (base.kind == nkind.N_IDENT) {
				let bn: str = base.str;
				let lc: *local = localfindnode(c, bn);
				if (lc != nil) {
					let tn: *node = lc.tnode;
					let lkind: nkind = nkind.N_NONE;
					if (tn != nil) { lkind = tn.kind; };
					let sname: str;
					sname.ptr = nil; sname.len = 0;
					if (lkind == nkind.N_TPTR) {
						let inner: *node = tn.lhs;
						if (inner != nil) {
							if (inner.kind == nkind.N_TNAME) { sname = inner.str; };
						};
					};
					if (lkind == nkind.N_TNAME) { sname = tn.str; };
					if (sname.len > 0) {
						let si: *structinfo = structlookup(c, sname);
						if (si != nil) {
							let fi: *fieldinfo = si.fields;
							for (fi != nil) {
								let fn_: str = fi.fname;
								if (streq(fn_, fld)) {
									return typenodeisunsigned(fi.tnode);
								};
								fi = fi.finext;
							};
						};
					};
				};
			};
		};
		return false;
	};
	if (k == nkind.N_CAST) { return typenodeisunsigned(n.rhs); };
	if (k == nkind.N_BIN) {
		if (nodeisunsigned(c, n.lhs)) { return true; };
		return nodeisunsigned(c, n.rhs);
	};
	if (k == nkind.N_UN) { return nodeisunsigned(c, n.lhs); };
	// nkind.N_INDEX: `p[i]` is unsigned iff p's element type is unsigned.
	// Walks the base local's declared type and pulls the element
	// out — *u8 → u8, [N]u32 → u32, []u64 → u64. Without this the
	// compare-codegen for `p[i] >= 48u8` falls back to signed JGE
	// instead of JAE, diverging from C w6c on byte indexing.
	if (k == nkind.N_INDEX) {
		let base: *node = n.lhs;
		if (base != nil) {
			if (base.kind == nkind.N_IDENT) {
				let lc: *local = localfindnode(c, base.str);
				if (lc != nil) {
					let tn: *node = lc.tnode;
					if (tn != nil) {
						let elem: *node = nil;
						if (tn.kind == nkind.N_TPTR)   { elem = tn.lhs; };
						if (tn.kind == nkind.N_TARRAY) { elem = tn.lhs; };
						if (tn.kind == nkind.N_TSLICE) { elem = tn.lhs; };
						if (elem != nil) {
							return typenodeisunsigned(elem);
						};
					};
				};
			};
		};
		return false;
	};
	return false;
};
// ---- type-driven slot sizing ----------------------------------------

fn structlookup(c: *cgen, name: str) *structinfo = {
	let s: *structinfo = c.structs;
	for (s != nil) {
		let sn: str = s.sname;
		if (streq(sn, name)) { return s; };
		s = s.sinext;
	};
	return nil;
};

// primsize — size in bytes of a primitive type name (or 0 if not
// recognised as a primitive — the caller falls back to other paths).
// fldnumidx — parse a tuple field name like "0" / "1" / "12" into an
// index, or -1 if not all-digits. Used by cgdot to dispatch
// `t.0` / `t.1` against an nkind.N_TTUPLE local without pulling in strconv.
fn fldnumidx(s: str) i32 = {
	if (s.len == 0) { return -1; };
	let r: i32 = 0;
	let i: i32 = 0;
	for (i < s.len) {
		let b: u8 = s[i];
		if (b < 48u8) { return -1; };
		if (b > 57u8) { return -1; };
		r = r * 10 + ((b - 48u8): i32);
		i += 1;
	};
	return r;
};

fn primsize(name: str) i32 = {
	if (streq(name, "u8"))   { return 1; };
	if (streq(name, "i8"))   { return 1; };
	if (streq(name, "bool")) { return 1; };
	if (streq(name, "u16"))  { return 2; };
	if (streq(name, "i16"))  { return 2; };
	if (streq(name, "u32"))  { return 4; };
	if (streq(name, "i32"))  { return 4; };
	if (streq(name, "f32"))  { return 4; };
	if (streq(name, "u64"))  { return 8; };
	if (streq(name, "i64"))  { return 8; };
	if (streq(name, "uint")) { return 8; };
	if (streq(name, "int"))  { return 8; };
	if (streq(name, "uintptr")) { return 8; };
	if (streq(name, "f64"))  { return 8; };
	if (streq(name, "rune")) { return 4; };
	if (streq(name, "void")) { return 0; };
	return 0;
};

// variantnamematch — tagged-union variant names are compared as if
// they'd been alias-resolved. Pattern names can be module-qualified
// (`strconv.invalid` from a `case let e: strconv.invalid =>`),
// while the variant's declared name inside its own module is bare
// (`invalid`). With no checker the cgen can't follow imports, so we
// accept exact match plus suffix-after-`.` on either side. Mirrors
// the C cgen's type_eq, which goes through resolved Type pointers.
fn variantnamematch(vname: str, pname: str) bool = {
	if (streq(vname, pname)) { return true; };
	// `pname` is qualified, `vname` is bare: drop module prefix.
	let i: i32 = 0;
	for (i < pname.len) {
		if (pname[i] == '.': u8) {
			let tail: str;
			tail.ptr = pname.ptr + i + 1;
			tail.len = pname.len - i - 1;
			if (streq(tail, vname)) { return true; };
		};
		i += 1;
	};
	// `vname` is qualified, `pname` is bare: same trick in reverse.
	let j: i32 = 0;
	for (j < vname.len) {
		if (vname[j] == '.': u8) {
			let tail: str;
			tail.ptr = vname.ptr + j + 1;
			tail.len = vname.len - j - 1;
			if (streq(tail, pname)) { return true; };
		};
		j += 1;
	};
	return false;
};

// inferletcalltype — for an annotation-less `let x = expr;`, return
// a usable tnode for cgen's struct-aware paths. Today: `let x =
// f()?` infers x's type from the success variant of f's tagged
// return; without this, x has tnode = nil and `x.field` falls into
// the SB-symbol fallback (linker reports `undefined reference to
// <fieldname>`). We don't infer for plain `let x = f()` yet —
// non-tagged returns don't carry their type back the same way.
fn inferletcalltype(c: *cgen, rhs: *node) *node = {
	if (rhs == nil) { return nil; };
	// `?` (N_TRYPROP) and `!` (N_TRYUNW) both unwrap a tagged
	// return to its success variant; the rhs we want the type of
	// is the inner call expression.
	let unwrap: bool = false;
	let call: *node = rhs;
	if (rhs.kind == nkind.N_TRYPROP) { call = rhs.lhs; unwrap = true; };
	if (rhs.kind == nkind.N_TRYUNW)  { call = rhs.lhs; unwrap = true; };
	if (call == nil) { return nil; };
	if (call.kind != nkind.N_CALL) { return nil; };
	let callee: *node = call.lhs;
	if (callee == nil) { return nil; };
	let cname: str;
	cname.ptr = nil; cname.len = 0;
	if (callee.kind == nkind.N_IDENT) { cname = callee.str; };
	if (callee.kind == nkind.N_DOT)   { cname = callee.str; };
	if (cname.len == 0) { return nil; };
	let rt: *node = fnretlookup(c, cname);
	if (rt == nil) { return nil; };
	if (unwrap) {
		// Strip error variants — success type is the first
		// variant of the tagged return.
		if (rt.kind != nkind.N_TTAGGED) { return nil; };
		return rt.list;
	};
	// Plain call: declared return type is the local's type.
	return rt;
};

// letslotsize — slot size for a `let` binding. Like slotsize, but
// detects `[_]T = arrlit;` (the type-AST has rhs == nil as the
// length-inferred sentinel) and computes count × element-size from
// the initialiser. Used by both scanlocals (prologue sizing) and
// cglet (slot alloc) so they agree on the frame layout.
//
// `let x = f();` (no annotation): infer from `f`'s declared return
// type so a 24B tagged-union return reserves all three spill slots,
// not the default 8B. Without this, the AX:DX:CX spill in cglet's
// tagged-init branch writes past the local and tramples the next
// slot.
export fn letslotsize(c: *cgen, n: *node) i32 = {
	// `[_]T = arrlit;` — inferred-length array. slotsize would
	// return elem_size * 1 (treating missing length as 1); intercept
	// and compute the real count first.
	if (n.lhs != nil) {
		if (n.lhs.kind == nkind.N_TARRAY) {
			if (n.lhs.rhs == nil) {
				if (n.rhs != nil) {
					if (n.rhs.kind == nkind.N_ARRLIT) {
						let elemn: *node = n.lhs.lhs;
						let esz: i32 = 8;
						if (elemn != nil) {
							if (elemn.kind == nkind.N_TNAME) {
								let ps: i32 = primsize(elemn.str);
								if (ps > 0) { esz = ps; };
							};
						};
						let cnt: i32 = 0;
						let e: *node = n.rhs.list;
						for (e != nil) {
							let adv: bool = true;
							if (e.kind == nkind.N_FIELD) {
								if (streq(e.str, "...")) {
									e = nil;
									adv = false;
								};
							};
							if (adv) {
								cnt += 1;
								e = e.next;
							};
						};
						return esz * cnt;
					};
				};
			};
		};
	};
	if (n.lhs != nil) { return slotsize(c, n.lhs); };
	// Annotation-less init: defer to the call's return type if we
	// can infer it. Tagged-union returns need 24B; everything else
	// matches slotsize on the inferred type.
	let inferred: *node = inferletcalltype(c, n.rhs);
	if (inferred != nil) { return slotsize(c, inferred); };
	return 8;
};

fn slotsize(c: *cgen, typn: *node) i32 = {
	if (typn == nil) { return 8; };
	let k: nkind = typn.kind;
	if (k == nkind.N_TPTR)   { return 8; };
	if (k == nkind.N_TFN)    { return 8; };
	if (k == nkind.N_TCHAN)  { return 8; };
	if (k == nkind.N_TSLICE) { return 24; };
	if (k == nkind.N_TTUPLE) {
		// Sum element sizes. Mirrors C cgen which uses raw type
		// sizes; padding to 8 happens inside slotsize for primitives,
		// so a `(i64, str)` resolves to 8 + 16 = 24 (matches the C
		// cgen 24B init / positional-access layout).
		let total: i32 = 0;
		let p: *node = typn.list;
		for (p != nil) {
			total += slotsize(c, p);
			p = p.next;
		};
		return total;
	};
	if (k == nkind.N_TTAGGED){
		// Nullable `(*T | void)` collapses to a single 8B pointer.
		if (isnullabletype(typn)) { return 8; };
		// Slot = 8 (tag) + max(variant payload sizes), rounded up
		// to an 8-byte multiple so the reg-passing ABI (size/8
		// words) doesn't drop the last value register. Mirrors C
		// cgen's resolve_type for nkind.N_TTAGGED.
		let v: *node = typn.list;
		let maxsz: i32 = 0;
		for (v != nil) {
			let sz: i32 = slotsize(c, v);
			if (sz > maxsz) { maxsz = sz; };
			v = v.next;
		};
		let pad: i32 = (maxsz + 7) & ~7;
		return 8 + pad;
	};
	if (k == nkind.N_TNAME) {
		let nm: str = typn.str;
		if (streq(nm, "str")) { return 16; };
		let ps: i32 = primsize(nm);
		if (ps > 0) {
			// Pad to 8 for stack slots — matches C cgen which spills
			// every primitive into an 8-byte slot.
			return 8;
		};
		// Named struct lookup.
		let si: *structinfo = structlookup(c, nm);
		if (si != nil) { return si.totsize; };
		// Type alias (`type foo = !str;` / `type foo = bar;`):
		// follow it so a tagged-union variant of a !str-aliased
		// error type contributes 16 bytes to the max payload
		// rather than 8 (the default).
		if (c != nil) {
			let aliased: *node = aliaslookup(c, nm);
			if (aliased != nil) {
				if (aliased.kind == nkind.N_TBANG) {
					return slotsize(c, aliased.lhs);
				};
				return slotsize(c, aliased);
			};
		};
		return 8;
	};
	if (k == nkind.N_TARRAY) {
		let lenn: *node = typn.rhs;
		let elemn: *node = typn.lhs;
		let elen: i64 = 1i64;
		if (lenn != nil) {
			if (lenn.kind == nkind.N_INTLIT) { elen = lenn.uval: i64; };
		};
		let esz: i32 = 8;
		if (elemn != nil) {
			if (elemn.kind == nkind.N_TNAME) {
				let en: str = elemn.str;
				let ps: i32 = primsize(en);
				if (ps > 0) { esz = ps; }
				else {
					// Named struct / aliased type: size off
					// the structinfo if present, else follow
					// the alias via aliaslookup so
					// `[N]formattable` reads the resolved
					// tagged slot (e.g. 24B for
					// `(i64|str|bool)`), not the fall-
					// through 8B.
					let si: *structinfo = structlookup(c, en);
					if (si != nil) { esz = si.totsize; }
					else { if (c != nil) {
						let al: *node = aliaslookup(c, en);
						if (al != nil) {
							esz = slotsize(c, al);
						};
					}; };
				};
			} else { if (elemn.kind == nkind.N_TTAGGED) {
				// Tagged-union element: full slot (8 tag +
				// padded max payload). Matches C cgen's
				// resolve_type for `[N]TAGGED`.
				esz = slotsize(c, elemn);
			} else { if (elemn.kind == nkind.N_TPTR) {
				esz = 8;
			} else { if (elemn.kind == nkind.N_TSTRUCT) {
				esz = slotsize(c, elemn);
			}; }; }; };
		};
		return (esz: i64 * elen): i32;
	};
	if (k == nkind.N_TSTRUCT) {
		// Inline anonymous struct — sum of field sizes.
		let f: *node = typn.list;
		let total: i32 = 0;
		for (f != nil) {
			if (f.kind == nkind.N_TFIELD) {
				total += slotsize(c, f.lhs);
			};
			f = f.next;
		};
		return total;
	};
	return 8;
};

// registerstruct — compute field offsets + total size for a struct
// type-decl, store in c.structs. Field type sizes use the same
// slotsize logic (with primitives kept at their natural width — we
// only round to 8 for stack slots, not struct interiors).
fn fieldsize(c: *cgen, tnode: *node) i32 = {
	if (tnode == nil) { return 8; };
	let k: nkind = tnode.kind;
	if (k == nkind.N_TNAME) {
		let nm: str = tnode.str;
		if (streq(nm, "str")) { return 16; };
		let ps: i32 = primsize(nm);
		if (ps > 0) { return ps; };
		let si: *structinfo = structlookup(c, nm);
		if (si != nil) { return si.totsize; };
		// Enum: size of its storage type. Mirrors the C cgen, which
		// reads Type.size off the TY_ENUM (which inherits from .sub).
		let en: *enumtype = enumlookup(c, nm);
		if (en != nil) {
			if (en.storage != nil) {
				if (en.storage.kind == nkind.N_TNAME) {
					let sps: i32 = primsize(en.storage.str);
					if (sps > 0) { return sps; };
				};
			};
			return 4;	// default storage is i32
		};
		return 8;
	};
	if (k == nkind.N_TPTR)   { return 8; };
	if (k == nkind.N_TSLICE) { return 24; };
	if (k == nkind.N_TARRAY) {
		// Same shape as slotsize's TARRAY branch.
		let lenn: *node = tnode.rhs;
		let elemn: *node = tnode.lhs;
		let elen: i64 = 1i64;
		if (lenn != nil) {
			if (lenn.kind == nkind.N_INTLIT) { elen = lenn.uval: i64; };
		};
		let esz: i32 = fieldsize(c, elemn);
		return (esz: i64 * elen): i32;
	};
	return 8;
};

fn registerstruct(c: *cgen, name: str, tstruct: *node) void = {
	let si: *structinfo = amalloc(c.a, 64u64): *structinfo;
	si.sname = name;
	si.fields = nil;
	si.totsize = 0;
	let head: *fieldinfo = nil;
	let tail: *fieldinfo = nil;
	let off: i32 = 0;
	let f: *node = tstruct.list;
	for (f != nil) {
		if (f.kind == nkind.N_TFIELD) {
			let sz: i32 = fieldsize(c, f.lhs);
			// Align to 8 for any field >= 4 bytes (matches our other
			// cgen choices). i8/u8/bool may sit on odd byte offsets;
			// the C cgen does similar best-effort packing.
			let aln: i32 = 1;
			if (sz >= 8) { aln = 8; }
			else { if (sz >= 4) { aln = 4; }
			else { if (sz >= 2) { aln = 2; }; }; };
			if ((off & (aln - 1)) != 0) {
				off = (off + aln - 1) & ~(aln - 1);
			};
			let fi: *fieldinfo = amalloc(c.a, 48u64): *fieldinfo;
			fi.fname = f.str;
			fi.foff = off;
			fi.fsz  = sz;
			fi.tnode = f.lhs;
			if (head == nil) { head = fi; tail = fi; }
			else { tail.finext = fi; tail = fi; };
			off += sz;
		};
		f = f.next;
	};
	// Round total to 8 for stack-slot use.
	if ((off & 7) != 0) { off = (off + 7) & ~7; };
	si.fields = head;
	si.totsize = off;
	si.sinext = c.structs;
	c.structs = si;
};

fn collectstructs(c: *cgen, file: *node) void = {
	c.structs = nil;
	if (file == nil) { return; };
	let d: *node = file.list;
	for (d != nil) {
		if (d.kind == nkind.N_TYPEDECL) {
			let body: *node = d.lhs;
			if (body != nil) {
				if (body.kind == nkind.N_TSTRUCT) {
					registerstruct(c, d.str, body);
				};
			};
		};
		d = d.next;
	};
};

// `type X = str;` aliases) to `str`. Takes *cgen so it can walk the
// alias chain registered at file load.
fn isstrtyperaw(t: *node) bool = {
	if (t == nil) { return false; };
	if (t.kind == nkind.N_TNAME) {
		let nm: str = t.str;
		if (streq(nm, "str")) { return true; };
	};
	return false;
};

fn isstrtype(c: *cgen, t: *node) bool = {
	if (isstrtyperaw(t)) { return true; };
	if (c == nil) { return false; };
	let r: *node = resolvetype(c, t);
	if (isstrtyperaw(r)) { return true; };
	// `parserr = !str` — `!T` aliases shouldn't hide their
	// underlying type from str-routing. Unwrap and re-check.
	if (r != nil) {
		if (r.kind == nkind.N_TBANG) {
			let inner: *node = r.lhs;
			if (isstrtyperaw(inner)) { return true; };
			if (inner != nil) {
				let r2: *node = resolvetype(c, inner);
				if (isstrtyperaw(r2)) { return true; };
			};
		};
	};
	return false;
};

fn isslicetyperaw(t: *node) bool = {
	if (t == nil) { return false; };
	if (t.kind == nkind.N_TSLICE) { return true; };
	return false;
};

fn isslicetype(c: *cgen, t: *node) bool = {
	if (isslicetyperaw(t)) { return true; };
	if (c == nil) { return false; };
	let r: *node = resolvetype(c, t);
	return isslicetyperaw(r);
};

fn istaggedtyperaw(t: *node) bool = {
	if (t == nil) { return false; };
	if (t.kind == nkind.N_TTAGGED) { return true; };
	return false;
};

// resolvetagged — return the underlying N_TTAGGED node for `t`, or nil
// if `t` doesn't ultimately denote a tagged union. Follows N_TNAME
// aliases (via resolvetype) and unwraps one leading N_TBANG so
// `type error = !(invalid | overflow);` resolves to its inner
// `(invalid | overflow)` node. Use at sites that read variant lists
// or detect nullable folding off a scrutinee — cgmatch, cgtypetest,
// cgtypeassert — so aliased `!(A|B)` shapes still dispatch.
export fn resolvetagged(c: *cgen, t: *node) *node = {
	let r: *node = resolvetype(c, t);
	if (r == nil) { return nil; };
	if (r.kind == nkind.N_TBANG) {
		let inner: *node = r.lhs;
		if (inner == nil) { return nil; };
		r = resolvetype(c, inner);
		if (r == nil) { return nil; };
	};
	if (r.kind == nkind.N_TTAGGED) { return r; };
	return nil;
};

// istaggedtype — alias-aware. Mirrors isstrtype: follow N_TNAME to its
// underlying decl, then unwrap a leading N_TBANG so `type error =
// !(invalid | overflow);` is still recognised as tagged. Without the
// bang unwrap the prologue treats the param as scalar (8B), spilling
// only DI and losing the value-word SI; the match read of slot+8 then
// trails into saved BP.
fn istaggedtype(c: *cgen, t: *node) bool = {
	if (istaggedtyperaw(t)) { return true; };
	if (c == nil) { return false; };
	let r: *node = resolvetype(c, t);
	if (istaggedtyperaw(r)) { return true; };
	if (r != nil) {
		if (r.kind == nkind.N_TBANG) {
			let inner: *node = r.lhs;
			if (istaggedtyperaw(inner)) { return true; };
			if (inner != nil) {
				let r2: *node = resolvetype(c, inner);
				if (istaggedtyperaw(r2)) { return true; };
			};
		};
	};
	return false;
};

// isf32typeraw / isf64typeraw — bare TNAME check, no alias resolution.
fn isf32typeraw(t: *node) bool = {
	if (t == nil) { return false; };
	if (t.kind != nkind.N_TNAME) { return false; };
	return streq(t.str, "f32");
};

fn isf64typeraw(t: *node) bool = {
	if (t == nil) { return false; };
	if (t.kind != nkind.N_TNAME) { return false; };
	return streq(t.str, "f64");
};

// isfloattype — f32 / f64 (and aliases of those). Used by cglet,
// cgident, cgassign, cgbin, cgcast, cgcall, cgreturn, fn-prologue to
// dispatch the MOVSS/MOVSD-shaped paths.
export fn isfloattype(c: *cgen, t: *node) bool = {
	if (isf32typeraw(t)) { return true; };
	if (isf64typeraw(t)) { return true; };
	if (c == nil) { return false; };
	let r: *node = resolvetype(c, t);
	if (isf32typeraw(r)) { return true; };
	if (isf64typeraw(r)) { return true; };
	return false;
};

// isf32type — narrower predicate: true only for f32 (after alias
// resolution). f64 returns false. Used to pick MOVSS vs MOVSD and
// the SS-variant arithmetic / cast opcodes.
export fn isf32type(c: *cgen, t: *node) bool = {
	if (isf32typeraw(t)) { return true; };
	if (c == nil) { return false; };
	let r: *node = resolvetype(c, t);
	return isf32typeraw(r);
};

// exprfloatkind — classify an expression's value-class so callers can
// pick float vs integer codegen without a full type system. Returns:
//   0  — integer-like (or unknown — same fallback the existing cgen
//        takes today)
//   1  — f32
//   2  — f64
// Recognises: float literals, idents bound to float lets/locals,
// chained casts whose target is float, and (recursively) the inner
// expr of a non-narrowing wrapping construct. Anything we can't
// pin down conservatively reports integer — the worst case is that
// CVT* is skipped for an exotic case the user can still spell with
// an explicit local.
export fn exprfloatkind(c: *cgen, n: *node) i32 = {
	if (n == nil) { return 0; };
	let k: nkind = n.kind;
	if (k == nkind.N_FLOATLIT) { return 2; };
	if (k == nkind.N_CAST) {
		if (isf32type(c, n.rhs)) { return 1; };
		if (isfloattype(c, n.rhs)) { return 2; };
		return 0;
	};
	if (k == nkind.N_IDENT) {
		let lc: *local = localfindnode(c, n.str);
		if (lc != nil) {
			if (isf32type(c, lc.tnode)) { return 1; };
			if (isfloattype(c, lc.tnode)) { return 2; };
			return 0;
		};
		let lv: *letvar = c.lets;
		for (lv != nil) {
			if (streq(lv.name, n.str)) {
				if (isf32type(c, lv.tnode)) { return 1; };
				if (isfloattype(c, lv.tnode)) { return 2; };
				return 0;
			};
			lv = lv.lvnext;
		};
		return 0;
	};
	if (k == nkind.N_UN) {
		// Unary on a float (TK_MINUS) returns float; everything
		// else is integer-coded.
		if (n.op == tkind.TK_MINUS) {
			return exprfloatkind(c, n.lhs);
		};
		return 0;
	};
	if (k == nkind.N_BIN) {
		// Arithmetic binops inherit the operands' kind. Comparison
		// (eq/ne/lt/...) returns bool — integer.
		let op: tkind = n.op;
		if (op == tkind.TK_PLUS)  { return exprfloatkind(c, n.lhs); };
		if (op == tkind.TK_MINUS) { return exprfloatkind(c, n.lhs); };
		if (op == tkind.TK_STAR)  { return exprfloatkind(c, n.lhs); };
		if (op == tkind.TK_SLASH) { return exprfloatkind(c, n.lhs); };
		return 0;
	};
	if (k == nkind.N_CALL) {
		// Look up the callee's declared return type — fnretlookup
		// returns the type-AST. Routes float-returning fns through
		// the X0 ABI so cglet / cgassign know to spill from X0.
		let nm: str;
		nm.ptr = nil; nm.len = 0;
		if (n.lhs != nil) {
			if (n.lhs.kind == nkind.N_IDENT) { nm = n.lhs.str; };
		};
		if (nm.len > 0) {
			let rt: *node = fnretlookup(c, nm);
			if (isf32type(c, rt)) { return 1; };
			if (isfloattype(c, rt)) { return 2; };
		};
		return 0;
	};
	if (k == nkind.N_DOT) {
		// `p.field` where the struct field is f64/f32. Without this,
		// `v.fval: i64` lowers to CVTSI on an integer-load value
		// instead of CVTTSD2SI on the X0 the cgdot path actually
		// emits for an f64 field.
		let base: *node = n.lhs;
		let fld: str = n.str;
		if (base != nil) {
			let sname: str;
			sname.ptr = nil; sname.len = 0;
			if (base.kind == nkind.N_IDENT) {
				let lc: *local = localfindnode(c, base.str);
				if (lc != nil) {
					let tn: *node = lc.tnode;
					if (tn != nil) {
						if (tn.kind == nkind.N_TNAME) { sname = tn.str; };
						if (tn.kind == nkind.N_TPTR) {
							let pe: *node = tn.lhs;
							if (pe != nil) {
								if (pe.kind == nkind.N_TNAME) { sname = pe.str; };
							};
						};
					};
				};
			};
			if (sname.len > 0) {
				let si: *structinfo = structlookup(c, sname);
				if (si != nil) {
					let fi: *fieldinfo = si.fields;
					for (fi != nil) {
						if (streq(fi.fname, fld)) {
							if (isf32type(c, fi.tnode)) { return 1; };
							if (isfloattype(c, fi.tnode)) { return 2; };
							return 0;
						};
						fi = fi.finext;
					};
				};
			};
		};
		return 0;
	};
	return 0;
};

// isnullabletype — nkind.N_TTAGGED with exactly two children, one *T and
// one `void`. Folds to a single 8-byte pointer slot per Hare's
// `(*T | null)` semantics. Mirrors check.c's resolve_type detection.
export fn isnullabletype(t: *node) bool = {
	if (t == nil) { return false; };
	if (t.kind != nkind.N_TTAGGED) { return false; };
	let a: *node = t.list;
	if (a == nil) { return false; };
	let b: *node = a.next;
	if (b == nil) { return false; };
	if (b.next != nil) { return false; };
	let aptr: bool = (a.kind == nkind.N_TPTR);
	let bptr: bool = (b.kind == nkind.N_TPTR);
	let avoid: bool = (a.kind == nkind.N_TNAME);
	if (avoid) { avoid = streq(a.str, "void"); };
	let bvoid: bool = (b.kind == nkind.N_TNAME);
	if (bvoid) { bvoid = streq(b.str, "void"); };
	if (aptr) { if (bvoid) { return true; }; };
	if (avoid) { if (bptr) { return true; }; };
	return false;
};

// nullableptrtag — 0-based index of the *T variant in a nullable
// union. The void variant takes the other slot (0 or 1).
export fn nullableptrtag(t: *node) i32 = {
	if (t == nil) { return 0; };
	if (t.kind != nkind.N_TTAGGED) { return 0; };
	let a: *node = t.list;
	if (a != nil) { if (a.kind == nkind.N_TPTR) { return 0; }; };
	return 1;
};

// voidvariantindex — find the 0-based index of the `void` variant in a
// tagged-union type expr, -1 if absent. Used by cgreturn to map bare
// `return;` in a tagged-union-returning fn to the void variant's tag.
fn voidvariantindex(tagged: *node) i32 = {
	if (tagged == nil) { return -1; };
	if (tagged.kind != nkind.N_TTAGGED) { return -1; };
	let v: *node = tagged.list;
	let idx: i32 = 0;
	for (v != nil) {
		if (v.kind == nkind.N_TNAME) {
			if (streq(v.str, "void")) { return idx; };
		};
		v = v.next;
		idx += 1;
	};
	return -1;
};

// rhstargetname — for a returned value, what's its declared (or
// surface-inferred) type name? `expr: T` casts dictate T directly;
// bare strlit/intlit fall back to a primitive name.
fn rhstargetname(c: *cgen, rhs: *node) str = {
	let nm: str;
	nm.ptr = nil; nm.len = 0;
	if (rhs == nil) { return nm; };
	if (rhs.kind == nkind.N_CAST) {
		let t: *node = rhs.rhs;
		if (t != nil) {
			if (t.kind == nkind.N_TNAME) { return t.str; };
		};
		return nm;
	};
	if (rhs.kind == nkind.N_STRLIT) { return "str"; };
	// `T{}` carries its type name on the lhs N_IDENT — the parser
	// builds `N_STRUCTLIT{ lhs = N_IDENT("T"), list = fields }`.
	// Needed so `return eof{};` (variant of a tagged union) resolves
	// to the `eof` variant index rather than falling through to the
	// "first non-str variant" fallback in taggedvariantindex.
	if (rhs.kind == nkind.N_STRUCTLIT) {
		let tref: *node = rhs.lhs;
		if (tref != nil) {
			if (tref.kind == nkind.N_IDENT) { return tref.str; };
			if (tref.kind == nkind.N_TNAME) { return tref.str; };
		};
		return nm;
	};
	if (rhs.kind == nkind.N_IDENT) {
		let lc: *local = localfindnode(c, rhs.str);
		if (lc != nil) {
			let tn: *node = lc.tnode;
			if (tn != nil) {
				if (tn.kind == nkind.N_TNAME) { return tn.str; };
			};
		};
	};
	return nm;
};

// taggedvariantindex — given the tagged-union type expr and the
// returned value's surface type, find the matching variant's 0-based
// index. Compare by exact type name first; if no match, fall back to
// "any str-shape variant matches an str-typed value".
fn taggedvariantindex(c: *cgen, tagged: *node, rhs: *node) i32 = {
	if (tagged == nil) { return -1; };
	if (rhs == nil)    { return -1; };
	let wantname: str = rhstargetname(c, rhs);
	if (wantname.len > 0) {
		let r: i32 = flatvariantidx(c, tagged, wantname);
		if (r >= 0) { return r; };
	};
	// Fallback: by str-shape (resolves aliases). Walks the
	// spread-flattened variant list so a `(...inner | str)` outer
	// agrees with the (i32 | str) inner's str position.
	let wantstr: bool = nodeisstr(c, rhs);
	let v: *node = tagged.list;
	let idx: i32 = 0;
	for (v != nil) {
		let isspread: bool = (v.op == tkind.TK_ELLIPSIS);
		if (isspread) {
			let inner: *node = v;
			if (inner.kind == nkind.N_TNAME) {
				let a: *node = aliaslookup(c, inner.str);
				if (a != nil) { inner = a; };
			};
			if (inner != nil) {
				if (inner.kind == nkind.N_TTAGGED) {
					let iv: *node = inner.list;
					for (iv != nil) {
						let ivisstr: bool = false;
						if (iv.kind == nkind.N_TNAME) {
							if (isstrtype(c, iv)) { ivisstr = true; };
						};
						if (ivisstr == wantstr) { return idx; };
						iv = iv.next;
						idx += 1;
					};
					v = v.next;
					continue;
				};
			};
		};
		let visstr: bool = false;
		if (v.kind == nkind.N_TNAME) {
			if (isstrtype(c, v)) { visstr = true; };
		};
		if (visstr == wantstr) { return idx; };
		v = v.next;
		idx += 1;
	};
	return -1;
};

// flatvariantidx — walk `tagged`'s variant list (with spread `...inner`
// expansion) and return the flat 0-based index where `want` matches.
// Mirrors check.c's spread flatten at type resolution: an outer
// `(...inner | T)` has the inner's variants inlined in declaration
// order, so the tag indices stay in sync between cstage (which
// resolves types upfront) and wwstage (which doesn't). Returns -1 if
// no variant matches.
fn flatvariantidx(c: *cgen, tagged: *node, want: str) i32 = {
	if (tagged == nil) { return -1; };
	if (tagged.kind != nkind.N_TTAGGED) { return -1; };
	if (want.len == 0) { return -1; };
	let v: *node = tagged.list;
	let idx: i32 = 0;
	for (v != nil) {
		let isspread: bool = (v.op == tkind.TK_ELLIPSIS);
		if (isspread) {
			let inner: *node = v;
			if (inner.kind == nkind.N_TNAME) {
				let a: *node = aliaslookup(c, inner.str);
				if (a != nil) { inner = a; };
			};
			if (inner != nil) {
				if (inner.kind == nkind.N_TTAGGED) {
					let iv: *node = inner.list;
					for (iv != nil) {
						if (iv.kind == nkind.N_TNAME) {
							if (variantnamematch(iv.str, want)) {
								return idx;
							};
						};
						iv = iv.next;
						idx += 1;
					};
					v = v.next;
					continue;
				};
			};
		};
		if (v.kind == nkind.N_TNAME) {
			if (variantnamematch(v.str, want)) { return idx; };
		};
		v = v.next;
		idx += 1;
	};
	return -1;
};

// cgwidentagremap — when widening from one tagged union to a wider one,
// rewrite the source's variant tag at slot_off+0 to use the destination's
// variant indices. No-op when src and dst index orders coincide.
// Mirrors cg_widen_tag_remap in cmd/w6c/cgen.c.
fn cgwidentagremap(c: *cgen, dst: *node, src: *node, slot_off: i32) void = {
	if (dst == nil) { return; };
	if (src == nil) { return; };
	if (dst.kind != nkind.N_TTAGGED) { return; };
	if (src.kind != nkind.N_TTAGGED) { return; };
	let identity: bool = true;
	let v: *node = src.list;
	let idx: i32 = 0;
	for (v != nil) {
		let di: i32 = cgtagvariantidx(c, dst, v);
		if (di < 0) { di = 0; };
		if (di != idx) { identity = false; v = nil; }
		else           { v = v.next; idx += 1; };
	};
	if (identity) { return; };
	let done: str = mklabel(c, "remap_done");
	emitline("\tMOVQ\t");
	emitoff(slot_off: i64);
	emitline("(BP), AX\n");
	v = src.list;
	idx = 0;
	for (v != nil) {
		let next: str = mklabel(c, "remap_next");
		let di: i32 = cgtagvariantidx(c, dst, v);
		if (di < 0) { di = 0; };
		emitline("\tCMPQ\t$");
		emitint(idx: i64);
		emitline(", AX\n");
		emitline("\tJNE\t");
		emitline(next);
		emitline("\n");
		emitline("\tMOVQ\t$");
		emitint(di: i64);
		emitline(", AX\n");
		emitline("\tMOVQ\tAX, ");
		emitoff(slot_off: i64);
		emitline("(BP)\n");
		emitline("\tJMP\t");
		emitline(done);
		emitline("\n");
		emitlabel(next);
		v = v.next;
		idx += 1;
	};
	emitlabel(done);
	return;
};

// rhsisstructpayload — is `src` a struct value (literal or local ident
// of a struct type)? Returns the struct name, or empty str. Only true
// when the name is registered in c.structs — `!void` / `!i32` aliases
// share the N_STRUCTLIT / N_TNAME shape but aren't structs, and must
// fall through to the scalar/str/tagged-source paths instead.
fn rhsstructpayload(c: *cgen, src: *node) str = {
	let empty: str;
	empty.ptr = nil; empty.len = 0;
	if (src == nil) { return empty; };
	if (src.kind == nkind.N_STRUCTLIT) {
		let trefn: *node = src.lhs;
		if (trefn != nil) {
			let nm: str;
			nm.ptr = nil; nm.len = 0;
			if (trefn.kind == nkind.N_IDENT) { nm = trefn.str; };
			if (trefn.kind == nkind.N_TNAME) { nm = trefn.str; };
			if (nm.len > 0) {
				if (structlookup(c, nm) != nil) { return nm; };
			};
		};
		return empty;
	};
	if (src.kind == nkind.N_IDENT) {
		let lc: *local = localfindnode(c, src.str);
		if (lc != nil) {
			let tn: *node = lc.tnode;
			if (tn != nil) {
				if (tn.kind == nkind.N_TNAME) {
					if (structlookup(c, tn.str) != nil) {
						return tn.str;
					};
				};
			};
		};
	};
	return empty;
};

// rhstaggedsource — return the tagged-type node for `src` when src is a
// tagged-typed local ident; nil otherwise. The slot-copy path uses this
// to walk variants for tag remap.
fn rhstaggedident(c: *cgen, src: *node) *node = {
	if (src == nil) { return nil; };
	if (src.kind != nkind.N_IDENT) { return nil; };
	let lc: *local = localfindnode(c, src.str);
	if (lc == nil) { return nil; };
	let tn: *node = lc.tnode;
	if (!istaggedtype(c, tn)) { return nil; };
	return resolvetagged(c, tn);
};

// rhstaggedabicall — does `src` produce a tagged value via the AX/DX/CX
// return ABI? True for N_CALL of a tagged-returning fn and N_INDEX of a
// tagged-element base. Used to decide whether cgexpr/spill works for the
// tagged-source branch of cgwidentaggedstore.
fn rhstaggedabicall(c: *cgen, src: *node) bool = {
	if (src == nil) { return false; };
	if (src.kind == nkind.N_CALL) {
		let callee: *node = src.lhs;
		if (callee != nil) {
			let calleename: str;
			calleename.ptr = nil; calleename.len = 0;
			if (callee.kind == nkind.N_IDENT) { calleename = callee.str; };
			if (callee.kind == nkind.N_DOT)   { calleename = callee.str; };
			if (calleename.len > 0) {
				let rt: *node = fnretlookup(c, calleename);
				if (rt != nil) {
					if (istaggedtype(c, rt)) { return true; };
				};
			};
		};
		return false;
	};
	if (src.kind == nkind.N_INDEX) {
		let base: *node = src.lhs;
		if (base != nil) {
			if (base.kind == nkind.N_IDENT) {
				let bl: *local = localfindnode(c, base.str);
				if (bl != nil) {
					let btn: *node = bl.tnode;
					if (btn != nil) {
						let bk: nkind = btn.kind;
						let elemt: *node = nil;
						if (bk == nkind.N_TARRAY) { elemt = btn.lhs; };
						if (bk == nkind.N_TSLICE) { elemt = btn.lhs; };
						if (bk == nkind.N_TPTR)   { elemt = btn.lhs; };
						if (elemt != nil) {
							if (istaggedtype(c, elemt)) {
								return true;
							};
						};
					};
				};
			};
		};
	};
	return false;
};

// cgwidentaggedstore — write tagged-union slot bytes for `src` into the
// slot at BP+slot_off, sized to slot_sz. Mirrors cg_widen_tagged_store
// in cmd/w6c/cgen.c. Branches by source shape:
//   - nullable dst (8B slot): cgexpr → AX → slot+0.
//   - tagged src ident: copy slot words, zero-pad, tag-remap.
//   - tagged src via AX/DX/CX ABI (call / tagged-arr index): cgexpr,
//     spill words; no remap (callee already speaks dst tag order — or
//     it doesn't, in which case the source is the wider one and remap
//     would need a reversed direction we don't currently emit).
//   - struct src (literal or ident): zero slot, write fields at +8+foff,
//     tag last.
//   - str src: tag@+0, ptr@+8, len@+16.
//   - scalar src: tag@+0, value@+8.
fn cgwidentaggedstore(c: *cgen, dst: *node, src: *node, slot_off: i32, slot_sz: i32) void = {
	let dt: *node = resolvetagged(c, dst);
	if (dt == nil) { return; };
	// Nullable fold: one 8B word holding the pointer (or 0 for void).
	if (isnullabletype(dst)) {
		cgexpr(c, src);
		emitline("\tMOVQ\tAX, ");
		emitoff(slot_off: i64);
		emitline("(BP)\n");
		return;
	};
	// `expr: TaggedAlias` where the cast's destination IS the union
	// itself is a widening, not a re-interpret. cgexpr on a CAST
	// produces the inner's register shape (str: AX=ptr, BX=len), not
	// the tagged AX/DX/CX triple — so peel to the inner and route
	// through the matching concrete-variant branch below. A cast to
	// a concrete variant (`7: i32`) is left intact so the existing
	// scalar / str / slice branches pick the right variant tag.
	if (src != nil) {
		if (src.kind == nkind.N_CAST) {
			if (src.lhs != nil) {
				let inner: *node = src.lhs;
				let inneristagged: bool = false;
				if (inner.kind == nkind.N_IDENT) {
					let lc: *local = localfindnode(c, inner.str);
					if (lc != nil) {
						inneristagged = istaggedtype(c, lc.tnode);
					};
				};
				if (rhstaggedabicall(c, inner)) {
					inneristagged = true;
				};
				// Cast's destination = the dst tagged union
				// itself? The rhs of N_CAST holds the target
				// type. Compare nominally via str match on
				// the tagged-alias name.
				let castisdst: bool = false;
				let castrhs: *node = src.rhs;
				if (castrhs != nil) {
					if (castrhs.kind == nkind.N_TTAGGED) {
						castisdst = true;
					};
					if (castrhs.kind == nkind.N_TNAME) {
						if (dst != nil) {
							if (dst.kind == nkind.N_TNAME) {
								if (streq(castrhs.str, dst.str)) {
									castisdst = true;
								};
							};
						};
					};
				};
				if (castisdst && !inneristagged) {
					src = inner;
				};
			};
		};
	};
	// Tagged source ident: byte-copy slot words then tag-remap.
	let st: *node = rhstaggedident(c, src);
	if (st != nil) {
		let lc: *local = localfindnode(c, src.str);
		let ssz: i32 = slotsize(c, lc.tnode);
		let soff: i32 = lc.off;
		let k: i32 = 0;
		for (k < ssz) {
			emitline("\tMOVQ\t");
			emitoff((soff + k): i64);
			emitline("(BP), AX\n");
			emitline("\tMOVQ\tAX, ");
			emitoff((slot_off + k): i64);
			emitline("(BP)\n");
			k += 8;
		};
		if (ssz < slot_sz) {
			emitline("\tXORQ\tAX, AX\n");
			let p: i32 = ssz;
			for (p < slot_sz) {
				emitline("\tMOVQ\tAX, ");
				emitoff((slot_off + p): i64);
				emitline("(BP)\n");
				p += 8;
			};
		};
		cgwidentagremap(c, dt, st, slot_off);
		return;
	};
	// Tagged source via AX/DX/CX/R8 register ABI (N_CALL, N_INDEX
	// of tagged element). R8 carries the 4th word for slice-payload
	// variants (slot 32B).
	if (rhstaggedabicall(c, src)) {
		cgexpr(c, src);
		emitline("\tMOVQ\tAX, ");
		emitoff(slot_off: i64);
		emitline("(BP)\n");
		if (slot_sz > 8) {
			emitline("\tMOVQ\tDX, ");
			emitoff((slot_off + 8): i64);
			emitline("(BP)\n");
		};
		if (slot_sz > 16) {
			emitline("\tMOVQ\tCX, ");
			emitoff((slot_off + 16): i64);
			emitline("(BP)\n");
		};
		if (slot_sz > 24) {
			emitline("\tMOVQ\tR8, ");
			emitoff((slot_off + 24): i64);
			emitline("(BP)\n");
		};
		return;
	};
	// Struct payload (literal or ident).
	let sname: str = rhsstructpayload(c, src);
	if (sname.len > 0) {
		let si: *structinfo = structlookup(c, sname);
		if (si != nil) {
			emitline("\tXORQ\tAX, AX\n");
			let zoff: i32 = 0;
			for (zoff < slot_sz) {
				emitline("\tMOVQ\tAX, ");
				emitoff((slot_off + zoff): i64);
				emitline("(BP)\n");
				zoff += 8;
			};
			let tag: i32 = taggedvariantindex(c, dt, src);
			if (tag < 0) { tag = 0; };
			if (src.kind == nkind.N_STRUCTLIT) {
				let fnode: *node = src.list;
				for (fnode != nil) {
					if (fnode.kind == nkind.N_FIELD) {
						let fname: str = fnode.str;
						let fi: *fieldinfo = si.fields;
						for (fi != nil) {
							if (streq(fi.fname, fname)) {
								cgexpr(c, fnode.lhs);
								if (isfloattype(c, fi.tnode)) {
									let mov: str = "MOVSD";
									if (isf32type(c, fi.tnode)) {
										mov = "MOVSS";
									};
									emitline("\t");
									emitline(mov);
									emitline("\tX0, ");
									emitoff((slot_off + 8 + fi.foff): i64);
									emitline("(BP)\n");
								} else { if (isstrtype(c, fi.tnode)) {
									emitline("\tMOVQ\tAX, ");
									emitoff((slot_off + 8 + fi.foff): i64);
									emitline("(BP)\n");
									emitline("\tMOVQ\tBX, ");
									emitoff((slot_off + 8 + fi.foff + 8): i64);
									emitline("(BP)\n");
								} else {
									let sop: str = fieldstoreop(fi);
									emitline("\t");
									emitline(sop);
									emitline("\tAX, ");
									emitoff((slot_off + 8 + fi.foff): i64);
									emitline("(BP)\n");
								}; };
								fi = nil;
							} else {
								fi = fi.finext;
							};
						};
					};
					fnode = fnode.next;
				};
			} else {
				// Struct ident source: byte-copy struct words to slot+8+k.
				let lc: *local = localfindnode(c, src.str);
				let soff: i32 = 0;
				if (lc != nil) { soff = lc.off; };
				let stotal: i32 = si.totsize;
				let ki: i32 = 0;
				for (ki + 8 <= stotal) {
					emitline("\tMOVQ\t");
					emitoff((soff + ki): i64);
					emitline("(BP), AX\n");
					emitline("\tMOVQ\tAX, ");
					emitoff((slot_off + 8 + ki): i64);
					emitline("(BP)\n");
					ki += 8;
				};
				if (ki < stotal) {
					let tail: i32 = stotal - ki;
					let lop: str = "MOVQ";
					if (tail == 4) { lop = "MOVL"; }
					else { if (tail == 1) { lop = "MOVB"; }; };
					emitline("\t");
					emitline(lop);
					emitline("\t");
					emitoff((soff + ki): i64);
					emitline("(BP), AX\n");
					emitline("\t");
					emitline(lop);
					emitline("\tAX, ");
					emitoff((slot_off + 8 + ki): i64);
					emitline("(BP)\n");
				};
			};
			emitline("\tMOVQ\t$");
			emitint(tag: i64);
			emitline(", ");
			emitoff(slot_off: i64);
			emitline("(BP)\n");
			return;
		};
	};
	// Str payload.
	if (nodeisstr(c, src)) {
		cgexpr(c, src);
		emitline("\tMOVQ\tAX, ");
		emitoff((slot_off + 8): i64);
		emitline("(BP)\n");
		emitline("\tMOVQ\tBX, ");
		emitoff((slot_off + 16): i64);
		emitline("(BP)\n");
		let tag: i32 = taggedvariantindex(c, dt, src);
		if (tag < 0) { tag = 0; };
		emitline("\tMOVQ\t$");
		emitint(tag: i64);
		emitline(", ");
		emitoff(slot_off: i64);
		emitline("(BP)\n");
		return;
	};
	// Slice payload (24B): cgexpr leaves (AX=ptr, BX=len, CX=cap).
	// Slot layout: [+0]=tag, [+8]=ptr, [+16]=len, [+24]=cap.
	if (nodeisslice(c, src)) {
		cgexpr(c, src);
		emitline("\tMOVQ\tAX, ");
		emitoff((slot_off + 8): i64);
		emitline("(BP)\n");
		emitline("\tMOVQ\tBX, ");
		emitoff((slot_off + 16): i64);
		emitline("(BP)\n");
		emitline("\tMOVQ\tCX, ");
		emitoff((slot_off + 24): i64);
		emitline("(BP)\n");
		let tag: i32 = taggedvariantindex(c, dt, src);
		if (tag < 0) { tag = 0; };
		emitline("\tMOVQ\t$");
		emitint(tag: i64);
		emitline(", ");
		emitoff(slot_off: i64);
		emitline("(BP)\n");
		return;
	};
	// Scalar payload.
	cgexpr(c, src);
	emitline("\tMOVQ\tAX, ");
	emitoff((slot_off + 8): i64);
	emitline("(BP)\n");
	let tag: i32 = taggedvariantindex(c, dt, src);
	if (tag < 0) { tag = 0; };
	emitline("\tMOVQ\t$");
	emitint(tag: i64);
	emitline(", ");
	emitoff(slot_off: i64);
	emitline("(BP)\n");
	return;
};