// selfhost/cmd/wcc/check.ww — minimal port of cmd/wcc/check.c.
//
// Status: name-resolution + primitive-type seeding only. Full type
// inference, conversion rules, tagged-union dispatch typing, return-
// type checking, etc. all live in cmd/wcc/check.c (937 lines) and
// will land here in subsequent commits.
//
// What this version does:
//   1. Creates a top scope and seeds it with primitive type names so
//      `i32`, `str`, `*u8` etc. resolve.
//   2. Walks the file's top-level decls (use/def/type/fn/let) and
//      installs Sym entries for each.
//   3. Recursively walks fn bodies; for every nkind.N_IDENT used as an
//      expression or as a type name, looks it up and counts the
//      resolved vs. unresolved.
//   4. Returns a summary the caller (wwdump -r) prints; the test
//      asserts unresolved == 0 on every selfhost fixture, which is
//      the floor signal that the frontend can name-resolve real ww.

package wcc;

import os;
import tok;
import strconv;

type checker = struct {
	tc:       *tctx,
	top:      *scope,
	cur:      *scope,
	nresolved:   i32,
	nunresolved: i32,
	errs:        i32,
	verbose:     i32,	// when non-zero, log each unresolved name
	fnret:       *node,	// enclosing fn's return type AST (for `?`)
	curmod:      str,	// importing-module bareword for the decl
				// currently being walked; "" for primary
				// compilation unit. Drives same-module
				// preference in bare-leaf lookups.
	file:        *node,	// N_FILE root; used by checkmoduleshadow
				// to consult the declaring source's own
				// `use` directives.
};

// seedprimitives — install the built-in type names so `i32`, `str`,
// etc. can be looked up like ordinary symbols.
fn seedprimitives(c: *checker) void = {
	scopedefine(c.top, "void",    skind.SK_TYPE, c.tc.tyvoid,    nil);
	scopedefine(c.top, "bool",    skind.SK_TYPE, c.tc.tybool,    nil);
	scopedefine(c.top, "rune",    skind.SK_TYPE, c.tc.tyrune,    nil);
	scopedefine(c.top, "i8",      skind.SK_TYPE, c.tc.tyi8,      nil);
	scopedefine(c.top, "i16",     skind.SK_TYPE, c.tc.tyi16,     nil);
	scopedefine(c.top, "i32",     skind.SK_TYPE, c.tc.tyi32,     nil);
	scopedefine(c.top, "i64",     skind.SK_TYPE, c.tc.tyi64,     nil);
	scopedefine(c.top, "u8",      skind.SK_TYPE, c.tc.tyu8,      nil);
	scopedefine(c.top, "u16",     skind.SK_TYPE, c.tc.tyu16,     nil);
	scopedefine(c.top, "u32",     skind.SK_TYPE, c.tc.tyu32,     nil);
	scopedefine(c.top, "u64",     skind.SK_TYPE, c.tc.tyu64,     nil);
	scopedefine(c.top, "int",     skind.SK_TYPE, c.tc.tyint,     nil);
	scopedefine(c.top, "uint",    skind.SK_TYPE, c.tc.tyuint,    nil);
	scopedefine(c.top, "uintptr", skind.SK_TYPE, c.tc.tyuintptr, nil);
	scopedefine(c.top, "f32",     skind.SK_TYPE, c.tc.tyf32,     nil);
	scopedefine(c.top, "f64",     skind.SK_TYPE, c.tc.tyf64,     nil);
	scopedefine(c.top, "str",     skind.SK_TYPE, c.tc.tystr,     nil);
	scopedefine(c.top, "never",   skind.SK_TYPE, c.tc.tynever,   nil);
	// #29: predeclare `type nomem = !void;` so user code needn't
	// declare it locally. Synthesize an nkind.N_TYPEDECL whose lhs is
	// nkind.N_TBANG{nkind.N_TNAME("void")} so varianterr and other
	// iserror-aware paths treat `nomem` identically to a user-written
	// alias. Mirrors cmd/wcc/check.c lookup_builtin returning
	// ty_nomem (NAMED, under=ty_void, iserror=1). Note: cgen owns a
	// separate alias chain — see collectaliases in cgen.ww for the
	// companion seed.
	let empty: str;
	let tnvoid: *node = newnode(nkind.N_TNAME, empty, 0, 0);
	tnvoid.str = "void";
	let bang: *node = newnode(nkind.N_TBANG, empty, 0, 0);
	bang.lhs = tnvoid;
	let nomemdecl: *node = newnode(nkind.N_TYPEDECL, empty, 0, 0);
	nomemdecl.str = "nomem";
	nomemdecl.lhs = bang;
	scopedefine(c.top, "nomem", skind.SK_TYPE, nil, nomemdecl);
	// `nil`, `true`, `false` are keywords — handled at the lex/parser
	// level, no symbol needed.
	// `len`, `alloc`, `free`, `append` are pseudo-builtins; scopedefine
	// them so their use sites resolve. The actual semantics live in cgen.
	scopedefine(c.top, "len",    skind.SK_FN, nil, nil);
	scopedefine(c.top, "alloc",  skind.SK_FN, nil, nil);
	scopedefine(c.top, "free",   skind.SK_FN, nil, nil);
	scopedefine(c.top, "append", skind.SK_FN, nil, nil);
	// #42: typed builtins folded to integer literals at check time —
	// `size(T)` / `align(T)` (arg is a type-expression planted by the
	// parser at lib/ww/parse/expr.ww:254-267) and `offset(e.f)` (arg is
	// an N_DOT). exprtype intercepts these and rewrites the N_CALL to
	// N_INTLIT so cgen never sees an unresolved size/align/offset symbol.
	// Mirrors cmd/wcc/check.c:907-955.
	scopedefine(c.top, "size",   skind.SK_FN, nil, nil);
	scopedefine(c.top, "align",  skind.SK_FN, nil, nil);
	scopedefine(c.top, "offset", skind.SK_FN, nil, nil);
};

// declmod — module-tag stamp for a top-level decl.
//
// The driver concatenates imported sources before the primary file and
// emits `// MODULE: foo` directives the lexer pins onto each decl's
// `module` field. We treat a decl as "imported" iff its module
// directive matches some `use IDENT;` bareword in this compilation
// unit. Primary-file decls return "" so they coexist (mod="") with
// imported decls of the same leaf name in scopelookupinmodule.
fn declmod(file: *node, d: *node) str = {
	let empty: str;
	if (d == nil) { return empty; };
	if (d.nmod.len == 0) { return empty; };
	if (file == nil) { return empty; };
	let u: *node = file.list;
	for (u != nil) {
		if (u.kind == nkind.N_USE) {
			if (streq(u.str, d.nmod)) { return d.nmod; };
		};
		u = u.next;
	};
	return empty;
};

// srcimports — does the source file that contributed decl-module
// `modtag` carry `use <name>;`? Mirrors cstage's src_imports —
// `modtag.len == 0` means primary, matching declmod's empty-str
// return for primary-source decls.
fn srcimports(file: *node, modtag: str, name: str) bool = {
	if (file == nil) { return false; };
	if (name.len == 0) { return false; };
	let u: *node = file.list;
	for (u != nil) {
		if (u.kind == nkind.N_USE) {
			// Skip self-imports: lib/fmt/fmttest.ww carries
			// `use fmt;` while its module tag is also "fmt".
			// That directive doesn't introduce a foreign
			// module bareword and lib/fmt's own
			// `fn bsprintf(fmt: str, ...)` is not a shadow.
			if (u.nmod.len > 0) {
				if (streq(u.nmod, u.str)) {
					u = u.next;
					continue;
				};
			};
			let um: str = declmod(file, u);
			let m: bool = false;
			if (modtag.len == 0) {
				if (um.len == 0) { m = true; };
			} else { if (streq(um, modtag)) { m = true; }; };
			if (m) {
				if (streq(u.str, name)) { return true; };
			};
		};
		u = u.next;
	};
	return false;
};

// checkmoduleshadow — enforce "value names and module names are
// disjoint" at nested-scope binds. Mirrors cstage check_module_shadow
// (cmd/wcc/check.c). Fires for fn params / lets / forrange iters /
// mcase bindings whose name matches an in-scope `use foo;` import
// declared in the same source file. Top-level decls are exempt
// (their same-leaf-as-module pattern is the intentional coexistence
// shape — `use fnmatch; fn fnmatch(...)` etc.).
fn checkmoduleshadow(c: *checker, name: str, kindstr: str) void = {
	if (name.len == 0) { return; };
	if (c.cur == c.top) { return; };
	let seen: bool = false;
	let s: *scope = c.cur;
	for (s != nil) {
		let r: *sym = scopelookuplocal(s, name);
		if (r != nil) {
			if (r.skind == skind.SK_USE) {
				seen = true;
				s = nil;
			};
		};
		if (s != nil) { s = s.parent; };
	};
	if (!seen) { return; };
	if (!srcimports(c.file, c.curmod, name)) { return; };
	os.write(2, kindstr.ptr, kindstr.len: u64);
	os.write(2, " '".ptr, 2u64);
	os.write(2, name.ptr, name.len: u64);
	os.write(2, "' shadows imported module '".ptr, 27u64);
	os.write(2, name.ptr, name.len: u64);
	os.write(2, "'\n".ptr, 2u64);
	c.errs += 1;
};

// installdecl — install the top-level decl's name into the top scope.
// We don't compute its type yet (that's the resolve pass) — just bind
// the name so forward references resolve.
//
// Architectural note: wwstage uses COEXISTENCE rather than the cstage
// promote-SK_USE-in-place approach in cmd/wcc/check.c. SK_USE and any
// same-leaf SK_TYPE/SK_FN/SK_DEF/SK_VAR live as separate entries in
// the same scope-bucket, distinguished by `sym.mod`. The dot-prefix
// lookup in resolvewalk + scopelookupinmodule's mod-filter already
// disambiguate `fnmatch.flag` against an `fn fnmatch(...)` of the same
// leaf — no `use_alias` flag needed. So the cstage L1722-class bug
// (promotion missing use_alias) is structurally non-reachable here.
// Don't port the use_alias flag from cstage without first re-reading
// the architecture: adding a field to `sym` changes its size and risks
// the wwstage cgen amalloc-undersize trap (rob-pike). #11 (wwstage
// checkfile pass) will reconsider this when wwstage grows a real check
// pass on the cgen path.
// TODO(#11): cstage check.c errors on duplicate top-level type/def/fn
// (see cmd/wcc/check.c L1800/L1839/L1860 "duplicate <kind>") and on
// duplicate top-level let (cmd/wcc/check.c L1880, "duplicate let %s")
// once #32 lands. Wwstage's installdecl just drops the second insert
// silently. Add `if (s == nil) err(...)` here once #11 wires checkfile
// into w6c_ww. Silent-accept matches the deferred-check design — see
// test/wcc/708 and test/wcc/696 for the same cstage-only neg-case
// precedent.
fn installdecl(c: *checker, file: *node, d: *node) void = {
	if (d == nil) { return; };
	let k: nkind = d.kind;
	let nm: str = d.str;
	let mod: str = declmod(file, d);
	if (k == nkind.N_USE)      { scopedefine(c.top, nm, skind.SK_USE,  nil, d); return; };
	if (k == nkind.N_DEF)      { scopedefineinmodule(c.top, nm, mod, skind.SK_DEF,  nil, d); return; };
	if (k == nkind.N_TYPEDECL) { scopedefineinmodule(c.top, nm, mod, skind.SK_TYPE, nil, d); return; };
	if (k == nkind.N_FNDECL)   { scopedefineinmodule(c.top, nm, mod, skind.SK_FN,   nil, d); return; };
	if (k == nkind.N_LET)      { scopedefineinmodule(c.top, nm, mod, skind.SK_VAR,  nil, d); return; };
};

// resolvewalk — recursive AST walk that, for every nkind.N_IDENT and
// nkind.N_TNAME seen, looks up the name and bumps the resolved/unresolved
// counters. Local lets are installed in the current scope as soon as
// their init/type expressions have been walked (forward use of a let
// before its declaration would resolve to nothing — same semantics as
// the C checker's collect-then-resolve flow within a function).
// Also runs the typed checks (match exhaustiveness, ? subset) in
// the same pass — they need the same scope state.
fn resolvewalk(c: *checker, n: *node) void = {
	if (n == nil) { return; };
	let k: nkind = n.kind;

	// Typed checks fire on the way down so the scrutinee/operand
	// is examined before the arm bodies install new bindings.
	if (k == nkind.N_MATCH)   { checkmatchexhaust(c, n); };
	if (k == nkind.N_TRYPROP) { checktryprop(c, n); };
	if (k == nkind.N_TYPETEST)   { checkisas(c, n); };
	if (k == nkind.N_TYPEASSERT) { checkisas(c, n); };
	if (k == nkind.N_LET)     { checkletassign(c, n); };
	if (k == nkind.N_RETURN)  { checkretassign(c, n); };

	// `use IDENT;` — name is a module label, not a free ident.
	if (k == nkind.N_USE) { return; };

	if (k == nkind.N_IDENT) {
		let nm: str = n.str;
		if (nm.len > 0) {
			let s: *sym = scopelookupprefer(c.cur, c.curmod, nm);
			if (s == nil) {
				c.nunresolved += 1;
				if (c.verbose != 0) {
					os.write(2, "  unresolved id: ".ptr, 17u64);
					os.write(2, nm.ptr, nm.len: u64);
					os.write(2, "\n".ptr, 1u64);
				};
			} else { c.nresolved += 1; };
		};
	};

	if (k == nkind.N_TNAME) {
		let nm: str = n.str;
		if (nm.len > 0) {
			let s: *sym = scopelookupprefer(c.cur, c.curmod, nm);
			// `pkg.Type` — strip the last dot prefix and look up
			// the leaf with a mod filter so same-leaf-name types
			// from different imports (`bufio.stream` vs
			// `io.stream`) disambiguate to the right one.
			// Mirrors cmd/wcc/check.c resolve_typename.
			if (s == nil) {
				let dot: i32 = nm.len - 1;
				for (dot >= 0) {
					if (nm[dot] == 46u8) { break; };
					dot -= 1;
				};
				if (dot > 0) {
					let head: str;
					head.ptr = nm.ptr;
					head.len = dot;
					let m: *sym = scopelookup(c.cur, head);
					if (m != nil) {
						let leaf: str;
						leaf.ptr = nm.ptr + (dot + 1): u64;
						leaf.len = nm.len - (dot + 1);
						s = scopelookupinmodule(c.cur, head, leaf);
					};
				};
			};
			if (s == nil) {
				c.nunresolved += 1;
				if (c.verbose != 0) {
					os.write(2, "  unresolved tname: ".ptr, 20u64);
					os.write(2, nm.ptr, nm.len: u64);
					os.write(2, "\n".ptr, 1u64);
				};
			} else { c.nresolved += 1; };
		};
	};

	// `for (let x .. slice) body` / `for (let (a, b) .. slice) body` —
	// each binding name becomes a fresh local. Walk the slice expr first
	// so its idents resolve before the bindings shadow anything, then
	// install bindings and walk the body/else.
	//
	// TODO(#11): cstage check.c (post-#32) errors `binding '%s'
	// redeclared in same scope` when the tuple-pattern lists the same
	// name twice (`for (let (a, a) .. xs)`). Wwstage's resolvewalk has
	// no per-block scope (see resolvefnbody's docstring) and is used
	// only by wwdump_ww as a diagnostic, so silent-accept here avoids
	// false-positives on legal cross-block shadow until #11 adds the
	// scoping infrastructure.
	if (k == nkind.N_FORRANGE) {
		if (n.lhs != nil) { resolvewalk(c, n.lhs); };
		if (n.list != nil) {
			let m: *node = n.list;
			for (m != nil) {
				let bnm: str = m.str;
				if (bnm.len > 0) {
					checkmoduleshadow(c, bnm, "binding");
					scopedefine(c.cur, bnm, skind.SK_VAR, nil, m);
				};
				m = m.next;
			};
		} else {
			let bnm: str = n.str;
			if (bnm.len > 0) {
				checkmoduleshadow(c, bnm, "binding");
				scopedefine(c.cur, bnm, skind.SK_VAR, nil, n);
			};
		};
		if (n.body != nil) { resolvewalk(c, n.body); };
		if (n.els  != nil) { resolvewalk(c, n.els);  };
		return;
	};

	// `match (e) { case let v: T => stmt; ... }` — the binding `v`
	// is declared by the case arm and visible inside its body. Push a
	// fresh scope so `case let e: str` doesn't collide with an outer
	// `let e: *T` (scopedefine drops same-scope dupes silently and
	// would leave references to `e` resolving to the outer type).
	// Mirrors cmd/wcc/check.c's newscope/saved-restore around cstmt.
	if (k == nkind.N_MCASE) {
		if (n.lhs  != nil) { resolvewalk(c, n.lhs);  };
		let outer: *scope = c.cur;
		c.cur = newscope(outer);
		let nm: str = n.str;
		if (nm.len > 0) {
			checkmoduleshadow(c, nm, "binding");
			scopedefine(c.cur, nm, skind.SK_VAR, nil, n);
		};
		if (n.body != nil) { resolvewalk(c, n.body); };
		c.cur = outer;
		return;
	};

	// #53: lexical block. Push a child scope so locals introduced by
	// inner-block lets (and the `let` install at the tail of this fn) go
	// out of scope at block exit. Without this, a deeply nested
	// `let i: u64 = 0u64;` survived to shadow a same-named outer
	// `let i: i32 = 1;` for the whole fn body, and exprtype handed
	// stale primitive types to checkletassign — silent miscompile
	// becomes a false-positive on the next driver (`wwdump_ww -r`
	// flagged the u64→i32 pair in selfhost/cmd/ww/enumeratedir).
	// Mirrors cstage cstmt N_BLOCK at cmd/wcc/check.c:1559-1566.
	if (k == nkind.N_BLOCK) {
		let outer: *scope = c.cur;
		c.cur = newscope(outer);
		let m: *node = n.list;
		for (m != nil) {
			resolvewalk(c, m);
			m = m.next;
		};
		c.cur = outer;
		return;
	};

	if (k == nkind.N_DOT) {
		// Walk only the base; the .field name is a member, not a
		// free identifier.
		if (n.lhs != nil) { resolvewalk(c, n.lhs); };
		// A.6.0: branch returns early; stamp here so the post-walk
		// dispatch below sees N_DOT covered. exprtype N_DOT arm is
		// added in A.6.1; for now this is a no-op nil return.
		let _t: *node = exprtype(c, n, nil);
		return;
	};

	if (k == nkind.N_FIELD) {
		if (n.lhs != nil) { resolvewalk(c, n.lhs); };
		return;
	};

	if (k == nkind.N_TFIELD) {
		if (n.lhs != nil) { resolvewalk(c, n.lhs); };
		return;
	};

	// Walk children (mirroring ast.ww's printer descent order).
	if (n.attr != nil) { resolvewalk(c, n.attr); };
	if (n.lhs  != nil) { resolvewalk(c, n.lhs);  };
	if (n.rhs  != nil) { resolvewalk(c, n.rhs);  };
	if (n.cond != nil) { resolvewalk(c, n.cond); };
	if (n.body != nil) { resolvewalk(c, n.body); };
	if (n.els  != nil) { resolvewalk(c, n.els);  };
	if (n.list != nil) {
		let m: *node = n.list;
		for (m != nil) {
			resolvewalk(c, m);
			m = m.next;
		};
	};

	// #61 audit §1.8 — A.2 population: stamp tinfo onto type-expression
	// nodes once their children have been walked (sub-element TNAMEs
	// are now in scope so resolvealias inside tinfofornode can follow
	// user-defined aliases). Cgen's slotsize fast-path reads off
	// n.type_; uncovered shapes fall through to the cstage-mirror
	// walker until the next sub-commit graduates them.
	if (k == nkind.N_TNAME   || k == nkind.N_TPTR    ||
	    k == nkind.N_TSLICE  || k == nkind.N_TCHAN   ||
	    k == nkind.N_TBANG   || k == nkind.N_TARRAY  ||
	    k == nkind.N_TFN     || k == nkind.N_TSTRUCT ||
	    k == nkind.N_TTUPLE  || k == nkind.N_TTAGGED ||
	    k == nkind.N_TENUM) {
		if (n.type_ == nil) {
			let ti: *tinfo = tinfofornode(c, n);
			if (ti != nil) { n.type_ = ti: *void; };
		};
	};

	// #42's size/align/offset fold trigger lived here pre-A.6.0; the
	// A.6.0 end-of-fn general dispatch (below) now fires exprtype on
	// every N_CALL — same context-free coverage, one dispatch site.

	// After walking children: a local `let X: T = init;` registers
	// `X` so subsequent statements can resolve it. Top-level lets
	// are installed in installdecl, so this duplicate install at
	// the file scope just no-ops (scopedefine returns nil on dup).
	//
	// Cross-block `let a; { let a; };` no longer trips dup-silence
	// since #53 added N_BLOCK push/pop above — the inner `a` lands in
	// the inner block's scope. Same-scope dup `let a=1; let a=2;`
	// still silent-accepts here; promoting that to an error stays
	// queued behind #11 (test/wcc/708 + test/wcc/696 are the cstage-
	// only neg-case precedent).
	if (k == nkind.N_LET) {
		let nm: str = n.str;
		if (nm.len > 0) {
			checkmoduleshadow(c, nm, "let");
			scopedefine(c.cur, nm, skind.SK_VAR, nil, n);
		};
	};

	// A.6.0: post-order dispatch of exprtype on every expression-yielding
	// node kind so n.type_ stamps fire universally — not only when reached
	// through checkletassign / checkretassign / checktryprop / the size-
	// align-offset fold. Mirrors cstage cmd/wcc/check.c cstmt's recursive
	// cexpr (cmd/wcc/check.c:1567 N_EXPRSTMT, :1570 N_RETURN, :1584 N_IF
	// cond, etc.). Plumbing-only: stamps fire from existing exprtype kind
	// arms (literals + idents); per-kind stamp coverage lands in A.6.1.
	// Stamps are tinfocache-backed idempotent so multi-walk via let /
	// return / try entry points is safe. N_DOT is dispatched in its own
	// early-return branch above; not listed here. N_LET / N_RETURN /
	// N_EXPRSTMT / N_IF / N_FOR / N_FORRANGE / N_BLOCK / N_MATCH-as-stmt
	// are not value-typed nodes; their expression children get stamped on
	// the recursive descent into them. Type-expression kinds (N_T*) are
	// covered separately by the tinfofornode block above.
	if (k == nkind.N_INTLIT    || k == nkind.N_FLOATLIT  ||
	    k == nkind.N_STRLIT    || k == nkind.N_RUNELIT   ||
	    k == nkind.N_TRUE      || k == nkind.N_FALSE     ||
	    k == nkind.N_NIL       || k == nkind.N_VOIDLIT   ||
	    k == nkind.N_IDENT     || k == nkind.N_BIN       ||
	    k == nkind.N_UN        || k == nkind.N_CALL      ||
	    k == nkind.N_INDEX     || k == nkind.N_CAST      ||
	    k == nkind.N_STRUCTLIT || k == nkind.N_ARRLIT    ||
	    k == nkind.N_RECV      ||
	    k == nkind.N_SLICE     || k == nkind.N_SPREAD    ||
	    k == nkind.N_TUPLE     || k == nkind.N_TRYPROP   ||
	    k == nkind.N_TRYUNW    || k == nkind.N_TYPETEST  ||
	    k == nkind.N_TYPEASSERT || k == nkind.N_YIELD    ||
	    k == nkind.N_MATCH) {
		let _t: *node = exprtype(c, n, nil);
	};
};

// ---- type-level helpers (AST-level, no resolved tinfo) --------------
//
// The selfhost check operates on AST type expressions rather than
// resolved Type structs. These helpers mirror what cmd/wcc/check.c
// does with tinfo, but only on the subset of cases this checker
// needs to enforce: tagged-union exhaustiveness, ? subset
// propagation, and !-flag semantics.

// unwrapbang — strip an nkind.N_TBANG wrapper; leaves other nodes alone.
fn unwrapbang(n: *node) *node = {
	if (n == nil) { return nil; };
	if (n.kind == nkind.N_TBANG) { return n.lhs; };
	return n;
};

// resolvealias — if n is an nkind.N_TNAME pointing at a typedecl, return
// the typedecl's body (possibly recursively). Pass-through for any
// other node. The chain stops once we hit a non-nkind.N_TNAME node or a
// name we can't resolve.
fn resolvealias(c: *checker, n: *node) *node = {
	let cur: *node = n;
	for (cur != nil) {
		if (cur.kind != nkind.N_TNAME) { return cur; };
		let nm: str = cur.str;
		// #51: pkg.alias type refs land here as a single TNAME whose
		// str is the joined form (lib/ww/parse/parse.ww:258-265 in
		// parsetype). Split on the rightmost '.' and bind the leaf in
		// the head module's scope. Mirrors cstage resolve_typename
		// cmd/wcc/check.c:74-83 strrchr branch — without this the
		// raw `os.oserror` lookup misses and checkisas false-positives
		// every cross-module tagged scrutinee.
		let dotidx: i32 = -1;
		let i: i32 = 0;
		for (i < nm.len) {
			if (nm[i] == 46u8) { dotidx = i; };
			i += 1;
		};
		let s: *sym = nil;
		if (dotidx >= 0) {
			let head: str;
			head.ptr = nm.ptr;
			head.len = dotidx;
			let leaf: str;
			leaf.ptr = nm.ptr + ((dotidx + 1): u64);
			leaf.len = nm.len - dotidx - 1;
			s = scopelookupinmodule(c.cur, head, leaf);
		} else {
			// #53: same-module preference. Mirrors cstage
			// cmd/wcc/check.c:66 scope_lookup_prefer. Without this,
			// two modules each declaring `type invalid = ...` collide
			// on the head-first bucket walk: e.g. utf8.invalid `!void`
			// vs strconv.invalid `!i32` resolves to whichever
			// registered first, driving localloadop MOVSXD/MOVQ
			// divergence at 994/995. Other bare-leaf callers in this
			// file (L1597 exprtype N_IDENT, L1795/L2720 N_DOT-callee
			// leaf, L600 varianterr, L647 scruttype) tracked as #55.
			s = scopelookupprefer(c.cur, c.curmod, nm);
			// #61 A.5: bare TNAME that collides with an imported
			// module bareword. Two shapes hit this:
			//   - `let l: lex;` where `lex` struct lives in
			//     `package lex;` (mod matches leaf).
			//   - `let t: tok;` where `tok` struct lives in
			//     `package lex;` (mod differs from leaf — tok.ww
			//     declares `package lex;`).
			// scopelookup bucket-walks the flat scope and can land
			// on the SK_USE entry first; without the fallback we'd
			// return the unresolved TNAME and tinfofornode aborts on
			// body == n. scopelookuptype walks the same bucket but
			// filters on SK_TYPE so the struct entry surfaces
			// regardless of its declaring package. Mirrors the
			// bare-vs-qualified pattern from task #57.
			if (s != nil) {
				if (s.skind != skind.SK_TYPE) {
					let sm: *sym = scopelookuptype(c.cur, nm);
					if (sm != nil) { s = sm; };
				};
			};
		};
		if (s == nil) { return cur; };
		if (s.skind != skind.SK_TYPE) { return cur; };
		let body: *node = nil;
		if (s.decl != nil) { body = s.decl.lhs; };
		if (body == nil) { return cur; };
		cur = unwrapbang(body);
	};
	return n;
};

// typeeqast — structural equality on AST type expressions, mod
// the `!` wrapper. Mirrors variant_match in cgen + check.c: NAMED
// types compare by string (the closest stand-in for pointer
// identity at the AST level); other nodes recurse by kind.
fn typeeqast(a: *node, b: *node) bool = {
	let aa: *node = unwrapbang(a);
	let bb: *node = unwrapbang(b);
	if (aa == nil) { return bb == nil; };
	if (bb == nil) { return false; };
	if (aa.kind != bb.kind) { return false; };
	let k: nkind = aa.kind;
	if (k == nkind.N_TNAME) { return streq(aa.str, bb.str); };
	if (k == nkind.N_TPTR)  { return typeeqast(aa.lhs, bb.lhs); };
	if (k == nkind.N_TSLICE){ return typeeqast(aa.lhs, bb.lhs); };
	if (k == nkind.N_TCHAN) { return typeeqast(aa.lhs, bb.lhs); };
	// Conservative: anything else (struct/fn/tagged/tuple/array)
	// fails the cheap check. Selfhost code doesn't currently rely
	// on equality at these shapes for the targeted checks.
	return false;
};

// varianterr — does this variant carry the `!` mark? Either
// the variant itself is nkind.N_TBANG or it's an alias whose typedecl
// body is `!T`. Mirrors C check.c's iserror-after-NAMED rule.
fn varianterr(c: *checker, v: *node) bool = {
	if (v == nil) { return false; };
	if (v.kind == nkind.N_TBANG) { return true; };
	if (v.kind == nkind.N_TNAME) {
		let s: *sym = scopelookup(c.cur, v.str);
		if (s != nil) {
			if (s.skind == skind.SK_TYPE) {
				if (s.decl != nil) {
					if (s.decl.lhs != nil) {
						if (s.decl.lhs.kind == nkind.N_TBANG) {
							return true;
						};
					};
				};
			};
		};
	};
	return false;
};

// taggedhaserr — true iff any variant of `n` (assumed
// nkind.N_TTAGGED) is `!`-marked. Picks the explicit-flag semantics over
// the legacy "first variant = success" rule.
fn taggedhaserr(c: *checker, n: *node) bool = {
	let v: *node = n.list;
	for (v != nil) {
		if (varianterr(c, v)) { return true; };
		v = v.next;
	};
	return false;
};

// iserrvariant — under flag-aware mode (any !-marked variant),
// returns true iff `v` is `!`-marked. Under legacy mode (no flags),
// returns true iff `v` is not the first variant of `tagged`.
fn iserrvariant(c: *checker, tagged: *node, v: *node) bool = {
	if (taggedhaserr(c, tagged)) {
		return varianterr(c, v);
	};
	// Legacy: first variant of the union is success.
	if (tagged.list == v) { return false; };
	return true;
};

// scruttype — resolve the type expression for a match's
// scrutinee. Handles nkind.N_IDENT (look up local/param's declared
// type) and nkind.N_DOT (module-qualified ref). Returns nil if we
// can't statically determine the type. Used by exhaustiveness.
fn scruttype(c: *checker, e: *node) *node = {
	if (e == nil) { return nil; };
	if (e.kind == nkind.N_IDENT) {
		let s: *sym = scopelookup(c.cur, e.str);
		if (s == nil) { return nil; };
		if (s.decl == nil) { return nil; };
		// For nkind.N_LET / nkind.N_PARAM: declared type is decl.lhs.
		return s.decl.lhs;
	};
	// #51: `match (pkg.var)` / `pkg.var is T` — module-qualified ref.
	// lhs is N_IDENT (module bareword), str is the leaf. Bind via
	// scopelookupinmodule so the declared type carries the same
	// shape resolvealias' dotted-name branch now consumes. Falls
	// silently to nil when lhs is a value (struct-field access) —
	// the rest of the lenient-check contract.
	if (e.kind == nkind.N_DOT) {
		if (e.lhs == nil) { return nil; };
		if (e.lhs.kind != nkind.N_IDENT) { return nil; };
		let s: *sym = scopelookupinmodule(c.cur, e.lhs.str, e.str);
		if (s == nil) { return nil; };
		if (s.decl == nil) { return nil; };
		return s.decl.lhs;
	};
	return nil;
};

// mktname — fabricate an nkind.N_TNAME node with str = `nm`. Used by
// exprtype to return primitive type nodes for literal
// expressions. The arena keeps them around as long as the checker.
fn mktname(c: *checker, nm: str) *node = {
	let n: *node = newnode(nkind.N_TNAME, "", 0, 0);
	n.str = nm;
	return n;
};

// #43: SSoT for primitive type byte sizes. astsize's N_TNAME-primitive
// arm and every wwstage cgen size walker (slotsize/fieldsize/letemit-
// size/elemsizeof/paramfieldsize) consult this table so a future
// ty_str.size bump (#1) lands in one place. Returns -1 for non-prim
// names; callers fall back to alias/struct/enum lookup. Cstage's
// equivalent SSoT is cmd/wcc/type.c:46-79 (ty_void/ty_bool/.../ty_str).
fn primtypesize(nm: str) i64 = {
	if (streq(nm, "void")) { return 0i64; };
	if (streq(nm, "bool")) { return 1i64; };
	if (streq(nm, "i8") || streq(nm, "u8")) { return 1i64; };
	if (streq(nm, "i16") || streq(nm, "u16")) { return 2i64; };
	if (streq(nm, "i32") || streq(nm, "u32") || streq(nm, "f32") || streq(nm, "rune")) { return 4i64; };
	if (streq(nm, "i64") || streq(nm, "u64") || streq(nm, "f64")) { return 8i64; };
	if (streq(nm, "int") || streq(nm, "uint") || streq(nm, "uintptr")) { return 8i64; };
	if (streq(nm, "str")) { return 16i64; }; // sizelint-ok: SSoT for ty_str primtype (#64)
	return -1i64;
};

// #43: SSoT for slice header size (ptr+len+cap = 24B today). Mirrors
// cstage cmd/wcc/type.c:103 (ty_slice->size = 24). Bumping a slice's
// header layout in #34 touches only this constant.
fn tyslicesize() i64 = { return 24i64; }; // sizelint-ok: SSoT for ty_slice header (#64)

// #42: AST-level layout helpers for the size(T)/align(T)/offset(e.f)
// fold. Mirror cstage resolve_type's size/align computation
// (cmd/wcc/check.c:286-528) on AST nodes — wwstage check.ww never
// materialises tinfo for user types so the fold has to walk the AST
// directly. Struct layout follows cstage check.c:471-526 (align each
// field, max align for the whole record, round size up to alignment).
fn astalign(c: *checker, t: *node) i64 = {
	if (t == nil) { return 1i64; };
	let k: nkind = t.kind;
	if (k == nkind.N_TBANG) { return astalign(c, t.lhs); };
	if (k == nkind.N_TPTR)   { return 8i64; };
	if (k == nkind.N_TSLICE) { return 8i64; };
	if (k == nkind.N_TCHAN)  { return 8i64; };
	if (k == nkind.N_TFN)    { return 8i64; };
	if (k == nkind.N_TARRAY) { return astalign(c, t.lhs); };
	if (k == nkind.N_TTAGGED) { return 8i64; };
	if (k == nkind.N_TTUPLE) {
		let m: i64 = 1i64;
		let p: *node = t.list;
		for (p != nil) {
			let pa: i64 = astalign(c, p.lhs);
			if (pa > m) { m = pa; };
			p = p.next;
		};
		return m;
	};
	if (k == nkind.N_TSTRUCT) {
		let m: i64 = 1i64;
		let f: *node = t.list;
		for (f != nil) {
			if (f.kind == nkind.N_TFIELD) {
				let fa: i64 = astalign(c, f.lhs);
				if (fa > m) { m = fa; };
			};
			f = f.next;
		};
		return m;
	};
	if (k == nkind.N_TENUM) {
		if (t.lhs != nil) { return astalign(c, t.lhs); };
		return 4i64;
	};
	if (k == nkind.N_TNAME) {
		let nm: str = t.str;
		if (streq(nm, "void") || streq(nm, "bool") || streq(nm, "i8") || streq(nm, "u8")) { return 1i64; };
		if (streq(nm, "i16") || streq(nm, "u16")) { return 2i64; };
		if (streq(nm, "i32") || streq(nm, "u32") || streq(nm, "f32") || streq(nm, "rune")) { return 4i64; };
		if (streq(nm, "i64") || streq(nm, "u64") || streq(nm, "f64") || streq(nm, "int") || streq(nm, "uint") || streq(nm, "uintptr") || streq(nm, "str")) { return 8i64; };
		let resolved: *node = resolvealias(c, t);
		if (resolved != nil && resolved != t) {
			return astalign(c, resolved);
		};
	};
	return 1i64;
};

fn astsize(c: *checker, t: *node) i64 = {
	if (t == nil) { return 0i64; };
	let k: nkind = t.kind;
	if (k == nkind.N_TBANG) { return astsize(c, t.lhs); };
	if (k == nkind.N_TPTR)   { return 8i64; };
	if (k == nkind.N_TSLICE) { return tyslicesize(); };
	if (k == nkind.N_TCHAN)  { return 8i64; };
	if (k == nkind.N_TFN)    { return 8i64; };
	if (k == nkind.N_TARRAY) {
		let elen: i64 = 0i64;
		if (t.rhs != nil) {
			if (t.rhs.kind == nkind.N_INTLIT) { elen = t.rhs.uval: i64; };
		};
		return astsize(c, t.lhs) * elen;
	};
	if (k == nkind.N_TTUPLE) {
		let total: i64 = 0i64;
		let p: *node = t.list;
		for (p != nil) {
			total += astsize(c, p.lhs);
			p = p.next;
		};
		return total;
	};
	if (k == nkind.N_TSTRUCT) {
		let off: i64 = 0i64;
		let maxal: i64 = 1i64;
		let f: *node = t.list;
		for (f != nil) {
			if (f.kind == nkind.N_TFIELD) {
				let fa: i64 = astalign(c, f.lhs);
				if (fa > maxal) { maxal = fa; };
				off = (off + fa - 1i64) & ~(fa - 1i64);
				off += astsize(c, f.lhs);
			};
			f = f.next;
		};
		return (off + maxal - 1i64) & ~(maxal - 1i64);
	};
	if (k == nkind.N_TTAGGED) {
		// 8 (tag) + max variant payload, rounded up to 8.
		let maxsz: i64 = 0i64;
		let v: *node = t.list;
		for (v != nil) {
			let sz: i64 = astsize(c, v);
			if (sz > maxsz) { maxsz = sz; };
			v = v.next;
		};
		let pad: i64 = (maxsz + 7i64) & ~7i64;
		return 8i64 + pad;
	};
	if (k == nkind.N_TENUM) {
		if (t.lhs != nil) { return astsize(c, t.lhs); };
		return 4i64;
	};
	if (k == nkind.N_TNAME) {
		let nm: str = t.str;
		let ps: i64 = primtypesize(nm);
		if (ps >= 0i64) { return ps; };
		let resolved: *node = resolvealias(c, t);
		if (resolved != nil && resolved != t) {
			return astsize(c, resolved);
		};
	};
	return 0i64;
};

// matchyieldtype — port of cstage cmd/wcc/check.c:110-135. Walks a
// match arm body for the first `yield expr;` and returns its operand
// type. Returns nil if no yield is reachable from `body`. Doesn't
// descend into a nested N_MATCH — each match opens its own yield
// scope. exprtype is idempotent on already-stamped nodes (tinfocache
// path at L467) so re-entering it on the yield operand here is safe.
fn matchyieldtype(c: *checker, body: *node) *node = {
	if (body == nil) { return nil; };
	let k: nkind = body.kind;
	if (k == nkind.N_YIELD) {
		if (body.lhs == nil) { return nil; };
		return exprtype(c, body.lhs, nil);
	};
	if (k == nkind.N_MATCH) { return nil; };
	if (k == nkind.N_BLOCK) {
		let s: *node = body.list;
		for (s != nil) {
			let t: *node = matchyieldtype(c, s);
			if (t != nil) { return t; };
			s = s.next;
		};
		return nil;
	};
	if (k == nkind.N_IF) {
		let t: *node = matchyieldtype(c, body.body);
		if (t != nil) { return t; };
		return matchyieldtype(c, body.els);
	};
	if (k == nkind.N_FOR || k == nkind.N_FORRANGE) {
		return matchyieldtype(c, body.body);
	};
	return nil;
};

// astoffset — byte offset of `dot.str` inside the struct type of
// `dot.lhs`. Mirrors cstage cmd/wcc/check.c:932-961: peel one N_TPTR
// (for `p.field` where p is *Struct), require N_TSTRUCT, walk fields
// honouring per-field alignment, return -1 if the field name is
// absent so the caller can flag the error and fold to 0.
fn astoffset(c: *checker, dot: *node) i64 = {
	if (dot == nil) { return -1i64; };
	if (dot.kind != nkind.N_DOT) { return -1i64; };
	let recv: *node = scruttype(c, dot.lhs);
	if (recv == nil) { return -1i64; };
	let rtyp: *node = resolvealias(c, unwrapbang(recv));
	if (rtyp == nil) { return -1i64; };
	if (rtyp.kind == nkind.N_TPTR) {
		rtyp = resolvealias(c, unwrapbang(rtyp.lhs));
	};
	if (rtyp == nil) { return -1i64; };
	if (rtyp.kind != nkind.N_TSTRUCT) { return -1i64; };
	let off: i64 = 0i64;
	let f: *node = rtyp.list;
	for (f != nil) {
		if (f.kind == nkind.N_TFIELD) {
			let fa: i64 = astalign(c, f.lhs);
			off = (off + fa - 1i64) & ~(fa - 1i64);
			if (streq(f.str, dot.str)) { return off; };
			off += astsize(c, f.lhs);
		};
		f = f.next;
	};
	return -1i64;
};

// arenau64tos — decimal string for the folded INTLIT's `str` field.
// Cstage uses aprintf("%llu") at the same site (cmd/wcc/check.c:921);
// wwstage cgen only reads `uval` for N_INTLIT codegen so `str` is
// just for the AST printer, but set it for parity with the parser's
// own literal-emit shape.
fn arenau64tos(v: u64) str = {
	let buf: []u8 = alloc([], 24u64)!;
	let i: i32 = 23;
	buf[i] = 0u8;
	if (v == 0u64) { i -= 1; buf[i] = 48u8; };
	let n: u64 = v;
	for (n > 0u64) {
		i -= 1;
		buf[i] = (48u64 + (n % 10u64)): u8;
		n /= 10u64;
	};
	let r: str;
	r.ptr = buf.ptr + (i: u64);
	r.len = 23 - i;
	return r;
};

// foldtointlit — mutate `n` in place to an N_INTLIT with value `v`.
// Used by the #42 size/align/offset intercepts so cgen sees the
// folded literal rather than an unresolved call. Mirrors cstage
// cmd/wcc/check.c:919-927 / :951-958.
fn foldtointlit(c: *checker, n: *node, v: i64) void = {
	n.kind = nkind.N_INTLIT;
	n.uval = v: u64;
	n.str = arenau64tos(v: u64);
	n.lhs = nil;
	n.list = nil;
	let empty: str;
	n.tsuffix = empty;
};

// enumvalfold — fold an enum member's value expression to a u64
// constant. The Hare-fidelity set: literal leaves, unary +/-/~,
// binary arithmetic (+ - * / %), bitwise (& | ^), shifts (<< >>),
// and sibling backref. Mirrors cstage cmd/wcc/check.c:185-208
// (fold_int_literal) + :210-284 (eval_enum_value); the wider
// constexpr evaluator is at ref/harec/src/eval.c (harec resolves
// each enum member via eval_expr per ref/harec/src/check.c:4419-
// 4434). Wwstage cgen.ww:158-227 (foldintliteral + enumevalmember)
// already ships this set for codegen — check now matches.
//
// `body` is the N_TENUM whose .list is the member chain. `until`
// is the member currently being resolved; sibling lookup walks
// forward from body.list and stops at `until` to enforce harec's
// lnext forward-only-ref discipline (ref/harec/src/check.c:4436-
// 4438). `e` starts as that member's lhs and recurses into its
// children. Returns false on unfoldable shape, unknown sibling,
// or division by zero — callers bail the wrapping N_DOT fold.
//
// Recursion bound: O(N²) worst case on chained sibling backrefs
// (each ident lookup re-walks 0..until). Enum bodies are tiny in
// practice — harec accepts the same shape without memoisation per
// resolve_enum_field's wrap_resolver chain
// (ref/harec/src/check.c:4438) — so the quadratic is harmless.
fn enumvalfold(body: *node, until: *node, e: *node, out: *u64) bool = {
	if (e == nil) { return false; };
	let k: nkind = e.kind;
	if (k == nkind.N_INTLIT)  { *out = e.uval; return true; };
	if (k == nkind.N_RUNELIT) { *out = e.uval; return true; };
	if (k == nkind.N_TRUE)    { *out = 1u64; return true; };
	if (k == nkind.N_FALSE)   { *out = 0u64; return true; };
	if (k == nkind.N_NIL)     { *out = 0u64; return true; };
	if (k == nkind.N_UN) {
		let v: u64 = 0u64;
		if (!enumvalfold(body, until, e.lhs, &v)) { return false; };
		let op: tkind = e.op;
		if (op == tkind.TK_MINUS) { *out = (-(v: i64)): u64; return true; };
		if (op == tkind.TK_TILDE) { *out = ~v; return true; };
		if (op == tkind.TK_PLUS)  { *out = v; return true; };
		return false;
	};
	if (k == nkind.N_BIN) {
		let a: u64 = 0u64;
		let b: u64 = 0u64;
		if (!enumvalfold(body, until, e.lhs, &a)) { return false; };
		if (!enumvalfold(body, until, e.rhs, &b)) { return false; };
		let op: tkind = e.op;
		if (op == tkind.TK_PLUS)    { *out = a + b; return true; };
		if (op == tkind.TK_MINUS)   { *out = a - b; return true; };
		if (op == tkind.TK_STAR)    { *out = a * b; return true; };
		if (op == tkind.TK_SLASH) {
			if (b == 0u64) { return false; };
			*out = a / b; return true;
		};
		if (op == tkind.TK_PERCENT) {
			if (b == 0u64) { return false; };
			*out = a % b; return true;
		};
		if (op == tkind.TK_AMP)    { *out = a & b; return true; };
		if (op == tkind.TK_PIPE)   { *out = a | b; return true; };
		if (op == tkind.TK_CARET)  { *out = a ^ b; return true; };
		if (op == tkind.TK_LSHIFT) { *out = a << b; return true; };
		if (op == tkind.TK_RSHIFT) { *out = a >> b; return true; };
		return false;
	};
	if (k == nkind.N_IDENT) {
		let prev: u64 = (-1i64): u64;
		let m: *node = body.list;
		for (m != nil && m != until) {
			let val: u64 = 0u64;
			if (m.lhs == nil) {
				val = prev + 1u64;
			} else {
				if (!enumvalfold(body, m, m.lhs, &val)) { return false; };
			};
			prev = val;
			if (streq(m.str, e.str)) { *out = val; return true; };
			m = m.next;
		};
		return false;
	};
	return false;
};

// #61 A.5 helper: per-element slot size when `pt` appears inside a
// tuple. Mirrors cgenutil.ww slotsize TTUPLE — cstage's tuple ABI
// spills each element into its own register / 8B eightbyte, so narrow
// scalars pad to 8 (cgen's let_emit_size + AX:DX:CX positional layout).
// str/slice and composites consult `pt.size` so a future #1 bump on
// any primitive layout propagates through the typ.ww SSoT seed
// instead of getting baked into this detour. pointer/fn/chan stay
// 8; void contributes 0 (never appears in tuples emitted by user
// code, but kept for SSoT symmetry with cgen's N_TNAME-"void"
// fallback arm).
fn tupleelemslot(pt: *tinfo) u64 = {
	if (pt == nil) { return 8u64; };
	// #63 Phase-N step 1: peel TY_NAMED before this structural query;
	// wrappers are built in step 2 (#64). No-op today (tinfofornode
	// still collapses aliases → no TY_NAMED), so byte-id is unchanged.
	let t: *tinfo = pt;
	for (t != nil && t.kind == tykind.TY_NAMED) { t = t.under; };
	if (t == nil) { return 8u64; };
	let pk: tykind = t.kind;
	if (pk == tykind.TY_VOID) { return 0u64; };
	if (pk == tykind.TY_STR)   { return t.size; };
	if (pk == tykind.TY_SLICE) { return t.size; };
	if (pk == tykind.TY_PTR  || pk == tykind.TY_FN ||
	    pk == tykind.TY_CHAN || pk == tykind.TY_I64 ||
	    pk == tykind.TY_U64  || pk == tykind.TY_INT ||
	    pk == tykind.TY_UINT || pk == tykind.TY_UINTPTR ||
	    pk == tykind.TY_F64) { return 8u64; };
	if (pk == tykind.TY_BOOL || pk == tykind.TY_RUNE ||
	    pk == tykind.TY_I8   || pk == tykind.TY_I16  ||
	    pk == tykind.TY_I32  || pk == tykind.TY_U8   ||
	    pk == tykind.TY_U16  || pk == tykind.TY_U32  ||
	    pk == tykind.TY_F32  || pk == tykind.TY_ENUM) { return 8u64; };
	// Composite — struct/tuple/array/tagged carry their own slot total.
	return t.slotsize;
};

// #61 A.5 helper: per-field slot size mirroring cgenutil.ww
// registerstruct/fieldsize. Nested struct fields contribute their
// slot-padded total (si.totsize equivalent); primitives keep their
// natural width (struct interior packing is unaffected by stack-slot
// pad-to-8); arrays use their slot-padded element-stride * elen.
fn fieldslotsize(ft: *tinfo) u64 = {
	if (ft == nil) { return 8u64; };
	// #63 Phase-N step 1: peel TY_NAMED before this structural query;
	// wrappers are built in step 2 (#64). No-op today (tinfofornode
	// still collapses aliases → no TY_NAMED), so byte-id is unchanged.
	let t: *tinfo = ft;
	for (t != nil && t.kind == tykind.TY_NAMED) { t = t.under; };
	if (t == nil) { return 8u64; };
	let fk: tykind = t.kind;
	if (fk == tykind.TY_STRUCT) { return t.slotsize; };
	if (fk == tykind.TY_ARRAY)  { return t.slotsize; };
	if (fk == tykind.TY_TAGGED) { return t.size; };
	// str / slice read t.size so the typ.ww SSoT seed is the single
	// source for #1 (str→24) / #34 (slice graduation) — no hardcoded
	// literal here to drift.
	if (fk == tykind.TY_SLICE)  { return t.size; };
	if (fk == tykind.TY_PTR  || fk == tykind.TY_FN ||
	    fk == tykind.TY_CHAN) { return 8u64; };
	if (fk == tykind.TY_STR)    { return t.size; };
	// Primitives keep natural width inside structs (matches
	// cgenutil fieldsize: primsize, not pad-to-8). TY_TUPLE inside a
	// struct currently defaults to 8 in cgenutil — preserve that
	// shape until a future graduation aligns the two.
	if (fk == tykind.TY_BOOL || fk == tykind.TY_RUNE ||
	    fk == tykind.TY_I8   || fk == tykind.TY_I16  ||
	    fk == tykind.TY_I32  || fk == tykind.TY_I64  ||
	    fk == tykind.TY_U8   || fk == tykind.TY_U16  ||
	    fk == tykind.TY_U32  || fk == tykind.TY_U64  ||
	    fk == tykind.TY_INT  || fk == tykind.TY_UINT ||
	    fk == tykind.TY_UINTPTR || fk == tykind.TY_F32 ||
	    fk == tykind.TY_F64  || fk == tykind.TY_ENUM) { return t.size; };
	return 8u64;
};

// #61 audit §1.8 — resolve a type-expression AST node to its *tinfo.
// Mirrors cstage's resolve_type (cmd/wcc/check.c:286-565) which
// produces ty_* singletons / arena-allocated composites from a Node*.
// Cache lives in c.tc (typ.ww) so the same shape can be reused across
// modules within one check pass. Rob+Drew convergence 2026-05-20: cgen
// reads sizes from here starting with slotsize in A.2; subsequent
// sub-commits graduate elemsize/fieldsize/letemitsize/etc. onto the
// same pivot.
//
// A.2 coverage: primitive TNAME singletons, TNAME aliases (via
// resolvealias), TBANG (inner unchanged — see iserror note), TPTR,
// TSLICE, TCHAN, TARRAY, TFN, TENUM, TTUPLE, TSTRUCT, TTAGGED. Size
// computation tracks cstage natural sizes; cgen's slot-padding
// contract (cmd/w6c/cgen.c let_emit_size:691-720 pads narrow scalars
// to 8B) stays in slotsize's fallback walker.
fn tinfofornode(c: *checker, n: *node) *tinfo = {
	if (n == nil) { return nil; };
	let cached: *tinfo = tinfocachelookup(c.tc, n);
	if (cached != nil) { return cached; };
	let r: *tinfo = nil;
	let k: nkind = n.kind;
	if (k == nkind.N_TNAME) {
		let nm: str = n.str;
		if (streq(nm, "void"))           { r = c.tc.tyvoid; };
		if (streq(nm, "bool"))           { r = c.tc.tybool; };
		if (streq(nm, "rune"))           { r = c.tc.tyrune; };
		if (streq(nm, "i8"))             { r = c.tc.tyi8; };
		if (streq(nm, "i16"))            { r = c.tc.tyi16; };
		if (streq(nm, "i32"))            { r = c.tc.tyi32; };
		if (streq(nm, "i64"))            { r = c.tc.tyi64; };
		if (streq(nm, "u8"))             { r = c.tc.tyu8; };
		if (streq(nm, "u16"))            { r = c.tc.tyu16; };
		if (streq(nm, "u32"))            { r = c.tc.tyu32; };
		if (streq(nm, "u64"))            { r = c.tc.tyu64; };
		if (streq(nm, "int"))            { r = c.tc.tyint; };
		if (streq(nm, "uint"))           { r = c.tc.tyuint; };
		if (streq(nm, "uintptr"))        { r = c.tc.tyuintptr; };
		if (streq(nm, "f32"))            { r = c.tc.tyf32; };
		if (streq(nm, "f64"))            { r = c.tc.tyf64; };
		if (streq(nm, "str"))            { r = c.tc.tystr; };
		if (streq(nm, "never"))          { r = c.tc.tynever; };
		if (streq(nm, "untyped_int"))    { r = c.tc.tyuntypedint; };
		if (streq(nm, "untyped_float"))  { r = c.tc.tyuntypedfloat; };
		if (streq(nm, "untyped_str"))    { r = c.tc.tyuntypedstr; };
		if (streq(nm, "untyped_rune"))   { r = c.tc.tyuntypedrune; };
		if (streq(nm, "untyped_bool"))   { r = c.tc.tyuntypedbool; };
		if (streq(nm, "untyped_nil"))    { r = c.tc.tyuntypednil; };
		if (r == nil) {
			// Alias / user-defined name: resolve via scope and recurse.
			// Mirrors astsize's TNAME fallback so the helpers stay in
			// lockstep until A.2 collapses each cgen size-walker onto
			// tinfo.size directly.
			//
			// #61 A.4: bind the resolved body too so future
			// tinfofornode calls on either the TNAME or its target
			// short-circuit on the cache hit instead of re-walking
			// the chain. Pre-bind matches A.2's TSTRUCT/TFN/TTUPLE/
			// TTAGGED cycle-break pattern (a self-referential
			// struct field's *T → TNAME → body would otherwise
			// re-enter the same chain).
			let body: *node = resolvealias(c, n);
			if (body != nil && body != n) {
				let cached2: *tinfo = tinfocachelookup(c.tc, body);
				if (cached2 != nil) {
					r = cached2;
				} else {
					r = tinfofornode(c, body);
					if (r != nil) {
						tinfocachebind(c.tc, body, r);
					};
				};
			};
		};
	} else { if (k == nkind.N_TBANG) {
		// #61 audit §1.8: `!T` propagates the inner shape; cstage's
		// resolve_type sets ty->iserror on the wrapper but no wwstage
		// cgen reader consumes it yet, so A.1 drops the flag and
		// returns the inner tinfo unchanged. Mirrors typeeqast's
		// unwrapbang pre-walk; graduate alongside the first cgen
		// site that needs iserror discrimination.
		r = tinfofornode(c, n.lhs);
	} else { if (k == nkind.N_TPTR) {
		r = typeptr(tinfofornode(c, n.lhs));
	} else { if (k == nkind.N_TSLICE) {
		r = typeslice(tinfofornode(c, n.lhs));
	} else { if (k == nkind.N_TCHAN) {
		r = typechan(tinfofornode(c, n.lhs));
	} else { if (k == nkind.N_TARRAY) {
		// Cstage cmd/wcc/check.c:314-326: length must be an integer
		// literal (`[_]T` keeps alen=0 as the inferred-length sentinel
		// patched at letslotsize-time).
		//
		// #61 A.5: ti.size = natural (sub.size * elen), ti.slotsize =
		// slot-padded (sub.slotsize * elen) — typearray handles both.
		// Reverts A.4's r.size override (which conflated stride with
		// natural size); the slot-padded stride now lives in slotsize
		// where cgenutil's fast-path reads it.
		let elen: u64 = 0u64;
		if (n.rhs != nil) {
			if (n.rhs.kind == nkind.N_INTLIT) { elen = n.rhs.uval; };
		};
		let sub: *tinfo = tinfofornode(c, n.lhs);
		r = typearray(sub, elen);
	} else { if (k == nkind.N_TFN) {
		// Cstage cmd/wcc/check.c:437-466: function types are 8B / 8B
		// (call-target pointer shape). Pre-bind before recursing into
		// the return type so a recursive `type F = fn() F` self-ref
		// doesn't spin (cycle-break mirror of the TSTRUCT/TTAGGED
		// pattern below).
		r = newtype(tykind.TY_FN);
		r.size = 8u64;
		r.align = 8u64;
		r.slotsize = 8u64;
		tinfocachebind(c.tc, n, r);
		r.ret = tinfofornode(c, n.lhs);
	} else { if (k == nkind.N_TENUM) {
		// Cstage cmd/wcc/check.c:529-542: storage type's size/align
		// (default i32 = 4B/4B). Cgen's slotsize-TENUM fallback pads
		// to 8B per its stack-slot contract; tinfo.size carries the
		// raw storage width so size(EnumT) folds to the correct value.
		r = newtype(tykind.TY_ENUM);
		let storage: *tinfo = nil;
		if (n.lhs != nil) { storage = tinfofornode(c, n.lhs); };
		if (storage == nil) { storage = c.tc.tyi32; };
		r.sub = storage;
		r.size = storage.size;
		r.align = storage.align;
		r.slotsize = storage.size;
	} else { if (k == nkind.N_TTUPLE) {
		// Cstage cmd/wcc/check.c:329-345: sum of element sizes with
		// per-element alignment NOT padded — cstage uses raw sums for
		// tuples and 8B-rounding lives at the call/return ABI layer.
		// Pre-bind for cycle protection (recursive tuple shapes).
		//
		// #61 A.5: ti.size = natural sum (cstage parity); ti.slotsize
		// = per-element slot sum mirroring cgenutil.ww:2018-2029
		// slotsize TTUPLE — narrow scalars pad to 8 (cgen spills each
		// tuple element into its own register / stack-slot eightbyte),
		// composites contribute their own ti.slotsize.
		r = newtype(tykind.TY_TUPLE);
		tinfocachebind(c.tc, n, r);
		// #57 A.6.3i-phase-1: populate r.tupleelems as a ttupleelem
		// linked list (head=positional 0) in lock-step with the
		// size/align accumulator. Harec analog ref/harec/src/type_
		// store.c:532-589 tuple_init_from_atype — {type, offset, next}
		// per member onto type->tuple.next chain. Diverges from cstage
		// cmd/wcc/check.c:329-345 which stores tuple positionals on
		// t->params (Tparam, no offset, consumer recomputes by walking
		// at cgen.c:5723-5750); the offset-stored shape lets Phase
		// 2/J/K consumers (dotchainresolve, indexbaseesz) read offsets
		// directly per the A.6 stamp-once-read-many arc. Direct analog
		// 26724fe (#50 phase 1, A.6.3f-a) for the head/tail append
		// pattern. Offset matches cstage's raw-sum layout (no per-
		// element padding) — rule 10 aligns wwstage tuple layout down
		// to cstage, distinct from harec's add_padding(&offset,
		// memb.align) at type_store.c:561.
		let teh: *ttupleelem = nil;
		let tet: *ttupleelem = nil;
		let total: u64 = 0u64;
		let slottotal: u64 = 0u64;
		let maxal: u64 = 1u64;
		let p: *node = n.list;
		for (p != nil) {
			let pt: *tinfo = tinfofornode(c, p.lhs);
			let elemoff: u64 = total;
			let te: *ttupleelem = alloc(ttupleelem{type_=pt, offset=elemoff, tnext=nil})!;
			if (teh == nil) { teh = te; } else { tet.tnext = te; };
			tet = te;
			if (pt != nil) {
				if (pt.align > maxal) { maxal = pt.align; };
				total += pt.size;
				slottotal += tupleelemslot(pt);
			};
			p = p.next;
		};
		r.tupleelems = teh;
		r.size = total;
		r.align = maxal;
		r.slotsize = slottotal;
	} else { if (k == nkind.N_TSTRUCT) {
		// Cstage cmd/wcc/check.c:468-527: per-field alignment, max
		// align for the whole record, total rounded up to alignment.
		// Anonymous-embed promotion is deferred (#13).
		//
		// Pre-bind into the cache BEFORE walking fields so a
		// self-referential pointer field (e.g., `next: *node` inside
		// `type node = struct {..., next: *node, ...}`) terminates:
		// the inner tinfofornode(TNAME(node)) resolvealias-recurses
		// back to this same body node, hits the cache, and returns
		// the in-progress stub. r.size is filled in below; the stub's
		// only consumer during the recursion is typeptr (8B/8B
		// regardless of pointee size), so partial-fill is safe.
		//
		// #61 A.5: alongside the natural layout (cstage parity), walk
		// the same fields with the slot-padded sizing cgenutil.ww
		// registerstruct uses (fieldsize → si.totsize for nested
		// struct; size-derived alignment; final round to 8). That
		// slot total lands in ti.slotsize so the cgen fast-path can
		// graduate TY_STRUCT off the AST walker.
		r = newtype(tykind.TY_STRUCT);
		tinfocachebind(c.tc, n, r);
		// #57 A.6.3i-phase-1: populate r.fields as a tfield linked
		// list (head=first declared field) in lock-step with the
		// natural-layout offset accumulator. Mirrors cstage cmd/wcc/
		// check.c:468-527 (Tfield {name, type, offset, next} per
		// member onto t->fields). Direct analog 26724fe (#50 phase 1,
		// A.6.3f-a) for the head/tail append pattern. Harec cite:
		// ref/harec/include/types.h:109-115 struct_field and
		// ref/harec/src/type_store.c:314-347 struct_init_from_atype.
		// Anonymous-embed promotion not populated here (#13 per
		// the cstage cite at check.ww:1263).
		let fh: *tfield = nil;
		let ft_: *tfield = nil;
		let off: u64 = 0u64;
		let maxalign: u64 = 1u64;
		let soff: u64 = 0u64;
		let f: *node = n.list;
		for (f != nil) {
			if (f.kind == nkind.N_TFIELD) {
				let ft: *tinfo = tinfofornode(c, f.lhs);
				if (ft != nil) {
					if (ft.align > maxalign) { maxalign = ft.align; };
					if (ft.align > 0u64) {
						off = (off + ft.align - 1u64) & ~(ft.align - 1u64);
					};
					let fldoff: u64 = off;
					let tf: *tfield = alloc(tfield{name=f.str, type_=ft, offset=fldoff, tnext=nil})!;
					if (fh == nil) { fh = tf; } else { ft_.tnext = tf; };
					ft_ = tf;
					off += ft.size;
					// Slot-padded layout (mirror of cgenutil
					// fieldsize + registerstruct align rules).
					let fsz: u64 = fieldslotsize(ft);
					let faln: u64 = 1u64;
					if (fsz >= 8u64)      { faln = 8u64; }
					else { if (fsz >= 4u64) { faln = 4u64; }
					else { if (fsz >= 2u64) { faln = 2u64; }; }; };
					if ((soff & (faln - 1u64)) != 0u64) {
						soff = (soff + faln - 1u64) & ~(faln - 1u64);
					};
					soff += fsz;
				};
			};
			f = f.next;
		};
		r.fields = fh;
		if (maxalign > 0u64) {
			r.size = (off + maxalign - 1u64) & ~(maxalign - 1u64);
		};
		r.align = maxalign;
		if ((soff & 7u64) != 0u64) {
			soff = (soff + 7u64) & ~7u64;
		};
		r.slotsize = soff;
	} else { if (k == nkind.N_TTAGGED) {
		// Cstage cmd/wcc/check.c:347-435: 8B tag + max(variant)
		// rounded up to 8. Pre-bind for cycle protection (recursive
		// sum-type shapes through NAMED variants).
		r = newtype(tykind.TY_TAGGED);
		tinfocachebind(c.tc, n, r);
		// #50 / A.6.3f phase 1: populate ti.params as a tparam linked
		// list (head=first source variant). #61a: flatten `...inner`
		// tagged spreads into the chain and stamp each variant's
		// iserror. Mirrors cstage check.c:366-389 — dealias one NAMED
		// level, require TY_TAGGED, splice its (already-flattened)
		// variants in declaration order; otherwise append the single
		// variant. size/align stays accounted off the surface member
		// (vt), so r.size is byte-identical to pre-#61a: the flatten +
		// iserror are additive, with no #61a-stage readers (the variant
		// machinery + cgwidentaggedstore/matchscrutt migrate onto the
		// chain in #61b/c). Same shared Tparam shape ww reuses across
		// struct-fields / tuple-fields / fn-params / tagged-variants
		// (sea-of-stars per rule 12). Phase 2 (#50b) retired cgenutil's
		// AST-keyed nullableptrtag onto the chain.
		let head: *tparam = nil;
		let tail: *tparam = nil;
		let maxsz: u64 = 0u64;
		let al: u64 = 8u64;
		let v: *node = n.list;
		for (v != nil) {
			let vt: *tinfo = tinfofornode(c, v);
			if (vt != nil) {
				if (vt.size > maxsz) { maxsz = vt.size; };
				if (vt.align > al) { al = vt.align; };
			};
			let isspread: bool = (v.op == tkind.TK_ELLIPSIS);
			let vu: *tinfo = vt;
			if (isspread) {
				if (vu != nil) {
					if (vu.kind == tykind.TY_NAMED) { vu = vu.under; };
				};
			};
			if (isspread && vu != nil && vu.kind == tykind.TY_TAGGED) {
				// Spliced variants carry the inner union's
				// already-stamped iserror; no re-derivation.
				let src: *tparam = vu.params;
				for (src != nil) {
					let tp: *tparam = alloc(tparam{name="", type_=src.type_, iserror=src.iserror, tnext=nil})!;
					if (head == nil) { head = tp; } else { tail.tnext = tp; };
					tail = tp;
					src = src.tnext;
				};
			} else {
				let ve: bool = varianterr(c, v);
				let tp: *tparam = alloc(tparam{name="", type_=vt, iserror=ve, tnext=nil})!;
				if (head == nil) { head = tp; } else { tail.tnext = tp; };
				tail = tp;
			};
			v = v.next;
		};
		r.params = head;
		// #61 A.3 nullable fold: `(*T | void)` collapses to a single
		// 8B pointer slot, null is the void variant. Mirrors
		// cmd/wcc/check.c:412-426 — bare TNAME("void"), not `!void`,
		// and not NAMED. AST-kind discrimination retained: wwstage
		// tinfo carries no `iserror` field, so cstage's tinfo-level
		// (kind==TY_VOID && !iserror) check doesn't port symmetrically.
		let a: *node = n.list;
		if (a != nil) {
			let b: *node = a.next;
			if (b != nil && b.next == nil) {
				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"); };
				let isnull: bool = false;
				if (aptr) { if (bvoid) { isnull = true; }; };
				if (avoid) { if (bptr) { isnull = true; }; };
				if (isnull) {
					r.size = 8u64;
					r.align = 8u64;
					r.nullable = 1;
					r.slotsize = 8u64;
					return r;
				};
			};
		};
		let pad: u64 = (maxsz + 7u64) & ~7u64;
		r.size = 8u64 + pad;
		r.align = al;
		r.slotsize = 8u64 + pad;
	};};};};};};};};};};};
	if (r != nil) {
		// #61 A.5: any arm that didn't set slotsize gets ti.size as
		// the default (covers primitives via prim() + the ptr/slice/
		// chan paths which already populate slotsize, plus TBANG which
		// inherits the inner's tinfo unchanged).
		if (r.slotsize == 0u64) { r.slotsize = r.size; };
		tinfocachebind(c.tc, n, r);
	};
	return r;
};

// unifyarith — usual-arithmetic-conversion analogue at the AST-tnode
// layer. Mirrors cstage cmd/wcc/check.c:580-596 `unify_arith` and harec
// ref/harec/src/types.c type_promote. Trailing `return ltn` covers
// mismatched typed pairs; cstage flags the same shape — wwstage's
// checker stays silent here per existing discipline.
//
// Nil-on-valid classification (5-lite-b #34, A.6.2.1c #24): both ltn
// and rtn can be nil when an operand was an inherent-IDENT bail
// (exprtype N_IDENT arm L1596-1599 — SK_USE module ref or pseudo-
// builtin callee with sym.decl == nil; #19 retires these as
// dedicated AST kinds). Propagation, not silent gap — asserttyped
// gates those idents at the consumer layer.
fn unifyarith(c: *checker, ltn: *node, rtn: *node) *node = {
	let lu: bool = isuntypedint(ltn) || isuntypedfloat(ltn);
	let ru: bool = isuntypedint(rtn) || isuntypedfloat(rtn);
	if (lu && ru) {
		if (isuntypedfloat(ltn) || isuntypedfloat(rtn)) {
			return mktname(c, "untyped_float");
		};
		return mktname(c, "untyped_int");
	};
	let conf: bool = false;
	if (lu) {
		if (isassignable(c, rtn, ltn, &conf)) { return rtn; };
	};
	if (ru) {
		if (isassignable(c, ltn, rtn, &conf)) { return ltn; };
	};
	if (typeeqast(ltn, rtn)) { return ltn; };
	// Mismatched typed pair — return ltn so the binop stamps something;
	// 5-lite-b: the trailing nil-on-mismatch shape was eliminated when
	// the helper was split out of binoptype.
	return ltn;
};

// binoptype — derive the result tnode of an N_BIN operator expression.
// Mirrors cstage cmd/wcc/check.c:598-640 `cbinop`. Operates on tnodes
// returned by exprtype; ptr arithmetic / bitwise / shifts / comparisons /
// logicals all reflect cstage's rules. Type-mismatch diagnostics are
// elided here (cstage gates the same shape).
fn binoptype(c: *checker, e: *node) *node = {
	let op: tkind = e.op;
	let ltn: *node = exprtype(c, e.lhs, nil);
	let rtn: *node = exprtype(c, e.rhs, nil);
	if (op == tkind.TK_PLUS || op == tkind.TK_MINUS) {
		if (ltn != nil && ltn.kind == nkind.N_TPTR && isinttypeast(rtn)) {
			return ltn;
		};
	};
	if (op == tkind.TK_PLUS) {
		if (isinttypeast(ltn) && rtn != nil && rtn.kind == nkind.N_TPTR) {
			return rtn;
		};
	};
	if (op == tkind.TK_MINUS) {
		if (ltn != nil && rtn != nil
		    && ltn.kind == nkind.N_TPTR && rtn.kind == nkind.N_TPTR) {
			return mktname(c, "i64");
		};
	};
	if (op == tkind.TK_PLUS    || op == tkind.TK_MINUS  ||
	    op == tkind.TK_STAR    || op == tkind.TK_SLASH  ||
	    op == tkind.TK_PERCENT || op == tkind.TK_AMP    ||
	    op == tkind.TK_PIPE    || op == tkind.TK_CARET  ||
	    op == tkind.TK_LSHIFT  || op == tkind.TK_RSHIFT) {
		return unifyarith(c, ltn, rtn);
	};
	if (op == tkind.TK_EQ  || op == tkind.TK_NEQ ||
	    op == tkind.TK_LT  || op == tkind.TK_LE  ||
	    op == tkind.TK_GT  || op == tkind.TK_GE  ||
	    op == tkind.TK_AND || op == tkind.TK_OR) {
		return mktname(c, "bool");
	};
	// Unreachable for valid input: op is one of TK_PLUS/MINUS/STAR/
	// SLASH/PERCENT/AMP/PIPE/CARET/LSHIFT/RSHIFT/EQ/NEQ/LT/LE/GT/GE/
	// AND/OR per parser invariant (lib/ww/parse/expr.ww binary-op
	// table); all are handled above. 5-lite-b #34.
	return nil;
};

// unoptype — derive the result tnode of an N_UN unary expression. Mirrors
// cstage cmd/wcc/check.c:642-687 `cunop` and harec ref/harec/src/types.c
// type_promote. The slice/str .len/.cap pseudo-field address-of widening
// to *i64 mirrors check.c:672-682 directly — its purpose is documented
// at the cstage site.
fn unoptype(c: *checker, e: *node) *node = {
	let op: tkind = e.op;
	let opt: *node = exprtype(c, e.lhs, nil);
	if (op == tkind.TK_MINUS || op == tkind.TK_PLUS) { return opt; };
	if (op == tkind.TK_NOT)   { return mktname(c, "bool"); };
	if (op == tkind.TK_TILDE) { return opt; };
	if (op == tkind.TK_STAR) {
		// opt nil here means the operand was an inherent-IDENT bail
		// (exprtype N_IDENT arm L1596-1599 — SK_USE / pseudo-builtin
		// sym.decl == nil — or another helper's nil propagation);
		// 5-lite-b #34, A.6.2.1c #24. The `u == nil` post-resolvealias
		// check was eliminated here — unwrapbang(non-nil) returns
		// non-nil (parser invariant N_TBANG.lhs always set) and
		// resolvealias passes through non-nil unchanged (L513
		// `for (cur != nil)` only exits via `return cur` or `return n`).
		if (opt == nil) { return nil; };
		let u: *node = resolvealias(c, unwrapbang(opt));
		// Invalid input (non-pointer dereference); cstage errors at
		// cmd/wcc/check.c:660. 5-lite-b #34.
		if (u.kind != nkind.N_TPTR) { return nil; };
		return u.lhs;
	};
	if (op == tkind.TK_AMP) {
		if (e.lhs != nil && e.lhs.kind == nkind.N_DOT) {
			let fld: str = e.lhs.str;
			if (streq(fld, "len") || streq(fld, "cap")) {
				let base: *node = e.lhs.lhs;
				if (base != nil && base.type_ != nil) {
					let bu: *tinfo = base.type_: *tinfo;
					if (bu != nil && bu.kind == tykind.TY_NAMED) { bu = bu.under; };
					if (bu != nil && bu.kind == tykind.TY_PTR)   { bu = bu.sub;   };
					if (bu != nil && bu.kind == tykind.TY_NAMED) { bu = bu.under; };
					if (bu != nil) {
						if (bu.kind == tykind.TY_SLICE || bu.kind == tykind.TY_STR) {
							let pp: *node = newnode(nkind.N_TPTR, "", 0, 0);
							pp.lhs = mktname(c, "i64");
							return pp;
						};
					};
				};
			};
		};
		// opt nil → propagation from inherent-IDENT bail (5-lite-b
		// #34). Generic &expr widens to *opt; without opt we can't
		// synthesize the pointer node.
		if (opt == nil) { return nil; };
		let pp: *node = newnode(nkind.N_TPTR, "", 0, 0);
		pp.lhs = opt;
		return pp;
	};
	// Unreachable for valid input: op is one of TK_MINUS/PLUS/NOT/
	// TILDE/STAR/AMP per parser invariant (lib/ww/parse/expr.ww unary
	// op set); all are handled above. 5-lite-b #34.
	return nil;
};

// indexresult — derive the result tnode of an N_INDEX expression.
// Mirrors cstage cmd/wcc/check.c:870-894 and harec ref/harec/src/types.c
// type_promote dispatch. Slice/array → elem; str → u8; `*[N]T` decays
// to T (pointer-to-array); `*[]T` does NOT decay (yields []T via the
// generic *U → U fallback — Hare-faithful, a pointer-to-slice is a 1D
// array of slices, not of T); generic *T → T.
fn indexresult(c: *checker, e: *node) *node = {
	let basetn: *node = exprtype(c, e.lhs, nil);
	let _idx: *node = exprtype(c, e.rhs, nil);
	let u: *node = resolvealias(c, unwrapbang(basetn));
	// basetn nil → propagation from inherent-IDENT bail at exprtype
	// N_IDENT arm L1596-1599 (5-lite-b #34, A.6.2.1c #24).
	// unwrapbang(nil)=nil and resolvealias(nil)=nil pass through.
	if (u == nil) { return nil; };
	if (u.kind == nkind.N_TSLICE) { return u.lhs; };
	if (u.kind == nkind.N_TARRAY) { return u.lhs; };
	if (u.kind == nkind.N_TNAME) {
		if (streq(u.str, "str")) { return mktname(c, "u8"); };
	};
	if (u.kind == nkind.N_TPTR) {
		let inner: *node = u.lhs;
		let iu: *node = resolvealias(c, unwrapbang(inner));
		if (iu != nil && iu.kind == nkind.N_TARRAY) {
			return iu.lhs;
		};
		return inner;
	};
	// Invalid input (non-indexable base — cstage errors at
	// cmd/wcc/check.c:893). 5-lite-b #34.
	return nil;
};

// exprtype — best-effort type-AST inference for an expression
// node. Handles literals, identifiers, calls, casts, binary/unary
// ops, indexing, module-qualified refs + enum-member folds; returns
// nil for shapes we don't statically know (struct field access into
// non-primitive types, etc).
// `hint`: optional declared-type AST passed by the caller (let
// target, assign target). nil = "no hint, derive from self". Threaded
// for use by A.6.1's STRUCTLIT/ARRLIT arms which can't self-type and
// need the enclosing declared type to resolve. Ignored by every arm
// in A.6.0; the param is plumbed here so the per-kind work that
// follows doesn't ripple a fresh signature change. Mirrors harec's
// `check_expression(..., result_type, ...)` per
// `feedback_hare_frontend_reference.md`.
//
// Dispatcher invariant (5-lite-a #33): every value-producing nkind
// listed in resolvewalk's post-order dispatch (L474-489) reaches a
// stamping arm here that sets e.type_ before returning. No
// fall-through. Arms that return nil (binoptype trailing, unoptype
// TK_STAR opt-nil, indexresult u-nil, N_DOT outer fold-miss, N_SLICE
// non-sliceable base, etc.) are propagation from a callee's nil —
// not silent gaps. Mirror of harec's
// `assert(expr->result)` at ref/harec/src/check.c:3810. The
// asserttyped pass at L2871 enforces the invariant on every
// dispatched node post-checker, with gates for the residual
// inherent-IDENT bails (SK_USE, pseudo-builtin sym.decl==nil,
// N_DOT-LHS syntactic position) until #19 retires the bail shape.
fn exprtype(c: *checker, e: *node, hint: *node) *node = {
	if (e == nil) { return nil; };
	let k: nkind = e.kind;
	// #61 audit §1.8 — A.2 widens A.1's single N_INTLIT population to
	// every primitive literal arm + N_IDENT. Cgen size walkers
	// (slotsize first; elemsize/fieldsize/letemitsize follow) consult
	// node.type_ as the SSoT; populating literals + idents closes the
	// loop from the read side.
	if (k == nkind.N_INTLIT)   {
		// Typed-int literal (`7u32`, `0i8`): tsuffix names a builtin
		// primitive. Mirrors cstage cmd/wcc/check.c:694-701 cexpr's
		// `lookup_builtin(n->tsuffix)`; falls through to untyped_int
		// when the suffix doesn't resolve.
		if (e.tsuffix.len > 0) {
			let suf: *node = mktname(c, e.tsuffix);
			let ti: *tinfo = tinfofornode(c, suf);
			if (ti != nil) {
				e.type_ = ti: *void;
				return suf;
			};
		};
		let tn: *node = mktname(c, "untyped_int");
		e.type_ = tinfofornode(c, tn): *void;
		return tn;
	};
	if (k == nkind.N_FLOATLIT) {
		// Typed-float literal (`1.5f32`, `0.0f64`): tsuffix names a
		// builtin primitive. Mirrors cstage cmd/wcc/check.c:702-709
		// cexpr's `lookup_builtin(n->tsuffix)`; falls through to
		// untyped_float when the suffix doesn't resolve.
		if (e.tsuffix.len > 0) {
			let suf: *node = mktname(c, e.tsuffix);
			let ti: *tinfo = tinfofornode(c, suf);
			if (ti != nil) {
				e.type_ = ti: *void;
				return suf;
			};
		};
		let tn: *node = mktname(c, "untyped_float");
		e.type_ = tinfofornode(c, tn): *void;
		return tn;
	};
	if (k == nkind.N_STRLIT)   {
		let tn: *node = mktname(c, "str");
		e.type_ = tinfofornode(c, tn): *void;
		return tn;
	};
	if (k == nkind.N_RUNELIT)  {
		let tn: *node = mktname(c, "rune");
		e.type_ = tinfofornode(c, tn): *void;
		return tn;
	};
	if (k == nkind.N_TRUE)     {
		let tn: *node = mktname(c, "bool");
		e.type_ = tinfofornode(c, tn): *void;
		return tn;
	};
	if (k == nkind.N_FALSE)    {
		let tn: *node = mktname(c, "bool");
		e.type_ = tinfofornode(c, tn): *void;
		return tn;
	};
	if (k == nkind.N_VOIDLIT)  {
		let tn: *node = mktname(c, "void");
		e.type_ = tinfofornode(c, tn): *void;
		return tn;
	};
	if (k == nkind.N_NIL)      {
		let tn: *node = mktname(c, "untyped_nil");
		e.type_ = tinfofornode(c, tn): *void;
		return tn;
	};
	if (k == nkind.N_IDENT) {
		let s: *sym = scopelookup(c.cur, e.str);
		if (s == nil) { return nil; };
		if (s.decl == nil) { return nil; };
		let t: *node = s.decl.lhs;
		// Propagate the declared type's tinfo onto the use site so
		// downstream cgen walkers can read n.type_ off an ident.
		if (t != nil) {
			if (t.type_ != nil) {
				e.type_ = t.type_;
			} else {
				let ti: *tinfo = tinfofornode(c, t);
				if (ti != nil) {
					e.type_ = ti: *void;
					t.type_ = ti: *void;
				};
			};
		};
		return t;
	};
	if (k == nkind.N_BIN) {
		let tn: *node = binoptype(c, e);
		e.type_ = tinfofornode(c, tn): *void;
		return tn;
	};
	if (k == nkind.N_UN) {
		let tn: *node = unoptype(c, e);
		e.type_ = tinfofornode(c, tn): *void;
		return tn;
	};
	if (k == nkind.N_INDEX) {
		let tn: *node = indexresult(c, e);
		e.type_ = tinfofornode(c, tn): *void;
		return tn;
	};
	if (k == nkind.N_CAST) {
		// `expr: T` — explicit cast; the type expr is e.rhs. Mirrors
		// cstage cmd/wcc/check.c:737 `n->type = resolve_type(c, n->rhs)`.
		e.type_ = tinfofornode(c, e.rhs): *void;
		return e.rhs;
	};
	if (k == nkind.N_CALL) {
		let callee: *node = e.lhs;
		if (callee == nil) { return nil; };
		// #31: synthesize the `alloc(value)` / `alloc([], n)` builtin
		// return shape so checkletassign sees the same `(*T | nomem)` /
		// `([]T | nomem)` cstage's check.c stamps at L981-1006. Without
		// this, exprtype returns the seeded decl's nil lhs and the let
		// silently accepts `let p: *T = alloc(v);` — rule 10 trap.
		// Same-module gate mirrors cstage's `c->cur_mod &&
		// scope_lookup_in_module(...)` check from task #23.
		if (callee.kind == nkind.N_IDENT) {
			if (streq(callee.str, "alloc")) {
				let shadowed: bool = false;
				if (c.curmod.len > 0) {
					if (scopelookupinmodule(c.cur, c.curmod, "alloc") != nil) {
						shadowed = true;
					};
				};
				if (!shadowed) {
					if (e.list != nil) {
						// Slice form: `alloc([], n)`.
						if (e.list.kind == nkind.N_ARRLIT) {
							if (e.list.list == nil) {
								if (e.list.next != nil) {
									if (e.list.next.next == nil) {
										let sl: *node = newnode(nkind.N_TSLICE, "", 0, 0);
										sl.lhs = mktname(c, "u8");
										let nome: *node = mktname(c, "nomem");
										sl.next = nome;
										let tt: *node = newnode(nkind.N_TTAGGED, "", 0, 0);
										tt.list = sl;
										e.type_ = tinfofornode(c, tt): *void;
										return tt;
									};
								};
							};
						};
						// Value form: `alloc(value)`.
						if (e.list.next == nil) {
							let argt: *node = exprtype(c, e.list, nil);
							let ptr: *node = newnode(nkind.N_TPTR, "", 0, 0);
							ptr.lhs = argt;
							let nome: *node = mktname(c, "nomem");
							ptr.next = nome;
							let tt: *node = newnode(nkind.N_TTAGGED, "", 0, 0);
							tt.list = ptr;
							e.type_ = tinfofornode(c, tt): *void;
							return tt;
						};
					};
				};
			};
		};
		// #42: size(T) / align(T) / offset(e.f) typed-builtin intercepts.
		// Fold the N_CALL in place to an N_INTLIT so cgen never sees an
		// unresolved size/align/offset symbol. Same-module shadow gate
		// mirrors the alloc precedent (#23) so a user `fn size(...)`
		// inside this module suppresses the builtin. Mirrors cstage
		// cmd/wcc/check.c:907-960.
		if (callee.kind == nkind.N_IDENT) {
			let bname: str = callee.str;
			let issize: bool = streq(bname, "size");
			let isalign: bool = streq(bname, "align");
			let isoffset: bool = streq(bname, "offset");
			if (issize || isalign || isoffset) {
				let shadowed: bool = false;
				if (c.curmod.len > 0) {
					if (scopelookupinmodule(c.cur, c.curmod, bname) != nil) {
						shadowed = true;
					};
				};
				if (!shadowed) {
					if (e.list != nil) {
						// Post-fold the node IS an N_INTLIT-shaped
						// untyped_int constant. Mirrors cstage
						// cmd/wcc/check.c:926/958 which stamps
						// ty_untyped_int after the fold. The return
						// tnode mktname("i32") is the assignability
						// target for callers, not the constant's
						// own type.
						let utn: *node = mktname(c, "untyped_int");
						if (issize) {
							let v: i64 = astsize(c, e.list);
							foldtointlit(c, e, v);
							e.type_ = tinfofornode(c, utn): *void;
							return mktname(c, "i32");
						};
						if (isalign) {
							let v: i64 = astalign(c, e.list);
							foldtointlit(c, e, v);
							e.type_ = tinfofornode(c, utn): *void;
							return mktname(c, "i32");
						};
						// offset(e.f): the arg is a value expression
						// (N_DOT), parsed via parsearglist — not a
						// type expression.
						if (isoffset) {
							if (e.list.next == nil && e.list.kind == nkind.N_DOT) {
								let off: i64 = astoffset(c, e.list);
								if (off < 0i64) {
									os.write(2, "offset: no field '".ptr, 18u64);
									os.write(2, e.list.str.ptr, e.list.str.len: u64);
									os.write(2, "'\n".ptr, 2u64);
									c.errs += 1;
									off = 0i64;
								};
								foldtointlit(c, e, off);
								e.type_ = tinfofornode(c, utn): *void;
								return mktname(c, "i32");
							};
						};
					};
				};
			};
		};
		// len(x) / append(s,...) / free(p) — Hare pseudo-builtins.
		// Mirror cstage cmd/wcc/check.c:896-1011 (rule 10 requires
		// stage byte-id; both stages stamp the same shape). No shadow
		// guard: cstage's len/append/free intercepts have none either
		// (check.c:901/962/1005), and the names are seeded into c.top
		// at L85-88 so a user same-module decl dup-silences. Harec
		// models these as dedicated AST kinds — EXPR_LEN at
		// ref/harec/src/check.c:2630 (result `&builtin_type_size`),
		// EXPR_APPEND at :745 (result `(nomem | void)`), EXPR_FREE at
		// :2443 (result `&builtin_type_void`). The cstage divergence
		// (len → i32 not size, append → void not tagged) pre-dates
		// this task; #19 (Drew's δ — dedicated AST kinds) is the
		// Hare-faithful path. This is the intercept-shim minimum to
		// unblock #15 (A.6.2.1e assertion enable).
		if (callee.kind == nkind.N_IDENT) {
			if (streq(callee.str, "len")) {
				let tn: *node = mktname(c, "i32");
				e.type_ = tinfofornode(c, tn): *void;
				return tn;
			};
			if (streq(callee.str, "append") || streq(callee.str, "free")) {
				let tn: *node = mktname(c, "void");
				e.type_ = tinfofornode(c, tn): *void;
				return tn;
			};
		};
		let nm: str;
		nm.ptr = nil; nm.len = 0;
		if (callee.kind == nkind.N_IDENT) { nm = callee.str; };
		if (callee.kind == nkind.N_DOT)   { nm = callee.str; };
		if (nm.len == 0) { return nil; };
		// #56: bare-leaf N_IDENT calls go through scopelookupprefer so
		// `foo()` inside module M binds to M.foo rather than another
		// module's same-leaf foo at the head of the flat scope bucket.
		// Mirrors cstage cexpr N_IDENT routing through
		// scope_lookup_prefer with c->cur_mod. N_DOT keeps the bare
		// scopelookup — its module-qualified resolution is a separate
		// gap (parser stores the leaf in callee.str; mod is in
		// callee.lhs.str, not consumed here yet).
		let s: *sym = nil;
		if (callee.kind == nkind.N_IDENT) {
			s = scopelookupprefer(c.cur, c.curmod, nm);
		} else {
			s = scopelookup(c.cur, nm);
		};
		if (s == nil) { return nil; };
		if (s.skind != skind.SK_FN) { return nil; };
		if (s.decl == nil) { return nil; };
		// fn-decl's lhs is the return-type AST node. Mirrors cstage
		// cmd/wcc/check.c:984+ regular-CALL `n->type = build_fn_type(c,
		// s->decl)->ret` shape.
		e.type_ = tinfofornode(c, s.decl.lhs): *void;
		return s.decl.lhs;
	};
	if (k == nkind.N_DOT) {
		// A.6.1.5a — fold cases only. Mirrors cstage cmd/wcc/check.c
		// :740-832. Struct field + pseudo-field (.len/.cap/.ptr) lands
		// in A.6.1.5b. Wwstage has no use_alias (sym.mod disambiguates
		// — see installdecl docstring at L195-207); SK_USE alone gates
		// case 1. Enum-member fold delegates non-literal lhs shapes
		// (sibling backref, unary, binary, shift) to enumvalfold,
		// matching cstage cmd/wcc/check.c:210-284 and harec's enum-
		// resolve constexpr set at ref/harec/src/check.c:4419-4434.
		let lhsn: *node = e.lhs;
		if (lhsn != nil) { if (lhsn.kind == nkind.N_IDENT) {
			let ms: *sym = scopelookupprefer(c.cur, c.curmod, lhsn.str);
			if (ms != nil) {
				// Fold case 1: module-qualified ref. Mirror cstage
				// check.c:749-775. cstage returns ty_err on SK_USE
				// with missing leaf (extern decl); wwstage falls
				// through to outer case — cgen has its own module-
				// qualified resolution and the lenient checker policy
				// keeps the silent miss documented at scruttype L656.
				if (ms.skind == skind.SK_USE) {
					let fs: *sym = scopelookupinmodule(c.cur, lhsn.str, e.str);
					if (fs != nil) { if (fs.decl != nil) {
						let tn: *node = fs.decl.lhs;
						if (tn != nil) {
							e.type_ = tinfofornode(c, tn): *void;
							return tn;
						};
					}; };
				};
				// Fold case 2 inner: bare `EnumT.MEMBER` where EnumT
				// is an SK_TYPE in the flat scope. Mirror cstage
				// check.c:780-803.
				if (ms.skind == skind.SK_TYPE) { if (ms.decl != nil) {
					let body: *node = ms.decl.lhs;
					let ub: *node = resolvealias(c, unwrapbang(body));
					if (ub != nil) { if (ub.kind == nkind.N_TENUM) {
						let prev: u64 = (-1i64): u64;
						let m: *node = ub.list;
						for (m != nil) {
							let val: u64 = 0u64;
							if (m.lhs == nil) {
								val = prev + 1u64;
							} else {
								if (!enumvalfold(ub, m, m.lhs, &val)) { return nil; };
							};
							prev = val;
							if (streq(m.str, e.str)) {
								foldtointlit(c, e, val: i64);
								e.type_ = tinfofornode(c, body): *void;
								return body;
							};
							m = m.next;
						};
					}; };
				}; };
			};
		}; };
		// Fold case 2 outer: base resolves to enum, e.g.
		// `pkg.EnumT.MEMBER` where the inner N_DOT (pkg.EnumT) folded
		// via case 1 above to the enum body. Mirror cstage
		// check.c:805-832. Peel one TPTR for `(*EnumT).MEMBER` (rare
		// but cstage handles it at L808).
		let basetn: *node = exprtype(c, lhsn, nil);
		if (basetn != nil) {
			let bu: *node = resolvealias(c, unwrapbang(basetn));
			if (bu != nil) { if (bu.kind == nkind.N_TPTR) {
				bu = resolvealias(c, unwrapbang(bu.lhs));
			}; };
			if (bu != nil) { if (bu.kind == nkind.N_TENUM) {
				let prev: u64 = (-1i64): u64;
				let m: *node = bu.list;
				for (m != nil) {
					let val: u64 = 0u64;
					if (m.lhs == nil) {
						val = prev + 1u64;
					} else {
						if (!enumvalfold(bu, m, m.lhs, &val)) { return nil; };
					};
					prev = val;
					if (streq(m.str, e.str)) {
						foldtointlit(c, e, val: i64);
						e.type_ = tinfofornode(c, basetn): *void;
						return basetn;
					};
					m = m.next;
				};
			}; };
			// A.6.1.5b stamp cases — mirror cstage check.c:833-866. Pure
			// type-AST stamps; never rewrite e.kind. Lenient on misses
			// (cstage errors); falls through to nil under scruttype L656.
			//
			// Pseudo-fields .len/.cap/.ptr on slice/str/array. Cstage
			// L833-842. `str` lives as N_TNAME("str") in wwstage — no
			// dedicated N_TSTR kind — so test the trio shape here.
			if (bu != nil) {
				let isstr: bool = (bu.kind == nkind.N_TNAME) && streq(bu.str, "str");
				if (bu.kind == nkind.N_TSLICE || bu.kind == nkind.N_TARRAY || isstr) {
					if (streq(e.str, "len")) {
						let tn: *node = mktname(c, "i32");
						e.type_ = tinfofornode(c, tn): *void;
						return tn;
					};
					if (streq(e.str, "cap")) {
						let tn: *node = mktname(c, "i32");
						e.type_ = tinfofornode(c, tn): *void;
						return tn;
					};
					if (streq(e.str, "ptr")) {
						let elem: *node = bu.lhs;
						if (isstr) { elem = mktname(c, "u8"); };
						let pp: *node = newnode(nkind.N_TPTR, "", 0, 0);
						pp.lhs = elem;
						e.type_ = tinfofornode(c, pp): *void;
						return pp;
					};
				};
			};
			// Struct field walk. Cstage L843-849 errors on missing field.
			if (bu != nil) { if (bu.kind == nkind.N_TSTRUCT) {
				let f: *node = bu.list;
				for (f != nil) {
					if (f.kind == nkind.N_TFIELD) { if (streq(f.str, e.str)) {
						e.type_ = tinfofornode(c, f.lhs): *void;
						return f.lhs;
					}; };
					f = f.next;
				};
			}; };
			// Tuple positional access `t.0`, `t.1`, …. Cstage L850-866
			// errors on non-numeric / out-of-range; wwstage falls
			// through. fldnumidx (cgenutil) returns -1 on non-digit.
			if (bu != nil) { if (bu.kind == nkind.N_TTUPLE) {
				let idx: i32 = fldnumidx(e.str);
				if (idx >= 0) {
					let p: *node = bu.list;
					for (idx > 0 && p != nil) {
						p = p.next;
						idx -= 1;
					};
					if (p != nil) {
						let pt: *node = p.lhs;
						e.type_ = tinfofornode(c, pt): *void;
						return pt;
					};
				};
			}; };
		};
		return nil;
	};
	if (k == nkind.N_STRUCTLIT) {
		// A.6.1.6 — head-only stamp of the struct-lit's overall type.
		// Mirror cstage cmd/wcc/check.c:1161-1197; field-level walk
		// (cstage L1178-1194) parked behind #23 / Phase 2 — field
		// values are walked by the post-order exprtype dispatch at
		// L460-489, so each field expr still gets its own n.type_.
		//
		// Parser at lib/ww/parse/expr.ww:147-148 always plants the
		// TYPE_IDENT in e.lhs; e.lhs == nil would be a future Hare-
		// style anonymous struct lit we don't yet parse — bail.
		if (e.lhs == nil) { return nil; };
		if (e.lhs.kind == nkind.N_IDENT) {
			let ms: *sym = scopelookupprefer(c.cur, c.curmod, e.lhs.str);
			if (ms != nil) { if (ms.skind == skind.SK_TYPE) { if (ms.decl != nil) {
				let tn: *node = ms.decl.lhs;
				if (tn != nil) {
					e.type_ = tinfofornode(c, tn): *void;
					return tn;
				};
			}; }; };
			// Lenient on miss: cstage L1170 errors, wwstage falls
			// through (scruttype L656 / A.6.1.5b N_DOT struct-miss).
			return nil;
		};
		// Synthetic type-expr (`(*T){...}` etc). Mirror cstage L1175
		// resolve_type(c, n->lhs).
		e.type_ = tinfofornode(c, e.lhs): *void;
		return e.lhs;
	};
	if (k == nkind.N_ARRLIT) {
		// A.6.1.7 — head-only stamp of the array-lit's overall type.
		// Mirror cstage cmd/wcc/check.c:1198-1211: walk elements,
		// skip the `...` repeat sentinel (parse/expr.ww:101-105),
		// first-element-wins for the elem type, count non-skipped
		// elements, synthesize an N_TARRAY{elt, INTLIT count}. Empty
		// list defaults to `[0]i32` per cstage L1209. Per-element
		// stamps still fire via the post-order dispatch at L460-489
		// (N_ARRLIT is in the kind list since A.6.0); the re-walk in
		// the loop below is tinfocache-idempotent (L467).
		//
		// Documented cstage divergence: cstage L1206 applies
		// type_default to lift untyped_int → i32 etc; wwstage stamps
		// the raw exprtype result, matching the alloc-value-form
		// precedent at L1509. Consumers default-type via the declared
		// `let` slot until A.6.3 lands. Mixed-type elements follow
		// cstage first-element-wins; no unify check (future scope).
		let elt: *node = nil;
		let count: u64 = 0u64;
		let it: *node = e.list;
		for (it != nil) {
			let skip: bool = false;
			if (it.kind == nkind.N_FIELD) {
				if (streq(it.str, "...")) { skip = true; };
			};
			if (!skip) {
				let t: *node = exprtype(c, it, nil);
				if (elt == nil) { elt = t; };
				count += 1u64;
			};
			it = it.next;
		};
		if (elt == nil) { elt = mktname(c, "i32"); };
		let arr: *node = newnode(nkind.N_TARRAY, "", 0, 0);
		arr.lhs = elt;
		let cn: *node = newnode(nkind.N_INTLIT, "", 0, 0);
		cn.uval = count;
		arr.rhs = cn;
		e.type_ = tinfofornode(c, arr): *void;
		return arr;
	};
	if (k == nkind.N_SLICE) {
		// A.6.2.0a — head-only stamp of the slice expression's overall
		// type. Mirrors cstage cmd/wcc/check.c:1214-1228 N_SLICE: peel
		// alias on the base; [N]T → []T, []T → []T (return base), str
		// → str, *T (non-nil sub) → []T. Slice bounds (e.rhs start,
		// e.cond end) are already covered by the post-order dispatch
		// at L460-489 (typically N_INTLIT/N_IDENT/N_BIN, all in the
		// dispatch list), so we do not double-walk them here.
		// Documented cstage divergence: cstage L1227 errors on a
		// non-sliceable base; wwstage returns nil (lenient on miss),
		// matching scruttype L656 / A.6.1.5b N_DOT precedent.
		let basetn: *node = exprtype(c, e.lhs, nil);
		let bu: *node = resolvealias(c, unwrapbang(basetn));
		if (bu == nil) { return nil; };
		if (bu.kind == nkind.N_TARRAY) {
			let sl: *node = newnode(nkind.N_TSLICE, "", 0, 0);
			sl.lhs = bu.lhs;
			e.type_ = tinfofornode(c, sl): *void;
			return sl;
		};
		if (bu.kind == nkind.N_TSLICE) {
			e.type_ = tinfofornode(c, basetn): *void;
			return basetn;
		};
		if (bu.kind == nkind.N_TNAME) {
			if (streq(bu.str, "str")) {
				let tn: *node = mktname(c, "str");
				e.type_ = tinfofornode(c, tn): *void;
				return tn;
			};
		};
		if (bu.kind == nkind.N_TPTR && bu.lhs != nil) {
			let sl: *node = newnode(nkind.N_TSLICE, "", 0, 0);
			sl.lhs = bu.lhs;
			e.type_ = tinfofornode(c, sl): *void;
			return sl;
		};
		return nil;
	};
	if (k == nkind.N_TUPLE) {
		// A.6.2.0b — head-only stamp of the tuple expression's
		// overall type. Mirrors cstage cmd/wcc/check.c:1437-1451
		// N_TUPLE: walk e.list, type each element via exprtype, and
		// assemble an N_TTUPLE whose .list chains N_TPARAM wrappers
		// (one per element) so shared element-type ASTs (sym.decl.lhs,
		// another tuple's element, struct field's .lhs) keep their
		// own .next untouched — see lib/ww/ast.ww:101 and the
		// A.6.2.0b-pre parser precedent at lib/ww/parse/parse.ww:302.
		// Per-element exprtype recursion is tinfocache-idempotent
		// (resolvewalk L460-489 already dispatches into N_TUPLE
		// children). Lenient on empty list: grammar requires >= 2
		// elements (lib/ww/parse/expr.ww:117 single-elem returns the
		// expression), so empty is unreachable and yields nil here
		// (matches scruttype L656 / A.6.1.5b N_DOT lenient-on-miss).
		if (e.list == nil) { return nil; };
		let head: *node = nil;
		let tail: *node = nil;
		let it: *node = e.list;
		for (it != nil) {
			let elemt: *node = exprtype(c, it, nil);
			let w: *node = newnode(nkind.N_TPARAM, "", 0, 0);
			w.lhs = elemt;
			if (head == nil) { head = w; }
			else { tail.next = w; };
			tail = w;
			it = it.next;
		};
		let tt: *node = newnode(nkind.N_TTUPLE, "", 0, 0);
		tt.list = head;
		e.type_ = tinfofornode(c, tt): *void;
		return tt;
	};
	if (k == nkind.N_RECV) {
		// A.6.2.0d — head-only stamp of the receive expression's
		// overall type. Mirrors cstage cmd/wcc/check.c:1230-1236
		// N_RECV: peel alias on the channel base; chan T → T.
		// Documented cstage divergence: cstage L1234 errors on a
		// non-chan base; wwstage returns nil (lenient on miss),
		// matching scruttype L656 / A.6.1.5b N_DOT precedent.
		let basetn: *node = exprtype(c, e.lhs, nil);
		let bu: *node = resolvealias(c, unwrapbang(basetn));
		if (bu == nil) { return nil; };
		if (bu.kind == nkind.N_TCHAN) {
			e.type_ = tinfofornode(c, bu.lhs): *void;
			return bu.lhs;
		};
		return nil;
	};
	if (k == nkind.N_SPREAD) {
		// A.6.2.0e — pass-through stamp. Mirrors cstage check.c:1212-1213.
		// The spread expression `xs...` carries the operand's type.
		let t: *node = exprtype(c, e.lhs, nil);
		if (t != nil) { e.type_ = tinfofornode(c, t): *void; };
		return t;
	};
	if (k == nkind.N_MATCH) {
		// A.6.2.0g — port of cstage cmd/wcc/check.c:1316-1330 match-as-
		// expression stamp. The match's type is the first arm's yield
		// operand type; void if no arm yields. Wwstage skips cstage's
		// arm-yield-unification check (L1322-1327) — that's a checker
		// concern, this arm only stamps. Closes the consumer half of
		// the match-as-expression contract that A.6.2.0f opened on the
		// producer side (N_YIELD).
		let yt: *node = nil;
		let cs: *node = e.list;
		for (cs != nil) {
			let t: *node = matchyieldtype(c, cs.body);
			if (t != nil) { yt = t; break; };
			cs = cs.next;
		};
		if (yt == nil) {
			yt = mktname(c, "void");
		};
		e.type_ = tinfofornode(c, yt): *void;
		return yt;
	};
	if (k == nkind.N_YIELD) {
		// A.6.2.0f — pass-through stamp; cstage check.c:1708 does NOT
		// stamp N_YIELD (statement-shaped). Wwstage's A.6.2 invariant
		// requires every post-dispatch kind have type_ set. Yield's
		// value type is the operand's type per Hare's unified stmt/expr
		// AST (ref/hare/hare/ast/expr.ha:449-461 — yield_expr is an
		// expression with a type). Bare `yield;` (no operand) stamps
		// void.
		if (e.lhs == nil) {
			let v: *node = mktname(c, "void");
			e.type_ = tinfofornode(c, v): *void;
			return v;
		};
		let t: *node = exprtype(c, e.lhs, nil);
		if (t != nil) { e.type_ = tinfofornode(c, t): *void; };
		return t;
	};
	if (k == nkind.N_TRYPROP) {
		// success unwrap: the success-variant type of operand's
		// tagged union.
		let opt: *node = exprtype(c, e.lhs, nil);
		let ou: *node = resolvealias(c, unwrapbang(opt));
		if (ou == nil) { return nil; };
		if (ou.kind != nkind.N_TTAGGED) { return nil; };
		// Hare semantics: success = first non-error variant if
		// any !-flag is present; else first variant.
		if (taggedhaserr(c, ou)) {
			let v: *node = ou.list;
			for (v != nil) {
				if (!iserrvariant(c, ou, v)) {
					e.type_ = tinfofornode(c, v): *void;
					return v;
				};
				v = v.next;
			};
			return nil;
		};
		e.type_ = tinfofornode(c, ou.list): *void;
		return ou.list;
	};
	if (k == nkind.N_TRYUNW) {
		// `e!` abort-on-error unwrap; success variant is what the
		// receiver gets, identical to `?` shape modulo control flow.
		// #31: required so `let p: *T = alloc(v)!;` resolves to *T.
		let opt: *node = exprtype(c, e.lhs, nil);
		let ou: *node = resolvealias(c, unwrapbang(opt));
		if (ou == nil) { return nil; };
		if (ou.kind != nkind.N_TTAGGED) { return nil; };
		if (taggedhaserr(c, ou)) {
			let v: *node = ou.list;
			for (v != nil) {
				if (!iserrvariant(c, ou, v)) {
					e.type_ = tinfofornode(c, v): *void;
					return v;
				};
				v = v.next;
			};
			return nil;
		};
		e.type_ = tinfofornode(c, ou.list): *void;
		return ou.list;
	};
	if (k == nkind.N_TYPEASSERT) {
		// `e as T` → T. Mirrors cstage cmd/wcc/check.c TYPEASSERT
		// `n->type = resolve_type(c, n->rhs)`.
		e.type_ = tinfofornode(c, e.rhs): *void;
		return e.rhs;
	};
	if (k == nkind.N_TYPETEST) {
		// `e is T` → bool
		let tn: *node = mktname(c, "bool");
		e.type_ = tinfofornode(c, tn): *void;
		return tn;
	};
	return nil;
};

// isuntypedint / is_str_like / is_bool_like — helpers used
// by the assignability check below to allow common AST shapes
// through without needing real type inference.
fn isuntypedint(t: *node) bool = {
	if (t == nil) { return false; };
	if (t.kind != nkind.N_TNAME) { return false; };
	return streq(t.str, "untyped_int");
};

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

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

// isinttypeast — int-typed AST node. Either a primitive int name
// (i8..i64/u8..u64/int/uint/uintptr/rune) or an N_TENUM. Floats are
// excluded so the enum↔int reinterpret in checkisas (#52) refuses a
// surprise `enum as f64` shape. Mirrors cstage's type_isint
// (cmd/wcc/type.c) restricted to the kinds reachable from AST.
fn isinttypeast(t: *node) bool = {
	if (t == nil) { return false; };
	if (t.kind == nkind.N_TENUM) { return true; };
	if (t.kind != nkind.N_TNAME) { return false; };
	let s: str = t.str;
	if (streq(s, "i8"))  { return true; };
	if (streq(s, "i16")) { return true; };
	if (streq(s, "i32")) { return true; };
	if (streq(s, "i64")) { return true; };
	if (streq(s, "u8"))  { return true; };
	if (streq(s, "u16")) { return true; };
	if (streq(s, "u32")) { return true; };
	if (streq(s, "u64")) { return true; };
	if (streq(s, "int"))  { return true; };
	if (streq(s, "uint")) { return true; };
	if (streq(s, "uintptr")) { return true; };
	if (streq(s, "rune")) { return true; };
	return false;
};

fn isnumerictname(t: *node) bool = {
	if (t == nil) { return false; };
	if (t.kind != nkind.N_TNAME) { return false; };
	let s: str = t.str;
	if (streq(s, "i8"))  { return true; };
	if (streq(s, "i16")) { return true; };
	if (streq(s, "i32")) { return true; };
	if (streq(s, "i64")) { return true; };
	if (streq(s, "u8"))  { return true; };
	if (streq(s, "u16")) { return true; };
	if (streq(s, "u32")) { return true; };
	if (streq(s, "u64")) { return true; };
	if (streq(s, "int"))  { return true; };
	if (streq(s, "uint")) { return true; };
	if (streq(s, "uintptr")) { return true; };
	if (streq(s, "rune")) { return true; };
	if (streq(s, "f32"))  { return true; };
	if (streq(s, "f64"))  { return true; };
	return false;
};

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

// isassignable — AST-level approximation of C check.c
// type_assignable. Returns true when we know the assignment is
// OK, false only when we're confident it isn't, and "skip" (true)
// when we can't tell — to avoid false positives. The trailing bool
// `confident` lets the caller decide whether to emit an error
// when the result is false: if !confident, the caller should not
// flag it.
fn isassignable(c: *checker, dst: *node, src: *node, confident: *bool) bool = {
	*confident = false;
	if (dst == nil) { return true; };	// no declared target
	if (src == nil) { return true; };	// unknown src type
	*confident = true;
	let du: *node = resolvealias(c, unwrapbang(dst));
	let su: *node = resolvealias(c, unwrapbang(src));
	if (du == nil) { *confident = false; return true; };
	if (su == nil) { *confident = false; return true; };
	if (typeeqast(du, su)) { return true; };
	// untyped numeric → any numeric named type.
	if (isuntypedint(su)) {
		if (isnumerictname(du)) { return true; };
		// (T | ...) tagged: only OK if some variant accepts untyped_int.
		if (du.kind == nkind.N_TTAGGED) {
			let v: *node = du.list;
			for (v != nil) {
				let vu: *node = resolvealias(c, unwrapbang(v));
				if (vu != nil) {
					if (isnumerictname(vu)) { return true; };
				};
				v = v.next;
			};
			*confident = false;
			return true;
		};
		// Known non-numeric primitive: confidently wrong.
		if (du.kind == nkind.N_TNAME) {
			if (streq(du.str, "bool")) { return false; };
			if (streq(du.str, "void")) { return false; };
			if (streq(du.str, "str"))  { return false; };
		};
		// Unknown shapes: stay quiet.
		*confident = false;
		return true;
	};
	if (isuntypedfloat(su)) {
		if (isnumerictname(du)) { return true; };
		if (du.kind == nkind.N_TNAME) {
			if (streq(du.str, "bool")) { return false; };
			if (streq(du.str, "void")) { return false; };
			if (streq(du.str, "str"))  { return false; };
		};
		*confident = false;
		return true;
	};
	if (isuntypednil(su)) {
		// nil → ptr/slice/chan/fn/nullable
		if (du.kind == nkind.N_TPTR)   { return true; };
		if (du.kind == nkind.N_TSLICE) { return true; };
		if (du.kind == nkind.N_TCHAN)  { return true; };
		if (du.kind == nkind.N_TFN)    { return true; };
		// nullable `(*T | void)` — already accepted by typeeqast
		// when matched whole; nil is OK there too.
		if (du.kind == nkind.N_TTAGGED) {
			let v: *node = du.list;
			for (v != nil) {
				if (v.kind == nkind.N_TPTR)  { return true; };
				if (v.kind == nkind.N_TSLICE){ return true; };
				v = v.next;
			};
		};
		*confident = false;
		return true;
	};
	// Tagged-union variant inclusion: src is one of dst's variants.
	// Recursive isassignable mirrors cstage type_assignable
	// (cmd/wcc/type.c:298-299) and harec tagged_select_subtype's
	// recursive type_is_assignable call (ref/harec/src/types.c:702-739,
	// :718; invoked from the TAGGED arm at :1110-1112). #39 cascade:
	// the prior typeeqast-only walk rejected widenings that aren't
	// strict surface-eq (NAMED-aliased variants, nested tagged inside
	// a variant, concrete → variant after the wrap-induced exprtype
	// reshape). #55 surface-nominal fast path is preserved by the
	// recursive call's leading typeeqast (line 2257). #57 bare-vs-
	// qualified TNAME residual unchanged.
	if (du.kind == nkind.N_TTAGGED && su.kind != nkind.N_TTAGGED) {
		let v: *node = du.list;
		for (v != nil) {
			let innerconf: bool = false;
			if (isassignable(c, v, src, &innerconf)) { return true; };
			v = v.next;
		};
		return false;
	};
	// tagged → tagged: structural variant list compare. Skip
	// (don't be confident) — common when forwarding a fallible
	// return through another fn with the same shape but possibly
	// a different surface spelling.
	if (du.kind == nkind.N_TTAGGED && su.kind == nkind.N_TTAGGED) {
		*confident = false;
		return true;
	};
	// tagged → non-tagged: requires `?` / `!` / match to project a
	// variant. #31: this is what traps `let p: *T = alloc(v);`
	// where the builtin returns `(*T | nomem)` and the LHS is bare.
	if (su.kind == nkind.N_TTAGGED && du.kind != nkind.N_TTAGGED) {
		return false;
	};
	// Two known primitives with different names are confidently
	// incompatible. `i32 ↔ bool`, `str ↔ i32`, etc.
	if (du.kind == nkind.N_TNAME && su.kind == nkind.N_TNAME) {
		let known_d: bool = isnumerictname(du) || isstrtname(du);
		if (!known_d) { if (streq(du.str, "bool")) { known_d = true; }; };
		if (!known_d) { if (streq(du.str, "void")) { known_d = true; }; };
		let known_s: bool = isnumerictname(su) || isstrtname(su);
		if (!known_s) { if (streq(su.str, "bool")) { known_s = true; }; };
		if (!known_s) { if (streq(su.str, "void")) { known_s = true; }; };
		if (known_d) {
			if (known_s) {
				// Both primitives, different names → no.
				return false;
			};
		};
	};
	// Anything else: don't claim confidence.
	*confident = false;
	return true;
};

// ---- match exhaustiveness --------------------------------------------
//
// For every match arm, verify that every variant of the scrutinee's
// tagged-union type is handled by some case (or a default arm
// exists). Multi-pattern `case A | B =>` covers all alts.

fn casecovers(c: *checker, cs: *node, want: *node) bool = {
	if (cs.lhs != nil) {
		if (typeeqast(cs.lhs, want)) { return true; };
	};
	let alt: *node = cs.list;
	for (alt != nil) {
		if (typeeqast(alt, want)) { return true; };
		alt = alt.next;
	};
	return false;
};

fn errmatchvariant(c: *checker, n: *node, vname: *node) void = {
	os.write(2, "match: variant not handled".ptr, 26u64);
	if (vname != nil) {
		if (vname.kind == nkind.N_TNAME) {
			os.write(2, " (".ptr, 2u64);
			os.write(2, vname.str.ptr, vname.str.len: u64);
			os.write(2, ")".ptr, 1u64);
		};
	};
	os.write(2, "\n".ptr, 1u64);
	c.errs += 1;
};

// casevariantin — true iff `pat` (a `case T` pattern, including
// each alt of a multi-pattern) names a variant of the tagged
// union `tagged`.
fn casevariantin(tagged: *node, pat: *node) bool = {
	let v: *node = tagged.list;
	for (v != nil) {
		if (typeeqast(v, pat)) { return true; };
		v = v.next;
	};
	return false;
};

fn errbadcase(c: *checker, pat: *node) void = {
	os.write(2, "case: not a variant of scrutinee".ptr, 32u64);
	if (pat != nil) {
		if (pat.kind == nkind.N_TNAME) {
			os.write(2, " (".ptr, 2u64);
			os.write(2, pat.str.ptr, pat.str.len: u64);
			os.write(2, ")".ptr, 1u64);
		};
	};
	os.write(2, "\n".ptr, 1u64);
	c.errs += 1;
};

fn checkmatchexhaust(c: *checker, n: *node) void = {
	if (n == nil) { return; };
	if (n.lhs == nil) { return; };
	let st: *node = scruttype(c, n.lhs);
	let u: *node = resolvealias(c, unwrapbang(st));
	if (u == nil) { return; };
	if (u.kind != nkind.N_TTAGGED) { return; };
	// Validity: every `case T` pattern (and multi-pattern alts)
	// must name a variant of u. Catches typos and dead arms that
	// the dispatch would never reach.
	let cs0: *node = n.list;
	for (cs0 != nil) {
		if (cs0.lhs != nil) {
			if (!casevariantin(u, cs0.lhs)) {
				errbadcase(c, cs0.lhs);
			};
			let alt: *node = cs0.list;
			for (alt != nil) {
				if (!casevariantin(u, alt)) {
					errbadcase(c, alt);
				};
				alt = alt.next;
			};
		};
		cs0 = cs0.next;
	};
	// Default arm absorbs anything; skip exhaustiveness.
	let cs: *node = n.list;
	for (cs != nil) {
		if (cs.lhs == nil) { return; };	// default
		cs = cs.next;
	};
	// For each variant of u, look for a covering case.
	let v: *node = u.list;
	for (v != nil) {
		let covered: bool = false;
		let cs2: *node = n.list;
		for (cs2 != nil) {
			if (casecovers(c, cs2, v)) {
				covered = true;
				cs2 = nil;
			} else {
				cs2 = cs2.next;
			};
		};
		if (!covered) { errmatchvariant(c, n, v); };
		v = v.next;
	};
};

// ---- let init / return assignability --------------------------------
//
// AST-level approximation: when we can infer src's type and dst is
// explicitly declared, verify isassignable. We only emit an error
// when isassignable says "false with confidence." If we can't tell
// (binary ops, complex exprs we don't infer), we stay quiet — full
// type inference lives only on the C side.

fn errnotassign(c: *checker, dst: *node, src: *node, where: str) void = {
	os.write(2, where.ptr, where.len: u64);
	os.write(2, ": not assignable".ptr, 16u64);
	if (src != nil) {
		if (src.kind == nkind.N_TNAME) {
			os.write(2, " (".ptr, 2u64);
			os.write(2, src.str.ptr, src.str.len: u64);
			os.write(2, " → ".ptr, 5u64);
			if (dst != nil) {
				if (dst.kind == nkind.N_TNAME) {
					os.write(2, dst.str.ptr, dst.str.len: u64);
				};
			};
			os.write(2, ")".ptr, 1u64);
		};
	};
	os.write(2, "\n".ptr, 1u64);
	c.errs += 1;
};

fn checkletassign(c: *checker, n: *node) void = {
	if (n == nil) { return; };
	if (n.rhs == nil) { return; };	// no init
	// hint = nil for A.6.0; A.6.1 will pass n.lhs once STRUCTLIT/ARRLIT
	// arms consume it. Plumbing-only at this point.
	let src: *node = exprtype(c, n.rhs, nil);
	// Inferred binding (`let r = expr;`, no type annotation). Mirror
	// cstage cmd/wcc/check.c:1477 clet `if (t == NULL && initt) t =
	// type_default(initt);` and ref/harec/src/check.c:1422
	// check_expr_binding. wwstage carries the let's type on decl.lhs
	// (exprtype N_IDENT at L1546 reads s.decl.lhs); cstage carries it
	// on Sym.type — same observable result, rule-10 byte-id holds.
	// Defaulting (untyped_int → i32, etc.) is exprtype's job at use
	// sites, not the binding site.
	if (n.lhs == nil) {
		if (src != nil) { n.lhs = src; };
		return;
	};
	if (src == nil) { return; };	// can't infer
	// #45: alloc([], n) defers element type to the let-init context
	// (Hare-style). exprtype's alloc-slice branch synthesizes
	// ([]u8 | nomem) / []u8 (for the ?/! wrap) with no LHS context;
	// when the let declares []T, retype src to []T / ([]T | nomem)
	// so isassignable sees exact equality. cgenstmt cglet drives the
	// element size from n.lhs already (cmd/wcc/cgenstmt.ww), so this
	// stays symmetric with cstage check.c clet's parallel retype.
	if (n.lhs.kind == nkind.N_TSLICE) {
		let wrapped: bool = false;
		let inner: *node = n.rhs;
		if (inner.kind == nkind.N_TRYPROP) {
			wrapped = true;
			inner = inner.lhs;
		} else { if (inner.kind == nkind.N_TRYUNW) {
			wrapped = true;
			inner = inner.lhs;
		}; };
		if (inner != nil && inner.kind == nkind.N_CALL) {
			let callee: *node = inner.lhs;
			let a0: *node = inner.list;
			let a1: *node = nil;
			let a2: *node = nil;
			if (a0 != nil) { a1 = a0.next; };
			if (a1 != nil) { a2 = a1.next; };
			if (callee != nil
			    && callee.kind == nkind.N_IDENT
			    && streq(callee.str, "alloc")
			    && a0 != nil && a0.kind == nkind.N_ARRLIT
			    && a0.list == nil
			    && a1 != nil && a2 == nil) {
				let shadowed: bool = false;
				if (c.curmod.len > 0) {
					if (scopelookupinmodule(c.cur, c.curmod, "alloc") != nil) {
						shadowed = true;
					};
				};
				if (!shadowed) {
					let sl: *node = newnode(nkind.N_TSLICE, "", 0, 0);
					sl.lhs = n.lhs.lhs;
					if (wrapped) {
						src = sl;
					} else {
						let nome: *node = mktname(c, "nomem");
						sl.next = nome;
						let tt: *node = newnode(nkind.N_TTAGGED, "", 0, 0);
						tt.list = sl;
						src = tt;
					};
				};
			};
		};
	};
	let conf: bool = false;
	let ok: bool = isassignable(c, n.lhs, src, &conf);
	if (!conf) { return; };
	if (!ok) { errnotassign(c, n.lhs, src, "let"); };
};

fn checkretassign(c: *checker, n: *node) void = {
	if (n == nil) { return; };
	if (n.lhs == nil) {
		// bare `return;` — OK iff fnret is void or a tagged union
		// with a void variant. Skip flagging for now; cgen handles
		// the void-variant tag synthesis already.
		return;
	};
	if (c.fnret == nil) { return; };
	let src: *node = exprtype(c, n.lhs, nil);
	if (src == nil) { return; };
	let conf: bool = false;
	let ok: bool = isassignable(c, c.fnret, src, &conf);
	if (!conf) { return; };
	if (!ok) { errnotassign(c, c.fnret, src, "return"); };
};

// ---- is / as validity ------------------------------------------------
//
// `e is T` and `e as T` require that e's declared type be a tagged
// union and that T name one of its variants. Operates on AST type
// expressions; falls back silently when we can't determine e's
// type (matches the case-variant rule for match).
fn checkisas(c: *checker, n: *node) void = {
	if (n == nil) { return; };
	// e is in n.lhs (value), T is in n.rhs (type expr).
	let st: *node = scruttype(c, n.lhs);
	let u: *node = resolvealias(c, unwrapbang(st));
	if (u == nil) { return; };
	// #52: enum ↔ int reinterpret (`enum as intT` / `intT as enum`).
	// Mirrors cstage cmd/wcc/check.c:1346-1357 — N_TYPEASSERT with an
	// enum on either side and integer types on both reinterprets in
	// the same register, no tag check involved. Returns early before
	// the tagged-union gate so lib/time/instant.ww `(c as i32)` and
	// the lib/os syscall casts stop false-positiving. `is` (TYPETEST)
	// stays rejected on non-tagged operands — cstage cmd/wcc/check.c
	// gates the bypass on N_TYPEASSERT only.
	if (n.kind == nkind.N_TYPEASSERT) {
		let v: *node = resolvealias(c, unwrapbang(n.rhs));
		let lhsenum: bool = false;
		let rhsenum: bool = false;
		if (u != nil) { if (u.kind == nkind.N_TENUM) { lhsenum = true; }; };
		if (v != nil) { if (v.kind == nkind.N_TENUM) { rhsenum = true; }; };
		if (lhsenum || rhsenum) {
			if (isinttypeast(u)) { if (isinttypeast(v)) { return; }; };
		};
	};
	if (u.kind != nkind.N_TTAGGED) {
		os.write(2, "is/as: operand is not a tagged union\n".ptr, 37u64);
		c.errs += 1;
		return;
	};
	let want: *node = n.rhs;
	if (want == nil) { return; };
	if (!casevariantin(u, want)) {
		os.write(2, "is/as: not a variant of operand".ptr, 31u64);
		if (want.kind == nkind.N_TNAME) {
			os.write(2, " (".ptr, 2u64);
			os.write(2, want.str.ptr, want.str.len: u64);
			os.write(2, ")".ptr, 1u64);
		};
		os.write(2, "\n".ptr, 1u64);
		c.errs += 1;
	};
};

// ---- ? subset propagation --------------------------------------------
//
// For `expr?`, the operand's error subset must be a subset of the
// enclosing fn's return-type variants. Mirrors C check.c. Operand
// is nkind.N_TRYPROP; its lhs is the value-bearing expr; we look at the
// expr's *declared* type for nkind.N_IDENT/nkind.N_CALL cases.

fn exprtypeoftry(c: *checker, e: *node) *node = {
	if (e == nil) { return nil; };
	if (e.kind == nkind.N_IDENT) {
		let s: *sym = scopelookup(c.cur, e.str);
		if (s == nil) { return nil; };
		if (s.decl == nil) { return nil; };
		return s.decl.lhs;
	};
	if (e.kind == nkind.N_CALL) {
		// callee return type lookup: callee is e.lhs (nkind.N_IDENT or
		// nkind.N_DOT). We need the fn-decl's lhs (return-type AST).
		let callee: *node = e.lhs;
		if (callee == nil) { return nil; };
		let nm: str;
		nm.ptr = nil; nm.len = 0;
		if (callee.kind == nkind.N_IDENT) { nm = callee.str; };
		if (callee.kind == nkind.N_DOT)   { nm = callee.str; };
		if (nm.len == 0) { return nil; };
		let s: *sym = scopelookup(c.cur, nm);
		if (s == nil) { return nil; };
		if (s.skind != skind.SK_FN) { return nil; };
		if (s.decl == nil) { return nil; };
		return s.decl.lhs;
	};
	return nil;
};

fn checktryprop(c: *checker, n: *node) void = {
	if (n == nil) { return; };
	let t: *node = exprtypeoftry(c, n.lhs);
	let u: *node = resolvealias(c, unwrapbang(t));
	if (u == nil) { return; };
	if (u.kind != nkind.N_TTAGGED) { return; };
	// Does the operand have any error variants?
	let haserr: bool = false;
	let v: *node = u.list;
	for (v != nil) {
		if (iserrvariant(c, u, v)) { haserr = true; };
		v = v.next;
	};
	if (!haserr) { return; };
	// Enclosing fn must return a tagged union with each operand
	// error variant present.
	let r: *node = resolvealias(c, unwrapbang(c.fnret));
	if (r == nil) {
		os.write(2, "?: enclosing fn has no tagged-union return\n".ptr, 43u64);
		c.errs += 1;
		return;
	};
	if (r.kind != nkind.N_TTAGGED) {
		os.write(2, "?: enclosing fn return is not tagged\n".ptr, 37u64);
		c.errs += 1;
		return;
	};
	let ev: *node = u.list;
	for (ev != nil) {
		if (iserrvariant(c, u, ev)) {
			let found: bool = false;
			let rv: *node = r.list;
			for (rv != nil) {
				if (typeeqast(rv, ev)) {
					found = true;
					rv = nil;
				} else { rv = rv.next; };
			};
			if (!found) {
				os.write(2, "?: error variant not in enclosing return\n".ptr, 41u64);
				c.errs += 1;
			};
		};
		ev = ev.next;
	};
};

// install_param — when entering a fn body, define its params in a
// fresh local scope.
//
// TODO(#11): cstage check.c (post-#32) errors `param '%s' redeclared`
// when two params share a name. The fn body's scope IS fresh here
// (resolvefnbody opens it before calling us), so guarding scopedefine's
// nil return would be sound — but we defer until #11 wires checkfile
// into w6c_ww so the diagnostic class lands as a single coordinated
// step rather than dribbling in. Matches the cstage-only neg-case
// precedent at test/wcc/708 + test/wcc/696.
fn installparams(c: *checker, params: *node) void = {
	let p: *node = params;
	for (p != nil) {
		if (p.kind == nkind.N_PARAM) {
			// Hare-style variadic `T...`: normalize p.lhs to []T so
			// downstream consumers (N_IDENT exprtype lookups via
			// s.decl.lhs, cgen's variadic-slot synthesis) see the
			// effective slice type. Mirrors cstage check.c:455
			// `tp->type = type_slice(c->a, pt)` and harec
			// check_func_type. Surface-fidelity preserved: wwdump
			// -a runs parser only and never reaches this mutation.
			if (p.op == tkind.TK_ELLIPSIS) {
				if (p.lhs != nil && p.lhs.kind != nkind.N_TSLICE) {
					let sl: *node = newnode(nkind.N_TSLICE, "", 0, 0);
					sl.lhs = p.lhs;
					p.lhs = sl;
				};
			};
			let nm: str = p.str;
			if (nm.len > 0) {
				checkmoduleshadow(c, nm, "param");
				scopedefine(c.cur, nm, skind.SK_PARAM, nil, p);
			};
		};
		p = p.next;
	};
};

// resolvefnbody — open a child scope for the fn, install its params,
// then walk the body. Local lets installed by walk_stmt (a future
// extension); for the current pass we just resolve-walk without
// per-statement scopes.
fn resolvefnbody(c: *checker, fnnode: *node) void = {
	let outer: *scope = c.cur;
	c.cur = newscope(c.cur);
	installparams(c, fnnode.list);
	// #61 audit §1.8 — A.2: walk each param's declared type-expr so
	// tinfofornode stamps n.type_ on it. installparams binds the name
	// but never recurses into the type; without this, cgen's slotsize
	// fast-path hits the fallback for every param load/store.
	let p: *node = fnnode.list;
	for (p != nil) {
		if (p.kind == nkind.N_PARAM) {
			if (p.lhs != nil) { resolvewalk(c, p.lhs); };
		};
		p = p.next;
	};
	let prevret: *node = c.fnret;
	c.fnret = fnnode.lhs;	// return type AST, used by `?` check
	if (fnnode.body != nil) {
		resolvewalk(c, fnnode.body);
	};
	c.fnret = prevret;
	c.cur = outer;
};

// asserttyped — post-checker invariant gate (#15, A.6.2.1e). Walks the
// file tree and fires (writes a one-line diagnostic to stderr) for any
// node in resolvewalk's value-producing dispatch set (L474-489) whose
// n.type_ remained nil. Mirror of harec's `assert(expr->result)` at
// ref/harec/src/check.c:3810 — wwstage's checker is lenient (rule 7),
// so this is a soft assertion (diagnostic, not abort) used by the
// 990_selfhost probes to catch regressions in the stamping discipline.
//
// Gates (per Drew 2026-05-22 — "guards value-producing expression
// nodes; SK_USE refs and bare builtin callees are syntactic positions,
// gate them out with WHY pointing at #19"):
//
//   1. N_IDENT whose resolved sym kind is SK_USE — module references
//      (`os` in `os.write`). Harec models these via EXPR_ACCESS whose
//      lookup-target is an OBJ_USE directly; there is no intermediate
//      "ident-as-value" expr. Until #19 ports that AST shape, skip.
//   2. N_IDENT whose resolved sym has decl == nil — pseudo-builtin
//      callees (len/append/free/alloc/size/align/offset, seeded in
//      checkinit L85-97 with decl=nil). Harec spells these as
//      dedicated EXPR_* kinds (EXPR_LEN, EXPR_APPEND, EXPR_FREE,
//      EXPR_ALLOC at ref/harec/src/check.c:2630/745/2443/...).
//      Drew's δ (#19) retires the seeded-SK_FN-with-nil-decl hack.
//   3. N_IDENT at the LHS-of-N_DOT syntactic position — the bare
//      name half of a member-access expr is a lookup target, not a
//      value-producing sub-expression. Harec's EXPR_ACCESS stores the
//      member as a string, not a node.
//
// `indot` tracks gate 3: true only when the immediate caller is an
// N_DOT recursing into its .lhs.
fn asserttyped(c: *checker, n: *node, indot: bool) void = {
	if (n == nil) { return; };
	let k: nkind = n.kind;
	let isexpr: bool =
		k == nkind.N_INTLIT    || k == nkind.N_FLOATLIT  ||
		k == nkind.N_STRLIT    || k == nkind.N_RUNELIT   ||
		k == nkind.N_TRUE      || k == nkind.N_FALSE     ||
		k == nkind.N_NIL       || k == nkind.N_VOIDLIT   ||
		k == nkind.N_IDENT     || k == nkind.N_BIN       ||
		k == nkind.N_UN        || k == nkind.N_CALL      ||
		k == nkind.N_INDEX     || k == nkind.N_CAST      ||
		k == nkind.N_STRUCTLIT || k == nkind.N_ARRLIT    ||
		k == nkind.N_RECV      || k == nkind.N_DOT       ||
		k == nkind.N_SLICE     || k == nkind.N_SPREAD    ||
		k == nkind.N_TUPLE     || k == nkind.N_TRYPROP   ||
		k == nkind.N_TRYUNW    || k == nkind.N_TYPETEST  ||
		k == nkind.N_TYPEASSERT || k == nkind.N_YIELD    ||
		k == nkind.N_MATCH;
	let skip: bool = false;
	if (isexpr && k == nkind.N_IDENT) {
		if (indot) { skip = true; };
		if (!skip) {
			let s: *sym = scopelookup(c.cur, n.str);
			if (s != nil) {
				if (s.skind == skind.SK_USE) { skip = true; };
				if (s.decl == nil) { skip = true; };
			};
		};
	};
	if (isexpr && !skip) {
		if (n.type_ == nil) {
			os.write(2, "asserttyped: ".ptr, 13u64);
			let kn: str = nkname(k);
			os.write(2, kn.ptr, kn.len: u64);
			os.write(2, " ".ptr, 1u64);
			if (n.file.len > 0) {
				os.write(2, n.file.ptr, n.file.len: u64);
				os.write(2, ":".ptr, 1u64);
				let ls: str = strconv.i32tos(n.line, strconv.base.DEC);
				os.write(2, ls.ptr, ls.len: u64);
			};
			if (n.str.len > 0) {
				os.write(2, " '".ptr, 2u64);
				os.write(2, n.str.ptr, n.str.len: u64);
				os.write(2, "'".ptr, 1u64);
			};
			os.write(2, "\n".ptr, 1u64);
		};
	};
	if (k == nkind.N_DOT) {
		if (n.lhs != nil) { asserttyped(c, n.lhs, true); };
		return;
	};
	if (n.attr != nil) { asserttyped(c, n.attr, false); };
	if (n.lhs  != nil) { asserttyped(c, n.lhs,  false); };
	if (n.rhs  != nil) { asserttyped(c, n.rhs,  false); };
	if (n.cond != nil) { asserttyped(c, n.cond, false); };
	if (n.body != nil) { asserttyped(c, n.body, false); };
	if (n.els  != nil) { asserttyped(c, n.els,  false); };
	let m: *node = n.list;
	for (m != nil) {
		asserttyped(c, m, false);
		m = m.next;
	};
};

export fn checkinit(c: *checker, tc: *tctx) void = {
	c.tc = tc;
	c.top = newscope(nil);
	c.cur = c.top;
	c.nresolved = 0;
	c.nunresolved = 0;
	c.errs = 0;
	c.verbose = 0;
	c.fnret = nil;
	let empty: str;
	c.curmod = empty;
	c.file = nil;
	seedprimitives(c);
};

export fn checkfile(c: *checker, file: *node) void = {
	if (file == nil) { return; };
	if (file.kind != nkind.N_FILE) { return; };
	c.file = file;

	// Pass 1: install all top-level names.
	let d: *node = file.list;
	for (d != nil) {
		installdecl(c, file, d);
		d = d.next;
	};

	// Pass 2: walk decl bodies/types and resolve identifiers.
	// Track the per-decl module bareword so bare-leaf lookups inside
	// the body prefer same-module entries over alphabetically-earlier
	// same-leaf imports.
	d = file.list;
	for (d != nil) {
		c.curmod = declmod(file, d);
		// A.6.2.1-pre — attr-subtree gap: top-level dispatch below walks
		// d.lhs / d.body per kind but never d.attr, leaving `@symbol("…")`
		// arg literals (N_STRLIT) outside the post-order exprtype
		// dispatch. Mirror resolvewalk L405 which descends n.attr on
		// inner nodes.
		if (d.attr != nil) { resolvewalk(c, d.attr); };
		let k: nkind = d.kind;
		if (k == nkind.N_FNDECL) {
			if (d.lhs != nil) { resolvewalk(c, d.lhs); };	// return type
			resolvefnbody(c, d);
		} else { if (k == nkind.N_DEF) {
			if (d.lhs != nil) { resolvewalk(c, d.lhs); };
			if (d.rhs != nil) { resolvewalk(c, d.rhs); };
		} else { if (k == nkind.N_TYPEDECL) {
			if (d.lhs != nil) { resolvewalk(c, d.lhs); };
		} else { if (k == nkind.N_LET) {
			if (d.lhs != nil) { resolvewalk(c, d.lhs); };
			if (d.rhs != nil) { resolvewalk(c, d.rhs); };
		};};};};
		d = d.next;
	};

	// Pass 3 (#15, A.6.2.1e): post-checker invariant gate. Walks each
	// decl with its curmod set so asserttyped's gate lookups resolve
	// against the same module context exprtype saw during pass 2.
	d = file.list;
	for (d != nil) {
		c.curmod = declmod(file, d);
		asserttyped(c, d, false);
		d = d.next;
	};

	let empty: str;
	c.curmod = empty;

};