gofront 0.0.4 → 0.0.6

package/src/typechecker.js

@@ -13,14 +13,17 @@ import {
 	BASIC_TYPES,
 	BOOL,
 	CMP_OPS,
+	COMPLEX128,
 	defaultType,
 	ERROR,
 	FLOAT64,
 	INT,
 	isAny,
-	isError,
+	isComplex,
+	isComplexOrNumeric,
 	isNil,
 	isNumeric,
+	isPointer,
 	isString,
 	isUntyped,
 	isVoid,
@@ -29,6 +32,7 @@ import {
 	STRING,
 	TypeCheckError,
 	typeStr,
+	UNTYPED_COMPLEX,
 	UNTYPED_FLOAT,
 	UNTYPED_INT,
 	VOID,
@@ -50,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() {
@@ -140,6 +146,24 @@ export class TypeChecker {
 				Printf: fmtVariadic(VOID),
 				Println: fmtVariadic(VOID),
 				Print: fmtVariadic(VOID),
+				Fprintf: {
+					kind: "func",
+					params: [ANY, STRING],
+					returns: [INT, ERROR],
+					variadic: true,
+				},
+				Fprintln: {
+					kind: "func",
+					params: [ANY],
+					returns: [INT, ERROR],
+					variadic: true,
+				},
+				Fprint: {
+					kind: "func",
+					params: [ANY],
+					returns: [INT, ERROR],
+					variadic: true,
+				},
 			},
 		});
 
@@ -194,6 +218,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",
@@ -329,6 +394,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] },
 			},
 		});
 
@@ -382,6 +449,195 @@ export class TypeChecker {
 			},
 		});
 
+		// slices package (Go 1.21)
+		// Functions are generic — use ANY for slice params so any concrete slice type
+		// is accepted without an assignability error (same pattern as sort.Slice).
+		this.globals.define("slices", {
+			kind: "namespace",
+			name: "slices",
+			members: {
+				Contains: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
+				Index: { kind: "func", params: [ANY, ANY], returns: [INT] },
+				Equal: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
+				Compare: { kind: "func", params: [ANY, ANY], returns: [INT] },
+				Sort: { kind: "func", params: [ANY], returns: [VOID] },
+				SortFunc: { kind: "func", params: [ANY, ANY], returns: [VOID] },
+				SortStableFunc: { kind: "func", params: [ANY, ANY], returns: [VOID] },
+				IsSorted: { kind: "func", params: [ANY], returns: [BOOL] },
+				IsSortedFunc: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
+				Reverse: { kind: "func", params: [ANY], returns: [VOID] },
+				Max: { kind: "func", params: [ANY], returns: [ANY] },
+				Min: { kind: "func", params: [ANY], returns: [ANY] },
+				MaxFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
+				MinFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
+				Clone: { kind: "func", params: [ANY], returns: [ANY] },
+				Compact: { kind: "func", params: [ANY], returns: [ANY] },
+				CompactFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
+				Concat: { kind: "func", params: [ANY], returns: [ANY], variadic: true },
+				Delete: { kind: "func", params: [ANY, INT, INT], returns: [ANY] },
+				DeleteFunc: { kind: "func", params: [ANY, ANY], returns: [ANY] },
+				Insert: {
+					kind: "func",
+					params: [ANY, INT, ANY],
+					returns: [ANY],
+					variadic: true,
+				},
+				Replace: {
+					kind: "func",
+					params: [ANY, INT, INT, ANY],
+					returns: [ANY],
+					variadic: true,
+				},
+				Grow: { kind: "func", params: [ANY, INT], returns: [ANY] },
+				Clip: { kind: "func", params: [ANY], returns: [ANY] },
+			},
+		});
+
+		// html package
+		this.globals.define("html", {
+			kind: "namespace",
+			name: "html",
+			members: {
+				EscapeString: { kind: "func", params: [STRING], returns: [STRING] },
+				UnescapeString: { kind: "func", params: [STRING], returns: [STRING] },
+			},
+		});
+
+		// maps package (Go 1.21)
+		this.globals.define("maps", {
+			kind: "namespace",
+			name: "maps",
+			members: {
+				Keys: { kind: "func", params: [ANY], returns: [ANY] },
+				Values: { kind: "func", params: [ANY], returns: [ANY] },
+				Clone: { kind: "func", params: [ANY], returns: [ANY] },
+				Copy: { kind: "func", params: [ANY, ANY], returns: [VOID] },
+				Equal: { kind: "func", params: [ANY, ANY], returns: [BOOL] },
+				EqualFunc: { kind: "func", params: [ANY, ANY, ANY], returns: [BOOL] },
+				Delete: { kind: "func", params: [ANY, ANY], returns: [VOID] },
+				DeleteFunc: { kind: "func", params: [ANY, ANY], returns: [VOID] },
+			},
+		});
+
+		// regexp package
+		const REGEXP_T = {
+			kind: "named",
+			name: "regexp.Regexp",
+			underlying: { kind: "struct", fields: new Map(), methods: new Map() },
+		};
+		const REGEXP_PTR = { kind: "pointer", base: REGEXP_T };
+		const STR_SLICE = { kind: "slice", elem: STRING };
+		const INT_SLICE = { kind: "slice", elem: INT };
+		const regexpMethods = new Map([
+			["MatchString", { kind: "func", params: [STRING], returns: [BOOL] }],
+			["FindString", { kind: "func", params: [STRING], returns: [STRING] }],
+			[
+				"FindStringIndex",
+				{ kind: "func", params: [STRING], returns: [INT_SLICE] },
+			],
+			[
+				"FindAllString",
+				{ kind: "func", params: [STRING, INT], returns: [STR_SLICE] },
+			],
+			[
+				"FindStringSubmatch",
+				{ kind: "func", params: [STRING], returns: [STR_SLICE] },
+			],
+			[
+				"FindAllStringSubmatch",
+				{
+					kind: "func",
+					params: [STRING, INT],
+					returns: [{ kind: "slice", elem: STR_SLICE }],
+				},
+			],
+			[
+				"ReplaceAllString",
+				{ kind: "func", params: [STRING, STRING], returns: [STRING] },
+			],
+			[
+				"ReplaceAllLiteralString",
+				{ kind: "func", params: [STRING, STRING], returns: [STRING] },
+			],
+			["Split", { kind: "func", params: [STRING, INT], returns: [STR_SLICE] }],
+			["String", { kind: "func", params: [], returns: [STRING] }],
+		]);
+		REGEXP_T.underlying.methods = regexpMethods;
+		this.types.set("regexp.Regexp", REGEXP_T);
+		this.globals.define("regexp", {
+			kind: "namespace",
+			name: "regexp",
+			members: {
+				MustCompile: { kind: "func", params: [STRING], returns: [REGEXP_PTR] },
+				Compile: {
+					kind: "func",
+					params: [STRING],
+					returns: [REGEXP_PTR, ERROR],
+				},
+				MatchString: {
+					kind: "func",
+					params: [STRING, STRING],
+					returns: [BOOL, ERROR],
+				},
+				QuoteMeta: { kind: "func", params: [STRING], returns: [STRING] },
+			},
+		});
+
+		// strings.Builder
+		const BYTE_SLICE_T = { kind: "slice", elem: INT };
+		const strBuilderMethods = new Map([
+			[
+				"WriteString",
+				{ kind: "func", params: [STRING], returns: [INT, ERROR] },
+			],
+			["WriteByte", { kind: "func", params: [INT], returns: [ERROR] }],
+			["WriteRune", { kind: "func", params: [INT], returns: [INT, ERROR] }],
+			[
+				"Write",
+				{ kind: "func", params: [BYTE_SLICE_T], returns: [INT, ERROR] },
+			],
+			["String", { kind: "func", params: [], returns: [STRING] }],
+			["Len", { kind: "func", params: [], returns: [INT] }],
+			["Reset", { kind: "func", params: [], returns: [VOID] }],
+			["Grow", { kind: "func", params: [INT], returns: [VOID] }],
+		]);
+		this.types.set("strings.Builder", {
+			kind: "named",
+			name: "strings.Builder",
+			underlying: {
+				kind: "struct",
+				fields: new Map(),
+				methods: strBuilderMethods,
+			},
+		});
+
+		// bytes.Buffer
+		const bytesBufferMethods = new Map([
+			[
+				"WriteString",
+				{ kind: "func", params: [STRING], returns: [INT, ERROR] },
+			],
+			["WriteByte", { kind: "func", params: [INT], returns: [ERROR] }],
+			[
+				"Write",
+				{ kind: "func", params: [BYTE_SLICE_T], returns: [INT, ERROR] },
+			],
+			["String", { kind: "func", params: [], returns: [STRING] }],
+			["Bytes", { kind: "func", params: [], returns: [BYTE_SLICE_T] }],
+			["Len", { kind: "func", params: [], returns: [INT] }],
+			["Reset", { kind: "func", params: [], returns: [VOID] }],
+			["Grow", { kind: "func", params: [INT], returns: [VOID] }],
+		]);
+		this.types.set("bytes.Buffer", {
+			kind: "named",
+			name: "bytes.Buffer",
+			underlying: {
+				kind: "struct",
+				fields: new Map(),
+				methods: bytesBufferMethods,
+			},
+		});
+
 		this.globals.define("append", { kind: "builtin", name: "append" });
 		this.globals.define("len", { kind: "builtin", name: "len" });
 		this.globals.define("cap", { kind: "builtin", name: "cap" });
@@ -397,6 +653,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) {
@@ -584,6 +843,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
@@ -604,11 +893,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;
@@ -623,13 +941,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);
+				}
 			}
 		}
 	}
@@ -657,11 +1000,20 @@ 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));
 		}
 		let returnType = decl.returnType
-			? this.resolveTypeNode(decl.returnType, outer)
+			? this.resolveTypeNode(decl.returnType, inner)
 			: VOID;
 		const hasNamedReturns = this._injectNamedReturns(
 			decl.returnType,
@@ -688,18 +1040,29 @@ export class TypeChecker {
 
 	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));
 		}
 		let returnType = decl.returnType
-			? this.resolveTypeNode(decl.returnType, outer)
+			? this.resolveTypeNode(decl.returnType, inner)
 			: VOID;
 		const hasNamedReturns = this._injectNamedReturns(
 			decl.returnType,
 			inner,
-			outer,
+			inner,
 		);
 		if (hasNamedReturns && returnType)
 			returnType = { ...returnType, _hasNamedReturns: true };
@@ -842,10 +1205,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",
@@ -964,11 +1354,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) {
@@ -981,6 +1567,15 @@ export class TypeChecker {
 	fieldType(baseType, field, node) {
 		baseType = this.resolveType(baseType);
 		if (!baseType || isAny(baseType)) return ANY;
+		// Transparent pointer dereference for named-type method calls: (*T).Method works like T.Method
+		// (only unwrap when the pointer's base is a named type that has methods)
+		if (
+			baseType.kind === "pointer" &&
+			field !== "value" &&
+			baseType.base?.kind === "named"
+		) {
+			baseType = this.resolveType(baseType.base);
+		}
 		let base = baseType.kind === "named" ? baseType.underlying : baseType;
 		base = this.resolveType(base);
 		if (base?.kind === "struct") {
@@ -988,6 +1583,10 @@ 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 (
@@ -1007,9 +1606,6 @@ export class TypeChecker {
 		// 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"];
@@ -1024,7 +1620,23 @@ export class TypeChecker {
 	}
 
 	binaryResultType(op, lt, rt, node) {
+		// 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);
@@ -1046,6 +1658,26 @@ export class TypeChecker {
 		}
 		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";
@@ -1076,8 +1708,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)) {
@@ -1099,6 +1742,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;
 			}
 		}
 
@@ -1107,6 +1762,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;