gofront 1.9.0 → 1.9.1

package/src/lower/json-codecs.js

@@ -220,6 +220,8 @@ export class JsonCodecGen extends TypeSpeller {
 				return `map[${this.refl(t.key)}]${this.refl(t.value)}`;
 			case "interface":
 				return t.name === "error" ? "error" : "interface {}";
+			case "namespace":
+				return t.name;
 			case "func":
 				return this.funcString(t, (x) => this.refl(x));
 			default:
@@ -273,9 +275,49 @@ export class JsonCodecGen extends TypeSpeller {
 
 	// Statements that encode the Go expression `x` of type `t`.
 	encValue(t, x, addr) {
+		if (holdsInterop(t)) return this.encInterop(t, x);
 		return [`${this.encFn(t, addr)}(e, ${x})`];
 	}
 
+	// A JS-interop value has no Go source to spell, so it is encoded where it
+	// sits: nil is `null` (an empty slice, map or array is `[]` or `{}`), and
+	// anything else fails with the type's name.
+	encInterop(t, x) {
+		const u = under(t);
+		const fail = (name) => `\te.FailType(${q(name)})`;
+		if (u.kind === "namespace")
+			return [`if ${x} == nil {`, "\te.Null()", "} else {", fail(u.name), "}"];
+		if (u.kind === "pointer")
+			return [
+				`if ${x} == nil {`,
+				"\te.Null()",
+				"} else {",
+				fail(this.refl(t)),
+				"}",
+			];
+		const [empty, elem] =
+			u.kind === "map"
+				? ["{}", holdsInterop(u.key) ? u.key : u.value]
+				: ["[]", u.elem];
+		if (u.kind === "array")
+			return [
+				`if ${u.size} == 0 {`,
+				`\te.Lit(${q(empty)})`,
+				"} else {",
+				fail(this.refl(elem)),
+				"}",
+			];
+		return [
+			`if ${x} == nil {`,
+			"\te.Null()",
+			`} else if len(${x}) == 0 {`,
+			`\te.Lit(${q(empty)})`,
+			"} else {",
+			fail(this.refl(elem)),
+			"}",
+		];
+	}
+
 	// `mt` is the type that declares the method (the pointee for a pointer).
 	marshalCall(x, t, mt = t) {
 		if (!marshalerOf(mt) && textMarshalerOf(mt))
@@ -413,6 +455,7 @@ export class JsonCodecGen extends TypeSpeller {
 		if (u.kind === "slice" || u.kind === "map") return `len(${x}) == 0`;
 		if (u.kind === "array") return u.size === 0 ? "true" : "false";
 		if (u.kind === "struct") return "false";
+		if (u.kind === "namespace") return `${x} == nil`;
 		const n = unalias(u.name);
 		if (n === "bool") return `!${x}`;
 		if (n === "string") return `${x} == ""`;
@@ -779,6 +822,9 @@ export class JsonCodecGen extends TypeSpeller {
 
 	decStruct(u, t, typ) {
 		const fields = resolveJsonFields(u);
+		for (const f of fields)
+			if (holdsInterop(f.type))
+				throw new Error(`json: cannot unmarshal into ${interopName(f.type)}`);
 		const sname = this.shortName(t);
 		const lines = [
 			"if d.Null() {",
@@ -1106,7 +1152,8 @@ export class JsonCodecGen extends TypeSpeller {
 			this.encFn(t, false);
 		}
 		for (const { type: t, via } of this.collectedTypes()) {
-			if (via !== "declared" || mentionsTypeParam(t)) continue;
+			if (via !== "boxed" || !t || mentionsTypeParam(t)) continue;
+			if (!this.spellable(t)) continue;
 			const u = under(t);
 			if (!u || u.kind === "interface" || u.kind === "func") continue;
 			this.encFn(t, false);
@@ -1114,12 +1161,15 @@ export class JsonCodecGen extends TypeSpeller {
 		}
 	}
 
+	// A struct holding a JS-interop value (a `.d.ts` interface) cannot be
+	// written as a dynamic case, so it is not spellable either.
 	spellableNamed(t, ok) {
+		if (isJsonValue(t)) return true;
 		return (
-			isJsonValue(t) ||
-			(!t.name.includes("$$") &&
-				!t.name.includes("[") &&
-				(t.typeArgs ?? []).every(ok))
+			!t.name.includes("$$") &&
+			!t.name.includes("[") &&
+			(t.typeArgs ?? []).every(ok) &&
+			!reachesInterop(t)
 		);
 	}
 
@@ -1157,7 +1207,12 @@ export class JsonCodecGen extends TypeSpeller {
 			}
 			// Slices, arrays and maps reach an interface from any expression
 			// (a function result, a variable), not only from a literal
-			if (!buildsValue(node) && !isCompositeType(t) && !isJsonValue(t))
+			if (
+				!buildsValue(node) &&
+				!isCompositeType(t) &&
+				!isFuncComposite(t) &&
+				!isJsonValue(t)
+			)
 				continue;
 			if (this.spellable(t) && under(t)?.kind !== "interface")
 				found.set(this.key(t), t);
@@ -1196,6 +1251,48 @@ const isTaggedSlice = (t) =>
 
 // json.RawMessage and json.Number values can reach an interface from any
 // expression (a conversion, a field read).
+// True when `t` is, or holds through pointers, elements and struct fields, a
+// JS-interop type (a `.d.ts` interface) that has no Go source to spell.
+export function reachesInterop(t, seen = new Set(), viaStruct = true) {
+	if (!t || seen.has(t)) return false;
+	seen.add(t);
+	const u = under(t) ?? t;
+	switch (u.kind) {
+		case "namespace":
+			return true;
+		case "pointer":
+			return reachesInterop(u.base, seen, viaStruct);
+		case "slice":
+		case "array":
+			return reachesInterop(u.elem, seen, viaStruct);
+		case "map":
+			return (
+				reachesInterop(u.key, seen, viaStruct) ||
+				reachesInterop(u.value, seen, viaStruct)
+			);
+		case "struct":
+			return (
+				viaStruct &&
+				(u._structFields ?? []).some((f) => reachesInterop(f.type, seen))
+			);
+		default:
+			return false;
+	}
+}
+
+// True when a value of type `t` is, or holds through pointers and elements
+// (not through a named struct, which has its own codec), a JS-interop value.
+const holdsInterop = (t) => reachesInterop(t, new Set(), false);
+
+// The name of the JS-interop type that `t` is or wraps.
+function interopName(t) {
+	const u = under(t);
+	if (u.kind === "namespace") return u.name;
+	if (u.kind === "map")
+		return interopName(holdsInterop(u.key) ? u.key : u.value);
+	return interopName(u.base ?? u.elem);
+}
+
 const isJsonValue = (t) => isRaw(t) || isNumber(t);
 
 export const isCompositeType = (t) => {
@@ -1207,6 +1304,17 @@ export const isCompositeType = (t) => {
 	);
 };
 
+// A slice, array or map holding funcs: it never encodes, but a nil one in an
+// interface still does, as `null`, and a non-nil one names the func.
+export const isFuncComposite = (t) => {
+	const k = under(t)?.kind;
+	return (
+		(k === "slice" || k === "array" || k === "map") &&
+		holdsFunc(t) &&
+		!hasSharedRepr(t)
+	);
+};
+
 // Func values are not JSON-encodable, and `case []func():` does not parse.
 export function holdsFunc(t, depth = 0) {
 	if (!t || depth > 8) return false;

package/src/parser/declarations.js

@@ -227,12 +227,14 @@ export const declarationParseMethods = {
 			this.check(T.EOF)
 		)
 			return null;
-		// Inside a type expression (e.g. func type in a tuple or a type-switch
-		// `case func():`), `,`, `)` and `:` also end the type
+		// Inside a type expression (e.g. func type in a tuple, a type-switch
+		// `case func():` or a type argument `f[func(int)]`), `,`, `)`, `]` and
+		// `:` also end the type
 		if (
 			inTypeExpr &&
 			(this.check(T.COMMA) ||
 				this.check(T.RPAREN) ||
+				this.check(T.RBRACKET) ||
 				this.check(T.COLON) ||
 				this.check(T.STRING) ||
 				this.check(T.ASSIGN))

package/src/parser/expressions.js

@@ -402,48 +402,20 @@ export const expressionParserMethods = {
 		return { kind: "CallExpr", func: fn, args };
 	},
 
-	// Returns true if the current position looks like a composite literal argument,
-	// e.g. []int{1,2,3} or map[string]int{"a":1}.  We scan ahead past the type
-	// tokens to check whether a { follows, without advancing this.pos permanently.
+	// Returns true if the current position starts a composite literal argument,
+	// e.g. []int{1,2,3}, map[string]int{"a":1} or []func() int{f}: the type is
+	// parsed speculatively and must be followed by `{`.  The position is
+	// always restored.
 	looksLikeCompositeLitArg() {
-		let i = this.pos;
-		const src = this.tokens;
-		// Skip over the type tokens: [, ], map, [, K, ], V, ident, etc.
-		// Simple approach: skip until we hit something that can't be part of a type
-		let depth = 0;
-		while (i < src.length) {
-			const tt = src[i].type;
-			if (tt === T.LBRACKET) {
-				depth++;
-				i++;
-				continue;
-			}
-			if (tt === T.RBRACKET) {
-				depth--;
-				i++;
-				continue;
-			}
-			if (depth > 0) {
-				i++;
-				continue;
-			}
-			if (
-				tt === T.MAP ||
-				tt === T.IDENT ||
-				tt === T.DOT || // qualified types: []pkg.Type{...}
-				tt === T.STAR ||
-				tt === T.INT ||
-				tt === T.FLOAT ||
-				tt === T.STRING
-			) {
-				i++;
-				continue;
-			}
-			break;
+		const start = this.pos;
+		try {
+			this.parseType();
+			return this.check(T.LBRACE);
+		} catch {
+			return false;
+		} finally {
+			this.pos = start;
 		}
-		// Skip whitespace tokens (shouldn't exist post-lex, but be safe)
-		while (i < src.length && src[i].type === T.SEMICOLON) i++;
-		return i < src.length && src[i].type === T.LBRACE;
 	},
 
 	parseCompositeLit(typeExpr) {
@@ -494,7 +466,9 @@ export const expressionParserMethods = {
 		// Literals
 		if (t.type === T.INT) {
 			this.advance();
-			return { kind: "BasicLit", litKind: "INT", value: t.value };
+			const lit = { kind: "BasicLit", litKind: "INT", value: t.value };
+			if (t.rune) lit.rune = true;
+			return lit;
 		}
 		if (t.type === T.FLOAT) {
 			this.advance();
@@ -589,6 +563,16 @@ export const expressionParserMethods = {
 			return this.parseCompositeLit(typeExpr);
 		}
 
+		// Interface conversion: interface{ M() }(v).  `interface{…}{` is not a
+		// composite literal in Go, so only the conversion form is accepted.
+		if (t.type === T.INTERFACE) {
+			const targetType = this.parseInterfaceType();
+			this.expect(T.LPAREN);
+			const expr = this.parseExpr();
+			this.expect(T.RPAREN);
+			return { kind: "TypeConversion", targetType, expr };
+		}
+
 		if (t.type === T.CHAN) {
 			this.err("channels are not supported in GoFront");
 		}

package/src/parser/statements.js

@@ -2,6 +2,57 @@
 
 import { T } from "../lexer/tokens.js";
 
+// Statement keywords: none of them can appear inside a composite literal or a
+// statement header's expressions.
+const STMT_KEYWORDS = new Set([
+	T.VAR,
+	T.CONST,
+	T.TYPE,
+	T.IF,
+	T.ELSE,
+	T.FOR,
+	T.RETURN,
+	T.BREAK,
+	T.CONTINUE,
+	T.SWITCH,
+	T.CASE,
+	T.DEFAULT,
+	T.SELECT,
+	T.DEFER,
+	T.GO,
+	T.FALLTHROUGH,
+]);
+
+// Tokens that only appear in statements: a brace pair holding one at its top
+// level is a block, not a composite literal.
+const STMT_ONLY_TOKENS = new Set([
+	...STMT_KEYWORDS,
+	T.SEMICOLON,
+	T.ASSIGN,
+	T.DEFINE,
+	T.PLUS_ASSIGN,
+	T.MINUS_ASSIGN,
+	T.STAR_ASSIGN,
+	T.SLASH_ASSIGN,
+	T.PERCENT_ASSIGN,
+	T.AMP_ASSIGN,
+	T.PIPE_ASSIGN,
+	T.AND_NOT_ASSIGN,
+	T.CARET_ASSIGN,
+	T.LSHIFT_ASSIGN,
+	T.RSHIFT_ASSIGN,
+	T.INC,
+	T.DEC,
+]);
+
+const OPEN_BRACKETS = new Set([T.LBRACE, T.LPAREN, T.LBRACKET]);
+const CLOSE_BRACKETS = new Set([T.RBRACE, T.RPAREN, T.RBRACKET]);
+
+function bracketDelta(tt) {
+	if (OPEN_BRACKETS.has(tt)) return 1;
+	return CLOSE_BRACKETS.has(tt) ? -1 : 0;
+}
+
 // Method-name dispatch for pure-delegation cases in _parseStmt.
 const PARSE_STMT_DELEGATE = {
 	[T.VAR]: "parseVarDecl",
@@ -130,6 +181,7 @@ export const statementParserMethods = {
 		let cond;
 		// if init; cond { } — use noCompLit to avoid "{" being parsed as composite literal
 		const first = this.parseSimpleStmtRaw(true);
+		this._rejectHeaderCompositeLit("if", 0, first);
 		// Only treat as "init; cond" if semicolon is followed by a non-brace token
 		if (this.check(T.SEMICOLON) && this.peek2().type !== T.LBRACE) {
 			this.advance(); // consume ;
@@ -166,6 +218,7 @@ export const statementParserMethods = {
 		let first = null;
 		if (!this.check(T.SEMICOLON)) {
 			first = this.parseSimpleStmtRaw(true);
+			this._rejectHeaderCompositeLit("for", 1, first);
 
 			if (this.check(T.LBRACE)) {
 				// for k, v := range expr { }  — range stmt ends right before {
@@ -201,6 +254,59 @@ export const statementParserMethods = {
 		return { kind: "ForStmt", init: first, cond, post, body };
 	},
 
+	// `if s := &T{f: 1}; s.f > 0 {`: in a header, `{` after a type name opens
+	// the body, so Go requires the literal to be parenthesized.  Reported when
+	// the brace pair holds no statement tokens, is followed by an explicit `;`,
+	// and the header then continues to its body `{` (with at most `semis`
+	// further `;`, one for a `for` post statement).  A bare expression or a
+	// range clause before the `{` (`if ok { f() };`) means it is the body.
+	_rejectHeaderCompositeLit(keyword, semis, first) {
+		if (!this.check(T.LBRACE)) return;
+		if (first?.kind === "ExprStmt" || this.isRangeStmt(first)) return;
+		const prev = this.tokens[this.pos - 1]?.type;
+		if (prev !== T.IDENT && prev !== T.RBRACKET) return;
+		const close = this._closingBrace(this.pos);
+		if (close < 0) return;
+		const semi = this.tokens[close + 1];
+		if (semi?.type !== T.SEMICOLON || !this._isExplicitSemi(semi)) return;
+		if (!this._headerContinues(close + 2, semis)) return;
+		this.err(`composite literal in ${keyword} header must be parenthesized`);
+	},
+
+	// Index of the `}` matching the `{` at `open`, or -1 when the pair holds a
+	// statement-only token at its top level (then it is a block).
+	_closingBrace(open) {
+		let depth = 0;
+		for (let i = open; i < this.tokens.length; i++) {
+			const tt = this.tokens[i].type;
+			depth += bracketDelta(tt);
+			if (depth === 0) return tt === T.RBRACE ? i : -1;
+			if (tt === T.EOF || (depth === 1 && STMT_ONLY_TOKENS.has(tt))) return -1;
+		}
+		return -1;
+	},
+
+	_isExplicitSemi(tok) {
+		if (!this.source) return false;
+		this._sourceLines ??= this.source.split("\n");
+		return this._sourceLines[tok.line - 1]?.[tok.col - 1] === ";";
+	},
+
+	// Whether the tokens from `i` reach a top-level `{` (the body) without a
+	// statement keyword and with at most `semis` semicolons on the way.
+	_headerContinues(i, semis) {
+		let depth = 0;
+		for (; i < this.tokens.length; i++) {
+			const tt = this.tokens[i].type;
+			if (tt === T.LBRACE && depth === 0) return true;
+			depth += bracketDelta(tt);
+			if (tt === T.SEMICOLON && depth === 0) semis--;
+			if (depth < 0 || semis < 0) return false;
+			if (tt === T.EOF || STMT_KEYWORDS.has(tt)) return false;
+		}
+		return false;
+	},
+
 	isRangeStmt(stmt) {
 		if (!stmt) return false;
 		if (stmt.kind !== "DefineStmt" && stmt.kind !== "AssignStmt") return false;
@@ -213,6 +319,7 @@ export const statementParserMethods = {
 		let tag = null;
 		if (!this.check(T.LBRACE)) {
 			const first = this.parseSimpleStmtRaw(true);
+			this._rejectHeaderCompositeLit("switch", 0, first);
 			if (this.match(T.SEMICOLON)) {
 				init = first;
 				if (!this.check(T.LBRACE))

package/src/parser/types.js

@@ -329,6 +329,17 @@ export const typeParserMethods = {
 				this.semi();
 				continue;
 			}
+			// Type-set element that is not a bare name: *T, []int, map[K]V, ...
+			if (!this.check(T.IDENT)) {
+				const terms = [{ approx: false, type: this.parseType() }];
+				while (this.match(T.PIPE)) {
+					const approx = this.match(T.TILDE);
+					terms.push({ approx, type: this.parseType() });
+				}
+				unionConstraint = { kind: "UnionConstraint", terms };
+				this.semi();
+				continue;
+			}
 			const name = this.expect(T.IDENT).value;
 			if (this.check(T.LPAREN)) {
 				// Method signature: Name(params) returnType

package/src/typechecker/assignability.js

@@ -12,6 +12,7 @@ import {
 	FLOAT64,
 	is64BitInt,
 	isAny,
+	isBool,
 	isComplex,
 	isComplex64,
 	isComplexOrNumeric,
@@ -27,9 +28,11 @@ import {
 	SIZED_INT_NAMES,
 	STRING,
 	typeStr,
+	UNTYPED_BOOL,
 	UNTYPED_COMPLEX,
 	UNTYPED_FLOAT,
 	UNTYPED_INT,
+	UNTYPED_RUNE,
 } from "./types.js";
 
 // Unnamed type literal kinds for Go's "identical underlying types" assignability rule.
@@ -63,6 +66,23 @@ const UNTYPED_COMPAT = {
 	complex128: new Set(["complex128", "complex64"]),
 };
 
+// `&&` and `||` of two untyped bools stay untyped; a typed operand (including
+// a defined bool type) gives its type, as in Go.
+// Two typed operands must have the same type, and the result has it.
+function logicalResultType(lt, rt) {
+	if (lt?.kind === "untyped" && rt?.kind === "untyped") return UNTYPED_BOOL;
+	if (rt?.kind === "untyped" && isBool(lt)) return lt;
+	if (lt?.kind === "untyped" && isBool(rt)) return rt;
+	if (isBool(lt) && isBool(rt) && typeStr(lt) === typeStr(rt)) return lt;
+	return BOOL;
+}
+
+// Two untyped numeric operands combine to the later of int, rune, float.
+function untypedIntegerKind(isFloat, lt, rt) {
+	if (isFloat) return UNTYPED_FLOAT;
+	return lt.rune || rt.rune ? UNTYPED_RUNE : UNTYPED_INT;
+}
+
 /** @type {ThisType<TypeChecker>} */
 export const assignabilityMethods = {
 	// ── Binary result types ───────────────────────────────────────────
@@ -71,12 +91,26 @@ export const assignabilityMethods = {
 		if (lt?.kind === "typeParam" || rt?.kind === "typeParam")
 			return this._binaryResultTypeTypeParam(op, lt, rt);
 		if (CMP_OPS.has(op)) return this._binaryResultTypeCmp(op, lt, rt, node);
-		if (LOG_OPS.has(op)) return BOOL;
+		if (LOG_OPS.has(op)) {
+			this._checkLogicalOperands(lt, rt, node);
+			return logicalResultType(lt, rt);
+		}
 		return this._binaryResultTypeNonComplex(op, lt, rt, node);
 	},
 
+	// `B && bool` mixes two distinct bool types, which Go rejects.
+	_checkLogicalOperands(lt, rt, node) {
+		if (!node || lt?.kind === "untyped" || rt?.kind === "untyped") return;
+		if (!isBool(lt) || !isBool(rt) || typeStr(lt) === typeStr(rt)) return;
+		this.err(
+			`invalid operation: ${exprText(node)} (mismatched types ${typeStr(lt)} and ${typeStr(rt)})`,
+			node,
+		);
+	},
+
 	_binaryResultTypeTypeParam(op, lt, rt) {
-		if (CMP_OPS.has(op) || LOG_OPS.has(op)) return BOOL;
+		if (CMP_OPS.has(op)) return UNTYPED_BOOL;
+		if (LOG_OPS.has(op)) return BOOL;
 		return lt?.kind === "typeParam" ? lt : rt;
 	},
 
@@ -137,7 +171,8 @@ export const assignabilityMethods = {
 		if (this._checkComplexCmpOp(op, lt, rt, node)) return ANY;
 		this._checkIntegerCmpKinds(op, lt, rt, node);
 		this._checkEqualityComparable(op, lt, rt, node);
-		return BOOL;
+		// A comparison is an untyped bool: it also fits a defined bool type.
+		return UNTYPED_BOOL;
 	},
 
 	_binaryResultTypeComplex(op, lt, rt, node) {
@@ -163,7 +198,7 @@ export const assignabilityMethods = {
 		const rFloat = rName === "float32" || rName === "float64";
 		const isFloat = lFloat || rFloat;
 		if (lt.kind === "untyped" && rt.kind === "untyped")
-			return isFloat ? UNTYPED_FLOAT : UNTYPED_INT;
+			return untypedIntegerKind(isFloat, lt, rt);
 		if (lt.kind === "untyped")
 			return isFloat && rt.name !== "float64" && rt.name !== "float32"
 				? FLOAT64
@@ -229,6 +264,19 @@ export const assignabilityMethods = {
 		}
 	},
 
+	// An untyped numeric constant that takes type float32 is rounded to
+	// float32 in JS output (`var c float32 = 0.01`, `v == 0.01`).
+	_tagFloat32Const(target, source, node) {
+		if (!node || typeof node !== "object" || !node._const) return;
+		if (!isUntyped(source) || this._float32Base(target) !== "float32") return;
+		node._f32Const = true;
+	},
+
+	_float32Base(t) {
+		const r = t?.kind === "named" ? t.underlying : t;
+		return r?.kind === "basic" || r?.kind === "untyped" ? r.name : null;
+	},
+
 	// `var m uint64 = (1 << k) - 1`: a non-constant shift whose left operand is
 	// an untyped constant takes the type its context gives it, so codegen
 	// computes it in that type (BigInt for 64-bit integers).
@@ -265,6 +313,17 @@ export const assignabilityMethods = {
 			!isComplex(source)
 		)
 			valueNode._asComplex = true;
+		this._tagComplex64Const(target, source, valueNode);
+	},
+
+	// An untyped constant that takes type complex64 is rounded to float32 in
+	// JS output: a real constant through `_f32Const`, a complex constant
+	// (`1 + 0.01i`) through `_c64Const`.
+	_tagComplex64Const(target, source, node) {
+		if (!node || typeof node !== "object") return;
+		if (!isComplex64(target) || !isUntyped(source)) return;
+		if (isComplex(source)) node._c64Const = true;
+		else if (node._const) node._f32Const = true;
 	},
 
 	// `operand` is the expression whose value flows in, when `node` (the
@@ -275,6 +334,7 @@ export const assignabilityMethods = {
 		target = this.resolveType(target);
 		source = this.resolveType(source);
 		this._tag64BitNode(target, node);
+		this._tagFloat32Const(target, source, operand ?? node);
 		this._retypeUntypedShift(target, source, operand ?? node);
 		this._tagComplexConst(target, source, operand ?? node);
 		this._markIfaceBox(target, source, node);
@@ -442,11 +502,13 @@ export const assignabilityMethods = {
 	},
 
 	// An interface-typed operand needs an explicit type assertion before it can
-	// flow into a concrete (non-interface) type.
+	// flow into a concrete (non-interface) type, or into an interface with
+	// methods (`var e error = b` with `b any`).
 	_checkIfaceToConcrete(target, source, node, ctx, operand) {
 		if (!source?._declared || !operand || typeof operand !== "object")
 			return false;
-		if (!this._isConcreteTarget(target)) return false;
+		if (!this._isConcreteTarget(target) && !this._isMethodIfaceTarget(target))
+			return false;
 		this.err(
 			`cannot use ${exprText(operand)} (${operandKind(operand, typeStr(source))}) as ${typeStr(target)} value in ${ctx}: need type assertion`,
 			node,
@@ -454,6 +516,31 @@ export const assignabilityMethods = {
 		return true;
 	},
 
+	// `int(x)`, `(*T)(x)` and `I(x)` (I with methods) with a source-written
+	// `any` operand need an assertion.
+	_checkIfaceConversion(srcType, targetType, expr, operand) {
+		if (!srcType?._declared || !operand) return false;
+		if (
+			!this._isConcreteTarget(targetType) &&
+			!this._isMethodIfaceTarget(targetType)
+		)
+			return false;
+		this.err(
+			`cannot convert ${exprText(operand)} (${operandKind(operand, typeStr(srcType))}) to type ${typeStr(targetType)}: need type assertion`,
+			expr,
+		);
+		return true;
+	},
+
+	// An interface type (named or literal) with at least one method.
+	_isMethodIfaceTarget(target) {
+		if (!target || isAny(target)) return false;
+		const base = this.resolveType(
+			target.kind === "named" ? target.underlying : target,
+		);
+		return base?.kind === "interface" && base.methods?.size > 0;
+	},
+
 	_isConcreteTarget(target) {
 		if (!target || target.kind === "typeParam" || isAny(target)) return false;
 		if (isNil(target) || isUntyped(target)) return false;
@@ -584,12 +671,7 @@ export const assignabilityMethods = {
 	_isNumericCoercible(target, source) {
 		if (target.kind !== "basic" || source.kind !== "basic") return false;
 		const pair = `${target.name}:${source.name}`;
-		return (
-			pair === "float64:int" ||
-			// rune was historically int in GoFront; keep rune/int interchangeable.
-			pair === "int:int32" ||
-			pair === "int32:int"
-		);
+		return pair === "float64:int";
 	},
 
 	// The lenient numeric pairs: accepted, except that a generic call result