gofront 1.6.1 → 1.8.0

package/src/typechecker/statements.js

@@ -79,10 +79,40 @@ 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);
 		}
 	},
 
+	_checkDefineCommaOkMap(stmt, scope) {
+		if (
+			stmt.lhs.length !== 2 ||
+			stmt.rhs.length !== 1 ||
+			stmt.rhs[0].kind !== "IndexExpr"
+		)
+			return false;
+		const mapBaseType = this.checkExpr(stmt.rhs[0].expr, scope);
+		const resolvedBase =
+			mapBaseType?.kind === "named" ? mapBaseType.underlying : mapBaseType;
+		if (resolvedBase?.kind !== "map") return false;
+		const keyType = this.checkExpr(stmt.rhs[0].index, scope);
+		this._markIfaceKey(resolvedBase, stmt.rhs[0].index, keyType);
+		stmt._commaOkMap = true;
+		stmt.rhs[0]._mapValueType = resolvedBase.value;
+		this._declareDefineVars(stmt, [resolvedBase.value, BOOL], scope);
+		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 = [resolvedBase.value, BOOL];
+		return true;
+	},
+
 	_checkDefineStmt(stmt, scope) {
 		// comma-ok type assertion: n, ok := x.(T)
 		if (
@@ -92,10 +122,24 @@ export const statementCheckMethods = {
 		) {
 			stmt.rhs[0]._commaOk = true;
 		}
+		if (this._checkDefineCommaOkMap(stmt, scope)) return;
 		const rhs = stmt.rhs.map((e) => this.checkExpr(e, scope));
-		const rhsFlat =
-			rhs.length === 1 && rhs[0].kind === "tuple" ? rhs[0].types : rhs;
+		const isTuple = rhs.length === 1 && rhs[0]?.kind === "tuple";
+		const rhsFlat = isTuple ? rhs[0].types : rhs;
 		if (this._checkDefineCommaOkAssert(stmt, rhs, scope)) return;
+		if (
+			stmt.rhs[0]?.kind !== "RangeExpr" &&
+			stmt.lhs.length !== rhsFlat.length
+		) {
+			const vars =
+				stmt.lhs.length === 1 ? "1 variable" : `${stmt.lhs.length} variables`;
+			const vals = isTuple
+				? `returns ${rhsFlat.length} values`
+				: rhsFlat.length === 1
+					? "1 value"
+					: `${rhsFlat.length} values`;
+			this.err(`assignment mismatch: ${vars} but ${vals}`, stmt);
+		}
 		this._declareDefineVars(stmt, rhsFlat, scope);
 		const allRedecl = stmt.lhs.every((e) => e._redecl || (e.name ?? e) === "_");
 		if (allRedecl && stmt.lhs.length > 0) {
@@ -110,15 +154,16 @@ export const statementCheckMethods = {
 			stmt.rhs.length !== 1 ||
 			stmt.rhs[0].kind !== "IndexExpr"
 		)
-			return false;
+			return null;
 		const mapBaseType = this.checkExpr(stmt.rhs[0].expr, scope);
 		const resolvedBase =
 			mapBaseType?.kind === "named" ? mapBaseType.underlying : mapBaseType;
-		if (resolvedBase?.kind !== "map") return false;
-		this.checkExpr(stmt.rhs[0].index, scope);
+		if (resolvedBase?.kind !== "map") return null;
+		const keyType = this.checkExpr(stmt.rhs[0].index, scope);
+		this._markIfaceKey(resolvedBase, stmt.rhs[0].index, keyType);
 		stmt._commaOkMap = true;
 		stmt.rhs[0]._mapValueType = resolvedBase.value;
-		return true;
+		return [resolvedBase.value, BOOL];
 	},
 
 	_checkConstAssignment(stmt, scope) {
@@ -154,6 +199,16 @@ 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]);
@@ -163,12 +218,34 @@ export const statementCheckMethods = {
 	},
 
 	_checkAssignStmt(stmt, scope) {
-		if (this._checkAssignCommaOkMap(stmt, scope)) return;
+		const commaOkMapTypes = this._checkAssignCommaOkMap(stmt, scope);
 		if (this._isCommaOkTypeAssertAssign(stmt)) stmt.rhs[0]._commaOk = true;
 		this._checkConstAssignment(stmt, scope);
-		const rhs = stmt.rhs.map((e) => this.checkExpr(e, scope));
-		const rhsFlat =
-			rhs.length === 1 && rhs[0]?.kind === "tuple" ? rhs[0].types : rhs;
+		let rhsFlat;
+		if (commaOkMapTypes) {
+			rhsFlat = commaOkMapTypes;
+		} else {
+			const rhs = stmt.rhs.map((e) => this.checkExpr(e, scope));
+			const isTuple = rhs.length === 1 && rhs[0]?.kind === "tuple";
+			rhsFlat = isTuple ? rhs[0].types : rhs;
+			if (
+				!stmt.rhs[0]?._commaOk &&
+				stmt.rhs[0]?.kind !== "RangeExpr" &&
+				stmt.lhs.length !== rhsFlat.length
+			) {
+				const vars =
+					stmt.lhs.length === 1 ? "1 variable" : `${stmt.lhs.length} variables`;
+				const vals = isTuple
+					? `returns ${rhsFlat.length} values`
+					: rhsFlat.length === 1
+						? "1 value"
+						: `${rhsFlat.length} values`;
+				this.err(`assignment mismatch: ${vars} but ${vals}`, stmt);
+			}
+			if (stmt.rhs[0]?._commaOk) {
+				rhsFlat = [rhs[0], BOOL];
+			}
+		}
 		const lhsTypes = stmt.lhs.map((e) => this._checkAssignLhsType(e, scope));
 		this._checkAssignTypes(stmt, rhsFlat, lhsTypes);
 	},
@@ -187,9 +264,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",
+					);
 			}
 		}
 	},
@@ -229,7 +331,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") {
@@ -240,7 +349,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);
@@ -261,6 +370,19 @@ export const statementCheckMethods = {
 		this._reportUnused(inner, stmt);
 	},
 
+	// 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;
+	},
+
 	_checkTypeSwitchStmt(stmt, scope, returnType) {
 		const inner = new Scope(scope);
 		this.checkExpr(stmt.expr, inner);
@@ -268,10 +390,23 @@ 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 (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
@@ -287,7 +422,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);