gofront 0.0.3 → 0.0.5

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,9 +51,14 @@ 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;
 			}
 
@@ -58,17 +69,35 @@ 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;
 			}
 
 			case "BinaryExpr": {
 				const lt = this.checkExpr(expr.left, scope);
 				const rt = this.checkExpr(expr.right, scope);
-				if (isAny(lt) || isAny(rt)) return this.binaryResultType(expr.op, ANY);
+				if (isAny(lt) || isAny(rt))
+					return this.binaryResultType(expr.op, ANY, ANY, expr);
 				return this.binaryResultType(expr.op, lt, rt, expr);
 			}
 
@@ -78,14 +107,59 @@ export const expressionCheckMethods = {
 
 			case "SelectorExpr": {
 				const baseType = this.checkExpr(expr.expr, scope);
-				return this.fieldType(baseType, expr.field, expr);
+				// Method expression: TypeName.MethodName → func(ReceiverType, ...params) ret
+				if (expr.expr._isTypeRef) {
+					let base = baseType.kind === "named" ? baseType.underlying : baseType;
+					base = this.resolveType(base);
+					if (base?.kind === "struct" && base.methods?.has(expr.field)) {
+						const methodType = base.methods.get(expr.field);
+						// 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)) {
+						expr._isMethodValue = true;
+					}
+				}
+				return ft;
 			}
 
 			case "IndexExpr": {
 				const bt = this.checkExpr(expr.expr, scope);
 				this.checkExpr(expr.index, scope);
 				if (isAny(bt)) return ANY;
-				if (bt.kind === "slice" || bt.kind === "array") return bt.elem;
+				if (bt.kind === "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;
@@ -143,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": {
@@ -170,7 +310,53 @@ export const expressionCheckMethods = {
 
 			case "RangeExpr": {
 				// Type-check the iterated expression so its _type is annotated
-				return this.checkExpr(expr.expr, scope);
+				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] };
+			}
+
+			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:
@@ -179,8 +365,22 @@ export const expressionCheckMethods = {
 		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.
@@ -193,10 +393,47 @@ export const expressionCheckMethods = {
 			return this.checkBuiltin(fnType.name, expr, argTypes, scope);
 		}
 
-		const argTypes = expr.args.map((a) => this.checkExpr(a, 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));
+		}
 
 		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);
 		}
@@ -238,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":
@@ -270,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;
 		}
@@ -283,7 +575,44 @@ 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");
+			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;
+			}
 			for (const elem of expr.elems) {
 				if (elem.kind === "KeyValueExpr") {
 					const keyName = elem.key.name;
@@ -316,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;
 		}
 
@@ -357,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";
 
@@ -72,9 +73,37 @@ export const statementCheckMethods = {
 			}
 
 			case "AssignStmt": {
+				// comma-ok map index: v, ok = m["key"]
+				// Evaluate map expr first so _type is populated, then detect the pattern.
+				if (
+					stmt.lhs.length === 2 &&
+					stmt.rhs.length === 1 &&
+					stmt.rhs[0].kind === "IndexExpr"
+				) {
+					const mapBaseType = this.checkExpr(stmt.rhs[0].expr, scope);
+					const resolvedBase =
+						mapBaseType?.kind === "named"
+							? mapBaseType.underlying
+							: mapBaseType;
+					if (resolvedBase?.kind === "map") {
+						this.checkExpr(stmt.rhs[0].index, scope);
+						stmt._commaOkMap = true;
+						// Store the map value type so codegen can emit the zero-value fallback
+						stmt.rhs[0]._mapValueType = resolvedBase.value;
+						break;
+					}
+				}
+				// comma-ok type assertion: v, ok = x.(T)
+				if (
+					stmt.lhs.length === 2 &&
+					stmt.rhs.length === 1 &&
+					stmt.rhs[0].kind === "TypeAssertExpr"
+				) {
+					stmt.rhs[0]._commaOk = true;
+				}
 				// Check for const reassignment before evaluating RHS
 				for (const lhs of stmt.lhs) {
-					if (lhs.kind === "Ident") {
+					if (lhs.kind === "Ident" && lhs.name !== "_") {
 						const ownerScope = scope.lookupScope(lhs.name);
 						if (ownerScope?.isConst(lhs.name))
 							this.err(`cannot assign to const '${lhs.name}'`, lhs);
@@ -83,8 +112,13 @@ export const statementCheckMethods = {
 				const rhs = stmt.rhs.map((e) => this.checkExpr(e, scope));
 				const rhsFlat =
 					rhs.length === 1 && rhs[0]?.kind === "tuple" ? rhs[0].types : rhs;
-				const lhsTypes = stmt.lhs.map((e) => this.checkExpr(e, scope));
+				const lhsTypes = stmt.lhs.map((e) => {
+					if (e.kind === "Ident" && e.name === "_") return ANY;
+					return this.checkExpr(e, scope);
+				});
 				for (let i = 0; i < lhsTypes.length; i++) {
+					if (stmt.lhs[i]?.kind === "Ident" && stmt.lhs[i]?.name === "_")
+						continue;
 					const r = rhsFlat[i] ?? ANY;
 					if (!isAny(lhsTypes[i]) && !isAny(r)) {
 						this.assertAssignable(lhsTypes[i], r, stmt.lhs[i]);
@@ -149,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);
@@ -200,6 +249,10 @@ export const statementCheckMethods = {
 								? this.resolveTypeNode(c.types[0], inner)
 								: ANY;
 						caseScope.defineLocal(stmt.assign, bindType);
+						// The capture variable is always considered used — it's the whole
+						// point of the switch-with-assign form. Each case body uses its own
+						// typed copy of the variable.
+						caseScope.lookup(stmt.assign);
 					}
 					for (const s of c.stmts) this.checkStmt(s, caseScope, returnType);
 					this._reportUnused(caseScope, stmt);
@@ -247,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;
+	},
 };