gofront 0.0.2 → 0.0.3

package/src/typechecker/expressions.js

@@ -0,0 +1,359 @@
+// TypeChecker expression-checking methods — installed as a mixin on TypeChecker.prototype.
+
+import {
+	ANY,
+	BOOL,
+	ERROR,
+	INT,
+	isAny,
+	isBool,
+	isNumeric,
+	isString,
+	NIL,
+	Scope,
+	STRING,
+	typeStr,
+	UNTYPED_BOOL,
+	UNTYPED_FLOAT,
+	UNTYPED_INT,
+	UNTYPED_STRING,
+	VOID,
+} from "./types.js";
+
+export const expressionCheckMethods = {
+	checkExpr(expr, scope) {
+		const t = this._checkExpr(expr, scope);
+		expr._type = t;
+		return t;
+	},
+
+	_checkExpr(expr, scope) {
+		switch (expr.kind) {
+			case "BasicLit": {
+				switch (expr.litKind) {
+					case "INT":
+						return UNTYPED_INT;
+					case "FLOAT":
+						return UNTYPED_FLOAT;
+					case "STRING":
+						return UNTYPED_STRING;
+					case "BOOL":
+						return UNTYPED_BOOL;
+					case "NIL":
+						return NIL;
+				}
+				break;
+			}
+
+			case "Ident": {
+				const t = scope.lookup(expr.name);
+				if (!t) return this.err(`Undefined: '${expr.name}'`, expr);
+				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) && !isAny(ot))
+						this.err(`${expr.op} requires numeric`, expr);
+					return ot;
+				}
+				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);
+				return this.binaryResultType(expr.op, lt, rt, expr);
+			}
+
+			case "CallExpr": {
+				return this.checkCall(expr, scope);
+			}
+
+			case "SelectorExpr": {
+				const baseType = this.checkExpr(expr.expr, scope);
+				return this.fieldType(baseType, expr.field, expr);
+			}
+
+			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 === "map") {
+					expr._mapValueType = bt.value; // for codegen zero-value fallback
+					return bt.value;
+				}
+				if (isString(bt)) return INT; // byte
+				return this.err(`Cannot index type ${typeStr(bt)}`, expr);
+			}
+
+			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);
+			}
+
+			case "CompositeLit": {
+				return this.checkCompositeLit(expr, scope);
+			}
+
+			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,
+				);
+				return {
+					kind: "func",
+					params: paramTypes,
+					returns: [ret],
+					async: expr.async,
+				};
+			}
+
+			case "AwaitExpr": {
+				// await unwraps whatever the expression produces — no Promise type modelling
+				return this.checkExpr(expr.expr, scope);
+			}
+
+			case "TypeConversion": {
+				this.checkExpr(expr.expr, scope);
+				return this.resolveTypeNode(expr.targetType, scope);
+			}
+
+			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,
+						);
+					}
+				}
+
+				return targetType;
+			}
+
+			case "RangeExpr": {
+				// Type-check the iterated expression so its _type is annotated
+				return this.checkExpr(expr.expr, scope);
+			}
+
+			default:
+				return ANY;
+		}
+		return ANY;
+	},
+
+	checkCall(expr, scope) {
+		const 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
+				if (fnType.name === "new" && i === 0) return ANY;
+				return this.checkExpr(a, scope);
+			});
+			return this.checkBuiltin(fnType.name, expr, argTypes, scope);
+		}
+
+		const argTypes = expr.args.map((a) => this.checkExpr(a, scope));
+
+		if (isAny(fnType)) return ANY;
+
+		if (fnType.kind !== "func") {
+			return this.err(`Cannot call non-function type ${typeStr(fnType)}`, expr);
+		}
+
+		// Check arg count (allow variadic slack)
+		const minArgs = fnType.params.filter(
+			(_, i) => !fnType.variadic || i < fnType.params.length - 1,
+		).length;
+		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) {
+			this.err(
+				`Too many arguments: expected ${fnType.params.length}, got ${argTypes.length}`,
+				expr,
+			);
+		}
+
+		// Check each argument is assignable to its parameter type
+		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":
+				return INT;
+			case "append":
+				return argTypes[0] ?? ANY;
+			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;
+			default:
+				return 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;
+
+		if (base?.kind === "struct") {
+			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 {
+						// 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);
+						}
+					}
+				} else {
+					this.checkExpr(elem, scope);
+				}
+			}
+			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 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);
+				}
+			}
+			return t;
+		}
+
+		// Unknown type context — still check elements
+		for (const elem of expr.elems) {
+			if (elem.kind === "KeyValueExpr") {
+				this.checkExpr(elem.value, scope);
+			} else {
+				this.checkExpr(elem, scope);
+			}
+		}
+		return t ?? ANY;
+	},
+};

package/src/typechecker/statements.js

@@ -0,0 +1,250 @@
+// TypeChecker statement-checking methods — installed as a mixin on TypeChecker.prototype.
+
+import {
+	ANY,
+	BOOL,
+	defaultType,
+	isAny,
+	isBool,
+	isVoid,
+	Scope,
+} from "./types.js";
+
+export const statementCheckMethods = {
+	checkBlock(block, scope, returnType) {
+		for (const stmt of block.stmts) {
+			this.checkStmt(stmt, scope, returnType);
+		}
+	},
+
+	checkStmt(stmt, scope, returnType) {
+		switch (stmt.kind) {
+			case "VarDecl":
+				this.checkVarDecl(stmt, scope);
+				break;
+			case "ConstDecl":
+				this.checkConstDecl(stmt, scope);
+				break;
+			case "TypeDecl":
+				this.collectType(stmt);
+				break;
+
+			case "DefineStmt": {
+				// comma-ok type assertion: n, ok := x.(T)
+				if (
+					stmt.lhs.length === 2 &&
+					stmt.rhs.length === 1 &&
+					stmt.rhs[0].kind === "TypeAssertExpr"
+				) {
+					stmt.rhs[0]._commaOk = true;
+				}
+				const rhs = stmt.rhs.map((e) => this.checkExpr(e, scope));
+				// Flatten tuple returns
+				const rhsFlat =
+					rhs.length === 1 && rhs[0].kind === "tuple" ? rhs[0].types : rhs;
+				// comma-ok type assertion returns [assertedType, bool]
+				if (stmt.rhs[0]?._commaOk) {
+					const lhsNames = stmt.lhs.map((e) => e.name ?? e);
+					if (lhsNames[0] !== "_") scope.defineLocal(lhsNames[0], rhs[0]);
+					if (lhsNames[1] !== "_") scope.defineLocal(lhsNames[1], BOOL);
+					stmt._rhsTypes = [rhs[0], BOOL];
+					break;
+				}
+				for (let i = 0; i < stmt.lhs.length; i++) {
+					const name = stmt.lhs[i].name ?? stmt.lhs[i];
+					if (name === "_") continue;
+					// Short variable re-declaration: mark vars that already exist
+					// in the current (not parent) scope as redeclared.
+					if (scope.symbols.has(name)) {
+						stmt.lhs[i]._redecl = true;
+					}
+					scope.defineLocal(name, defaultType(rhsFlat[i]) ?? ANY);
+				}
+				// Go requires at least one new variable in :=
+				const allRedecl = stmt.lhs.every(
+					(e) => e._redecl || (e.name ?? e) === "_",
+				);
+				if (allRedecl && stmt.lhs.length > 0) {
+					this.err("no new variables on left side of :=", stmt.lhs[0]);
+				}
+				stmt._rhsTypes = rhsFlat.map((t) => defaultType(t) ?? ANY);
+				break;
+			}
+
+			case "AssignStmt": {
+				// Check for const reassignment before evaluating RHS
+				for (const lhs of stmt.lhs) {
+					if (lhs.kind === "Ident") {
+						const ownerScope = scope.lookupScope(lhs.name);
+						if (ownerScope?.isConst(lhs.name))
+							this.err(`cannot assign to const '${lhs.name}'`, lhs);
+					}
+				}
+				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));
+				for (let i = 0; i < lhsTypes.length; i++) {
+					const r = rhsFlat[i] ?? ANY;
+					if (!isAny(lhsTypes[i]) && !isAny(r)) {
+						this.assertAssignable(lhsTypes[i], r, stmt.lhs[i]);
+					}
+				}
+				break;
+			}
+
+			case "IncDecStmt":
+				this.checkExpr(stmt.expr, scope);
+				break;
+
+			case "ExprStmt":
+				this.checkExpr(stmt.expr, scope);
+				break;
+
+			case "ReturnStmt": {
+				const types = stmt.values.map((v) => this.checkExpr(v, scope));
+				stmt._types = types;
+				if (
+					!isVoid(returnType) &&
+					types.length === 0 &&
+					!returnType?._hasNamedReturns
+				) {
+					this.err("Missing return value", stmt);
+				}
+				// Check each returned value is assignable to its declared type
+				if (!isVoid(returnType) && types.length > 0) {
+					const expected =
+						returnType.kind === "tuple" ? returnType.types : [returnType];
+					for (let i = 0; i < expected.length; i++) {
+						if (types[i])
+							this.assertAssignable(
+								expected[i],
+								types[i],
+								stmt.values[i] ?? stmt,
+							);
+					}
+				}
+				break;
+			}
+
+			case "IfStmt": {
+				const inner = new Scope(scope);
+				if (stmt.init) this.checkStmt(stmt.init, inner, returnType);
+				const ct = this.checkExpr(stmt.cond, inner);
+				if (!isBool(ct) && !isAny(ct))
+					this.err("If condition must be bool", stmt);
+				const bodyScope = new Scope(inner);
+				this.checkBlock(stmt.body, bodyScope, returnType);
+				this._reportUnused(bodyScope, stmt);
+				if (stmt.elseBody) {
+					if (stmt.elseBody.kind === "Block") {
+						const elseScope = new Scope(inner);
+						this.checkBlock(stmt.elseBody, elseScope, returnType);
+						this._reportUnused(elseScope, stmt);
+					} else this.checkStmt(stmt.elseBody, inner, returnType);
+				}
+				this._reportUnused(inner, stmt);
+				break;
+			}
+
+			case "ForStmt": {
+				const inner = new Scope(scope);
+				if (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);
+					}
+				}
+				if (stmt.post) this.checkStmt(stmt.post, inner, returnType);
+				this._loopDepth++;
+				const bodyScope = new Scope(inner);
+				this.checkBlock(stmt.body, bodyScope, returnType);
+				this._reportUnused(bodyScope, stmt);
+				this._loopDepth--;
+				this._reportUnused(inner, stmt);
+				break;
+			}
+
+			case "SwitchStmt": {
+				const inner = new Scope(scope);
+				if (stmt.init) this.checkStmt(stmt.init, inner, returnType);
+				if (stmt.tag) this.checkExpr(stmt.tag, inner);
+				this._switchDepth++;
+				for (const c of stmt.cases) {
+					const caseScope = new Scope(inner);
+					if (c.list) for (const e of c.list) this.checkExpr(e, caseScope);
+					for (const s of c.stmts) this.checkStmt(s, caseScope, returnType);
+					this._reportUnused(caseScope, stmt);
+				}
+				this._switchDepth--;
+				this._reportUnused(inner, stmt);
+				break;
+			}
+
+			case "TypeSwitchStmt": {
+				const inner = new Scope(scope);
+				this.checkExpr(stmt.expr, inner);
+				this._switchDepth++;
+				this._typeSwitchDepth++;
+				for (const c of stmt.cases) {
+					const caseScope = new Scope(inner);
+					if (stmt.assign) {
+						// Bind the variable to the single case type, or any for multi/default
+						const bindType =
+							c.types?.length === 1
+								? this.resolveTypeNode(c.types[0], inner)
+								: ANY;
+						caseScope.defineLocal(stmt.assign, bindType);
+					}
+					for (const s of c.stmts) this.checkStmt(s, caseScope, returnType);
+					this._reportUnused(caseScope, stmt);
+				}
+				this._typeSwitchDepth--;
+				this._switchDepth--;
+				break;
+			}
+
+			case "DeferStmt": {
+				if (stmt.call.kind !== "CallExpr")
+					this.err("defer requires a function call", stmt.call);
+				this.checkExpr(stmt.call, scope);
+				this._deferCount++;
+				break;
+			}
+
+			case "LabeledStmt":
+				this.checkStmt(stmt.body, scope, returnType);
+				break;
+
+			case "BranchStmt": {
+				const kw = stmt.keyword;
+				if (kw === "continue" && this._loopDepth === 0)
+					this.err("continue statement outside for loop", stmt);
+				else if (
+					kw === "break" &&
+					this._loopDepth === 0 &&
+					this._switchDepth === 0
+				)
+					this.err("break statement outside for loop or switch", stmt);
+				else if (kw === "fallthrough" && this._switchDepth === 0)
+					this.err("fallthrough statement outside switch", stmt);
+				else if (kw === "fallthrough" && this._typeSwitchDepth > 0)
+					this.err("cannot fallthrough in type switch", stmt);
+				break;
+			}
+			case "Block": {
+				const blockScope = new Scope(scope);
+				this.checkBlock(stmt, blockScope, returnType);
+				this._reportUnused(blockScope, stmt);
+				break;
+			}
+			default:
+				break;
+		}
+	},
+};