// 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 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.

use os;
use mem;
use tok;

type checker = struct {
	a:        *arena,
	tc:       *tctx,
	top:      *scope,
	cur:      *scope,
	nresolved:   i32,
	nunresolved: i32,
	errs:        i32,
	verbose:     i32,	// when non-zero, log each unresolved name
};

// 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",    SK_TYPE, c.tc.tyvoid,    nil);
	scopedefine(c.top, "bool",    SK_TYPE, c.tc.tybool,    nil);
	scopedefine(c.top, "rune",    SK_TYPE, c.tc.tyrune,    nil);
	scopedefine(c.top, "i8",      SK_TYPE, c.tc.tyi8,      nil);
	scopedefine(c.top, "i16",     SK_TYPE, c.tc.tyi16,     nil);
	scopedefine(c.top, "i32",     SK_TYPE, c.tc.tyi32,     nil);
	scopedefine(c.top, "i64",     SK_TYPE, c.tc.tyi64,     nil);
	scopedefine(c.top, "u8",      SK_TYPE, c.tc.tyu8,      nil);
	scopedefine(c.top, "u16",     SK_TYPE, c.tc.tyu16,     nil);
	scopedefine(c.top, "u32",     SK_TYPE, c.tc.tyu32,     nil);
	scopedefine(c.top, "u64",     SK_TYPE, c.tc.tyu64,     nil);
	scopedefine(c.top, "int",     SK_TYPE, c.tc.tyint,     nil);
	scopedefine(c.top, "uint",    SK_TYPE, c.tc.tyuint,    nil);
	scopedefine(c.top, "uintptr", SK_TYPE, c.tc.tyuintptr, nil);
	scopedefine(c.top, "f32",     SK_TYPE, c.tc.tyf32,     nil);
	scopedefine(c.top, "f64",     SK_TYPE, c.tc.tyf64,     nil);
	scopedefine(c.top, "str",     SK_TYPE, c.tc.tystr,     nil);
	scopedefine(c.top, "never",   SK_TYPE, c.tc.tynever,   nil);
	// `nil`, `true`, `false` are keywords — handled at the lex/parser
	// level, no symbol needed.
	// `len`, `alloc`, `free` are pseudo-builtins; scopedefine them so
	// their use sites resolve. The actual semantics live in cgen.
	scopedefine(c.top, "len",   SK_FN, nil, nil);
	scopedefine(c.top, "alloc", SK_FN, nil, nil);
	scopedefine(c.top, "free",  SK_FN, nil, nil);
};

// 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.
fn installdecl(c: *checker, d: *node) void = {
	if (d == nil) { return; };
	let k: i32 = d.kind;
	let nm: str = d.str;
	if (k == N_USE)      { scopedefine(c.top, nm, SK_USE,  nil, d); return; };
	if (k == N_DEF)      { scopedefine(c.top, nm, SK_DEF,  nil, d); return; };
	if (k == N_TYPEDECL) { scopedefine(c.top, nm, SK_TYPE, nil, d); return; };
	if (k == N_FNDECL)   { scopedefine(c.top, nm, SK_FN,   nil, d); return; };
	if (k == N_LET)      { scopedefine(c.top, nm, SK_VAR,  nil, d); return; };
};

// resolvewalk — recursive AST walk that, for every N_IDENT and
// 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).
fn resolvewalk(c: *checker, n: *node) void = {
	if (n == nil) { return; };
	let k: i32 = n.kind;

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

	if (k == N_IDENT) {
		let nm: str = n.str;
		if (nm.len > 0) {
			let s: *sym = scopelookup(c.cur, 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 == N_TNAME) {
		let nm: str = n.str;
		if (nm.len > 0) {
			let s: *sym = scopelookup(c.cur, nm);
			// `pkg.Type` — strip the last dot prefix and look up
			// the leaf if `pkg` is a use-imported name. 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 = scopelookup(c.cur, 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; };
		};
	};

	// `match (e) { case let v: T => stmt; ... }` — the binding `v`
	// is declared by the case arm and visible inside its body.
	if (k == N_MCASE) {
		if (n.lhs  != nil) { resolvewalk(c, n.lhs);  };
		let nm: str = n.str;
		if (nm.len > 0) {
			scopedefine(c.cur, nm, SK_VAR, nil, n);
		};
		if (n.body != nil) { resolvewalk(c, n.body); };
		return;
	};

	if (k == N_DOT) {
		// Walk only the base; the .field name is a member, not a
		// free identifier.
		if (n.lhs != nil) { resolvewalk(c, n.lhs); };
		return;
	};

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

	if (k == 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;
		};
	};

	// 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).
	if (k == N_LET) {
		let nm: str = n.str;
		if (nm.len > 0) {
			scopedefine(c.cur, nm, SK_VAR, nil, n);
		};
	};
};

// install_param — when entering a fn body, define its params in a
// fresh local scope.
fn installparams(c: *checker, params: *node) void = {
	let p: *node = params;
	for (p != nil) {
		if (p.kind == N_PARAM) {
			let nm: str = p.str;
			if (nm.len > 0) {
				scopedefine(c.cur, nm, 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.a, c.cur);
	installparams(c, fnnode.list);
	if (fnnode.body != nil) {
		resolvewalk(c, fnnode.body);
	};
	c.cur = outer;
};

export fn checkinit(c: *checker, a: *arena, tc: *tctx) void = {
	c.a = a;
	c.tc = tc;
	c.top = newscope(a, nil);
	c.cur = c.top;
	c.nresolved = 0;
	c.nunresolved = 0;
	c.errs = 0;
	c.verbose = 0;
	seedprimitives(c);
};

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

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

	// Pass 2: walk decl bodies/types and resolve identifiers.
	d = file.list;
	for (d != nil) {
		let k: i32 = d.kind;
		if (k == N_FNDECL) {
			if (d.lhs != nil) { resolvewalk(c, d.lhs); };	// return type
			resolvefnbody(c, d);
		} else { if (k == N_DEF) {
			if (d.lhs != nil) { resolvewalk(c, d.lhs); };
			if (d.rhs != nil) { resolvewalk(c, d.rhs); };
		} else { if (k == N_TYPEDECL) {
			if (d.lhs != nil) { resolvewalk(c, d.lhs); };
		} else { if (k == N_LET) {
			if (d.lhs != nil) { resolvewalk(c, d.lhs); };
			if (d.rhs != nil) { resolvewalk(c, d.rhs); };
		};};};};
		d = d.next;
	};
};