gofront 0.0.4 → 0.0.6

package/src/typechecker/expressions.js

@@ -3,10 +3,15 @@
 import {
 	ANY,
 	BOOL,
+	COMPLEX128,
 	ERROR,
+	FLOAT64,
 	INT,
 	isAny,
+	isArray,
 	isBool,
+	isComplex,
+	isComplexOrNumeric,
 	isNumeric,
 	isString,
 	NIL,
@@ -14,6 +19,7 @@ import {
 	STRING,
 	typeStr,
 	UNTYPED_BOOL,
+	UNTYPED_COMPLEX,
 	UNTYPED_FLOAT,
 	UNTYPED_INT,
 	UNTYPED_STRING,
@@ -45,6 +51,9 @@ 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);
@@ -60,10 +69,27 @@ export const expressionCheckMethods = {
 					return BOOL;
 				}
 				if (expr.op === "-" || expr.op === "+") {
-					if (!isNumeric(ot) && !isAny(ot))
+					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;
 			}
 
@@ -114,7 +140,26 @@ export const expressionCheckMethods = {
 				const bt = this.checkExpr(expr.expr, scope);
 				this.checkExpr(expr.index, scope);
 				if (isAny(bt)) return ANY;
-				if (bt.kind === "slice" || bt.kind === "array") return bt.elem;
+				if (bt.kind === "slice" || bt.kind === "array") {
+					// Compile-time bounds checking for arrays
+					if (bt.kind === "array" && bt.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 >= bt.size) {
+								this.err(
+									`invalid array index ${idx} (out of bounds for ${typeStr(bt)})`,
+									expr,
+								);
+							}
+						}
+					}
+					return bt.elem;
+				}
 				if (bt.kind === "map") {
 					expr._mapValueType = bt.value; // for codegen zero-value fallback
 					return bt.value;
@@ -172,8 +217,74 @@ export const expressionCheckMethods = {
 			}
 
 			case "TypeConversion": {
-				this.checkExpr(expr.expr, scope);
-				return this.resolveTypeNode(expr.targetType, 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;
+				// 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;
 			}
 
 			case "TypeAssertExpr": {
@@ -211,7 +322,7 @@ export const expressionCheckMethods = {
 					// string range: (int index, rune value) — rune is an alias for int
 					return { kind: "tuple", types: [INT, INT] };
 				}
-				if (resolved?.kind === "slice") {
+				if (resolved?.kind === "slice" || resolved?.kind === "array") {
 					return { kind: "tuple", types: [INT, resolved.elem ?? ANY] };
 				}
 				if (resolved?.kind === "map") {
@@ -224,14 +335,52 @@ export const expressionCheckMethods = {
 				return { kind: "tuple", types: [collType] };
 			}
 
+			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;
+			}
+
 			default:
 				return ANY;
 		}
 		return ANY;
 	},
 
+	_constIntValue(expr) {
+		if (expr.kind === "BasicLit" && expr.litKind === "INT")
+			return Number(expr.value);
+		if (
+			expr.kind === "UnaryExpr" &&
+			expr.op === "-" &&
+			expr.operand?.kind === "BasicLit" &&
+			expr.operand.litKind === "INT"
+		) {
+			return -Number(expr.operand.value);
+		}
+		return null;
+	},
+
 	checkCall(expr, scope) {
-		const fnType = this.checkExpr(expr.func, 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.
@@ -261,6 +410,30 @@ export const expressionCheckMethods = {
 
 		if (isAny(fnType)) return ANY;
 
+		// 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);
+		}
+
 		if (fnType.kind !== "func") {
 			return this.err(`Cannot call non-function type ${typeStr(fnType)}`, expr);
 		}
@@ -302,10 +475,32 @@ export const expressionCheckMethods = {
 	checkBuiltin(name, expr, argTypes, scope) {
 		switch (name) {
 			case "len":
-			case "cap":
+			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":
-				return argTypes[0] ?? ANY;
+			}
+			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":
@@ -334,6 +529,39 @@ export const expressionCheckMethods = {
 				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;
 		}
@@ -347,6 +575,19 @@ export const expressionCheckMethods = {
 				: 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
+		}
+
 		if (base?.kind === "struct") {
 			// Detect positional (unkeyed) literal: all elements must be non-KeyValueExpr
 			const hasPositional = expr.elems.some((e) => e.kind !== "KeyValueExpr");
@@ -404,11 +645,26 @@ export const expressionCheckMethods = {
 				if (elem.kind === "CompositeLit" && elem.typeExpr === null) {
 					const et = this.checkCompositeLit(elem, scope, base.elem);
 					elem._type = et;
-				} else if (elem.kind !== "KeyValueExpr") {
+				} 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);
 				}
 			}
+
+			// 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;
 		}
 
@@ -445,3 +701,16 @@ export const expressionCheckMethods = {
 		return t ?? ANY;
 	},
 };
+
+function computeMaxIndex(elems) {
+	let sequential = 0;
+	let maxKeyed = -1;
+	for (const e of elems) {
+		if (e.kind === "KeyValueExpr" && e.key?.value !== undefined) {
+			maxKeyed = Math.max(maxKeyed, Number(e.key.value));
+		} else {
+			sequential++;
+		}
+	}
+	return Math.max(sequential - 1, maxKeyed);
+}

package/src/typechecker/statements.js

@@ -7,6 +7,7 @@ import {
 	isAny,
 	isBool,
 	isVoid,
+	iteratorYieldParams,
 	Scope,
 } from "./types.js";
 
@@ -182,15 +183,30 @@ export const statementCheckMethods = {
 
 			case "ForStmt": {
 				const inner = new Scope(scope);
-				if (stmt.init) this.checkStmt(stmt.init, inner, returnType);
+				let iterInfo = null;
+				if (stmt.init?.rhs?.[0]?.kind === "RangeExpr") {
+					iterInfo = this._checkRangeIterStmt(stmt.init, inner, returnType);
+				}
+				if (!iterInfo && stmt.init)
+					this.checkStmt(stmt.init, inner, returnType);
 				if (stmt.cond) {
-					// for range N { } — RangeExpr as condition is valid (Go 1.22 int range)
 					if (stmt.cond.kind !== "RangeExpr") {
 						const ct = this.checkExpr(stmt.cond, inner);
 						if (!isBool(ct) && !isAny(ct))
 							this.err("For condition must be bool", stmt);
 					} else {
-						this.checkExpr(stmt.cond.expr, inner);
+						// for range expr — could be int range or 0-param iterator
+						const ct = this.checkExpr(stmt.cond.expr, inner);
+						const info = iteratorYieldParams(ct);
+						if (info) {
+							stmt.cond._isIterator = true;
+							stmt.cond._yieldParams = info.yieldParams;
+						} else if (ct?.kind === "func") {
+							this.err(
+								"cannot range over func: not an iterator function",
+								stmt,
+							);
+						}
 					}
 				}
 				if (stmt.post) this.checkStmt(stmt.post, inner, returnType);
@@ -284,4 +300,49 @@ export const statementCheckMethods = {
 				break;
 		}
 	},
+
+	_checkRangeIterStmt(initStmt, scope, _returnType) {
+		const rangeExpr = initStmt.rhs[0];
+		const iterType = this.checkExpr(rangeExpr.expr, scope);
+		const info = iteratorYieldParams(iterType);
+		if (!info) {
+			// If it's a func but not a valid iterator shape, reject it
+			const underlying =
+				iterType?.kind === "named" ? iterType.underlying : iterType;
+			if (underlying?.kind === "func") {
+				this.err("cannot range over func: not an iterator function", initStmt);
+			}
+			return null;
+		}
+
+		const lhs = initStmt.lhs;
+		if (lhs.length > info.yieldParams.length) {
+			this.err(
+				`range over iterator: too many loop variables (got ${lhs.length}, max ${info.yieldParams.length})`,
+				initStmt,
+			);
+		}
+
+		// Annotate for codegen
+		rangeExpr._isIterator = true;
+		rangeExpr._yieldParams = info.yieldParams;
+
+		// Bind loop variables to their yield param types
+		if (initStmt.kind === "DefineStmt") {
+			for (let i = 0; i < lhs.length; i++) {
+				const name = lhs[i].name ?? lhs[i];
+				if (name === "_") continue;
+				const varType = info.yieldParams[i] ?? ANY;
+				scope.defineLocal(name, varType);
+			}
+		} else {
+			// AssignStmt — just type-check the lhs expressions
+			for (const e of lhs) {
+				if (e.kind === "Ident" && e.name !== "_") {
+					this.checkExpr(e, scope);
+				}
+			}
+		}
+		return info;
+	},
 };

package/src/typechecker/types.js

@@ -47,7 +47,13 @@ export const BOOL = { kind: "basic", name: "bool" };
 export const ANY = { kind: "basic", name: "any" };
 export const VOID = { kind: "basic", name: "void" };
 export const NIL = { kind: "basic", name: "nil" };
-export const ERROR = { kind: "basic", name: "error" };
+export const ERROR = {
+	kind: "interface",
+	name: "error",
+	methods: new Map([
+		["Error", { kind: "func", params: [], returns: [STRING], async: false }],
+	]),
+};
 
 // ── Untyped constant types (Go spec §Constants) ─────────────
 // Untyped constants coerce to any compatible typed context.
@@ -56,6 +62,11 @@ export const UNTYPED_FLOAT = { kind: "untyped", base: "float64" };
 export const UNTYPED_STRING = { kind: "untyped", base: "string" };
 export const UNTYPED_BOOL = { kind: "untyped", base: "bool" };
 
+// ── Complex types ────────────────────────────────────────────
+export const COMPLEX128 = { kind: "basic", name: "complex128" };
+export const COMPLEX64 = { kind: "basic", name: "complex64" };
+export const UNTYPED_COMPLEX = { kind: "untyped", base: "complex128" };
+
 export const BASIC_TYPES = {
 	int: INT,
 	float64: FLOAT64,
@@ -64,7 +75,6 @@ export const BASIC_TYPES = {
 	any: ANY,
 	byte: INT,
 	rune: INT,
-	error: ERROR,
 	// Sized integer / float aliases — all map to int or float64 at runtime
 	uint: INT,
 	int8: INT,
@@ -77,19 +87,51 @@ export const BASIC_TYPES = {
 	uint64: INT,
 	uintptr: INT,
 	float32: FLOAT64,
+	complex64: COMPLEX64,
+	complex128: COMPLEX128,
 };
 
+export const COMPARABLE = { kind: "basic", name: "comparable" };
+
+export function isTypeParam(t) {
+	return t?.kind === "typeParam";
+}
+
+export function isGeneric(t) {
+	return t?.kind === "generic";
+}
+
 export function isNumeric(t) {
-	if (t?.kind === "untyped") return t.base === "int" || t.base === "float64";
-	return t?.kind === "basic" && (t.name === "int" || t.name === "float64");
+	if (!t) return false;
+	if (t.kind === "untyped") return t.base === "int" || t.base === "float64";
+	if (t.kind === "basic") return t.name === "int" || t.name === "float64";
+	if (t.kind === "named") return isNumeric(t.underlying);
+	return false;
+}
+export function isComplex(t) {
+	if (!t) return false;
+	if (t.kind === "basic" && (t.name === "complex128" || t.name === "complex64"))
+		return true;
+	if (t.kind === "untyped" && t.base === "complex128") return true;
+	if (t.kind === "named") return isComplex(t.underlying);
+	return false;
+}
+export function isComplexOrNumeric(t) {
+	return isNumeric(t) || isComplex(t);
 }
 export function isString(t) {
-	if (t?.kind === "untyped") return t.base === "string";
-	return t?.kind === "basic" && t.name === "string";
+	if (!t) return false;
+	if (t.kind === "untyped") return t.base === "string";
+	if (t.kind === "basic") return t.name === "string";
+	if (t.kind === "named") return isString(t.underlying);
+	return false;
 }
 export function isBool(t) {
-	if (t?.kind === "untyped") return t.base === "bool";
-	return t?.kind === "basic" && t.name === "bool";
+	if (!t) return false;
+	if (t.kind === "untyped") return t.base === "bool";
+	if (t.kind === "basic") return t.name === "bool";
+	if (t.kind === "named") return isBool(t.underlying);
+	return false;
 }
 export function isAny(t) {
 	return t?.kind === "basic" && t.name === "any";
@@ -101,7 +143,23 @@ export function isVoid(t) {
 	return t?.kind === "basic" && t.name === "void";
 }
 export function isError(t) {
-	return t?.kind === "basic" && t.name === "error";
+	if (!t) return false;
+	if (t === ERROR) return true;
+	if (t.kind === "interface" && t.name === "error") return true;
+	if (t.kind === "named" && isError(t.underlying)) return true;
+	return false;
+}
+export function isPointer(t) {
+	if (!t) return false;
+	if (t.kind === "pointer") return true;
+	if (t.kind === "named") return t.underlying?.kind === "pointer";
+	return false;
+}
+export function isArray(t) {
+	if (!t) return false;
+	if (t.kind === "array") return true;
+	if (t.kind === "named") return t.underlying?.kind === "array";
+	return false;
 }
 export function isUntyped(t) {
 	return t?.kind === "untyped";
@@ -119,6 +177,8 @@ export function defaultType(t) {
 			return STRING;
 		case "bool":
 			return BOOL;
+		case "complex128":
+			return COMPLEX128;
 		default:
 			return ANY;
 	}
@@ -135,7 +195,7 @@ export function typeStr(t) {
 		case "slice":
 			return `[]${typeStr(t.elem)}`;
 		case "array":
-			return `[${t.size}]${typeStr(t.elem)}`;
+			return `[${t.size ?? "..."}]${typeStr(t.elem)}`;
 		case "map":
 			return `map[${typeStr(t.key)}]${typeStr(t.value)}`;
 		case "struct":
@@ -152,11 +212,37 @@ export function typeStr(t) {
 			return t.name;
 		case "pointer":
 			return `*${typeStr(t.base)}`;
+		case "typeParam":
+			return t.name;
+		case "generic":
+			return t.name || `generic(${typeStr(t.underlying)})`;
 		default:
 			return "?";
 	}
 }
 
+// ── Iterator function detection (Go 1.23 range-over-func) ───
+
+/**
+ * Returns null if t is not an iterator function.
+ * Returns { yieldParams: Type[] } if it is, where yieldParams are the
+ * types the range variables will be bound to (0, 1, or 2 elements).
+ *
+ * An iterator is func(yield func(...) bool) — single param that is a
+ * func returning bool with 0-2 params.
+ */
+export function iteratorYieldParams(t) {
+	const fn = t?.kind === "named" ? t.underlying : t;
+	if (fn?.kind !== "func") return null;
+	if (fn.params.length !== 1) return null;
+	const yieldFn =
+		fn.params[0]?.kind === "named" ? fn.params[0].underlying : fn.params[0];
+	if (yieldFn?.kind !== "func") return null;
+	if (yieldFn.returns.length !== 1 || !isBool(yieldFn.returns[0])) return null;
+	if (yieldFn.params.length > 2) return null;
+	return { yieldParams: yieldFn.params };
+}
+
 // ── Scope / environment ──────────────────────────────────────
 
 export class Scope {