gofront 0.0.9 → 1.0.1

package/src/typechecker/expressions.js

@@ -17,6 +17,7 @@ import {
 	NIL,
 	Scope,
 	STRING,
+	TAINTED_ANY,
 	typeStr,
 	UNTYPED_BOOL,
 	UNTYPED_COMPLEX,
@@ -26,6 +27,63 @@ import {
 	VOID,
 } from "./types.js";
 
+/** @typedef {import('./index.js').TypeChecker} TypeChecker */
+
+// Dispatch table for builtin function type checking.
+// Each value is (self, name, expr, argTypes, scope) => returnType.
+const BUILTIN_CHECK = {
+	len: (s, n, e, at) => s._checkBuiltinLen(n, e, at),
+	cap: (s, n, e, at) => s._checkBuiltinLen(n, e, at),
+	append: (s, _n, e, at) => {
+		const st = at[0] ?? ANY;
+		if (isArray(st)) {
+			s.err(`cannot append to array (type ${typeStr(st)})`, e);
+			return st;
+		}
+		return st;
+	},
+	copy: () => INT,
+	delete: () => VOID,
+	make: (s, _n, e, _at, sc) => {
+		if (e.args.length < 1) return ANY;
+		const ta = e.args[0];
+		const tn = ta.kind === "TypeExpr" ? ta.type : ta;
+		return s.resolveTypeNode(tn, sc) ?? ANY;
+	},
+	new: (s, _n, e, _at, sc) => {
+		if (e.args.length < 1) return ANY;
+		const inner = s.resolveTypeNode(e.args[0], sc);
+		return { kind: "pointer", base: inner };
+	},
+	print: () => VOID,
+	println: () => VOID,
+	panic: () => VOID,
+	recover: () => ANY,
+	error: () => ERROR,
+	min: (_s, _n, _e, at) => at[0] ?? ANY,
+	max: (_s, _n, _e, at) => at[0] ?? ANY,
+	clear: () => VOID,
+	complex: (s, _n, e, at) => s._checkBuiltinComplex(e, at),
+	real: (s, n, e, at) => s._checkBuiltinRealImag(n, e, at),
+	imag: (s, n, e, at) => s._checkBuiltinRealImag(n, e, at),
+};
+
+// Method-name dispatch for _checkExpr — string values add no static call edges.
+const CHECK_EXPR_DELEGATE = {
+	UnaryExpr: "_checkUnaryExpr",
+	CallExpr: "checkCall",
+	SelectorExpr: "_checkSelectorExpr",
+	IndexExpr: "_checkIndexExpr",
+	SliceExpr: "_checkSliceExpr",
+	CompositeLit: "checkCompositeLit",
+	FuncLit: "_checkFuncLit",
+	TypeConversion: "_checkTypeConversion",
+	TypeAssertExpr: "_checkTypeAssertExpr",
+	RangeExpr: "_checkRangeExpr",
+	InstantiationExpr: "_checkInstantiationExpr",
+};
+
+/** @type {ThisType<TypeChecker>} */
 export const expressionCheckMethods = {
 	checkExpr(expr, scope) {
 		const t = this._checkExpr(expr, scope);
@@ -50,335 +108,317 @@ export const expressionCheckMethods = {
 				}
 				break;
 			}
-
 			case "ImagLit":
 				return UNTYPED_COMPLEX;
-
 			case "Ident": {
 				const t = scope.lookup(expr.name);
 				if (!t) return this.err(`Undefined: '${expr.name}'`, expr);
-				// Mark type-name identifiers so SelectorExpr can detect method expressions
 				if (this.types.has(expr.name)) expr._isTypeRef = true;
 				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) && !isComplex(ot) && !isAny(ot))
-						this.err(`${expr.op} requires numeric`, expr);
-					return ot;
-				}
-				if (expr.op === "&") {
-					// Mark the operand as address-taken for codegen
-					if (expr.operand.kind === "Ident") {
-						expr.operand._addressTaken = true;
-						const sym = scope.lookup(expr.operand.name);
-						if (sym) sym._addressTaken = true;
-					}
-					return { kind: "pointer", base: ot };
-				}
-				if (expr.op === "*") {
-					if (ot === ANY) return ANY;
-					if (ot.kind === "pointer") return ot.base;
-					if (ot.kind === "named" && ot.underlying?.kind === "pointer")
-						return ot.underlying.base;
-					this.err(`cannot dereference non-pointer type ${typeStr(ot)}`, expr);
-					return ANY;
-				}
-				return ot;
-			}
-
 			case "BinaryExpr": {
 				const lt = this.checkExpr(expr.left, scope);
 				const rt = this.checkExpr(expr.right, scope);
+				if (lt?._tainted || rt?._tainted) return TAINTED_ANY;
 				if (isAny(lt) || isAny(rt))
 					return this.binaryResultType(expr.op, ANY, ANY, expr);
 				return this.binaryResultType(expr.op, lt, rt, expr);
 			}
-
-			case "CallExpr": {
-				return this.checkCall(expr, scope);
+			case "AwaitExpr":
+				return this.checkExpr(expr.expr, scope);
+			case "InstantiationExpr":
+				return this._checkInstantiationExpr(expr, scope);
+			default: {
+				const m = CHECK_EXPR_DELEGATE[expr.kind];
+				if (m) return this[m](expr, scope);
+				return ANY;
 			}
+		}
+		return ANY;
+	},
 
-			case "SelectorExpr": {
-				const baseType = this.checkExpr(expr.expr, scope);
-				// Method expression: TypeName.MethodName → func(ReceiverType, ...params) ret
-				if (expr.expr._isTypeRef) {
-					let base = baseType.kind === "named" ? baseType.underlying : baseType;
-					base = this.resolveType(base);
-					let methodType = null;
-					if (base?.kind === "struct" && base.methods?.has(expr.field)) {
-						methodType = base.methods.get(expr.field);
-					} else if (
-						baseType.kind === "named" &&
-						baseType.methods?.has(expr.field)
-					) {
-						methodType = baseType.methods.get(expr.field);
-					}
-					if (methodType) {
-						// Return a func type with the receiver prepended to params
-						expr._isMethodExpr = true;
-						expr._methodExprRecv = baseType;
-						return {
-							kind: "func",
-							params: [baseType, ...(methodType.params ?? [])],
-							returns: methodType.returns ?? [],
-							variadic: methodType.variadic,
-						};
-					}
-				}
-				const ft = this.fieldType(baseType, expr.field, expr);
-				// Mark method selectors so codegen can emit .bind() when used as a value
-				if (ft?.kind === "func") {
-					let base = baseType.kind === "named" ? baseType.underlying : baseType;
-					base = this.resolveType(base);
-					if (
-						(base?.kind === "struct" && base.methods?.has(expr.field)) ||
-						(baseType.kind === "named" && baseType.methods?.has(expr.field))
-					) {
-						expr._isMethodValue = true;
-					}
-				}
-				return ft;
-			}
+	_checkDeref(ot, expr) {
+		if (ot === ANY) return ANY;
+		if (ot.kind === "pointer") return ot.base;
+		if (ot.kind === "named" && ot.underlying?.kind === "pointer")
+			return ot.underlying.base;
+		this.err(`cannot dereference non-pointer type ${typeStr(ot)}`, expr);
+		return ANY;
+	},
 
-			case "IndexExpr": {
-				const bt = this.checkExpr(expr.expr, scope);
-				this.checkExpr(expr.index, scope);
-				if (isAny(bt)) return ANY;
-				// Named types (e.g. type Nums []int) are indexable via their underlying
-				const btu =
-					bt.kind === "named"
-						? (this.resolveType(bt.underlying) ?? bt.underlying)
-						: bt;
-				if (btu.kind === "slice" || btu.kind === "array") {
-					// Compile-time bounds checking for arrays
-					if (btu.kind === "array" && btu.size != null) {
-						const idx = this._constIntValue(expr.index);
-						if (idx !== null) {
-							if (idx < 0) {
-								this.err(
-									`invalid array index ${idx} (index must not be negative)`,
-									expr,
-								);
-							} else if (idx >= btu.size) {
-								this.err(
-									`invalid array index ${idx} (out of bounds for ${typeStr(bt)})`,
-									expr,
-								);
-							}
-						}
-					}
-					return btu.elem;
-				}
-				if (btu.kind === "map") {
-					expr._mapValueType = btu.value; // for codegen zero-value fallback
-					return btu.value;
-				}
-				if (isString(bt)) return INT; // byte
-				return this.err(`Cannot index type ${typeStr(bt)}`, expr);
-			}
+	_checkBoolUnaryOp(ot, expr) {
+		if (!isBool(ot) && !isAny(ot)) this.err("! requires bool", expr);
+		return BOOL;
+	},
 
-			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 (expr.max) this.checkExpr(expr.max, 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);
-			}
+	_checkNumericUnaryOp(ot, expr) {
+		if (!isNumeric(ot) && !isComplex(ot) && !isAny(ot))
+			this.err(`${expr.op} requires numeric`, expr);
+		return ot;
+	},
 
-			case "CompositeLit": {
-				return this.checkCompositeLit(expr, scope);
-			}
+	_checkAddressOfExpr(expr, scope, ot) {
+		if (expr.operand.kind === "Ident") {
+			expr.operand._addressTaken = true;
+			const sym = scope.lookup(expr.operand.name);
+			if (sym) sym._addressTaken = true;
+		}
+		return { kind: "pointer", base: ot };
+	},
 
-			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;
-				const savedDefer = this._deferCount;
-				this._deferCount = 0;
-				this.checkBlock(expr.body, inner, ret);
-				this._reportUnused(inner, expr);
-				if (this._deferCount > 0) expr.body._hasDefer = true;
-				this._deferCount = savedDefer;
-				const paramTypes = expr.params.map((p) =>
-					p.type ? this.resolveTypeNode(p.type, scope) : ANY,
-				);
+	_checkUnaryExpr(expr, scope) {
+		const ot = this.checkExpr(expr.operand, scope);
+		if (expr.op === "!") return this._checkBoolUnaryOp(ot, expr);
+		if (expr.op === "-" || expr.op === "+")
+			return this._checkNumericUnaryOp(ot, expr);
+		if (expr.op === "&") return this._checkAddressOfExpr(expr, scope, ot);
+		if (expr.op === "*") return this._checkDeref(ot, expr);
+		return ot;
+	},
+
+	_isStructOrNamedMethod(baseType, base, field) {
+		return (
+			(base?.kind === "struct" && base.methods?.has(field)) ||
+			(baseType.kind === "named" && baseType.methods?.has(field))
+		);
+	},
+
+	_resolveMethodExprType(baseType, base, field) {
+		if (!this._isStructOrNamedMethod(baseType, base, field)) return null;
+		return base?.methods?.get(field) ?? baseType.methods?.get(field);
+	},
+
+	_checkSelectorExpr(expr, scope) {
+		const baseType = this.checkExpr(expr.expr, scope);
+		if (baseType?._tainted) return TAINTED_ANY;
+		if (expr.expr._isTypeRef) {
+			let base = baseType.kind === "named" ? baseType.underlying : baseType;
+			base = this.resolveType(base);
+			const methodType = this._resolveMethodExprType(
+				baseType,
+				base,
+				expr.field,
+			);
+			if (methodType) {
+				expr._isMethodExpr = true;
+				expr._methodExprRecv = baseType;
 				return {
 					kind: "func",
-					params: paramTypes,
-					returns: [ret],
-					async: expr.async,
+					params: [baseType, ...(methodType.params ?? [])],
+					returns: methodType.returns ?? [],
+					variadic: methodType.variadic,
 				};
 			}
+		}
+		const ft = this.fieldType(baseType, expr.field, expr);
+		if (ft?.kind === "func") {
+			let base = baseType.kind === "named" ? baseType.underlying : baseType;
+			base = this.resolveType(base);
+			if (this._isStructOrNamedMethod(baseType, base, expr.field))
+				expr._isMethodValue = true;
+		}
+		return ft;
+	},
 
-			case "AwaitExpr": {
-				// await unwraps whatever the expression produces — no Promise type modelling
-				return this.checkExpr(expr.expr, scope);
-			}
+	_checkArrayBoundsExpr(btu, bt, expr) {
+		if (btu.kind !== "array" || btu.size == null) return;
+		const idx = this._constIntValue(expr.index);
+		if (idx === null) return;
+		if (idx < 0)
+			this.err(`invalid array index ${idx} (index must not be negative)`, expr);
+		else if (idx >= btu.size)
+			this.err(
+				`invalid array index ${idx} (out of bounds for ${typeStr(bt)})`,
+				expr,
+			);
+	},
 
-			case "TypeConversion": {
-				const srcType = this.checkExpr(expr.expr, scope);
-				const targetType = this.resolveTypeNode(expr.targetType, scope);
-				const srcResolved =
-					srcType?.kind === "named" ? srcType.underlying : srcType;
-				const tgtResolved =
-					targetType?.kind === "named" ? targetType.underlying : targetType;
-				// Reject float64(complex) — must use real()/imag()
-				if (isNumeric(targetType) && isComplex(srcType)) {
-					this.err(
-						`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)} (use real() or imag())`,
-						expr,
-					);
-				}
-				// Allow complex128/64(numeric) and complex128/64(complex)
-				if (isComplex(targetType)) {
-					if (!isComplexOrNumeric(srcType) && !isAny(srcType)) {
-						this.err(
-							`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)}`,
-							expr,
-						);
-					}
-				}
-				// Slice → array conversion: [N]T(slice)
-				if (tgtResolved?.kind === "array" && srcResolved?.kind === "slice") {
-					const tgtElem = tgtResolved.elem;
-					const srcElem = srcResolved.elem;
-					if (
-						tgtElem &&
-						srcElem &&
-						!isAny(tgtElem) &&
-						!isAny(srcElem) &&
-						typeStr(tgtElem) !== typeStr(srcElem)
-					) {
-						this.err(
-							`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)}`,
-							expr,
-						);
-					}
-					return targetType;
-				}
-				// Array → slice conversion: []T(array)
-				if (tgtResolved?.kind === "slice" && srcResolved?.kind === "array") {
-					const tgtElem = tgtResolved.elem;
-					const srcElem = srcResolved.elem;
-					if (
-						tgtElem &&
-						srcElem &&
-						!isAny(tgtElem) &&
-						!isAny(srcElem) &&
-						typeStr(tgtElem) !== typeStr(srcElem)
-					) {
-						this.err(
-							`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)}`,
-							expr,
-						);
-					}
-					return targetType;
-				}
-				// Reject conversions between array and incompatible types
-				if (tgtResolved?.kind === "array" && srcResolved?.kind !== "array") {
-					if (!isAny(srcType)) {
-						this.err(
-							`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)}`,
-							expr,
-						);
-					}
-				}
-				return targetType;
-			}
+	_checkIndexExpr(expr, scope) {
+		const bt = this.checkExpr(expr.expr, scope);
+		this.checkExpr(expr.index, scope);
+		if (bt?._tainted) return TAINTED_ANY;
+		if (isAny(bt)) return ANY;
+		const btu =
+			bt.kind === "named"
+				? (this.resolveType(bt.underlying) ?? bt.underlying)
+				: bt;
+		if (btu.kind === "slice" || btu.kind === "array") {
+			this._checkArrayBoundsExpr(btu, bt, expr);
+			return btu.elem;
+		}
+		if (btu.kind === "map") {
+			expr._mapValueType = btu.value;
+			return btu.value;
+		}
+		if (isString(bt)) return INT;
+		return this.err(`Cannot index type ${typeStr(bt)}`, expr);
+	},
 
-			case "TypeAssertExpr": {
-				const srcType = this.checkExpr(expr.expr, scope);
-				const targetType = this.resolveTypeNode(expr.type, scope);
-
-				// In Go, the source of a type assertion must be an interface type.
-				// We allow `any` (which is GoFront's basic any) and interface types.
-				if (srcType && !isAny(srcType)) {
-					let underlying =
-						srcType.kind === "named" ? srcType.underlying : srcType;
-					underlying = this.resolveType(underlying);
-					if (underlying?.kind !== "interface") {
-						this.err(
-							`invalid type assertion: ${typeStr(srcType)} is not an interface`,
-							expr,
-						);
-					}
-				}
+	_checkSliceExpr(expr, scope) {
+		const bt = this.checkExpr(expr.expr, scope);
+		if (expr.low) this.checkExpr(expr.low, scope);
+		if (expr.high) this.checkExpr(expr.high, scope);
+		if (expr.max) this.checkExpr(expr.max, scope);
+		if (bt?._tainted) return TAINTED_ANY;
+		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);
+	},
 
-				return targetType;
-			}
+	_checkFuncLit(expr, scope) {
+		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;
+		const savedDefer = this._deferCount;
+		this._deferCount = 0;
+		this.checkBlock(expr.body, inner, ret);
+		this._reportUnused(inner, expr);
+		if (this._deferCount > 0) expr.body._hasDefer = true;
+		this._deferCount = savedDefer;
+		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 "RangeExpr": {
-				// Type-check the iterated expression so its _type is annotated
-				const collType = this.checkExpr(expr.expr, scope);
-				const resolved =
-					collType?.kind === "named" ? collType.underlying : collType;
-				// Return a tuple of (index/key type, value type) so DefineStmt can
-				// assign the correct types to range variables.
-				const isString =
-					(resolved?.kind === "basic" && resolved.name === "string") ||
-					(resolved?.kind === "untyped" && resolved.base === "string");
-				if (isString) {
-					// string range: (int index, rune value) — rune is an alias for int
-					return { kind: "tuple", types: [INT, INT] };
-				}
-				if (resolved?.kind === "slice" || resolved?.kind === "array") {
-					return { kind: "tuple", types: [INT, resolved.elem ?? ANY] };
-				}
-				if (resolved?.kind === "map") {
-					return {
-						kind: "tuple",
-						types: [resolved.key ?? ANY, resolved.value ?? ANY],
-					};
-				}
-				// integer range or unknown — return single-element tuple
-				return { kind: "tuple", types: [collType] };
-			}
+	_checkElemTypeCompatible(tgtElem, srcElem, srcType, targetType, expr) {
+		if (
+			tgtElem &&
+			srcElem &&
+			!isAny(tgtElem) &&
+			!isAny(srcElem) &&
+			typeStr(tgtElem) !== typeStr(srcElem)
+		)
+			this.err(
+				`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)}`,
+				expr,
+			);
+	},
 
-			case "InstantiationExpr": {
-				// Generic instantiation: Foo[int] or Foo[int, string]
-				const baseType = this.checkExpr(expr.expr, scope);
-				if (baseType?.kind === "generic") {
-					const typeArgs = expr.typeArgs.map((ta) =>
-						this.resolveTypeNode(ta, scope),
-					);
-					// Check constraints
-					for (
-						let i = 0;
-						i < baseType.typeParams.length && i < typeArgs.length;
-						i++
-					) {
-						const tp = baseType.typeParams[i];
-						const constraint = tp.constraint
-							? this.resolveTypeNode(tp.constraint, scope)
-							: null;
-						if (constraint) this.checkConstraint(typeArgs[i], constraint, expr);
-					}
-					return this.instantiateGenericFunc(baseType, typeArgs);
-				}
-				return baseType;
+	_isMutualArraySlice(tgt, src) {
+		return (
+			(tgt?.kind === "array" && src?.kind === "slice") ||
+			(tgt?.kind === "slice" && src?.kind === "array")
+		);
+	},
+
+	_isInvalidArrayConv(tgt, src, srcType) {
+		return tgt?.kind === "array" && src?.kind !== "array" && !isAny(srcType);
+	},
+
+	_checkTypeConversion(expr, scope) {
+		const srcType = this.checkExpr(expr.expr, scope);
+		const targetType = this.resolveTypeNode(expr.targetType, scope);
+		const srcResolved =
+			srcType?.kind === "named" ? srcType.underlying : srcType;
+		const tgtResolved =
+			targetType?.kind === "named" ? targetType.underlying : targetType;
+		if (isNumeric(targetType) && isComplex(srcType)) {
+			this.err(
+				`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)} (use real() or imag())`,
+				expr,
+			);
+		}
+		if (
+			isComplex(targetType) &&
+			!isComplexOrNumeric(srcType) &&
+			!isAny(srcType)
+		) {
+			this.err(
+				`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)}`,
+				expr,
+			);
+		}
+		if (this._isMutualArraySlice(tgtResolved, srcResolved)) {
+			this._checkElemTypeCompatible(
+				tgtResolved.elem,
+				srcResolved.elem,
+				srcType,
+				targetType,
+				expr,
+			);
+			return targetType;
+		}
+		if (this._isInvalidArrayConv(tgtResolved, srcResolved, srcType)) {
+			this.err(
+				`cannot convert ${typeStr(srcType)} to ${typeStr(targetType)}`,
+				expr,
+			);
+		}
+		return targetType;
+	},
+
+	_checkTypeAssertExpr(expr, scope) {
+		const srcType = this.checkExpr(expr.expr, scope);
+		const targetType = this.resolveTypeNode(expr.type, scope);
+
+		// In Go, the source of a type assertion must be an interface type.
+		// We allow `any` (which is GoFront's basic any) and interface types.
+		if (srcType && !isAny(srcType)) {
+			let underlying = srcType.kind === "named" ? srcType.underlying : srcType;
+			underlying = this.resolveType(underlying);
+			if (underlying?.kind !== "interface") {
+				this.err(
+					`invalid type assertion: ${typeStr(srcType)} is not an interface`,
+					expr,
+				);
 			}
+		}
 
-			default:
-				return ANY;
+		return targetType;
+	},
+
+	_rangeCollTypeTuple(resolved, collType) {
+		if (isString(resolved)) return { kind: "tuple", types: [INT, INT] };
+		if (resolved?.kind === "slice" || resolved?.kind === "array")
+			return { kind: "tuple", types: [INT, resolved.elem ?? ANY] };
+		if (resolved?.kind === "map")
+			return {
+				kind: "tuple",
+				types: [resolved.key ?? ANY, resolved.value ?? ANY],
+			};
+		return { kind: "tuple", types: [collType] };
+	},
+
+	_checkRangeExpr(expr, scope) {
+		const collType = this.checkExpr(expr.expr, scope);
+		const resolved =
+			collType?.kind === "named" ? collType.underlying : collType;
+		return this._rangeCollTypeTuple(resolved, collType);
+	},
+
+	_checkInstantiationExpr(expr, scope) {
+		// Generic instantiation: Foo[int] or Foo[int, string]
+		const baseType = this.checkExpr(expr.expr, scope);
+		if (baseType?.kind === "generic") {
+			const typeArgs = expr.typeArgs.map((ta) =>
+				this.resolveTypeNode(ta, scope),
+			);
+			// Check constraints
+			for (
+				let i = 0;
+				i < baseType.typeParams.length && i < typeArgs.length;
+				i++
+			) {
+				const tp = baseType.typeParams[i];
+				const constraint = tp.constraint
+					? this.resolveTypeNode(tp.constraint, scope)
+					: null;
+				if (constraint) this.checkConstraint(typeArgs[i], constraint, expr);
+			}
+			return this.instantiateGenericFunc(baseType, typeArgs);
 		}
-		return ANY;
+		return baseType;
 	},
 
 	_constIntValue(expr) {
@@ -395,11 +435,36 @@ export const expressionCheckMethods = {
 		return null;
 	},
 
+	_resolveCallArgTypes(expr, scope) {
+		if (expr.args.length === 1 && expr.args[0].kind === "CallExpr") {
+			const argType = this.checkExpr(expr.args[0], scope);
+			if (argType?.kind === "tuple") {
+				expr._multiForward = true;
+				return argType.types;
+			}
+			return [argType];
+		}
+		return expr.args.map((a) => this.checkExpr(a, scope));
+	},
+
+	_resolveCallFnType(fnType, argTypes, expr, scope) {
+		if (fnType.kind === "named" && fnType.underlying?.kind === "func")
+			fnType = fnType.underlying;
+		if (fnType.kind === "generic") {
+			const resolved = this._resolveGenericFnType(
+				fnType,
+				argTypes,
+				expr,
+				scope,
+			);
+			if (!resolved) return null;
+			fnType = resolved;
+		}
+		return fnType;
+	},
+
 	checkCall(expr, scope) {
 		let 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
@@ -409,21 +474,9 @@ export const expressionCheckMethods = {
 			return this.checkBuiltin(fnType.name, expr, argTypes, scope);
 		}
 
-		// Multi-value forwarding: f(g()) where g() returns multiple values
-		// When a single argument is a multi-return call, flatten its tuple into args.
-		let argTypes;
-		if (expr.args.length === 1 && expr.args[0].kind === "CallExpr") {
-			const argType = this.checkExpr(expr.args[0], scope);
-			if (argType?.kind === "tuple") {
-				expr._multiForward = true; // flag for codegen
-				argTypes = argType.types;
-			} else {
-				argTypes = [argType];
-			}
-		} else {
-			argTypes = expr.args.map((a) => this.checkExpr(a, scope));
-		}
+		const argTypes = this._resolveCallArgTypes(expr, scope);
 
+		if (fnType?._tainted) return TAINTED_ANY;
 		if (isAny(fnType)) return ANY;
 
 		// Named type used as a constructor/conversion: Greeter(fn), NodeFunc(fn)
@@ -434,300 +487,266 @@ export const expressionCheckMethods = {
 			return fnType;
 		}
 
-		// Named func types (e.g. type Handler func(int) int) are callable via variable
-		if (fnType.kind === "named" && fnType.underlying?.kind === "func") {
-			fnType = fnType.underlying;
+		fnType = this._resolveCallFnType(fnType, argTypes, expr, scope);
+		if (!fnType) return ANY;
+		if (fnType.kind !== "func") {
+			return this.err(`Cannot call non-function type ${typeStr(fnType)}`, expr);
 		}
 
-		// Generic function inference
-		if (fnType.kind === "generic") {
-			const typeArgs = this.inferTypeArgs(fnType, argTypes);
-			if (!typeArgs) {
-				return this.err(
-					`Cannot infer type arguments for generic function '${fnType.name}'`,
-					expr,
-				);
-			}
-			// Check constraints
-			for (
-				let i = 0;
-				i < fnType.typeParams.length && i < typeArgs.length;
-				i++
-			) {
-				const tp = fnType.typeParams[i];
-				const constraint = tp.constraint
-					? this.resolveTypeNode(tp.constraint, scope)
-					: null;
-				if (constraint) this.checkConstraint(typeArgs[i], constraint, expr);
-			}
-			fnType = this.instantiateGenericFunc(fnType, typeArgs);
-		}
+		this._checkCallArgs(fnType, argTypes, expr);
 
-		if (fnType.kind !== "func") {
-			return this.err(`Cannot call non-function type ${typeStr(fnType)}`, expr);
+		const ret = fnType.returns;
+		if (!ret || ret.length === 0) return VOID;
+		if (ret.length === 1) return ret[0];
+		return { kind: "tuple", types: ret };
+	},
+
+	_resolveGenericFnType(fnType, argTypes, expr, scope) {
+		const typeArgs = this.inferTypeArgs(fnType, argTypes);
+		if (!typeArgs) {
+			this.err(
+				`Cannot infer type arguments for generic function '${fnType.name}'`,
+				expr,
+			);
+			return null;
+		}
+		// Check constraints
+		for (let i = 0; i < fnType.typeParams.length && i < typeArgs.length; i++) {
+			const tp = fnType.typeParams[i];
+			const constraint = tp.constraint
+				? this.resolveTypeNode(tp.constraint, scope)
+				: null;
+			if (constraint) this.checkConstraint(typeArgs[i], constraint, expr);
 		}
+		return this.instantiateGenericFunc(fnType, typeArgs);
+	},
 
-		// Check arg count (allow variadic slack)
+	_checkArgCount(fnType, argTypes, expr) {
 		const minArgs = fnType.params.filter(
 			(_, i) => !fnType.variadic || i < fnType.params.length - 1,
 		).length;
-		if (argTypes.length < minArgs) {
+		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) {
+		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
+	_checkCallArgs(fnType, argTypes, expr) {
+		this._checkArgCount(fnType, argTypes, expr);
 		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": {
-				// Compile-time len() for fixed arrays
-				if (
-					name === "len" &&
-					argTypes[0]?.kind === "array" &&
-					argTypes[0].size != null
-				) {
-					expr._constLen = argTypes[0].size;
-				} else if (
-					name === "len" &&
-					argTypes[0]?.kind === "named" &&
-					argTypes[0].underlying?.kind === "array" &&
-					argTypes[0].underlying.size != null
-				) {
-					expr._constLen = argTypes[0].underlying.size;
-				}
-				return INT;
-			}
-			case "append": {
-				const sliceType = argTypes[0] ?? ANY;
-				if (isArray(sliceType)) {
-					this.err(`cannot append to array (type ${typeStr(sliceType)})`, expr);
-					return sliceType;
-				}
-				return sliceType;
-			}
-			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;
-			case "complex": {
-				if (expr.args.length !== 2) {
-					this.err("complex() requires exactly 2 arguments", expr);
-					return ANY;
-				}
-				const crt = argTypes[0];
-				const cit = argTypes[1];
-				if (!isNumeric(crt)) {
-					this.err(`cannot use ${typeStr(crt)} as float in complex()`, expr);
-					return ANY;
-				}
-				if (!isNumeric(cit)) {
-					this.err(`cannot use ${typeStr(cit)} as float in complex()`, expr);
-					return ANY;
-				}
-				if (crt.kind === "untyped" && cit.kind === "untyped")
-					return UNTYPED_COMPLEX;
-				return COMPLEX128;
-			}
-			case "real":
-			case "imag": {
-				if (expr.args.length !== 1) {
-					this.err(`${name}() requires exactly 1 argument`, expr);
-					return ANY;
-				}
-				const zt = argTypes[0];
-				if (!isComplex(zt)) {
-					this.err(`cannot use ${typeStr(zt)} as complex in ${name}()`, expr);
-					return ANY;
-				}
-				if (zt.kind === "untyped") return UNTYPED_FLOAT;
-				return FLOAT64;
-			}
-			default:
-				return ANY;
+		const gen = BUILTIN_CHECK[name];
+		return gen ? gen(this, name, expr, argTypes, scope) : ANY;
+	},
+
+	_constLenFromType(arg0) {
+		if (arg0?.kind === "array" && arg0.size != null) return arg0.size;
+		if (
+			arg0?.kind === "named" &&
+			arg0.underlying?.kind === "array" &&
+			arg0.underlying.size != null
+		)
+			return arg0.underlying.size;
+		return null;
+	},
+
+	_checkBuiltinLen(name, expr, argTypes) {
+		if (name === "len") {
+			const size = this._constLenFromType(argTypes[0]);
+			if (size != null) expr._constLen = size;
+		}
+		return INT;
+	},
+
+	_checkBuiltinComplex(expr, argTypes) {
+		if (expr.args.length !== 2) {
+			this.err("complex() requires exactly 2 arguments", expr);
+			return ANY;
+		}
+		const crt = argTypes[0];
+		const cit = argTypes[1];
+		if (!isNumeric(crt)) {
+			this.err(`cannot use ${typeStr(crt)} as float in complex()`, expr);
+			return ANY;
+		}
+		if (!isNumeric(cit)) {
+			this.err(`cannot use ${typeStr(cit)} as float in complex()`, expr);
+			return ANY;
+		}
+		if (crt.kind === "untyped" && cit.kind === "untyped")
+			return UNTYPED_COMPLEX;
+		return COMPLEX128;
+	},
+
+	_checkBuiltinRealImag(name, expr, argTypes) {
+		if (expr.args.length !== 1) {
+			this.err(`${name}() requires exactly 1 argument`, expr);
+			return ANY;
+		}
+		const zt = argTypes[0];
+		if (!isComplex(zt)) {
+			this.err(`cannot use ${typeStr(zt)} as complex in ${name}()`, expr);
+			return ANY;
 		}
+		if (zt.kind === "untyped") return UNTYPED_FLOAT;
+		return FLOAT64;
+	},
+
+	_inferArraySize(expr, typeNode, base) {
+		if (
+			typeNode?.kind === "ArrayType" &&
+			typeNode.inferLen &&
+			base?.kind === "array"
+		)
+			base.size = computeMaxIndex(expr.elems) + 1;
+	},
+
+	_isSliceOrArray(base) {
+		return base?.kind === "slice" || base?.kind === "array";
+	},
+
+	_checkUnknownCompositeLit(expr, scope, t) {
+		for (const elem of expr.elems) {
+			if (elem.kind === "KeyValueExpr") this.checkExpr(elem.value, scope);
+			else this.checkExpr(elem, scope);
+		}
+		return t ?? 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;
-
-		// [...]T size inference: count elements and set size
 		const typeNode = expr.typeExpr;
-		if (
-			typeNode?.kind === "ArrayType" &&
-			typeNode.inferLen &&
-			base?.kind === "array"
-		) {
-			const maxIndex = computeMaxIndex(expr.elems);
-			base.size = maxIndex + 1;
-			// If t is a named type wrapping the array, the underlying is already base
-			// If t === base, it's the same object
-		}
+		this._inferArraySize(expr, typeNode, base);
+		if (base?.kind === "struct")
+			return this._checkStructCompositeLit(expr, scope, t, base);
+		if (this._isSliceOrArray(base))
+			return this._checkSliceArrayCompositeLit(expr, scope, t, base, typeNode);
+		if (base?.kind === "map")
+			return this._checkMapCompositeLit(expr, scope, t, base);
+		return this._checkUnknownCompositeLit(expr, scope, t);
+	},
 
-		if (base?.kind === "struct") {
-			// Detect positional (unkeyed) literal: all elements must be non-KeyValueExpr
-			const hasPositional = expr.elems.some((e) => e.kind !== "KeyValueExpr");
-			const hasKeyed = expr.elems.some((e) => e.kind === "KeyValueExpr");
-			if (hasPositional && hasKeyed) {
-				this.err("mixture of field:value and value initializers", expr);
-			}
-			if (hasPositional) {
-				// Map positional elements to struct fields by declaration order
-				const fieldNames = [...(base.fields?.keys() ?? [])];
-				for (let i = 0; i < expr.elems.length; i++) {
-					const elem = expr.elems[i];
-					const fieldName = fieldNames[i];
-					if (!fieldName) {
-						this.err("too many values in struct literal", elem);
-						continue;
-					}
-					const fieldType = base.fields.get(fieldName);
-					const vt = this.checkExpr(elem, scope);
-					if (fieldType) this.assertAssignable(fieldType, vt, elem);
-					// Annotate for codegen
-					elem._positionalField = fieldName;
-				}
-				return t;
+	_checkStructPositionalElems(expr, scope, t, base) {
+		const fieldNames = [...(base.fields?.keys() ?? [])];
+		for (let i = 0; i < expr.elems.length; i++) {
+			const elem = expr.elems[i];
+			const fieldName = fieldNames[i];
+			if (!fieldName) {
+				this.err("too many values in struct literal", elem);
+				continue;
 			}
-			for (const elem of expr.elems) {
-				if (elem.kind === "KeyValueExpr") {
-					const keyName = elem.key.name;
-					const fieldType = base.fields?.get(keyName);
-					if (fieldType) {
+			const fieldType = base.fields.get(fieldName);
+			const vt = this.checkExpr(elem, scope);
+			if (fieldType) this.assertAssignable(fieldType, vt, elem);
+			elem._positionalField = fieldName;
+		}
+		return t;
+	},
+
+	_checkStructKeyedElems(expr, scope, t, base) {
+		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 {
+					const embed = base._embeds?.find(
+						(e) => (e.kind === "named" ? e.name : null) === keyName,
+					);
+					if (embed) {
 						const vt = this.checkExpr(elem.value, scope);
-						this.assertAssignable(fieldType, vt, elem.value);
+						this.assertAssignable(embed, vt, elem.value);
+						elem._isEmbedInit = true;
 					} 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);
-						}
+						this.err(`Unknown field '${keyName}'`, elem.key);
 					}
-				} else {
-					this.checkExpr(elem, scope);
 				}
+			} else {
+				this.checkExpr(elem, scope);
 			}
-			return t;
 		}
+		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 vt = this.checkExpr(elem.value, scope);
-					this.assertAssignable(base.elem, vt, elem.value);
-				} else {
-					const et = this.checkExpr(elem, scope);
-					this.assertAssignable(base.elem, et, elem);
-				}
-			}
+	_checkStructCompositeLit(expr, scope, t, base) {
+		const hasPositional = expr.elems.some((e) => e.kind !== "KeyValueExpr");
+		const hasKeyed = expr.elems.some((e) => e.kind === "KeyValueExpr");
+		if (hasPositional && hasKeyed)
+			this.err("mixture of field:value and value initializers", expr);
+		if (hasPositional)
+			return this._checkStructPositionalElems(expr, scope, t, base);
+		return this._checkStructKeyedElems(expr, scope, t, base);
+	},
 
-			// Composite literal element count validation for explicit-size arrays
-			if (base.kind === "array" && base.size != null && !typeNode?.inferLen) {
-				const maxIndex = computeMaxIndex(expr.elems);
-				if (maxIndex >= base.size) {
-					this.err(
-						`array index ${maxIndex} out of bounds [0:${base.size}]`,
-						expr,
-					);
-				}
+	_checkSliceArrayCompositeLit(expr, scope, t, base, typeNode) {
+		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 vt = this.checkExpr(elem.value, scope);
+				this.assertAssignable(base.elem, vt, elem.value);
+			} else {
+				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);
-				}
+		// Composite literal element count validation for explicit-size arrays
+		if (base.kind === "array" && base.size != null && !typeNode?.inferLen) {
+			const maxIndex = computeMaxIndex(expr.elems);
+			if (maxIndex >= base.size) {
+				this.err(
+					`array index ${maxIndex} out of bounds [0:${base.size}]`,
+					expr,
+				);
 			}
-			return t;
 		}
 
-		// Unknown type context — still check elements
+		return t;
+	},
+
+	_checkMapCompositeLit(expr, scope, t, base) {
 		for (const elem of expr.elems) {
 			if (elem.kind === "KeyValueExpr") {
-				this.checkExpr(elem.value, scope);
-			} else {
-				this.checkExpr(elem, scope);
+				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 ?? ANY;
+		return t;
 	},
 };