gofront 1.9.0 → 1.9.1

package/src/lexer/lexer.js

@@ -637,6 +637,7 @@ export class Lexer {
 			}
 			if (ch === "'") {
 				this.push(T.INT, this.readRuneLiteral(), l, c);
+				this.tokens[this.tokens.length - 1].rune = true;
 				continue;
 			}
 

package/src/link/stdlib.js

@@ -20,6 +20,7 @@ import { lowerStdlibRefs, registerWasmUnit } from "./wasm.js";
 
 export {
 	mangleCollidingTypes,
+	registerLocalTypeOwners,
 	renameLocalTypes,
 	withOriginalTypeNames,
 } from "./type-names.js";

package/src/link/type-names.js

@@ -37,10 +37,12 @@ export function mangleCollidingTypes(programs, pkgKey, pkgName, owners) {
 // backends key types by bare name.  A local type whose name another type of the
 // package also uses (a package-level type or a local of another function)
 // is renamed to `Name__L<n>` for its scope; `%T` and diagnostics drop the
-// suffix (see `displayTypeName`).  Returns whether anything was renamed.
+// suffix (see `displayTypeName`).  `reserved` holds type names other packages
+// own: a local type spelled like one is renamed too, so it cannot clash with
+// the imported type in the flat module.  Returns whether anything was renamed.
 let localTypeCounter = 0;
 
-export function renameLocalTypes(programs) {
+export function renameLocalTypes(programs, reserved = new Set()) {
 	const counts = new Map();
 	const count = (node) => {
 		if (!node || typeof node !== "object") return;
@@ -50,34 +52,88 @@ export function renameLocalTypes(programs) {
 		forEachChild(node, count);
 	};
 	for (const p of programs) count(p.decls);
-	const dup = new Set([...counts].filter(([, n]) => n > 1).map(([k]) => k));
-	if (dup.size === 0) return false;
+	const dup = new Set(
+		[...counts].filter(([k, n]) => n > 1 || reserved.has(k)).map(([k]) => k),
+	);
 	let changed = false;
 	// Inner scopes first, so an outer rename never touches a nested
-	// declaration that already has its own name.
-	const scan = (node) => {
+	// declaration that already has its own name.  `visible` holds the value
+	// names declared so far in the enclosing scopes.
+	const scan = (node, visible) => {
 		if (!node || typeof node !== "object") return;
 		if (Array.isArray(node)) {
-			node.forEach(scan);
+			const seen = new Set(visible);
 			for (let i = 0; i < node.length; i++) {
 				const d = node[i];
-				if (d?.kind !== "TypeDecl" || !dup.has(d.name)) continue;
-				const renamed = new Map([
-					[d.name, `${d.name}__L${++localTypeCounter}`],
-				]);
-				for (let j = i; j < node.length; j++)
-					renameTypeRefs(node[j], renamed, new Set(), new Set());
-				changed = true;
+				scan(d, seen);
+				if (d?.kind === "TypeDecl") {
+					// A value of the same name would clash with the type in JS.
+					const stop = node.findIndex(
+						(s, j) => j > i && declaresValue(s, d.name),
+					);
+					if (dup.has(d.name) || seen.has(d.name) || stop >= 0) {
+						const renamed = new Map([
+							[d.name, `${d.name}__L${++localTypeCounter}`],
+						]);
+						const end = stop >= 0 ? stop : node.length - 1;
+						for (let j = i; j <= end; j++) {
+							// The shadowing declaration's own right-hand side and type
+							// are evaluated before its new value is in scope.
+							const target =
+								j === stop && node[j].kind === "DefineStmt"
+									? node[j].rhs
+									: node[j];
+							renameTypeRefs(target, renamed, new Set(), new Set());
+						}
+						changed = true;
+					}
+				} else if (d) for (const n of valueNames(d)) seen.add(n);
 			}
 			return;
 		}
-		forEachChild(node, scan);
+		const here = FUNC_KINDS.has(node.kind)
+			? new Set([...visible, ...declaredParams(node)])
+			: visible;
+		forEachChild(node, (c) => scan(c, here));
 	};
 	for (const p of programs)
-		for (const d of p.decls ?? []) if (d.kind !== "TypeDecl") scan(d);
+		for (const d of p.decls ?? [])
+			if (d.kind !== "TypeDecl") scan(d, new Set());
 	return changed;
 }
 
+const VALUE_DECL_KINDS = new Set(["DefineStmt", "VarDecl", "ConstDecl"]);
+
+// Names a statement declares as values in its own scope.
+function valueNames(stmt) {
+	return VALUE_DECL_KINDS.has(stmt.kind) ? declaredNames(stmt) : [];
+}
+
+function declaresValue(stmt, name) {
+	return valueNames(stmt).includes(name);
+}
+
+function declaredParams(fn) {
+	const names = (fn.params ?? []).map((p) => p.name).filter(Boolean);
+	if (fn.recvName) names.push(fn.recvName);
+	return names;
+}
+
+// A package compiled later that declares a type this package only declares
+// inside a function is renamed by `mangleCollidingTypes`, so `Pt` of one package
+// and a local `Pt` of another never meet in the flat module.
+export function registerLocalTypeOwners(programs, pkgKey, owners) {
+	if (!owners) return;
+	const visit = (node) => {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) return node.forEach(visit);
+		if (node.kind === "TypeDecl" && !owners.has(node.name))
+			owners.set(node.name, pkgKey);
+		forEachChild(node, visit);
+	};
+	for (const p of programs) visit(p.decls);
+}
+
 // `tparams` are type parameters in scope; `values` are names a function
 // declares as parameters or locals, which shadow a same-spelled bare `Ident`.
 function renameTypeRefs(node, renamed, tparams, values) {

package/src/lower/embedding.js

@@ -1,7 +1,10 @@
 // src/lower/embedding.js
 // Computes promoted methods and delegation stubs for embedded structs.
 
-import { embeddedFieldName } from "../typechecker/types.js";
+import {
+	ambiguousPromotions,
+	embeddedFieldName,
+} from "../typechecker/types.js";
 
 // A method promoted from an embedded struct value but declared on its
 // pointer receiver is outside the method set of the outer struct's value.
@@ -10,36 +13,60 @@ function isPtrOnlyPromotion(rawEmbed, embed, mName, mType) {
 	return Boolean((mType ?? embed.methods?.get(mName))?._ptrRecv);
 }
 
+// A pointer-receiver method reached through an embedded pointer, which may
+// be nil.
+function isNilablePtrRecv(rawEmbed, mType) {
+	return rawEmbed.kind === "pointer" && Boolean(mType?._ptrRecv);
+}
+
+// An embedded interface (named, literal or `error`) forwards each method of
+// its method set to the interface value in the field.
+function pushInterfaceStubs(stubs, declared, iface, fieldName) {
+	for (const mName of iface.methods?.keys() ?? []) {
+		if (declared.has(mName)) continue;
+		stubs.push({ methodName: mName, fieldName, ifaceEmbed: true });
+		declared.add(mName);
+	}
+}
+
+function pushValueEmbedStubs(stubs, declared, embed, embedName, fieldName) {
+	for (const [mName, mType] of embed.methods?.entries() ?? []) {
+		if (declared.has(mName) || mType?._ptrRecv) continue;
+		stubs.push({ methodName: mName, embedName, fieldName, valueEmbed: true });
+		declared.add(mName);
+	}
+}
+
 export function computeEmbeddedStubs(name, methodDecls, checker) {
 	if (!checker) return [];
 	const resolvedType = checker.types.get(name)?.underlying;
 	if (resolvedType?.kind !== "struct" || !resolvedType._embeds) return [];
 
-	const declared = new Set(methodDecls.map((m) => m.name));
+	// A method two embeds declare at the same depth is in neither method set:
+	// no stub, so the value does not satisfy an interface that needs it.
+	const declared = new Set([
+		...methodDecls.map((m) => m.name),
+		...ambiguousPromotions(resolvedType),
+	]);
 	const stubs = [];
 
 	const embedded = (resolvedType._structFields ?? []).filter((f) => f.embedded);
 	for (const [i, rawEmbed] of resolvedType._embeds.entries()) {
 		const fieldName = embedded[i] ? embeddedFieldName(embedded[i]) : null;
 		const embed = rawEmbed.kind === "pointer" ? rawEmbed.base : rawEmbed;
+		const embedBase = embed.kind === "named" ? embed.underlying : embed;
+		if (embedBase?.kind === "interface") {
+			if (rawEmbed.kind !== "pointer" && fieldName)
+				pushInterfaceStubs(stubs, declared, embedBase, fieldName);
+			continue;
+		}
 		const embedName = embed.kind === "named" ? embed.name : null;
 		if (!embedName) continue;
-		const embedBase = embed.kind === "named" ? embed.underlying : embed;
 		if (embedBase?.kind !== "struct" || !embedBase.methods) {
 			// A named non-struct type (`time.Duration`) promotes its value
 			// methods; the stub passes the embedded value as the receiver.
-			if (rawEmbed.kind === "pointer" || embedBase?.kind === "interface")
-				continue;
-			for (const [mName, mType] of embed.methods?.entries() ?? []) {
-				if (declared.has(mName) || mType?._ptrRecv) continue;
-				stubs.push({
-					methodName: mName,
-					embedName,
-					fieldName,
-					valueEmbed: true,
-				});
-				declared.add(mName);
-			}
+			if (rawEmbed.kind !== "pointer")
+				pushValueEmbedStubs(stubs, declared, embed, embedName, fieldName);
 			continue;
 		}
 
@@ -50,6 +77,7 @@ export function computeEmbeddedStubs(name, methodDecls, checker) {
 					embedName,
 					fieldName,
 					ptrOnly: isPtrOnlyPromotion(rawEmbed, embed, mName, mType),
+					nilPtrRecv: isNilablePtrRecv(rawEmbed, mType),
 				});
 				declared.add(mName); // Prevent duplicate stubs for diamond embeds
 			}

package/src/lower/fmt-formatters.js

@@ -34,7 +34,7 @@ import {
 	under,
 	walkNodes,
 } from "./gen-types.js";
-import { holdsFunc, isCompositeType } from "./json-codecs.js";
+import { holdsFunc } from "./json-codecs.js";
 
 const FMT_PATH = "fmt";
 const RT_PATH = "internal/fmtrt";
@@ -137,6 +137,12 @@ const returnsString = (m) => {
 	);
 };
 
+// A map, slice or array type: one that generic code boxes into an interface
+// is not spelled in the package, so the formatter lookup must describe it.
+function isMapSliceOrArray(t) {
+	return t?.kind === "map" || t?.kind === "slice" || t?.kind === "array";
+}
+
 class FmtGen extends TypeSpeller {
 	constructor(checker, pkgName, qualifiers, programs, formatted = false) {
 		super(pkgName, qualifiers, programs);
@@ -559,12 +565,17 @@ class FmtGen extends TypeSpeller {
 			if (via === "declared" && !this.topLevel.has(type.name)) continue;
 			add(type);
 		}
-		// Only instances of generic types (and pointers to them): they are the
-		// types a package never spells, and any other type here would take the
-		// place of the dispatch a type parameter value already has.
-		for (const type of this.genericBodyTypes()) {
+		// Only instances of generic types (and pointers to them), and maps, slices and
+		// arrays a generic body boxes into an interface: they are the types a package
+		// never spells, and any other type here would take the place of the
+		// dispatch a type parameter value already has.
+		for (const { type, boxed } of this.genericBodyTypes()) {
 			const base = type.kind === "pointer" ? type.base : type;
-			if (base.kind === "named" && base.typeArgs?.length > 0) add(type);
+			if (
+				(boxed && isMapSliceOrArray(type)) ||
+				(base.kind === "named" && base.typeArgs?.length > 0)
+			)
+				add(type);
 		}
 		return [...found.values()];
 	}
@@ -593,16 +604,28 @@ class FmtGen extends TypeSpeller {
 		while (queue.length > 0) {
 			const { decl, map } = queue.shift();
 			walkNodes(decl.body, (node) => {
-				// A type without a type parameter is found by the walk of the
-				// package already.
-				if (node._type && mentionsTypeParam(node._type))
-					out.push(defaultType(this.checker.substituteType(node._type, map)));
+				out.push(...this.bodyNodeTypes(node, map));
 				request(node, map);
 			});
 		}
 		return out;
 	}
 
+	// The types a node of an instantiated generic body adds: the node's own
+	// type once substituted (a type without a type parameter is found by the
+	// walk of the package already), and a map it boxes into an interface,
+	// which is a type of its own (a type parameter's value keeps its dispatch).
+	bodyNodeTypes(node, map) {
+		const sub = (t) => defaultType(this.checker.substituteType(t, map));
+		const out = [];
+		if (node._type && mentionsTypeParam(node._type))
+			out.push({ type: sub(node._type) });
+		const src = node._ifaceSrc;
+		if (isMapSliceOrArray(src) && mentionsTypeParam(src))
+			out.push({ type: sub(src), boxed: true });
+		return out;
+	}
+
 	// The instantiation of a generic function that `call` makes, with its
 	// type arguments substituted through `map` (the instantiation of the
 	// function that contains the call), or null for any other node or one
@@ -626,11 +649,12 @@ class FmtGen extends TypeSpeller {
 		if (isInterface(t) || under(t)?.kind === "interface") return false;
 		if (t.kind === "basic") return false;
 		if (t.kind === "func") return true;
-		if (holdsFunc(t)) return false;
-		// An unnamed array or map of small integers would shadow its look-alikes
-		// in the type switch (see SHARED_REPR in json-codecs).
+		// An array, map or slice is boxed by its Go type, so one with small
+		// integer or boolean keys or elements no longer shadows its look-alikes in
+		// the type switch. One holding funcs is described too, so `%T` names it.
 		if (t.kind === "array" || t.kind === "map" || t.kind === "slice")
-			return isCompositeType(t);
+			return true;
+		if (holdsFunc(t)) return false;
 		return true;
 	}
 

package/src/lower/functions.js

@@ -1,7 +1,7 @@
 // src/lower/functions.js
 // Analyzes function signatures, named returns and defer structures.
 
-import { forEachChild, someChild } from "./walk.js";
+import { forEachChild, hasCallOrReceive, someChild } from "./walk.js";
 
 export function extractNamedReturns(decl) {
 	const named = decl?.returnType?._namedReturns;
@@ -146,6 +146,80 @@ function deferCalleeMayRecover(funcExpr, ctx) {
 	return true;
 }
 
+// A constant argument (`2.5`, `"a"`, `nil`, `k` for a constant `k`, `-1`)
+// has no value to capture at the `defer` statement, so it stays in the
+// deferred call, where it takes the callee's parameter type exactly as in a
+// direct call.  Hoisting it into a temporary would default its type (`float64`,
+// `int`) and reject a defined-type, interface, pointer or generic parameter.
+function isDeferConstant(arg) {
+	if (arg?.kind === "BasicLit" && arg.litKind === "NIL") return true;
+	if (arg?._type?.kind !== "untyped") return false;
+	if (arg._const) return true;
+	switch (arg.kind) {
+		case "BasicLit":
+		case "ImagLit":
+			return true;
+		case "ParenExpr":
+			return isDeferConstant(arg.expr);
+		case "UnaryExpr":
+			return isDeferConstant(arg.operand);
+		case "BinaryExpr":
+			return isDeferConstant(arg.left) && isDeferConstant(arg.right);
+		default:
+			return false;
+	}
+}
+
+// A package-level basic or defined type a temporary can be declared with by
+// its name; other parameter types (qualified, generic, composite) are not
+// hoisted with a declared type.
+function isNamedScalarParam(t) {
+	if (t?.kind === "basic")
+		return t.name !== "any" && /^[A-Za-z_]\w*$/.test(t.name ?? "");
+	return (
+		t?.kind === "named" &&
+		t.underlying?.kind === "basic" &&
+		!t.typeArgs?.length &&
+		/^[A-Za-z_]\w*$/.test(t.name ?? "")
+	);
+}
+
+// A non-constant untyped expression (`1 << n`) the typechecker already gave
+// its parameter's type: it is still untyped when the lowered code is checked
+// again, so its temporary needs that type declared.
+function isRetypedUntyped(e) {
+	if (!e || e._const) return false;
+	switch (e.kind) {
+		case "ParenExpr":
+			return isRetypedUntyped(e.expr);
+		case "UnaryExpr":
+			return isRetypedUntyped(e.operand);
+		case "BinaryExpr":
+			if (e.op === "<<" || e.op === ">>") return Boolean(e.left?._const);
+			return isRetypedUntyped(e.left) || isRetypedUntyped(e.right);
+		default:
+			return false;
+	}
+}
+
+// The type of the temporary that holds deferred argument `a`: an untyped
+// non-constant value (a shift, a comparison) takes its basic or defined
+// scalar parameter's type, as it does in a direct call.  A variadic call's
+// trailing arguments take the element type.
+function deferTempType(funcType, a, arg) {
+	const argType = arg._type;
+	if (argType?.kind !== "untyped" && !isRetypedUntyped(arg)) return argType;
+	const params = funcType?.params;
+	let param = params?.[a];
+	if (funcType?.variadic && a >= params.length - 1) {
+		// The last parameter's type is the element type (a slice only when
+		// a table spells it that way).
+		param = params[params.length - 1];
+		if (!isNamedScalarParam(param)) param = param?.elem;
+	}
+	return isNamedScalarParam(param) ? param : argType;
+}
+
 function normalizeDeferStmt(stmt, parentList = null, index = -1, ctx = null) {
 	if (stmt.call?.kind !== "CallExpr") return 0;
 	const call = stmt.call;
@@ -245,19 +319,40 @@ function normalizeDeferStmt(stmt, parentList = null, index = -1, ctx = null) {
 					lhs: tupleLhs,
 					rhs: [arg],
 				});
+			} else if (isDeferConstant(arg)) {
+				tempIdents.push(arg);
 			} else {
 				defargCounter++;
 				const tempName = `__defarg$${defargCounter}`;
+				const tempType = deferTempType(call.func?._type, a, arg);
 				tempIdents.push({
 					kind: "Ident",
 					name: tempName,
-					_type: arg._type,
-				});
-				tempStmts.push({
-					kind: "DefineStmt",
-					lhs: [{ kind: "Ident", name: tempName, _type: arg._type }],
-					rhs: [arg],
+					_type: tempType,
+					// A spread argument stays one: the call gets the slice itself.
+					...(arg._spread && { _spread: true }),
 				});
+				tempStmts.push(
+					tempType === arg._type &&
+						!(isRetypedUntyped(arg) && isNamedScalarParam(tempType))
+						? {
+								kind: "DefineStmt",
+								lhs: [{ kind: "Ident", name: tempName, _type: tempType }],
+								rhs: [arg],
+							}
+						: {
+								// Declared with the parameter's type so the lowered code
+								// type-checks again with the constant converted.
+								kind: "VarDecl",
+								decls: [
+									{
+										names: [tempName],
+										type: { kind: "TypeName", name: tempType.name },
+										value: [arg],
+									},
+								],
+							},
+				);
 			}
 		}
 	}
@@ -302,3 +397,124 @@ function normalizeDeferStmt(stmt, parentList = null, index = -1, ctx = null) {
 
 	return tempStmts.length;
 }
+
+let fwdCounter = 0;
+
+/**
+ * Splits a multi-value call forwarded into interfaces into temps:
+ * `return f()` where some result is an interface becomes
+ * `__fwd$1, __fwd$2 := f(); return __fwd$1, __fwd$2`, and `g(f())` where
+ * some parameter is an interface becomes `…; g(__fwd$1, __fwd$2)`.  The
+ * typechecker records per-element interface-box marks in `call._fwdIface`;
+ * each temp takes its element's marks, so both backends box it through their
+ * ordinary per-value path.  Forwards with no interface element are left alone.
+ *
+ * `g(f())` is split only as the operand of a statement (expression
+ * statement, single-value `:=`/`=`/`var`/`return`) whose callee evaluates
+ * no call, so hoisting `f()` keeps Go's evaluation order.
+ */
+export function splitForwardedTuples(programOrPrograms) {
+	fwdCounter = 0;
+	const programs = Array.isArray(programOrPrograms)
+		? programOrPrograms
+		: [programOrPrograms];
+	for (const program of programs)
+		for (const d of program?.decls ?? []) splitForwardsIn(d);
+}
+
+function splitForwardsIn(node) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (let i = 0; i < node.length; i++) {
+			const item = node[i];
+			splitForwardsIn(item);
+			const defines = splitForwardsInStmt(item);
+			node.splice(i, 0, ...defines);
+			i += defines.length;
+		}
+		return;
+	}
+	forEachChild(node, splitForwardsIn);
+}
+
+// The `:=` statements to insert before `stmt` (in order) after rewriting its
+// forwarded calls to read the temps.
+function splitForwardsInStmt(stmt) {
+	const defines = [];
+	const operand = statementOperand(stmt);
+	if (
+		operand?.kind === "CallExpr" &&
+		operand._multiForward &&
+		operand.args?.length === 1 &&
+		!hasCallOrReceive(operand.func)
+	) {
+		const split = forwardTemps(operand.args[0]);
+		if (split) {
+			operand.args = split.operands;
+			operand._multiForward = false;
+			defines.push(split.define);
+		}
+	}
+	if (stmt?.kind === "ReturnStmt") {
+		const define = splitForwardedReturn(stmt);
+		if (define) defines.push(define);
+	}
+	return defines;
+}
+
+// The single expression a statement evaluates last, or null.
+function statementOperand(stmt) {
+	switch (stmt?.kind) {
+		case "ExprStmt":
+			return stmt.expr;
+		case "DefineStmt":
+		case "AssignStmt":
+			return stmt.rhs?.length === 1 &&
+				stmt.lhs?.every((e) => e.kind === "Ident")
+				? stmt.rhs[0]
+				: null;
+		case "ReturnStmt":
+			return stmt.values?.length === 1 ? stmt.values[0] : null;
+		case "VarDecl":
+			return stmt.decls?.length === 1 && stmt.decls[0].value?.length === 1
+				? stmt.decls[0].value[0]
+				: null;
+		default:
+			return null;
+	}
+}
+
+// Splits one forwarded call into temps: returns the `:=` statement defining
+// them and the operand idents (carrying each element's interface-box marks),
+// or null when the call needs no split.
+function forwardTemps(call) {
+	const holders = call?._fwdIface;
+	const types = call?._type?.types;
+	if (!holders || !Array.isArray(types) || types.length !== holders.length)
+		return null;
+	const names = types.map(() => `__fwd$${++fwdCounter}`);
+	const define = {
+		kind: "DefineStmt",
+		lhs: names.map((name, i) => ({ kind: "Ident", name, _type: types[i] })),
+		rhs: [call],
+	};
+	// The call is no longer a forward; a cached AST must not split it again.
+	call._fwdIface = undefined;
+	const operands = names.map((name, i) => ({
+		kind: "Ident",
+		name,
+		_type: types[i],
+		...holders[i],
+	}));
+	return { define, operands };
+}
+
+function splitForwardedReturn(stmt) {
+	if (stmt.values?.length !== 1) return null;
+	const split = forwardTemps(stmt.values[0]);
+	if (!split) return null;
+	stmt.values = split.operands;
+	if (Array.isArray(stmt._types))
+		stmt._types = split.operands.map((o) => o._type);
+	return split.define;
+}

package/src/lower/gen-types.js

@@ -59,8 +59,16 @@ export function walkNodes(root, fn) {
 	}
 	fn(root);
 	forEachChild(root, (c) => walkNodes(c, fn));
+	// templ bodies keep their Go expressions in non-enumerable properties
+	// (see parser/templ.js), which forEachChild does not visit.
+	for (const name of TEMPL_EXPR_PROPS) {
+		const d = Object.getOwnPropertyDescriptor(root, name);
+		if (d && !d.enumerable) walkNodes(d.value, fn);
+	}
 }
 
+const TEMPL_EXPR_PROPS = ["expr", "exprs", "forStmt"];
+
 // True when `t` mentions a type parameter (a generic declaration, or a type
 // built from one inside a generic function).
 export function mentionsTypeParam(t, seen = new Set()) {
@@ -126,8 +134,9 @@ export function importsFor(qualifiers) {
 
 // Every type a closed-world generator may need to describe: the entries
 // { type, node, via } for the type arguments of generic calls (`typeArg`),
-// the type of every expression (`expr`) and the package's declared named
-// types (`declared`, node null).
+// the type of every expression (`expr`), the static type of every value
+// converted to an interface (`boxed`) and the package's declared named types
+// (`declared`, node null).
 export function collectProgramTypes(programs, checker) {
 	const found = [];
 	for (const p of programs)
@@ -136,6 +145,14 @@ export function collectProgramTypes(programs, checker) {
 				found.push({ type: defaultType(a), node, via: "typeArg" });
 			if (node._type)
 				found.push({ type: defaultType(node._type), node, via: "expr" });
+			if (node._ifaceSrc)
+				found.push({ type: defaultType(node._ifaceSrc), node, via: "boxed" });
+			// A multi-value call forwarded into interfaces (`return f()`,
+			// `g(f())`) keeps one mark holder per element until lowering
+			// splits it.
+			for (const h of node._fwdIface ?? [])
+				if (h?._ifaceSrc)
+					found.push({ type: defaultType(h._ifaceSrc), node, via: "boxed" });
 		});
 	for (const [name, t] of checker.types) {
 		if (t?.kind !== "named" || t.name !== name) continue;
@@ -253,6 +270,8 @@ export class TypeSpeller {
 		const byKind = {
 			basic: () => t.name !== "void" && t.name !== "nil",
 			named: () => this.spellableNamed(t, ok, seen),
+			// A JS-interop (.d.ts) type has no Go source to write.
+			namespace: () => false,
 			pointer: () => ok(t.base),
 			slice: () => ok(t.elem),
 			array: () => ok(t.elem),

package/src/lower/index.js

@@ -16,7 +16,12 @@ import { scanAddressTaken } from "./boxing.js";
 import { analyzeCaptures } from "./captures.js";
 import { computeEmbeddedStubs } from "./embedding.js";
 import { paramEscapes } from "./escape.js";
-import { extractNamedReturns, hasDefer, normalizeDefers } from "./functions.js";
+import {
+	extractNamedReturns,
+	hasDefer,
+	normalizeDefers,
+	splitForwardedTuples,
+} from "./functions.js";
 import { computeGlobalAnalysis } from "./globals.js";
 import { OwnershipContext, takesElementAddress } from "./ownership.js";
 
@@ -83,6 +88,7 @@ export function lower(programOrPrograms, checker = null) {
 		? programOrPrograms
 		: [programOrPrograms];
 
+	splitForwardedTuples(programs);
 	normalizeDefers(programs);
 
 	res.elemAddrTaken = programs.some((p) => takesElementAddress(p?.decls));