gofront 0.0.2 → 0.0.4

package/src/typechecker/statements.js

@@ -0,0 +1,287 @@
+// 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": {
+				// 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" && lhs.name !== "_") {
+						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) => {
+					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]);
+					}
+				}
+				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);
+						// 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);
+				}
+				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;
+		}
+	},
+};

package/src/typechecker/types.js

@@ -0,0 +1,208 @@
+// GoFront type system — shared type constants, predicates, and utilities
+// used across the type-checker sub-modules.
+//
+// Type representation:
+//   { kind: 'basic',     name: 'int'|'float64'|'string'|'bool'|'any'|'void' }
+//   { kind: 'slice',     elem: Type }
+//   { kind: 'array',     size: n, elem: Type }
+//   { kind: 'map',       key: Type, value: Type }
+//   { kind: 'struct',    name: string, fields: Map<string, Type>, methods: Map<string, FuncType> }
+//   { kind: 'interface', name: string, methods: Map<string, FuncType> }
+//   { kind: 'func',      params: Type[], returns: Type[]  }
+//   { kind: 'tuple',     types: Type[] }   ← multiple return values
+//   { kind: 'named',     name: string, underlying: Type }
+
+export class TypeCheckError extends Error {
+	constructor(msg, node, filename, sourceCode) {
+		const lineNum = node?.line || node?._line;
+		const loc = filename
+			? lineNum
+				? ` in ${filename} at line ${lineNum}`
+				: ` in ${filename}`
+			: lineNum
+				? ` at line ${lineNum}`
+				: "";
+		let lineContext = "";
+		if (lineNum && sourceCode) {
+			const lines = sourceCode.split("\n");
+			const lineStr = lines[lineNum - 1];
+			if (lineStr !== undefined) {
+				lineContext = `\n  ${lineNum} | ${lineStr}`;
+			}
+		}
+		super(`Type error${loc}: ${msg}${lineContext}`);
+	}
+}
+
+// ── Static operator sets (module-level for reuse) ────────────
+export const CMP_OPS = new Set(["==", "!=", "<", ">", "<=", ">="]);
+export const LOG_OPS = new Set(["&&", "||"]);
+
+// ── Built-in types ───────────────────────────────────────────
+
+export const INT = { kind: "basic", name: "int" };
+export const FLOAT64 = { kind: "basic", name: "float64" };
+export const STRING = { kind: "basic", name: "string" };
+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" };
+
+// ── Untyped constant types (Go spec §Constants) ─────────────
+// Untyped constants coerce to any compatible typed context.
+export const UNTYPED_INT = { kind: "untyped", base: "int" };
+export const UNTYPED_FLOAT = { kind: "untyped", base: "float64" };
+export const UNTYPED_STRING = { kind: "untyped", base: "string" };
+export const UNTYPED_BOOL = { kind: "untyped", base: "bool" };
+
+export const BASIC_TYPES = {
+	int: INT,
+	float64: FLOAT64,
+	string: STRING,
+	bool: BOOL,
+	any: ANY,
+	byte: INT,
+	rune: INT,
+	error: ERROR,
+	// Sized integer / float aliases — all map to int or float64 at runtime
+	uint: INT,
+	int8: INT,
+	int16: INT,
+	int32: INT,
+	int64: INT,
+	uint8: INT,
+	uint16: INT,
+	uint32: INT,
+	uint64: INT,
+	uintptr: INT,
+	float32: FLOAT64,
+};
+
+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");
+}
+export function isString(t) {
+	if (t?.kind === "untyped") return t.base === "string";
+	return t?.kind === "basic" && t.name === "string";
+}
+export function isBool(t) {
+	if (t?.kind === "untyped") return t.base === "bool";
+	return t?.kind === "basic" && t.name === "bool";
+}
+export function isAny(t) {
+	return t?.kind === "basic" && t.name === "any";
+}
+export function isNil(t) {
+	return t?.kind === "basic" && t.name === "nil";
+}
+export function isVoid(t) {
+	return t?.kind === "basic" && t.name === "void";
+}
+export function isError(t) {
+	return t?.kind === "basic" && t.name === "error";
+}
+export function isUntyped(t) {
+	return t?.kind === "untyped";
+}
+
+/** Materialize an untyped type to its default concrete type. */
+export function defaultType(t) {
+	if (t?.kind !== "untyped") return t;
+	switch (t.base) {
+		case "int":
+			return INT;
+		case "float64":
+			return FLOAT64;
+		case "string":
+			return STRING;
+		case "bool":
+			return BOOL;
+		default:
+			return ANY;
+	}
+}
+
+export function typeStr(t) {
+	if (!t) return "void";
+	if (t.kind === "basic" && t.alias) return t.alias;
+	switch (t.kind) {
+		case "basic":
+			return t.name;
+		case "untyped":
+			return `untyped ${t.base}`;
+		case "slice":
+			return `[]${typeStr(t.elem)}`;
+		case "array":
+			return `[${t.size}]${typeStr(t.elem)}`;
+		case "map":
+			return `map[${typeStr(t.key)}]${typeStr(t.value)}`;
+		case "struct":
+			return t.name || "struct{...}";
+		case "interface":
+			return t.name || "interface{...}";
+		case "namespace":
+			return t.name || "namespace{...}";
+		case "func":
+			return `func(${t.params.map(typeStr).join(", ")}) ${typeStr(t.returns[0] ?? VOID)}`;
+		case "tuple":
+			return `(${t.types.map(typeStr).join(", ")})`;
+		case "named":
+			return t.name;
+		case "pointer":
+			return `*${typeStr(t.base)}`;
+		default:
+			return "?";
+	}
+}
+
+// ── Scope / environment ──────────────────────────────────────
+
+export class Scope {
+	constructor(parent = null) {
+		this.parent = parent;
+		this.symbols = new Map();
+		this._consts = new Set(); // names declared as const in this scope
+		this._locals = new Set(); // names declared as local variables (var / :=)
+		this._used = new Set(); // names referenced in this scope
+	}
+	define(name, type) {
+		this.symbols.set(name, type);
+	}
+	defineLocal(name, type) {
+		this.symbols.set(name, type);
+		if (name !== "_") this._locals.add(name);
+	}
+	defineConst(name, type) {
+		this.symbols.set(name, type);
+		this._consts.add(name);
+	}
+	isConst(name) {
+		if (this._consts.has(name)) return true;
+		// Don't walk parent — shadowing a const with a var in a child scope is valid
+		return false;
+	}
+	lookup(name) {
+		if (this.symbols.has(name)) {
+			this._used.add(name);
+			return this.symbols.get(name);
+		}
+		if (this.parent) return this.parent.lookup(name);
+		return null;
+	}
+	// Lookup which scope owns the name (to check const flag)
+	lookupScope(name) {
+		if (this.symbols.has(name)) return this;
+		if (this.parent) return this.parent.lookupScope(name);
+		return null;
+	}
+	// Returns local variable names that were never referenced
+	unusedLocals() {
+		const unused = [];
+		for (const name of this._locals) {
+			if (!this._used.has(name)) unused.push(name);
+		}
+		return unused;
+	}
+}