gofront 0.0.2 → 0.0.4

package/src/typechecker/expressions.js

@@ -0,0 +1,447 @@
+// 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);
+				// 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) && !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, ANY, expr);
+				return this.binaryResultType(expr.op, lt, rt, expr);
+			}
+
+			case "CallExpr": {
+				return this.checkCall(expr, scope);
+			}
+
+			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);
+					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 === "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
+				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") {
+					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] };
+			}
+
+			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);
+		}
+
+		// 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;
+
+		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") {
+			// 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;
+					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;
+	},
+};