gofront 0.0.3 → 0.0.5

package/src/typechecker.js

@@ -13,21 +13,26 @@ import {
 	BASIC_TYPES,
 	BOOL,
 	CMP_OPS,
+	COMPLEX128,
 	defaultType,
 	ERROR,
 	FLOAT64,
 	INT,
 	isAny,
-	isError,
+	isComplex,
+	isComplexOrNumeric,
 	isNil,
 	isNumeric,
+	isPointer,
 	isString,
 	isUntyped,
+	isVoid,
 	LOG_OPS,
 	Scope,
 	STRING,
 	TypeCheckError,
 	typeStr,
+	UNTYPED_COMPLEX,
 	UNTYPED_FLOAT,
 	UNTYPED_INT,
 	VOID,
@@ -49,6 +54,8 @@ export class TypeChecker {
 		this._deferCount = 0; // tracks defer usage in current function body
 		this._imports = []; // tracked imports for unused-import detection
 		this._setupGlobals();
+		// Register error as a named type (interface)
+		this.types.set("error", ERROR);
 	}
 
 	_setupGlobals() {
@@ -193,6 +200,47 @@ export class TypeChecker {
 			},
 		});
 
+		// bytes package — operates on []byte (JS arrays of numbers)
+		const BYTE_SLICE = { kind: "slice", elem: INT };
+		const byFn1 = (ret) => ({
+			kind: "func",
+			params: [BYTE_SLICE],
+			returns: [ret],
+		});
+		const byFn2 = (p2, ret) => ({
+			kind: "func",
+			params: [BYTE_SLICE, p2],
+			returns: [ret],
+		});
+		this.globals.define("bytes", {
+			kind: "namespace",
+			name: "bytes",
+			members: {
+				Contains: byFn2(BYTE_SLICE, BOOL),
+				HasPrefix: byFn2(BYTE_SLICE, BOOL),
+				HasSuffix: byFn2(BYTE_SLICE, BOOL),
+				Index: byFn2(BYTE_SLICE, INT),
+				Count: byFn2(BYTE_SLICE, INT),
+				Repeat: byFn2(INT, BYTE_SLICE),
+				Replace: {
+					kind: "func",
+					params: [BYTE_SLICE, BYTE_SLICE, BYTE_SLICE, INT],
+					returns: [BYTE_SLICE],
+				},
+				ToUpper: byFn1(BYTE_SLICE),
+				ToLower: byFn1(BYTE_SLICE),
+				TrimSpace: byFn1(BYTE_SLICE),
+				Trim: byFn2(STRING, BYTE_SLICE),
+				Equal: byFn2(BYTE_SLICE, BOOL),
+				Split: byFn2(BYTE_SLICE, { kind: "slice", elem: BYTE_SLICE }),
+				Join: {
+					kind: "func",
+					params: [{ kind: "slice", elem: BYTE_SLICE }, BYTE_SLICE],
+					returns: [BYTE_SLICE],
+				},
+			},
+		});
+
 		// strconv package
 		this.globals.define("strconv", {
 			kind: "namespace",
@@ -328,6 +376,8 @@ export class TypeChecker {
 			name: "errors",
 			members: {
 				New: { kind: "func", params: [STRING], returns: [ERROR] },
+				Is: { kind: "func", params: [ERROR, ERROR], returns: [BOOL] },
+				Unwrap: { kind: "func", params: [ERROR], returns: [ERROR] },
 			},
 		});
 
@@ -346,6 +396,41 @@ export class TypeChecker {
 			},
 		});
 
+		// 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" });
@@ -361,6 +446,9 @@ export class TypeChecker {
 		this.globals.define("min", { kind: "builtin", name: "min" });
 		this.globals.define("max", { kind: "builtin", name: "max" });
 		this.globals.define("clear", { kind: "builtin", name: "clear" });
+		this.globals.define("complex", { kind: "builtin", name: "complex" });
+		this.globals.define("real", { kind: "builtin", name: "real" });
+		this.globals.define("imag", { kind: "builtin", name: "imag" });
 	}
 
 	addDefinitions(types, values) {
@@ -378,7 +466,13 @@ 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);
 	}
 
@@ -542,6 +636,36 @@ export class TypeChecker {
 	// ── Type collection ──────────────────────────────────────────
 
 	collectType(decl) {
+		if (decl.typeParams) {
+			// Generic type — resolve underlying with type params as ANY for struct fields
+			const typeScope = new Scope(this.globals);
+			const typeParamTypes = decl.typeParams.map((tp) => {
+				const t = {
+					kind: "typeParam",
+					name: tp.name,
+					constraint: tp.constraint,
+				};
+				typeScope.define(tp.name, t);
+				return t;
+			});
+			const underlying = this.resolveTypeNode(decl.type, typeScope);
+			const named = {
+				kind: "named",
+				name: decl.name,
+				underlying,
+				_generic: {
+					typeParams: typeParamTypes,
+					declNode: decl,
+				},
+			};
+			if (underlying.kind === "struct") {
+				underlying.name = decl.name;
+				underlying.methods = new Map();
+			}
+			this.types.set(decl.name, named);
+			this.globals.define(decl.name, named);
+			return;
+		}
 		const underlying = this.resolveTypeNode(decl.type, this.globals);
 		if (decl.isAlias) {
 			// type A = B — transparent alias, A and B are identical types
@@ -562,11 +686,40 @@ export class TypeChecker {
 	}
 
 	collectFunc(decl) {
+		// For generic functions, create type param scope for resolving param/return types
+		let resolveScope = this.globals;
+		let typeParamTypes = null;
+		if (decl.typeParams) {
+			resolveScope = new Scope(this.globals);
+			typeParamTypes = decl.typeParams.map((tp) => {
+				const t = {
+					kind: "typeParam",
+					name: tp.name,
+					constraint: tp.constraint,
+				};
+				resolveScope.define(tp.name, t);
+				return t;
+			});
+		}
+		// For methods on generic types, inject the receiver's type params
+		if (decl.kind === "MethodDecl") {
+			const recvTypeName =
+				decl.recvType.kind === "GenericTypeName"
+					? decl.recvType.name
+					: decl.recvType.name;
+			const recvNamedType = this.types.get(recvTypeName);
+			if (recvNamedType?._generic) {
+				resolveScope = new Scope(this.globals);
+				for (const tp of recvNamedType._generic.typeParams) {
+					resolveScope.define(tp.name, tp);
+				}
+			}
+		}
 		const paramTypes = decl.params.map((p) =>
-			this.resolveTypeNode(p.type, this.globals),
+			this.resolveTypeNode(p.type, resolveScope),
 		);
 		const returnType = decl.returnType
-			? this.resolveTypeNode(decl.returnType, this.globals)
+			? this.resolveTypeNode(decl.returnType, resolveScope)
 			: VOID;
 		const isVariadic =
 			decl.params.length > 0 && decl.params[decl.params.length - 1].variadic;
@@ -581,13 +734,38 @@ export class TypeChecker {
 			if (this.globals.symbols.has(decl.name) && decl.name !== "init") {
 				this.err(`${decl.name} redeclared in this block`, decl);
 			}
-			this.globals.define(decl.name, funcType);
+			if (typeParamTypes) {
+				this.globals.define(decl.name, {
+					kind: "generic",
+					name: decl.name,
+					typeParams: typeParamTypes,
+					underlying: funcType,
+				});
+			} else {
+				this.globals.define(decl.name, funcType);
+			}
 		} else {
 			// Method: attach to struct type
-			const recvType = this.resolveTypeNodeName(decl.recvType, this.globals);
-			const base = recvType?.underlying ?? recvType;
-			if (base?.kind === "struct") {
-				base.methods.set(decl.name, funcType);
+			const recvTypeName =
+				decl.recvType.kind === "GenericTypeName"
+					? decl.recvType.name
+					: decl.recvType.name;
+			const recvNamedType = this.types.get(recvTypeName);
+			if (recvNamedType?._generic) {
+				// Store method on the generic metadata and on the underlying struct
+				if (!recvNamedType._generic.methods)
+					recvNamedType._generic.methods = new Map();
+				recvNamedType._generic.methods.set(decl.name, funcType);
+				const base = recvNamedType.underlying;
+				if (base?.kind === "struct") {
+					base.methods.set(decl.name, funcType);
+				}
+			} else {
+				const recvType = this.resolveTypeNodeName(decl.recvType, this.globals);
+				const base = recvType?.underlying ?? recvType;
+				if (base?.kind === "struct") {
+					base.methods.set(decl.name, funcType);
+				}
 			}
 		}
 	}
@@ -615,18 +793,29 @@ export class TypeChecker {
 
 	checkFuncDecl(decl, outer) {
 		const inner = new Scope(outer);
+		// Inject type params into scope for generic functions
+		if (decl.typeParams) {
+			for (const tp of decl.typeParams) {
+				const constraint = tp.constraint
+					? this.resolveTypeNode(tp.constraint, outer)
+					: ANY;
+				inner.define(tp.name, { kind: "typeParam", name: tp.name, constraint });
+			}
+		}
 		for (const p of decl.params) {
-			inner.define(p.name, this.resolveTypeNode(p.type, outer));
+			inner.define(p.name, this.resolveTypeNode(p.type, inner));
 		}
-		const returnType = decl.returnType
-			? this.resolveTypeNode(decl.returnType, outer)
+		let returnType = decl.returnType
+			? this.resolveTypeNode(decl.returnType, inner)
 			: VOID;
 		const hasNamedReturns = this._injectNamedReturns(
 			decl.returnType,
 			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);
@@ -634,24 +823,42 @@ export class TypeChecker {
 		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) {
 		const inner = new Scope(outer);
+		// For generic receiver types (e.g. Stack[T]), inject type params
+		const recvTypeName =
+			decl.recvType.kind === "GenericTypeName"
+				? decl.recvType.name
+				: decl.recvType.name;
+		const recvNamedType = this.types.get(recvTypeName);
+		if (recvNamedType?._generic) {
+			for (const tp of recvNamedType._generic.typeParams) {
+				inner.define(tp.name, tp);
+			}
+		}
 		const recvType = this.resolveTypeNodeName(decl.recvType, outer);
 		inner.define(decl.recvName, recvType);
 		for (const p of decl.params) {
-			inner.define(p.name, this.resolveTypeNode(p.type, outer));
+			inner.define(p.name, this.resolveTypeNode(p.type, inner));
 		}
-		const returnType = decl.returnType
-			? this.resolveTypeNode(decl.returnType, outer)
+		let returnType = decl.returnType
+			? this.resolveTypeNode(decl.returnType, inner)
 			: VOID;
 		const hasNamedReturns = this._injectNamedReturns(
 			decl.returnType,
 			inner,
-			outer,
+			inner,
 		);
-		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);
@@ -659,6 +866,92 @@ export class TypeChecker {
 		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) {
@@ -705,10 +998,37 @@ export class TypeChecker {
 		switch (node.kind) {
 			case "TypeName": {
 				if (BASIC_TYPES[node.name]) return BASIC_TYPES[node.name];
+				if (node.name === "comparable")
+					return { kind: "basic", name: "comparable" };
+				// Check scope for type params before checking this.types
+				if (scope) {
+					const fromScope = scope.lookup(node.name);
+					if (fromScope?.kind === "typeParam") return fromScope;
+				}
 				const named = this.types.get(node.name);
 				if (named) return named;
 				return this.err(`Unknown type '${node.name}'`, node);
 			}
+			case "GenericTypeName": {
+				const base = this.types.get(node.name);
+				if (!base) return this.err(`Unknown type '${node.name}'`, node);
+				if (base.kind === "named" && base._generic) {
+					return this.instantiateGenericType(
+						base._generic,
+						node.typeArgs,
+						scope,
+					);
+				}
+				return this.err(`Type '${node.name}' is not generic`, node);
+			}
+			case "TypeParam": {
+				const constraint = node.constraint
+					? this.resolveTypeNode(node.constraint, scope)
+					: ANY;
+				return { kind: "typeParam", name: node.name, constraint };
+			}
+			case "UnionConstraint":
+				return node;
 			case "SliceType":
 				return {
 					kind: "slice",
@@ -827,11 +1147,207 @@ export class TypeChecker {
 			const named = this.types.get(node.name);
 			if (named) return named;
 		}
+		if (node.kind === "GenericTypeName") {
+			const named = this.types.get(node.name);
+			if (named) return named;
+		}
 		return this.resolveTypeNode(node, scope);
 	}
 
 	// ── Helpers ───────────────────────────────────────────────────
 
+	// ── Generics — instantiation, inference, substitution ────────
+
+	substituteType(type, map) {
+		if (!type) return type;
+		if (type.kind === "typeParam") {
+			const bound = map.get(type.name);
+			return bound ?? type;
+		}
+		switch (type.kind) {
+			case "basic":
+			case "untyped":
+				return type;
+			case "slice":
+				return { kind: "slice", elem: this.substituteType(type.elem, map) };
+			case "array":
+				return {
+					kind: "array",
+					size: type.size,
+					elem: this.substituteType(type.elem, map),
+				};
+			case "map":
+				return {
+					kind: "map",
+					key: this.substituteType(type.key, map),
+					value: this.substituteType(type.value, map),
+				};
+			case "func": {
+				return {
+					kind: "func",
+					params: type.params.map((p) => this.substituteType(p, map)),
+					returns: type.returns.map((r) => this.substituteType(r, map)),
+					variadic: type.variadic,
+					async: type.async,
+				};
+			}
+			case "struct": {
+				const fields = new Map();
+				for (const [k, v] of type.fields)
+					fields.set(k, this.substituteType(v, map));
+				const methods = new Map();
+				for (const [k, v] of type.methods)
+					methods.set(k, this.substituteType(v, map));
+				return {
+					kind: "struct",
+					name: type.name,
+					fields,
+					methods,
+					_embeds: type._embeds,
+				};
+			}
+			case "interface": {
+				const methods = new Map();
+				for (const [k, v] of type.methods)
+					methods.set(k, this.substituteType(v, map));
+				return { kind: "interface", name: type.name, methods };
+			}
+			case "named":
+				return {
+					kind: "named",
+					name: type.name,
+					underlying: this.substituteType(type.underlying, map),
+				};
+			case "pointer":
+				return { kind: "pointer", base: this.substituteType(type.base, map) };
+			case "tuple":
+				return {
+					kind: "tuple",
+					types: type.types.map((t) => this.substituteType(t, map)),
+				};
+			default:
+				return type;
+		}
+	}
+
+	instantiateGenericFunc(genericType, typeArgs) {
+		const map = new Map();
+		for (let i = 0; i < genericType.typeParams.length; i++) {
+			map.set(genericType.typeParams[i].name, typeArgs[i] ?? ANY);
+		}
+		return this.substituteType(genericType.underlying, map);
+	}
+
+	instantiateGenericType(generic, typeArgNodes, scope) {
+		const map = new Map();
+		const typeArgs = typeArgNodes.map((n) => this.resolveTypeNode(n, scope));
+		for (let i = 0; i < generic.typeParams.length; i++) {
+			map.set(generic.typeParams[i].name, typeArgs[i] ?? ANY);
+		}
+		// Resolve the underlying type from the decl node using a scope with type params bound
+		const typeScope = new Scope(this.globals);
+		for (const [name, type] of map) typeScope.define(name, type);
+		const underlying = this.resolveTypeNode(generic.declNode.type, typeScope);
+		const instantiated = this.substituteType(underlying, map);
+		if (instantiated.kind === "struct") {
+			instantiated.name = generic.declNode.name;
+			if (!instantiated.methods) instantiated.methods = new Map();
+			// Copy and substitute methods from the generic
+			if (generic.methods) {
+				for (const [mName, mType] of generic.methods) {
+					instantiated.methods.set(mName, this.substituteType(mType, map));
+				}
+			}
+		}
+		return {
+			kind: "named",
+			name: generic.declNode.name,
+			underlying: instantiated,
+		};
+	}
+
+	inferTypeArgs(genericType, argTypes) {
+		const map = new Map();
+		const params = genericType.underlying.params;
+		for (let i = 0; i < params.length && i < argTypes.length; i++) {
+			this._inferFromPair(params[i], argTypes[i], map);
+		}
+		// Check all type params are resolved
+		for (const tp of genericType.typeParams) {
+			if (!map.has(tp.name)) return null;
+		}
+		// Apply defaultType to resolve untyped constants
+		const result = [];
+		for (const tp of genericType.typeParams) {
+			result.push(defaultType(map.get(tp.name)));
+		}
+		return result;
+	}
+
+	_inferFromPair(paramType, argType, map) {
+		if (!paramType || !argType) return;
+		if (paramType.kind === "typeParam") {
+			if (!map.has(paramType.name)) {
+				map.set(paramType.name, argType);
+			}
+			return;
+		}
+		if (paramType.kind === "slice" && argType.kind === "slice") {
+			this._inferFromPair(paramType.elem, argType.elem, map);
+		}
+		if (paramType.kind === "map" && argType.kind === "map") {
+			this._inferFromPair(paramType.key, argType.key, map);
+			this._inferFromPair(paramType.value, argType.value, map);
+		}
+		if (paramType.kind === "func" && argType.kind === "func") {
+			for (
+				let i = 0;
+				i < paramType.params.length && i < argType.params.length;
+				i++
+			) {
+				this._inferFromPair(paramType.params[i], argType.params[i], map);
+			}
+			for (
+				let i = 0;
+				i < paramType.returns.length && i < argType.returns.length;
+				i++
+			) {
+				this._inferFromPair(paramType.returns[i], argType.returns[i], map);
+			}
+		}
+	}
+
+	checkConstraint(typeArg, constraint, node) {
+		if (!constraint) return;
+		if (isAny(constraint)) return;
+		if (constraint.kind === "basic" && constraint.name === "comparable") return;
+		if (constraint.kind === "UnionConstraint") {
+			// Check if typeArg matches any term; ~terms always pass (v1)
+			for (const term of constraint.terms) {
+				if (term.approx) return; // ~ means approximate, always passes
+				const termType = this.resolveTypeNode(term.type, this.globals);
+				if (typeStr(typeArg) === typeStr(termType)) return;
+			}
+			this.err(`type ${typeStr(typeArg)} does not satisfy constraint`, node);
+			return;
+		}
+		// Interface constraint — unwrap named types
+		const base =
+			constraint.kind === "named" ? constraint.underlying : constraint;
+		if (base?.kind === "interface") {
+			if (base.methods.size === 0 && !base.unionConstraint) return;
+			if (base.unionConstraint) {
+				return this.checkConstraint(typeArg, base.unionConstraint, node);
+			}
+			if (!this.implements(typeArg, base, node)) {
+				this.err(
+					`type ${typeStr(typeArg)} does not satisfy constraint ${typeStr(constraint)}`,
+					node,
+				);
+			}
+		}
+	}
+
 	resolveType(t) {
 		if (!t) return ANY;
 		if (t.kind === "basic" && t.alias) {
@@ -851,16 +1367,29 @@ export class TypeChecker {
 			if (base.methods?.has(field)) return base.methods.get(field);
 			return this.err(`No field '${field}' on ${typeStr(baseType)}`, node);
 		}
+		if (base?.kind === "interface") {
+			if (base.methods?.has(field)) return base.methods.get(field);
+			return this.err(`No method '${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);
 		}
 		// For explicitly typed non-any values, report the bad access rather than
 		// silently returning any — this catches typos on structs and primitive misuse.
 		if (base && !isAny(base)) {
-			// error.Error() is valid — it returns the error string
-			if (isError(base) && field === "Error")
-				return { kind: "func", params: [], returns: [STRING], async: false };
 			// pointer.value is the GoFront new(T) pattern
 			if (base.kind === "pointer" && field === "value") return base.base ?? ANY;
 			const badKinds = ["basic", "slice", "array", "map", "func", "tuple"];
@@ -875,9 +1404,64 @@ export class TypeChecker {
 	}
 
 	binaryResultType(op, lt, rt, node) {
-		if (CMP_OPS.has(op)) return BOOL;
+		// Type parameters are permissive — allow operations and return the typeParam
+		if (lt?.kind === "typeParam" || rt?.kind === "typeParam") {
+			if (CMP_OPS.has(op)) return BOOL;
+			if (LOG_OPS.has(op)) return BOOL;
+			return lt?.kind === "typeParam" ? lt : rt;
+		}
+		if (CMP_OPS.has(op)) {
+			// Complex only supports == and !=
+			if (isComplex(lt) || isComplex(rt)) {
+				if (op !== "==" && op !== "!=") {
+					this.err(
+						`invalid operation: ${typeStr(lt)} ${op} ${typeStr(rt)}`,
+						node,
+					);
+					return ANY;
+				}
+			}
+			// 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;
+		// Complex arithmetic: +, -, *, /
+		if (isComplex(lt) || isComplex(rt)) {
+			if (!isComplexOrNumeric(lt) || !isComplexOrNumeric(rt)) {
+				this.err(
+					`invalid operation: ${typeStr(lt)} ${op} ${typeStr(rt)}`,
+					node,
+				);
+				return ANY;
+			}
+			if (op !== "+" && op !== "-" && op !== "*" && op !== "/") {
+				this.err(
+					`invalid operation: ${typeStr(lt)} ${op} ${typeStr(rt)}`,
+					node,
+				);
+				return ANY;
+			}
+			if (lt.kind === "untyped" && rt.kind === "untyped")
+				return UNTYPED_COMPLEX;
+			return COMPLEX128;
+		}
 		if (isNumeric(lt) && isNumeric(rt)) {
 			const lFloat = (lt.kind === "untyped" ? lt.base : lt.name) === "float64";
 			const rFloat = (rt.kind === "untyped" ? rt.base : rt.name) === "float64";
@@ -908,8 +1492,19 @@ export class TypeChecker {
 		if (!target || !source) return;
 		target = this.resolveType(target);
 		source = this.resolveType(source);
+		// Type params are permissive — allow any assignment
+		if (target?.kind === "typeParam" || source?.kind === "typeParam") return;
 		if (isAny(target) || isAny(source)) return;
 		if (isNil(source)) return; // nil is assignable to anything nullable
+		// Pointer type: nil → *T is allowed (handled above); *T → *T check base types
+		if (isPointer(target) && isPointer(source)) {
+			this.assertAssignable(
+				target.base ?? target.underlying?.base,
+				source.base ?? source.underlying?.base,
+				node,
+			);
+			return;
+		}
 
 		// Untyped constants coerce to any compatible typed target
 		if (isUntyped(source)) {
@@ -931,6 +1526,18 @@ export class TypeChecker {
 				if (source.base === "string" && target.name === "string") return;
 				// untyped bool → bool
 				if (source.base === "bool" && target.name === "bool") return;
+				// untyped complex → complex128 or complex64
+				if (
+					source.base === "complex128" &&
+					(target.name === "complex128" || target.name === "complex64")
+				)
+					return;
+				// untyped int/float → complex (Go allows: var z complex128 = 5)
+				if (
+					isComplex(target) &&
+					(source.base === "int" || source.base === "float64")
+				)
+					return;
 			}
 		}
 
@@ -939,6 +1546,33 @@ export class TypeChecker {
 			if (target.name === "float64" && source.name === "int") return;
 			if (target.name === "int" && source.name === "float64") return; // truncating
 		}
+
+		// Array-specific checks: size matching and array/slice incompatibility
+		if (target.kind === "array" && source.kind === "array") {
+			if (
+				target.size != null &&
+				source.size != null &&
+				target.size !== source.size
+			) {
+				this.err(
+					`Cannot assign ${typeStr(source)} to ${typeStr(target)} (different array lengths)`,
+					node,
+				);
+				return;
+			}
+			// Check element type compatibility
+			this.assertAssignable(target.elem, source.elem, node);
+			return;
+		}
+		if (target.kind === "array" && source.kind === "slice") {
+			this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
+			return;
+		}
+		if (target.kind === "slice" && source.kind === "array") {
+			this.err(`Cannot assign ${typeStr(source)} to ${typeStr(target)}`, node);
+			return;
+		}
+
 		if (typeStr(target) !== typeStr(source)) {
 			// Interface satisfaction check
 			let tBase = target.kind === "named" ? target.underlying : target;
@@ -946,6 +1580,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)}`,