gofront 0.0.2 → 0.0.4

package/src/typechecker.js

@@ -1,164 +1,41 @@
 // Type checker: walks the AST, resolves types for all expressions,
 // and reports type errors at compile time.
 //
-// Type representation:
-//   { kind: 'basic',     name: 'int'|'float64'|'string'|'bool'|'any'|'void' }
-//   { kind: 'slice',     elem: Type }
-//   { kind: 'array',     size: n, elem: Type }
-//   { kind: 'map',       key: Type, value: Type }
-//   { kind: 'struct',    name: string, fields: Map<string, Type>, methods: Map<string, FuncType> }
-//   { kind: 'interface', name: string, methods: Map<string, FuncType> }
-//   { kind: 'func',      params: Type[], returns: Type[]  }
-//   { kind: 'tuple',     types: Type[] }   ← multiple return values
-//   { kind: 'named',     name: string, underlying: Type }
-
-export class TypeCheckError extends Error {
-	constructor(msg, node, filename, sourceCode) {
-		const lineNum = node?.line || node?._line;
-		const loc = filename
-			? lineNum
-				? ` in ${filename} at line ${lineNum}`
-				: ` in ${filename}`
-			: lineNum
-				? ` at line ${lineNum}`
-				: "";
-		let lineContext = "";
-		if (lineNum && sourceCode) {
-			const lines = sourceCode.split("\n");
-			const lineStr = lines[lineNum - 1];
-			if (lineStr !== undefined) {
-				lineContext = `\n  ${lineNum} | ${lineStr}`;
-			}
-		}
-		super(`Type error${loc}: ${msg}${lineContext}`);
-	}
-}
-
-// ── Static operator sets (module-level for reuse) ────────────
-const CMP_OPS = new Set(["==", "!=", "<", ">", "<=", ">="]);
-const LOG_OPS = new Set(["&&", "||"]);
-
-// ── Built-in types ───────────────────────────────────────────
-
-const INT = { kind: "basic", name: "int" };
-const FLOAT64 = { kind: "basic", name: "float64" };
-const STRING = { kind: "basic", name: "string" };
-const BOOL = { kind: "basic", name: "bool" };
-const ANY = { kind: "basic", name: "any" };
-const VOID = { kind: "basic", name: "void" };
-const NIL = { kind: "basic", name: "nil" };
-const ERROR = { kind: "basic", name: "error" };
-
-const BASIC_TYPES = {
-	int: INT,
-	float64: FLOAT64,
-	string: STRING,
-	bool: BOOL,
-	any: ANY,
-	byte: INT,
-	rune: INT,
-	error: ERROR,
-	// Sized integer / float aliases — all map to int or float64 at runtime
-	uint: INT,
-	int8: INT,
-	int16: INT,
-	int32: INT,
-	int64: INT,
-	uint8: INT,
-	uint16: INT,
-	uint32: INT,
-	uint64: INT,
-	uintptr: INT,
-	float32: FLOAT64,
-};
-
-function isNumeric(t) {
-	return t.kind === "basic" && (t.name === "int" || t.name === "float64");
-}
-function isString(t) {
-	return t.kind === "basic" && t.name === "string";
-}
-function isBool(t) {
-	return t.kind === "basic" && t.name === "bool";
-}
-function isAny(t) {
-	return t.kind === "basic" && t.name === "any";
-}
-function isNil(t) {
-	return t.kind === "basic" && t.name === "nil";
-}
-function isVoid(t) {
-	return t.kind === "basic" && t.name === "void";
-}
-function isError(t) {
-	return t.kind === "basic" && t.name === "error";
-}
-
-export function typeStr(t) {
-	if (!t) return "void";
-	if (t.kind === "basic" && t.alias) return t.alias;
-	switch (t.kind) {
-		case "basic":
-			return t.name;
-		case "slice":
-			return `[]${typeStr(t.elem)}`;
-		case "array":
-			return `[${t.size}]${typeStr(t.elem)}`;
-		case "map":
-			return `map[${typeStr(t.key)}]${typeStr(t.value)}`;
-		case "struct":
-			return t.name || "struct{...}";
-		case "interface":
-			return t.name || "interface{...}";
-		case "namespace":
-			return t.name || "namespace{...}";
-		case "func":
-			return `func(${t.params.map(typeStr).join(", ")}) ${typeStr(t.returns[0] ?? VOID)}`;
-		case "tuple":
-			return `(${t.types.map(typeStr).join(", ")})`;
-		case "named":
-			return t.name;
-		case "pointer":
-			return `*${typeStr(t.base)}`;
-		default:
-			return "?";
-	}
-}
-
-// ── Scope / environment ──────────────────────────────────────
-
-class Scope {
-	constructor(parent = null) {
-		this.parent = parent;
-		this.symbols = new Map();
-		this._consts = new Set(); // names declared as const in this scope
-	}
-	define(name, type) {
-		this.symbols.set(name, type);
-	}
-	defineConst(name, type) {
-		this.symbols.set(name, type);
-		this._consts.add(name);
-	}
-	isConst(name) {
-		if (this._consts.has(name)) return true;
-		// Don't walk parent — shadowing a const with a var in a child scope is valid
-		return false;
-	}
-	lookup(name) {
-		if (this.symbols.has(name)) return this.symbols.get(name);
-		if (this.parent) return this.parent.lookup(name);
-		return null;
-	}
-	// Lookup which scope owns the name (to check const flag)
-	lookupScope(name) {
-		if (this.symbols.has(name)) return this;
-		if (this.parent) return this.parent.lookupScope(name);
-		return null;
-	}
-}
-
-// ── Type checker ─────────────────────────────────────────────
+// Split into sub-modules under typechecker/:
+//   types.js        — shared type constants, predicates, Scope
+//   statements.js   — checkBlock, checkStmt
+//   expressions.js  — checkExpr, checkCall, checkBuiltin, checkCompositeLit
+
+import { expressionCheckMethods } from "./typechecker/expressions.js";
+import { statementCheckMethods } from "./typechecker/statements.js";
+import {
+	ANY,
+	BASIC_TYPES,
+	BOOL,
+	CMP_OPS,
+	defaultType,
+	ERROR,
+	FLOAT64,
+	INT,
+	isAny,
+	isError,
+	isNil,
+	isNumeric,
+	isString,
+	isUntyped,
+	isVoid,
+	LOG_OPS,
+	Scope,
+	STRING,
+	TypeCheckError,
+	typeStr,
+	UNTYPED_FLOAT,
+	UNTYPED_INT,
+	VOID,
+} from "./typechecker/types.js";
+
+// Re-export for consumers that import from typechecker.js
+export { TypeCheckError, typeStr };
 
 export class TypeChecker {
 	constructor() {
@@ -169,6 +46,9 @@ export class TypeChecker {
 		this._currentSource = null;
 		this._loopDepth = 0; // for break/continue validation
 		this._switchDepth = 0; // for break/fallthrough validation
+		this._typeSwitchDepth = 0; // for rejecting fallthrough in type switch
+		this._deferCount = 0; // tracks defer usage in current function body
+		this._imports = []; // tracked imports for unused-import detection
 		this._setupGlobals();
 	}
 
@@ -263,6 +143,245 @@ export class TypeChecker {
 			},
 		});
 
+		// strings package
+		const strFn1 = (ret) => ({
+			kind: "func",
+			params: [STRING],
+			returns: [ret],
+		});
+		const strFn2 = (p2, ret) => ({
+			kind: "func",
+			params: [STRING, p2],
+			returns: [ret],
+		});
+		const strFn3 = (p2, p3, ret) => ({
+			kind: "func",
+			params: [STRING, p2, p3],
+			returns: [ret],
+		});
+		this.globals.define("strings", {
+			kind: "namespace",
+			name: "strings",
+			members: {
+				Contains: strFn2(STRING, BOOL),
+				HasPrefix: strFn2(STRING, BOOL),
+				HasSuffix: strFn2(STRING, BOOL),
+				Index: strFn2(STRING, INT),
+				LastIndex: strFn2(STRING, INT),
+				Count: strFn2(STRING, INT),
+				Repeat: strFn2(INT, STRING),
+				Replace: {
+					kind: "func",
+					params: [STRING, STRING, STRING, INT],
+					returns: [STRING],
+				},
+				ReplaceAll: strFn3(STRING, STRING, STRING),
+				ToUpper: strFn1(STRING),
+				ToLower: strFn1(STRING),
+				TrimSpace: strFn1(STRING),
+				Trim: strFn2(STRING, STRING),
+				TrimPrefix: strFn2(STRING, STRING),
+				TrimSuffix: strFn2(STRING, STRING),
+				TrimLeft: strFn2(STRING, STRING),
+				TrimRight: strFn2(STRING, STRING),
+				Split: strFn2(STRING, { kind: "slice", elem: STRING }),
+				Join: {
+					kind: "func",
+					params: [{ kind: "slice", elem: STRING }, STRING],
+					returns: [STRING],
+				},
+				EqualFold: strFn2(STRING, BOOL),
+			},
+		});
+
+		// strconv package
+		this.globals.define("strconv", {
+			kind: "namespace",
+			name: "strconv",
+			members: {
+				Itoa: { kind: "func", params: [INT], returns: [STRING] },
+				Atoi: {
+					kind: "func",
+					params: [STRING],
+					returns: [INT, ERROR],
+				},
+				FormatFloat: {
+					kind: "func",
+					params: [FLOAT64, INT, INT, INT],
+					returns: [STRING],
+				},
+				FormatBool: { kind: "func", params: [BOOL], returns: [STRING] },
+				FormatInt: { kind: "func", params: [INT, INT], returns: [STRING] },
+				ParseFloat: {
+					kind: "func",
+					params: [STRING, INT],
+					returns: [FLOAT64, ERROR],
+				},
+				ParseInt: {
+					kind: "func",
+					params: [STRING, INT, INT],
+					returns: [INT, ERROR],
+				},
+				ParseBool: {
+					kind: "func",
+					params: [STRING],
+					returns: [BOOL, ERROR],
+				},
+			},
+		});
+
+		// sort package
+		this.globals.define("sort", {
+			kind: "namespace",
+			name: "sort",
+			members: {
+				Ints: {
+					kind: "func",
+					params: [{ kind: "slice", elem: INT }],
+					returns: [VOID],
+				},
+				Float64s: {
+					kind: "func",
+					params: [{ kind: "slice", elem: FLOAT64 }],
+					returns: [VOID],
+				},
+				Strings: {
+					kind: "func",
+					params: [{ kind: "slice", elem: STRING }],
+					returns: [VOID],
+				},
+				Slice: {
+					kind: "func",
+					params: [ANY, ANY],
+					returns: [VOID],
+				},
+				SliceStable: {
+					kind: "func",
+					params: [ANY, ANY],
+					returns: [VOID],
+				},
+				SliceIsSorted: {
+					kind: "func",
+					params: [ANY, ANY],
+					returns: [BOOL],
+				},
+			},
+		});
+
+		// math package
+		this.globals.define("math", {
+			kind: "namespace",
+			name: "math",
+			members: {
+				Abs: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+				Floor: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+				Ceil: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+				Round: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+				Sqrt: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+				Cbrt: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+				Pow: {
+					kind: "func",
+					params: [FLOAT64, FLOAT64],
+					returns: [FLOAT64],
+				},
+				Log: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+				Log2: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+				Log10: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+				Sin: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+				Cos: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+				Tan: { kind: "func", params: [FLOAT64], returns: [FLOAT64] },
+				Min: {
+					kind: "func",
+					params: [FLOAT64, FLOAT64],
+					returns: [FLOAT64],
+				},
+				Max: {
+					kind: "func",
+					params: [FLOAT64, FLOAT64],
+					returns: [FLOAT64],
+				},
+				Mod: {
+					kind: "func",
+					params: [FLOAT64, FLOAT64],
+					returns: [FLOAT64],
+				},
+				Inf: { kind: "func", params: [INT], returns: [FLOAT64] },
+				IsNaN: { kind: "func", params: [FLOAT64], returns: [BOOL] },
+				IsInf: {
+					kind: "func",
+					params: [FLOAT64, INT],
+					returns: [BOOL],
+				},
+				NaN: { kind: "func", params: [], returns: [FLOAT64] },
+				// Constants (typed as func with no params for namespace member access)
+				Pi: FLOAT64,
+				E: FLOAT64,
+				MaxFloat64: FLOAT64,
+				SmallestNonzeroFloat64: FLOAT64,
+				MaxInt: INT,
+				MinInt: INT,
+			},
+		});
+
+		// errors package
+		this.globals.define("errors", {
+			kind: "namespace",
+			name: "errors",
+			members: {
+				New: { kind: "func", params: [STRING], returns: [ERROR] },
+			},
+		});
+
+		// time package (partial — JS-friendly subset)
+		this.globals.define("time", {
+			kind: "namespace",
+			name: "time",
+			members: {
+				Now: { kind: "func", params: [], returns: [ANY] },
+				Since: { kind: "func", params: [ANY], returns: [ANY] },
+				Sleep: { kind: "func", params: [ANY], returns: [VOID], async: true },
+				Millisecond: INT,
+				Second: INT,
+				Minute: INT,
+				Hour: INT,
+			},
+		});
+
+		// unicode package
+		const runeToStr = { kind: "func", params: [INT], returns: [BOOL] };
+		const runeTrans = { kind: "func", params: [INT], returns: [INT] };
+		this.globals.define("unicode", {
+			kind: "namespace",
+			name: "unicode",
+			members: {
+				IsLetter: runeToStr,
+				IsDigit: runeToStr,
+				IsSpace: runeToStr,
+				IsUpper: runeToStr,
+				IsLower: runeToStr,
+				IsPunct: runeToStr,
+				IsControl: runeToStr,
+				IsPrint: runeToStr,
+				IsGraphic: runeToStr,
+				ToUpper: runeTrans,
+				ToLower: runeTrans,
+			},
+		});
+
+		// os package (JS-friendly subset)
+		this.globals.define("os", {
+			kind: "namespace",
+			name: "os",
+			members: {
+				Exit: { kind: "func", params: [INT], returns: [VOID] },
+				Args: { kind: "slice", elem: STRING },
+				Getenv: { kind: "func", params: [STRING], returns: [STRING] },
+				Stdout: ANY,
+				Stderr: ANY,
+				Stdin: ANY,
+			},
+		});
+
 		this.globals.define("append", { kind: "builtin", name: "append" });
 		this.globals.define("len", { kind: "builtin", name: "len" });
 		this.globals.define("cap", { kind: "builtin", name: "cap" });
@@ -295,10 +414,37 @@ export class TypeChecker {
 	addPackageNamespace(pkgName, symbols, types) {
 		const members = {};
 		for (const [name, type] of symbols) members[name] = type;
-		this.globals.define(pkgName, { kind: "namespace", name: pkgName, members });
+		// _gofront: true marks this as a GoFront package — exported identifier rules apply
+		this.globals.define(pkgName, {
+			kind: "namespace",
+			name: pkgName,
+			members,
+			_gofront: true,
+		});
 		for (const [name, type] of types) this.types.set(name, type);
 	}
 
+	// Register an import for unused-import detection.
+	// `name` is the package name or alias used in code.
+	// `node` carries _line for error reporting.
+	// `filename` / `source` identify the file containing the import.
+	trackImport(name, node, filename, source) {
+		this._imports.push({ name, node, filename, source });
+	}
+
+	// Report any tracked imports whose package name was never referenced.
+	reportUnusedImports() {
+		for (const { name, node, filename, source } of this._imports) {
+			if (!this.globals._used.has(name)) {
+				const saved = [this._currentFile, this._currentSource];
+				this._currentFile = filename;
+				this._currentSource = source;
+				this.err(`'${name}' imported and not used`, node);
+				[this._currentFile, this._currentSource] = saved;
+			}
+		}
+	}
+
 	// Return a snapshot of all user-defined globals (excludes built-ins).
 	// Used by the compiler to expose a package's exports to importers.
 	getExportedSymbols() {
@@ -326,6 +472,12 @@ export class TypeChecker {
 		return ANY; // recovery type
 	}
 
+	_reportUnused(scope, node) {
+		for (const name of scope.unusedLocals()) {
+			this.err(`'${name}' declared and not used`, node);
+		}
+	}
+
 	check(program) {
 		this._currentFile = program._filename ?? null;
 		this._currentSource = program._source ?? null;
@@ -508,7 +660,7 @@ export class TypeChecker {
 		for (const p of decl.params) {
 			inner.define(p.name, this.resolveTypeNode(p.type, outer));
 		}
-		const returnType = decl.returnType
+		let returnType = decl.returnType
 			? this.resolveTypeNode(decl.returnType, outer)
 			: VOID;
 		const hasNamedReturns = this._injectNamedReturns(
@@ -516,9 +668,22 @@ export class TypeChecker {
 			inner,
 			outer,
 		);
-		if (hasNamedReturns && returnType) returnType._hasNamedReturns = true;
+		// Wrap the return type to avoid mutating the shared singleton
+		if (hasNamedReturns && returnType)
+			returnType = { ...returnType, _hasNamedReturns: true };
+		const savedDefer = this._deferCount;
+		this._deferCount = 0;
 		this.checkBlock(decl.body, inner, returnType);
+		this._reportUnused(inner, decl);
+		if (this._deferCount > 0) decl.body._hasDefer = true;
+		this._deferCount = savedDefer;
 		decl._returnType = returnType;
+		// Missing return check: non-void functions must terminate on all paths
+		if (!isVoid(returnType) && !returnType._hasNamedReturns) {
+			if (!this._isTerminating(decl.body)) {
+				this.err(`missing return at end of function '${decl.name}'`, decl);
+			}
+		}
 	}
 
 	checkMethodDecl(decl, outer) {
@@ -528,7 +693,7 @@ export class TypeChecker {
 		for (const p of decl.params) {
 			inner.define(p.name, this.resolveTypeNode(p.type, outer));
 		}
-		const returnType = decl.returnType
+		let returnType = decl.returnType
 			? this.resolveTypeNode(decl.returnType, outer)
 			: VOID;
 		const hasNamedReturns = this._injectNamedReturns(
@@ -536,9 +701,101 @@ export class TypeChecker {
 			inner,
 			outer,
 		);
-		if (hasNamedReturns && returnType) returnType._hasNamedReturns = true;
+		if (hasNamedReturns && returnType)
+			returnType = { ...returnType, _hasNamedReturns: true };
+		const savedDefer = this._deferCount;
+		this._deferCount = 0;
 		this.checkBlock(decl.body, inner, returnType);
+		this._reportUnused(inner, decl);
+		if (this._deferCount > 0) decl.body._hasDefer = true;
+		this._deferCount = savedDefer;
 		decl._returnType = returnType;
+		// Missing return check
+		if (!isVoid(returnType) && !returnType._hasNamedReturns) {
+			if (!this._isTerminating(decl.body)) {
+				this.err(`missing return at end of method '${decl.name}'`, decl);
+			}
+		}
+	}
+
+	// Go spec §Terminating statements — returns true if the statement always terminates.
+	_isTerminating(stmt) {
+		if (!stmt) return false;
+		switch (stmt.kind) {
+			case "ReturnStmt":
+				return true;
+			case "BranchStmt":
+				// panic() is in ExprStmt, not BranchStmt — but "goto" could be here
+				return false;
+			case "ExprStmt":
+				// panic(...) is a terminating call
+				if (
+					stmt.expr?.kind === "CallExpr" &&
+					stmt.expr?.func?.kind === "Ident" &&
+					stmt.expr?.func?.name === "panic"
+				)
+					return true;
+				return false;
+			case "Block":
+				return this._isTerminatingBlock(stmt);
+			case "IfStmt":
+				// Terminating if: has else, and both branches terminate
+				if (!stmt.elseBody) return false;
+				return (
+					this._isTerminatingBlock(stmt.body) &&
+					(stmt.elseBody.kind === "Block"
+						? this._isTerminatingBlock(stmt.elseBody)
+						: this._isTerminating(stmt.elseBody))
+				);
+			case "ForStmt":
+				// Infinite loop (no condition) with no break — terminating
+				if (!stmt.cond && !this._blockHasBreak(stmt.body)) return true;
+				return false;
+			case "SwitchStmt":
+				// Terminating switch: has default and every case terminates
+				return this._isTerminatingSwitch(stmt);
+			case "TypeSwitchStmt":
+				return this._isTerminatingTypeSwitch(stmt);
+			case "LabeledStmt":
+				return this._isTerminating(stmt.body);
+			default:
+				return false;
+		}
+	}
+
+	_isTerminatingBlock(block) {
+		if (!block?.stmts?.length) return false;
+		return this._isTerminating(block.stmts[block.stmts.length - 1]);
+	}
+
+	_blockHasBreak(block) {
+		if (!block?.stmts) return false;
+		for (const s of block.stmts) {
+			if (s.kind === "BranchStmt" && s.keyword === "break") return true;
+		}
+		return false;
+	}
+
+	_isTerminatingSwitch(stmt) {
+		let hasDefault = false;
+		for (const c of stmt.cases ?? []) {
+			if (!c.list) hasDefault = true;
+			if (!c.stmts?.length) return false;
+			const last = c.stmts[c.stmts.length - 1];
+			if (!this._isTerminating(last)) return false;
+		}
+		return hasDefault;
+	}
+
+	_isTerminatingTypeSwitch(stmt) {
+		let hasDefault = false;
+		for (const c of stmt.cases ?? []) {
+			if (!c.types) hasDefault = true;
+			if (!c.stmts?.length) return false;
+			const last = c.stmts[c.stmts.length - 1];
+			if (!this._isTerminating(last)) return false;
+		}
+		return hasDefault;
 	}
 
 	_injectNamedReturns(returnTypeNode, scope, outer) {
@@ -554,20 +811,21 @@ export class TypeChecker {
 			let type = spec.type ? this.resolveTypeNode(spec.type, scope) : null;
 			if (spec.value) {
 				const valTypes = spec.value.map((v) => this.checkExpr(v, scope));
-				if (!type) type = valTypes[0] ?? ANY;
+				if (!type) type = defaultType(valTypes[0]) ?? ANY;
 				for (let i = 0; i < spec.names.length; i++) {
 					const vt = valTypes[i] ?? ANY;
 					this.assertAssignable(type, vt, spec.value[i]);
 				}
 			}
 			if (!type) type = ANY;
-			for (const name of spec.names) scope.define(name, type);
+			for (const name of spec.names) scope.defineLocal(name, type);
 		}
 	}
 
 	checkConstDecl(decl, scope) {
 		for (const spec of decl.decls) {
 			const valTypes = spec.value.map((v) => this.checkExpr(v, scope));
+			// Explicit type annotation → typed constant; otherwise preserve untyped
 			const type = spec.type
 				? this.resolveTypeNode(spec.type, scope)
 				: (valTypes[0] ?? ANY);
@@ -577,541 +835,6 @@ export class TypeChecker {
 
 	// ── Statement checking ───────────────────────────────────────
 
-	checkBlock(block, scope, returnType) {
-		for (const stmt of block.stmts) {
-			this.checkStmt(stmt, scope, returnType);
-		}
-	}
-
-	checkStmt(stmt, scope, returnType) {
-		switch (stmt.kind) {
-			case "VarDecl":
-				this.checkVarDecl(stmt, scope);
-				break;
-			case "ConstDecl":
-				this.checkConstDecl(stmt, scope);
-				break;
-			case "TypeDecl":
-				this.collectType(stmt);
-				break;
-
-			case "DefineStmt": {
-				// comma-ok type assertion: n, ok := x.(T)
-				if (
-					stmt.lhs.length === 2 &&
-					stmt.rhs.length === 1 &&
-					stmt.rhs[0].kind === "TypeAssertExpr"
-				) {
-					stmt.rhs[0]._commaOk = true;
-				}
-				const rhs = stmt.rhs.map((e) => this.checkExpr(e, scope));
-				// Flatten tuple returns
-				const rhsFlat =
-					rhs.length === 1 && rhs[0].kind === "tuple" ? rhs[0].types : rhs;
-				// comma-ok type assertion returns [assertedType, bool]
-				if (stmt.rhs[0]?._commaOk) {
-					const lhsNames = stmt.lhs.map((e) => e.name ?? e);
-					if (lhsNames[0] !== "_") scope.define(lhsNames[0], rhs[0]);
-					if (lhsNames[1] !== "_") scope.define(lhsNames[1], BOOL);
-					stmt._rhsTypes = [rhs[0], BOOL];
-					break;
-				}
-				for (let i = 0; i < stmt.lhs.length; i++) {
-					const name = stmt.lhs[i].name ?? stmt.lhs[i];
-					if (name === "_") continue;
-					// Short variable re-declaration: mark vars that already exist
-					// in the current (not parent) scope as redeclared.
-					if (scope.symbols.has(name)) {
-						stmt.lhs[i]._redecl = true;
-					}
-					scope.define(name, rhsFlat[i] ?? ANY);
-				}
-				// Go requires at least one new variable in :=
-				const allRedecl = stmt.lhs.every(
-					(e) => e._redecl || (e.name ?? e) === "_",
-				);
-				if (allRedecl && stmt.lhs.length > 0) {
-					this.err("no new variables on left side of :=", stmt.lhs[0]);
-				}
-				stmt._rhsTypes = rhsFlat;
-				break;
-			}
-
-			case "AssignStmt": {
-				// Check for const reassignment before evaluating RHS
-				for (const lhs of stmt.lhs) {
-					if (lhs.kind === "Ident") {
-						const ownerScope = scope.lookupScope(lhs.name);
-						if (ownerScope?.isConst(lhs.name))
-							this.err(`cannot assign to const '${lhs.name}'`, lhs);
-					}
-				}
-				const rhs = stmt.rhs.map((e) => this.checkExpr(e, scope));
-				const rhsFlat =
-					rhs.length === 1 && rhs[0]?.kind === "tuple" ? rhs[0].types : rhs;
-				const lhsTypes = stmt.lhs.map((e) => this.checkExpr(e, scope));
-				for (let i = 0; i < lhsTypes.length; i++) {
-					const r = rhsFlat[i] ?? ANY;
-					if (!isAny(lhsTypes[i]) && !isAny(r)) {
-						this.assertAssignable(lhsTypes[i], r, stmt.lhs[i]);
-					}
-				}
-				break;
-			}
-
-			case "IncDecStmt":
-				this.checkExpr(stmt.expr, scope);
-				break;
-
-			case "ExprStmt":
-				this.checkExpr(stmt.expr, scope);
-				break;
-
-			case "ReturnStmt": {
-				const types = stmt.values.map((v) => this.checkExpr(v, scope));
-				stmt._types = types;
-				if (
-					!isVoid(returnType) &&
-					types.length === 0 &&
-					!returnType?._hasNamedReturns
-				) {
-					this.err("Missing return value", stmt);
-				}
-				// Check each returned value is assignable to its declared type
-				if (!isVoid(returnType) && types.length > 0) {
-					const expected =
-						returnType.kind === "tuple" ? returnType.types : [returnType];
-					for (let i = 0; i < expected.length; i++) {
-						if (types[i])
-							this.assertAssignable(
-								expected[i],
-								types[i],
-								stmt.values[i] ?? stmt,
-							);
-					}
-				}
-				break;
-			}
-
-			case "IfStmt": {
-				const inner = new Scope(scope);
-				if (stmt.init) this.checkStmt(stmt.init, inner, returnType);
-				const ct = this.checkExpr(stmt.cond, inner);
-				if (!isBool(ct) && !isAny(ct))
-					this.err("If condition must be bool", stmt);
-				this.checkBlock(stmt.body, new Scope(inner), returnType);
-				if (stmt.elseBody) {
-					if (stmt.elseBody.kind === "Block")
-						this.checkBlock(stmt.elseBody, new Scope(inner), returnType);
-					else this.checkStmt(stmt.elseBody, inner, returnType);
-				}
-				break;
-			}
-
-			case "ForStmt": {
-				const inner = new Scope(scope);
-				if (stmt.init) this.checkStmt(stmt.init, inner, returnType);
-				if (stmt.cond) {
-					// for range N { } — RangeExpr as condition is valid (Go 1.22 int range)
-					if (stmt.cond.kind !== "RangeExpr") {
-						const ct = this.checkExpr(stmt.cond, inner);
-						if (!isBool(ct) && !isAny(ct))
-							this.err("For condition must be bool", stmt);
-					} else {
-						this.checkExpr(stmt.cond.expr, inner);
-					}
-				}
-				if (stmt.post) this.checkStmt(stmt.post, inner, returnType);
-				this._loopDepth++;
-				this.checkBlock(stmt.body, new Scope(inner), returnType);
-				this._loopDepth--;
-				break;
-			}
-
-			case "SwitchStmt": {
-				const inner = new Scope(scope);
-				if (stmt.init) this.checkStmt(stmt.init, inner, returnType);
-				if (stmt.tag) this.checkExpr(stmt.tag, inner);
-				this._switchDepth++;
-				for (const c of stmt.cases) {
-					const caseScope = new Scope(inner);
-					if (c.list) for (const e of c.list) this.checkExpr(e, caseScope);
-					for (const s of c.stmts) this.checkStmt(s, caseScope, returnType);
-				}
-				this._switchDepth--;
-				break;
-			}
-
-			case "TypeSwitchStmt": {
-				const inner = new Scope(scope);
-				this.checkExpr(stmt.expr, inner);
-				this._switchDepth++;
-				for (const c of stmt.cases) {
-					const caseScope = new Scope(inner);
-					if (stmt.assign) {
-						// Bind the variable to the single case type, or any for multi/default
-						const bindType =
-							c.types?.length === 1
-								? this.resolveTypeNode(c.types[0], inner)
-								: ANY;
-						caseScope.define(stmt.assign, bindType);
-					}
-					for (const s of c.stmts) this.checkStmt(s, caseScope, returnType);
-				}
-				this._switchDepth--;
-				break;
-			}
-
-			case "DeferStmt": {
-				if (stmt.call.kind !== "CallExpr")
-					this.err("defer requires a function call", stmt.call);
-				this.checkExpr(stmt.call, scope);
-				break;
-			}
-
-			case "LabeledStmt":
-				this.checkStmt(stmt.body, scope, returnType);
-				break;
-
-			case "BranchStmt": {
-				const kw = stmt.keyword;
-				if (stmt.label) break; // labeled branch — target checked by JS
-				if (kw === "continue" && this._loopDepth === 0)
-					this.err("continue statement outside for loop", stmt);
-				else if (
-					kw === "break" &&
-					this._loopDepth === 0 &&
-					this._switchDepth === 0
-				)
-					this.err("break statement outside for loop or switch", stmt);
-				else if (kw === "fallthrough" && this._switchDepth === 0)
-					this.err("fallthrough statement outside switch", stmt);
-				break;
-			}
-			case "Block":
-				this.checkBlock(stmt, new Scope(scope), returnType);
-				break;
-			default:
-				break;
-		}
-	}
-
-	// ── Expression checking (returns type) ───────────────────────
-
-	checkExpr(expr, scope) {
-		const t = this._checkExpr(expr, scope);
-		expr._type = t;
-		return t;
-	}
-
-	_checkExpr(expr, scope) {
-		switch (expr.kind) {
-			case "BasicLit": {
-				switch (expr.litKind) {
-					case "INT":
-						return INT;
-					case "FLOAT":
-						return FLOAT64;
-					case "STRING":
-						return STRING;
-					case "BOOL":
-						return BOOL;
-					case "NIL":
-						return NIL;
-				}
-				break;
-			}
-
-			case "Ident": {
-				const t = scope.lookup(expr.name);
-				if (!t) return this.err(`Undefined: '${expr.name}'`, expr);
-				return t;
-			}
-
-			case "UnaryExpr": {
-				const ot = this.checkExpr(expr.operand, scope);
-				if (expr.op === "!") {
-					if (!isBool(ot) && !isAny(ot)) this.err("! requires bool", expr);
-					return BOOL;
-				}
-				if (expr.op === "-" || expr.op === "+") {
-					if (!isNumeric(ot) && !isAny(ot))
-						this.err(`${expr.op} requires numeric`, expr);
-					return ot;
-				}
-				return ot;
-			}
-
-			case "BinaryExpr": {
-				const lt = this.checkExpr(expr.left, scope);
-				const rt = this.checkExpr(expr.right, scope);
-				if (isAny(lt) || isAny(rt)) return this.binaryResultType(expr.op, ANY);
-				return this.binaryResultType(expr.op, lt, rt, expr);
-			}
-
-			case "CallExpr": {
-				return this.checkCall(expr, scope);
-			}
-
-			case "SelectorExpr": {
-				const baseType = this.checkExpr(expr.expr, scope);
-				return this.fieldType(baseType, expr.field, expr);
-			}
-
-			case "IndexExpr": {
-				const bt = this.checkExpr(expr.expr, scope);
-				this.checkExpr(expr.index, scope);
-				if (isAny(bt)) return ANY;
-				if (bt.kind === "slice" || bt.kind === "array") return bt.elem;
-				if (bt.kind === "map") {
-					expr._mapValueType = bt.value; // for codegen zero-value fallback
-					return bt.value;
-				}
-				if (isString(bt)) return INT; // byte
-				return this.err(`Cannot index type ${typeStr(bt)}`, expr);
-			}
-
-			case "SliceExpr": {
-				const bt = this.checkExpr(expr.expr, scope);
-				if (expr.low) this.checkExpr(expr.low, scope);
-				if (expr.high) this.checkExpr(expr.high, scope);
-				if (isAny(bt)) return ANY;
-				if (bt.kind === "slice" || bt.kind === "array")
-					return { kind: "slice", elem: bt.elem };
-				if (isString(bt)) return STRING;
-				return this.err(`Cannot slice type ${typeStr(bt)}`, expr);
-			}
-
-			case "CompositeLit": {
-				return this.checkCompositeLit(expr, scope);
-			}
-
-			case "FuncLit": {
-				const inner = new Scope(scope);
-				for (const p of expr.params)
-					inner.define(
-						p.name,
-						p.type ? this.resolveTypeNode(p.type, scope) : ANY,
-					);
-				const ret = expr.returnType
-					? this.resolveTypeNode(expr.returnType, scope)
-					: VOID;
-				this.checkBlock(expr.body, inner, ret);
-				const paramTypes = expr.params.map((p) =>
-					p.type ? this.resolveTypeNode(p.type, scope) : ANY,
-				);
-				return {
-					kind: "func",
-					params: paramTypes,
-					returns: [ret],
-					async: expr.async,
-				};
-			}
-
-			case "AwaitExpr": {
-				// await unwraps whatever the expression produces — no Promise type modelling
-				return this.checkExpr(expr.expr, scope);
-			}
-
-			case "TypeConversion": {
-				this.checkExpr(expr.expr, scope);
-				return this.resolveTypeNode(expr.targetType, scope);
-			}
-
-			case "TypeAssertExpr": {
-				this.checkExpr(expr.expr, scope);
-				return this.resolveTypeNode(expr.type, scope);
-			}
-
-			case "RangeExpr": {
-				// Type-check the iterated expression so its _type is annotated
-				return this.checkExpr(expr.expr, scope);
-			}
-
-			default:
-				return ANY;
-		}
-		return ANY;
-	}
-
-	checkCall(expr, scope) {
-		const fnType = this.checkExpr(expr.func, scope);
-
-		// Handle built-ins before evaluating args; some (e.g. new) take type names as
-		// arguments, which would otherwise produce false "Undefined" errors.
-		if (fnType.kind === "builtin") {
-			const argTypes = expr.args.map((a, i) => {
-				// new(T) — first arg is a type name, not a value expression
-				if (fnType.name === "new" && i === 0) return ANY;
-				return this.checkExpr(a, scope);
-			});
-			return this.checkBuiltin(fnType.name, expr, argTypes, scope);
-		}
-
-		const argTypes = expr.args.map((a) => this.checkExpr(a, scope));
-
-		if (isAny(fnType)) return ANY;
-
-		if (fnType.kind !== "func") {
-			return this.err(`Cannot call non-function type ${typeStr(fnType)}`, expr);
-		}
-
-		// Check arg count (allow variadic slack)
-		const minArgs = fnType.params.filter(
-			(_, i) => !fnType.variadic || i < fnType.params.length - 1,
-		).length;
-		if (argTypes.length < minArgs) {
-			this.err(
-				`Too few arguments: expected ${fnType.params.length}, got ${argTypes.length}`,
-				expr,
-			);
-		}
-		if (!fnType.variadic && argTypes.length > fnType.params.length) {
-			this.err(
-				`Too many arguments: expected ${fnType.params.length}, got ${argTypes.length}`,
-				expr,
-			);
-		}
-
-		// Check each argument is assignable to its parameter type
-		for (let i = 0; i < fnType.params.length && i < argTypes.length; i++) {
-			const paramIdx =
-				fnType.variadic && i >= fnType.params.length - 1
-					? fnType.params.length - 1
-					: i;
-			// Spread arg (f(slice...)) passes a whole slice into a variadic — skip per-element check
-			if (expr.args[i]?._spread) continue;
-			this.assertAssignable(fnType.params[paramIdx], argTypes[i], expr.args[i]);
-		}
-
-		const ret = fnType.returns;
-		if (!ret || ret.length === 0) return VOID;
-		if (ret.length === 1) return ret[0];
-		return { kind: "tuple", types: ret };
-	}
-
-	checkBuiltin(name, expr, argTypes, scope) {
-		switch (name) {
-			case "len":
-			case "cap":
-				return INT;
-			case "append":
-				return argTypes[0] ?? ANY;
-			case "copy":
-				return INT;
-			case "delete":
-				return VOID;
-			case "make": {
-				if (expr.args.length < 1) return ANY;
-				const typeArg = expr.args[0];
-				const typeNode = typeArg.kind === "TypeExpr" ? typeArg.type : typeArg;
-				return this.resolveTypeNode(typeNode, scope) ?? ANY;
-			}
-			case "new": {
-				if (expr.args.length < 1) return ANY;
-				const inner = this.resolveTypeNode(expr.args[0], scope);
-				return { kind: "pointer", base: inner };
-			}
-			case "print":
-			case "println":
-			case "panic":
-				return VOID;
-			case "recover":
-				return ANY;
-			case "error":
-				return ERROR;
-			case "min":
-			case "max":
-				return argTypes[0] ?? ANY;
-			case "clear":
-				return VOID;
-			default:
-				return ANY;
-		}
-	}
-
-	checkCompositeLit(expr, scope, hintType = null) {
-		// null typeExpr = implicit lit inside a slice/map: {X:1} in []Point{{X:1}}
-		const t =
-			expr.typeExpr === null
-				? (hintType ?? ANY)
-				: this.resolveTypeNode(expr.typeExpr, scope);
-		const base = t.kind === "named" ? t.underlying : t;
-
-		if (base?.kind === "struct") {
-			for (const elem of expr.elems) {
-				if (elem.kind === "KeyValueExpr") {
-					const keyName = elem.key.name;
-					const fieldType = base.fields?.get(keyName);
-					if (fieldType) {
-						const vt = this.checkExpr(elem.value, scope);
-						this.assertAssignable(fieldType, vt, elem.value);
-					} else {
-						// Check if it's an embedded type name (e.g. Dog{Animal: Animal{...}})
-						const embed = base._embeds?.find(
-							(e) => (e.kind === "named" ? e.name : null) === keyName,
-						);
-						if (embed) {
-							const vt = this.checkExpr(elem.value, scope);
-							this.assertAssignable(embed, vt, elem.value);
-							elem._isEmbedInit = true;
-						} else {
-							this.err(`Unknown field '${keyName}'`, elem.key);
-						}
-					}
-				} else {
-					this.checkExpr(elem, scope);
-				}
-			}
-			return t;
-		}
-
-		if (base?.kind === "slice" || base?.kind === "array") {
-			for (const elem of expr.elems) {
-				if (elem.kind === "CompositeLit" && elem.typeExpr === null) {
-					const et = this.checkCompositeLit(elem, scope, base.elem);
-					elem._type = et;
-				} else if (elem.kind !== "KeyValueExpr") {
-					const et = this.checkExpr(elem, scope);
-					this.assertAssignable(base.elem, et, elem);
-				}
-			}
-			return t;
-		}
-
-		if (base?.kind === "map") {
-			for (const elem of expr.elems) {
-				if (elem.kind === "KeyValueExpr") {
-					const kt = this.checkExpr(elem.key, scope);
-					// value may be an implicit composite lit
-					let vt;
-					if (
-						elem.value.kind === "CompositeLit" &&
-						elem.value.typeExpr === null
-					) {
-						vt = this.checkCompositeLit(elem.value, scope, base.value);
-						elem.value._type = vt;
-					} else {
-						vt = this.checkExpr(elem.value, scope);
-					}
-					this.assertAssignable(base.key, kt, elem.key);
-					this.assertAssignable(base.value, vt, elem.value);
-				}
-			}
-			return t;
-		}
-
-		// Unknown type context — still check elements
-		for (const elem of expr.elems) {
-			if (elem.kind === "KeyValueExpr") {
-				this.checkExpr(elem.value, scope);
-			} else {
-				this.checkExpr(elem, scope);
-			}
-		}
-		return t ?? ANY;
-	}
-
 	// ── Type resolution ──────────────────────────────────────────
 
 	resolveTypeNode(node, scope) {
@@ -1192,7 +915,11 @@ export class TypeChecker {
 					const returns = m.returnType
 						? [this.resolveTypeNode(m.returnType, scope)]
 						: [VOID];
-					methods.set(m.name, { kind: "func", params, returns });
+					const isVariadic =
+						m.params.length > 0 && m.params[m.params.length - 1].variadic;
+					const mType = { kind: "func", params, returns };
+					if (isVariadic) mType.variadic = true;
+					methods.set(m.name, mType);
 				}
 				// Flatten embedded interface methods
 				if (node.embeds) {
@@ -1262,6 +989,18 @@ export class TypeChecker {
 			return this.err(`No field '${field}' on ${typeStr(baseType)}`, node);
 		}
 		if (base?.kind === "namespace") {
+			// Enforce exported identifier rule for GoFront packages only
+			if (
+				base._gofront &&
+				field.length > 0 &&
+				field[0] >= "a" &&
+				field[0] <= "z"
+			) {
+				return this.err(
+					`cannot refer to unexported name ${base.name}.${field}`,
+					node,
+				);
+			}
 			if (field in base.members) return base.members[field];
 			return this.err(`No member '${field}' in namespace ${base.name}`, node);
 		}
@@ -1285,14 +1024,49 @@ export class TypeChecker {
 	}
 
 	binaryResultType(op, lt, rt, node) {
-		if (CMP_OPS.has(op)) return BOOL;
+		if (CMP_OPS.has(op)) {
+			// Reject slice/map/func comparisons unless one side is nil (Go spec)
+			if (op === "==" || op === "!=") {
+				const lNil = isNil(lt);
+				const rNil = isNil(rt);
+				if (!lNil && !rNil) {
+					for (const t of [lt, rt]) {
+						const base = t?.kind === "named" ? t.underlying : t;
+						if (
+							base?.kind === "slice" ||
+							base?.kind === "map" ||
+							base?.kind === "func"
+						) {
+							this.err(`operator ${op} not defined on ${typeStr(t)}`, node);
+						}
+					}
+				}
+			}
+			return BOOL;
+		}
 		if (LOG_OPS.has(op)) return BOOL;
 		if (isAny(lt) || isAny(rt)) return ANY;
 		if (isNumeric(lt) && isNumeric(rt)) {
-			// float64 is contagious
-			return lt.name === "float64" || rt.name === "float64" ? FLOAT64 : INT;
+			const lFloat = (lt.kind === "untyped" ? lt.base : lt.name) === "float64";
+			const rFloat = (rt.kind === "untyped" ? rt.base : rt.name) === "float64";
+			const isFloat = lFloat || rFloat;
+			// Both untyped → result is untyped
+			if (lt.kind === "untyped" && rt.kind === "untyped")
+				return isFloat ? UNTYPED_FLOAT : UNTYPED_INT;
+			// One typed, one untyped → typed wins
+			if (lt.kind === "untyped")
+				return isFloat && rt.name !== "float64" ? FLOAT64 : rt;
+			if (rt.kind === "untyped")
+				return isFloat && lt.name !== "float64" ? FLOAT64 : lt;
+			// Both typed
+			return isFloat ? FLOAT64 : INT;
+		}
+		if (isString(lt) && isString(rt) && op === "+") {
+			if (lt.kind === "untyped" && rt.kind === "untyped") return lt;
+			if (lt.kind === "untyped") return rt;
+			if (rt.kind === "untyped") return lt;
+			return STRING;
 		}
-		if (isString(lt) && isString(rt) && op === "+") return STRING;
 		if (node)
 			this.err(`Invalid operation: ${typeStr(lt)} ${op} ${typeStr(rt)}`, node);
 		return ANY;
@@ -1305,6 +1079,29 @@ export class TypeChecker {
 		if (isAny(target) || isAny(source)) return;
 		if (isNil(source)) return; // nil is assignable to anything nullable
 
+		// Untyped constants coerce to any compatible typed target
+		if (isUntyped(source)) {
+			if (isUntyped(target)) return; // untyped → untyped always OK
+			if (target.kind === "basic") {
+				// untyped int → int or float64
+				if (
+					source.base === "int" &&
+					(target.name === "int" || target.name === "float64")
+				)
+					return;
+				// untyped float → float64 (and int for compatibility)
+				if (
+					source.base === "float64" &&
+					(target.name === "float64" || target.name === "int")
+				)
+					return;
+				// untyped string → string
+				if (source.base === "string" && target.name === "string") return;
+				// untyped bool → bool
+				if (source.base === "bool" && target.name === "bool") return;
+			}
+		}
+
 		// Go untyped constant promotion: int literals are assignable to float64
 		if (target.kind === "basic" && source.kind === "basic") {
 			if (target.name === "float64" && source.name === "int") return;
@@ -1317,6 +1114,8 @@ export class TypeChecker {
 			tBase = this.resolveType(tBase);
 			sBase = this.resolveType(sBase);
 			if (tBase?.kind === "interface") {
+				// Empty interface (interface{}) accepts any type
+				if (tBase.methods.size === 0) return;
 				if (!this.implements(source, tBase, node)) {
 					this.err(
 						`${typeStr(source)} does not implement ${typeStr(target)}`,
@@ -1336,11 +1135,31 @@ export class TypeChecker {
 		for (const [name, required] of iface.methods) {
 			const actual = base.methods?.get(name);
 			if (!actual) return false;
-			// Check return type matches (params are not strictly checked — Go allows covariance)
-			const reqRet = required.returns?.[0];
-			const actRet = actual.returns?.[0];
-			if (reqRet && actRet && typeStr(reqRet) !== typeStr(actRet)) return false;
+
+			// Check parameter count matches
+			const reqParams = required.params ?? [];
+			const actParams = actual.params ?? [];
+			if (reqParams.length !== actParams.length) return false;
+
+			// Check each parameter type matches
+			for (let i = 0; i < reqParams.length; i++) {
+				if (typeStr(reqParams[i]) !== typeStr(actParams[i])) return false;
+			}
+
+			// Check variadic flag matches
+			if (!!required.variadic !== !!actual.variadic) return false;
+
+			// Check return types match (count and each type)
+			const reqRets = required.returns ?? [];
+			const actRets = actual.returns ?? [];
+			if (reqRets.length !== actRets.length) return false;
+			for (let i = 0; i < reqRets.length; i++) {
+				if (typeStr(reqRets[i]) !== typeStr(actRets[i])) return false;
+			}
 		}
 		return true;
 	}
 }
+
+Object.assign(TypeChecker.prototype, statementCheckMethods);
+Object.assign(TypeChecker.prototype, expressionCheckMethods);