gofront 1.7.0 → 1.9.0

package/src/typechecker/statements.js

@@ -15,15 +15,20 @@ const CHECK_STMT_DELEGATE = {
 	BranchStmt: "_checkBranchStmt",
 };
 
+import { exprText, operandKind } from "./operand-text.js";
 import {
 	ANY,
 	BOOL,
 	defaultType,
+	is64BitInt,
 	isAny,
 	isBool,
+	isNil,
+	isUntyped,
 	isVoid,
 	iteratorYieldParams,
 	Scope,
+	typeStr,
 } from "./types.js";
 
 /** @typedef {import('./index.js').TypeChecker} TypeChecker */
@@ -67,9 +72,9 @@ export const statementCheckMethods = {
 
 	_checkDefineCommaOkAssert(stmt, rhs, scope) {
 		if (!stmt.rhs[0]?._commaOk) return false;
-		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);
+		this._declareDefineVars(stmt, [rhs[0], BOOL], scope);
+		if (stmt.lhs.every((e) => e._redecl || (e.name ?? e) === "_"))
+			this.err("no new variables on left side of :=", stmt.lhs[0]);
 		stmt._rhsTypes = [rhs[0], BOOL];
 		return true;
 	},
@@ -79,6 +84,12 @@ export const statementCheckMethods = {
 			const name = stmt.lhs[i].name ?? stmt.lhs[i];
 			if (name === "_") continue;
 			if (scope.symbols.has(name)) stmt.lhs[i]._redecl = true;
+			if (stmt.rhs.length === stmt.lhs.length)
+				this._checkConstDefault(
+					rhsFlat[i],
+					stmt.rhs[i],
+					"variable declaration",
+				);
 			scope.defineLocal(name, defaultType(rhsFlat[i]) ?? ANY);
 		}
 	},
@@ -91,10 +102,11 @@ export const statementCheckMethods = {
 		)
 			return false;
 		const mapBaseType = this.checkExpr(stmt.rhs[0].expr, scope);
-		const resolvedBase =
-			mapBaseType?.kind === "named" ? mapBaseType.underlying : mapBaseType;
+		const resolvedBase = this._underlyingOrCore(mapBaseType, scope);
 		if (resolvedBase?.kind !== "map") return false;
-		this.checkExpr(stmt.rhs[0].index, scope);
+		const keyType = this.checkExpr(stmt.rhs[0].index, scope);
+		this.assertAssignable(resolvedBase.key, keyType, stmt.rhs[0].index);
+		this._markIfaceKey(resolvedBase, stmt.rhs[0].index, keyType);
 		stmt._commaOkMap = true;
 		stmt.rhs[0]._mapValueType = resolvedBase.value;
 		this._declareDefineVars(stmt, [resolvedBase.value, BOOL], scope);
@@ -122,7 +134,8 @@ export const statementCheckMethods = {
 		if (this._checkDefineCommaOkAssert(stmt, rhs, scope)) return;
 		if (
 			stmt.rhs[0]?.kind !== "RangeExpr" &&
-			stmt.lhs.length !== rhsFlat.length
+			stmt.lhs.length !== rhsFlat.length &&
+			!rhsFlat.some((t) => t?._tainted)
 		) {
 			const vars =
 				stmt.lhs.length === 1 ? "1 variable" : `${stmt.lhs.length} variables`;
@@ -149,10 +162,11 @@ export const statementCheckMethods = {
 		)
 			return null;
 		const mapBaseType = this.checkExpr(stmt.rhs[0].expr, scope);
-		const resolvedBase =
-			mapBaseType?.kind === "named" ? mapBaseType.underlying : mapBaseType;
+		const resolvedBase = this._underlyingOrCore(mapBaseType, scope);
 		if (resolvedBase?.kind !== "map") return null;
-		this.checkExpr(stmt.rhs[0].index, scope);
+		const keyType = this.checkExpr(stmt.rhs[0].index, scope);
+		this.assertAssignable(resolvedBase.key, keyType, stmt.rhs[0].index);
+		this._markIfaceKey(resolvedBase, stmt.rhs[0].index, keyType);
 		stmt._commaOkMap = true;
 		stmt.rhs[0]._mapValueType = resolvedBase.value;
 		return [resolvedBase.value, BOOL];
@@ -191,9 +205,25 @@ export const statementCheckMethods = {
 					this.resolveType(r),
 					stmt.rhs[i],
 				);
+			// A shift count is not converted to the left operand's type.
+			if (stmt.op === "<<=" || stmt.op === ">>=") {
+				if (r && !isAny(r)) this.checkShiftCount(r, stmt.rhs[i]);
+				continue;
+			}
+			if (
+				stmt.rhs.length === lhsTypes.length &&
+				this._checkConstOverflow(lhsTypes[i], r, stmt.rhs[i], "assignment")
+			)
+				continue;
 			if (!isAny(lhsTypes[i]) && !isAny(r)) {
 				this._skipIfaceMark = true;
-				this.assertAssignable(lhsTypes[i], r, stmt.lhs[i]);
+				this.assertAssignable(
+					lhsTypes[i],
+					r,
+					stmt.lhs[i],
+					"assignment",
+					stmt.rhs.length === lhsTypes.length ? stmt.rhs[i] : undefined,
+				);
 				this._skipIfaceMark = false;
 			}
 		}
@@ -213,7 +243,8 @@ export const statementCheckMethods = {
 			if (
 				!stmt.rhs[0]?._commaOk &&
 				stmt.rhs[0]?.kind !== "RangeExpr" &&
-				stmt.lhs.length !== rhsFlat.length
+				stmt.lhs.length !== rhsFlat.length &&
+				!rhsFlat.some((t) => t?._tainted)
 			) {
 				const vars =
 					stmt.lhs.length === 1 ? "1 variable" : `${stmt.lhs.length} variables`;
@@ -246,9 +277,34 @@ export const statementCheckMethods = {
 		if (!isVoid(returnType) && types.length > 0) {
 			const expected =
 				returnType.kind === "tuple" ? returnType.types : [returnType];
+			// `return f()` forwards every result of a multi-value call.
+			if (types.length === 1 && types[0]?.kind === "tuple") {
+				const forwarded = types[0].types;
+				if (forwarded.length !== expected.length) {
+					this.err(
+						`return count mismatch: have ${forwarded.length} values, want ${expected.length}`,
+						stmt,
+					);
+					return;
+				}
+				for (let i = 0; i < expected.length; i++) {
+					this.assertAssignable(
+						expected[i],
+						forwarded[i],
+						stmt.values[0],
+						"return statement",
+					);
+				}
+				return;
+			}
 			for (let i = 0; i < expected.length; i++) {
 				if (types[i])
-					this.assertAssignable(expected[i], types[i], stmt.values[i] ?? stmt);
+					this.assertAssignable(
+						expected[i],
+						types[i],
+						stmt.values[i] ?? stmt,
+						"return statement",
+					);
 			}
 		}
 	},
@@ -278,6 +334,8 @@ export const statementCheckMethods = {
 				this.err("For condition must be bool", stmt);
 		} else {
 			const ct = this.checkExpr(stmt.cond.expr, inner);
+			const core = ct?.kind === "typeParam" ? this._coreType(ct, inner) : null;
+			if (core) stmt.cond.expr._coreType = core;
 			const info = iteratorYieldParams(ct);
 			if (info) {
 				stmt.cond._isIterator = true;
@@ -288,7 +346,14 @@ export const statementCheckMethods = {
 		}
 	},
 
-	_checkForStmt(stmt, scope, returnType) {
+	// `checkBody(bodyScope)` checks the loop body; templ `for` loops pass one
+	// that checks their HTML nodes in place of the header's empty block.
+	_checkForStmt(
+		stmt,
+		scope,
+		returnType,
+		checkBody = (s) => this.checkBlock(stmt.body, s, returnType),
+	) {
 		const inner = new Scope(scope);
 		let iterInfo = null;
 		if (stmt.init?.rhs?.[0]?.kind === "RangeExpr") {
@@ -299,7 +364,7 @@ export const statementCheckMethods = {
 		if (stmt.post) this.checkStmt(stmt.post, inner, returnType);
 		this._loopDepth++;
 		const bodyScope = new Scope(inner);
-		this.checkBlock(stmt.body, bodyScope, returnType);
+		checkBody(bodyScope);
 		this._reportUnused(bodyScope, stmt);
 		this._loopDepth--;
 		this._reportUnused(inner, stmt);
@@ -309,10 +374,17 @@ export const statementCheckMethods = {
 		const inner = new Scope(scope);
 		if (stmt.init) this.checkStmt(stmt.init, inner, returnType);
 		if (stmt.tag) this.checkExpr(stmt.tag, inner);
+		const tagIs64 = stmt.tag && is64BitInt(stmt.tag._type);
 		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);
+			if (c.list) {
+				for (const e of c.list) {
+					this.checkExpr(e, caseScope);
+					this._checkCaseValue(stmt.tag, e);
+					if (tagIs64 && e._type?.kind === "untyped") e._is64Bit = true;
+				}
+			}
 			for (const s of c.stmts) this.checkStmt(s, caseScope, returnType);
 			this._reportUnused(caseScope, stmt);
 		}
@@ -320,6 +392,106 @@ export const statementCheckMethods = {
 		this._reportUnused(inner, stmt);
 	},
 
+	// `case e:` compares `tag == e`, so `e` must convert to the tag's type
+	// (or the other way round for typed values).
+	_checkCaseValue(tag, e) {
+		const caseType = this.resolveType(e._type);
+		if (!tag) {
+			this._checkTaglessCase(e, caseType);
+			return;
+		}
+		let tagType = this.resolveType(tag._type);
+		// `switch "foo" {` compares as the constant's default type.
+		if (isUntyped(tagType) && !isNil(tagType) && tagType.base !== "bool")
+			tagType = defaultType(tagType);
+		if (this._caseValueUnchecked(tagType, caseType)) return;
+		if (isUntyped(caseType)) {
+			if (this._isUntypedAssignable(tagType, caseType)) return;
+			this.err(
+				`cannot convert ${exprText(e)} (${operandKind(e, caseType.base, true)}) to type ${typeStr(tagType)}`,
+				e,
+			);
+			return;
+		}
+		if (
+			this._assignableQuietly(tagType, caseType) ||
+			this._assignableQuietly(caseType, tagType)
+		)
+			return;
+		this.err(
+			`invalid case ${exprText(e)} in switch on ${exprText(tag)} (mismatched types ${typeStr(caseType)} and ${typeStr(tagType)})`,
+			e,
+		);
+	},
+
+	// A tagless `switch` is `switch true`, so every case must be boolean.
+	_checkTaglessCase(e, caseType) {
+		if (!caseType || caseType._tainted || caseType.kind === "typeParam") return;
+		if (isAny(caseType) || isNil(caseType) || isBool(caseType)) return;
+		if (isUntyped(caseType) && caseType.base === "bool") return;
+		const under = this.resolveType(caseType.underlying ?? caseType);
+		if (isBool(under)) return;
+		this.err(
+			`invalid case ${exprText(e)} in switch (mismatched types ${typeStr(caseType)} and bool)`,
+			e,
+		);
+	},
+
+	// Operands whose comparison the checker cannot (or need not) judge: unknown
+	// or recovered types, `any`/interface tags, nil cases, type parameters.
+	_caseValueUnchecked(tagType, caseType) {
+		if (!tagType || !caseType || tagType._tainted || caseType._tainted)
+			return true;
+		if (isAny(tagType) || isAny(caseType) || isNil(caseType)) return true;
+		if (isUntyped(tagType) || tagType.kind === "typeParam") return true;
+		return (
+			this.resolveType(tagType.underlying ?? tagType)?.kind === "interface"
+		);
+	},
+
+	// Whether assertAssignable(target, source) reports nothing.
+	_assignableQuietly(target, source) {
+		const saved = this.errors;
+		const savedSkip = this._skipIfaceMark;
+		this.errors = [];
+		this._skipIfaceMark = true;
+		this.assertAssignable(target, source, null);
+		const ok = this.errors.length === 0;
+		this.errors = saved;
+		this._skipIfaceMark = savedSkip;
+		return ok;
+	},
+
+	// A case naming an interface (literal or declared) records the resolved
+	// type so backends test its method set.
+	_markInterfaceCaseType(t, scope) {
+		if (!t || (t.kind !== "InterfaceType" && t.kind !== "TypeName")) return;
+		if (t.kind === "TypeName" && (t.name === "nil" || t.name === "error"))
+			return;
+		const resolved = this.resolveTypeNode(t, scope);
+		const u = this.resolveType(
+			resolved?.kind === "named" ? resolved.underlying : resolved,
+		);
+		if (u?.kind === "interface") t._type = resolved;
+	},
+
+	// Records the resolved type of a composite type node used as an assertion
+	// or type-switch target (`[]int`, `map[string]any`, `*int`, `iter.Seq[int]`)
+	// so the backend can match it against the dynamic type of an interface value.
+	_markDynamicType(node, resolved) {
+		const kind = node?.kind;
+		if (
+			kind === "SliceType" ||
+			kind === "ArrayType" ||
+			kind === "MapType" ||
+			kind === "PointerType" ||
+			kind === "FuncType" ||
+			kind === "StructType" ||
+			kind === "GenericTypeName"
+		)
+			node._assertType = resolved;
+	},
+
 	_checkTypeSwitchStmt(stmt, scope, returnType) {
 		const inner = new Scope(scope);
 		this.checkExpr(stmt.expr, inner);
@@ -327,10 +499,25 @@ export const statementCheckMethods = {
 		this._typeSwitchDepth++;
 		for (const c of stmt.cases) {
 			const caseScope = new Scope(inner);
+			// Resolve instantiated generic case types so backends can tell
+			// `*Stack[int]` from `*Stack[string]`.
+			for (const t of c.types ?? []) {
+				const base = t?.kind === "PointerType" ? t.base : t;
+				if (base?.kind === "GenericTypeName") this.resolveTypeNode(t, inner);
+				this._markInterfaceCaseType(t, inner);
+				if (t && t.kind !== "TypeName" && t.kind !== "InterfaceType")
+					this._markDynamicType(t, this.resolveTypeNode(t, 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;
+				// Bind the variable to the single case type, or any for multi/default.
+				// `case nil` binds the switch expression's own type, as in Go.
+				const only = c.types?.length === 1 ? c.types[0] : null;
+				const isNilCase = only?.kind === "TypeName" && only.name === "nil";
+				const bindType = isNilCase
+					? (stmt.expr._type ?? ANY)
+					: only
+						? this.resolveTypeNode(only, 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
@@ -346,7 +533,12 @@ export const statementCheckMethods = {
 
 	_checkBranchStmt(stmt) {
 		const kw = stmt.keyword;
-		if (kw === "continue" && this._loopDepth === 0)
+		if (kw === "goto")
+			this.err(
+				"goto is not supported; restructure with labeled break/continue",
+				stmt,
+			);
+		else 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);