gofront 1.9.0 → 1.9.2

package/src/backend/wasm/emit.js

@@ -213,6 +213,35 @@ export class FunctionEmitter {
 		return targets;
 	}
 
+	// Outer stacked labels (`a: b: for`) alias the innermost one. Collected
+	// once per root function so the yield closures of a range-over-func loop
+	// (emitted by their own emitter) resolve them too.
+	_stackedLabelAlias(label) {
+		const root = this.rootFuncDecl;
+		if (root && !root._labelAliases) {
+			const aliases = new Map();
+			const scan = (node) => {
+				if (!node || typeof node !== "object") return;
+				if (Array.isArray(node)) {
+					for (const item of node) scan(item);
+					return;
+				}
+				if (node.kind === "LabeledStmt" && node.body?.kind === "LabeledStmt") {
+					let inner = node.body;
+					while (inner.body?.kind === "LabeledStmt") inner = inner.body;
+					aliases.set(node.label, inner.label);
+				}
+				for (const k of Object.keys(node)) {
+					if (k.startsWith("_")) continue;
+					scan(node[k]);
+				}
+			};
+			scan(root.body);
+			root._labelAliases = aliases;
+		}
+		return root?._labelAliases?.get(label) ?? this._labelAliases?.get(label);
+	}
+
 	_findLabelTarget(label, role) {
 		for (const target of this.rootFuncDecl?._labelTargets?.values() ?? []) {
 			if (target.label === label && target.role === role) return target;
@@ -1434,31 +1463,9 @@ export class FunctionEmitter {
 					typeIndex: cand.testTypeIndex,
 					fieldIndex: 0,
 				});
-				if (cand.embedPath) {
-					for (const step of cand.embedPath) {
-						if (step.castTypeIndex) {
-							this.pushInstruction({
-								op: "ref.cast",
-								typeIndex: step.castTypeIndex,
-							});
-						}
-						this.pushInstruction({
-							op: "struct.get",
-							typeIndex: step.parentTypeIndex,
-							fieldIndex: step.fieldIndex,
-						});
-					}
-				}
+				if (cand.embedPath) this._emitEmbedPath(cand);
 			} else {
-				if (cand.embedPath) {
-					for (const step of cand.embedPath) {
-						this.pushInstruction({
-							op: "struct.get",
-							typeIndex: step.parentTypeIndex,
-							fieldIndex: step.fieldIndex,
-						});
-					}
-				}
+				if (cand.embedPath) this._emitEmbedPath(cand);
 				if (cand.needsValueDeref && cand.structInfo) {
 					this.emitCloneStruct(cand.structInfo, cand.targetRecvWType);
 				}
@@ -1469,7 +1476,10 @@ export class FunctionEmitter {
 				this.pushInstruction({ op: "local.get", index: p });
 			}
 
-			this.pushInstruction({ op: "call", funcIndex: cand.funcIndex });
+			this.pushInstruction({
+				op: "call",
+				funcIndex: cand.selfDispatch ? fn._globalFuncIndex : cand.funcIndex,
+			});
 			this.pushInstruction("return");
 			this.pushInstruction("end");
 		}
@@ -1477,12 +1487,49 @@ export class FunctionEmitter {
 		emitMiss("interface conversion: nil or unmatched type for method call");
 	}
 
+	// Walks `cand.embedPath` from the embedder on the stack to the embedded
+	// value. A step through a nil embedded pointer panics, except that the last
+	// step may be nil for a pointer-receiver method (`nilCheckLast` is unset).
+	_emitEmbedPath(cand) {
+		const steps = cand.embedPath;
+		for (const [i, step] of steps.entries()) {
+			if (step.castTypeIndex) {
+				this.pushInstruction({ op: "ref.cast", typeIndex: step.castTypeIndex });
+			}
+			this.pushInstruction({
+				op: "struct.get",
+				typeIndex: step.parentTypeIndex,
+				fieldIndex: step.fieldIndex,
+			});
+			if (step.ptrWType && (i < steps.length - 1 || cand.nilCheckLast))
+				this._emitNilPanicIfNull(step.ptrWType);
+		}
+	}
+
+	// Panics with a nil dereference when the reference on the stack is null,
+	// leaving it on the stack otherwise.
+	_emitNilPanicIfNull(wType) {
+		const tmp = this.acquireTemp(wType);
+		this.pushInstruction({ op: "local.tee", index: tmp });
+		this.pushInstruction("ref.is_null");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.emitPanic(
+			"runtime error: invalid memory address or nil pointer dereference",
+		);
+		this.pushInstruction("end");
+		this.pushInstruction({ op: "local.get", index: tmp });
+		this.releaseTemp(tmp, wType);
+	}
+
 	// A typed nil `*S` inside the interface is a marker object (see
 	// getNilBoxType): a pointer-receiver method runs with a nil receiver, as in
 	// Go; a value-receiver or promoted method must read through the nil pointer.
+	// A promoted candidate tests the outer struct but carries the embedded
+	// struct's info, so it is recognised by its embed path.
 	_emitNilPtrCandidate(cand, fn, recvLocal) {
 		if (cand.isBoxedValue || !cand.structInfo) return;
-		if (cand.testTypeIndex !== cand.structInfo.typeIndex) return;
+		if (!cand.embedPath && cand.testTypeIndex !== cand.structInfo.typeIndex)
+			return;
 		const nilBox = this.mod.getNilBoxType({
 			kind: "pointer",
 			base: { kind: "named", name: cand.recvTypeName },

package/src/backend/wasm/globals.js

@@ -104,6 +104,7 @@ function _zeroFieldConst(f, mod) {
 	const w = f.wType;
 	if (w === "i64") return [{ op: "i64.const", value: 0n }];
 	if (w === "f32" || w === "f64") return [{ op: `${w}.const`, value: 0 }];
+	if (w === "v128") return [{ op: "v128.const", bytes: new Array(16).fill(0) }];
 	if (w === "externref") return [{ op: "ref.null", heapType: "extern" }];
 	if (w === "anyref") return [{ op: "ref.null", heapType: "any" }];
 	if (typeof w !== "object" || w === null)

package/src/backend/wasm/index.js

@@ -259,6 +259,7 @@ export function compileWasmModule(
 				_isClosure: true,
 				_isYieldClosure: Boolean(node._isYieldClosure),
 				_iterStateName: node._iterStateName ?? null,
+				_forStmt: node._forStmt ?? null,
 				_funcLit: node,
 				_rootFuncDecl: rootFn,
 				_srcFile: rootFn?._srcFile ?? null,
@@ -701,6 +702,13 @@ export function compileWasmModule(
 			),
 		);
 	}
+	// fmt's %p identity of a reference in an `any`: a defined map or func type
+	// is boxed there, so the helper hands the host the boxed reference.
+	if (funcDecls.some((fn) => fn.intrinsic === "fmt_ptr_id")) {
+		funcDecls.push(
+			helper("__any_ref", [{ name: "a", type: ANY_T }], ANY_T, "any_ref"),
+		);
+	}
 	if (mod.hasErrorType) {
 		const errPtr = {
 			kind: "pointer",

package/src/backend/wasm/module-emitter.js

@@ -576,6 +576,7 @@ export class ModuleEmitter {
 		const known = this.taggedSliceTypes.get(key);
 		if (known) return known;
 		const base = this.getSliceType(elemGoType);
+		const root = this.getTaggedSliceRoot(base);
 		const tagIndex = this.taggedSliceTypes.size + 1;
 		const tagTypeIndex = this._getTotalTypeCount();
 		this._pushType({
@@ -589,7 +590,7 @@ export class ModuleEmitter {
 		this._pushType({
 			form: "struct",
 			sub: true,
-			superTypeIndex: base.typeIndex,
+			superTypeIndex: root.typeIndex,
 			fields: [
 				...base.typeEntry.fields,
 				{
@@ -603,6 +604,23 @@ export class ModuleEmitter {
 		return info;
 	}
 
+	// The common supertype of every tagged subtype of the slice type `base`.  An
+	// unnamed `[]int` in an interface is the bare slice type, which every
+	// tagged subtype (`type S []int`) also passes `ref.test` for; testing
+	// "base and not root" is what keeps `any(S{}).([]int)` from matching.
+	getTaggedSliceRoot(base) {
+		if (base.tagRoot) return base.tagRoot;
+		const typeIndex = this._getTotalTypeCount();
+		this._pushType({
+			form: "struct",
+			sub: true,
+			superTypeIndex: base.typeIndex,
+			fields: [...base.typeEntry.fields],
+		});
+		base.tagRoot = { typeIndex };
+		return base.tagRoot;
+	}
+
 	getSliceTypeByIndex(typeIndex) {
 		return this.sliceTypesByIndex?.get(typeIndex) ?? null;
 	}
@@ -1330,61 +1348,60 @@ export class ModuleEmitter {
 			}
 
 			// Promoted methods on sName
-			if (sInfo.embeds && sInfo.embeds.length > 0) {
-				for (const embed of sInfo.embeds) {
-					const embedType = embed.typeName ?? embed.name;
-					const embedMethodName = `${embedType}.${methodName}`;
-					if (this.funcMap.has(embedMethodName)) {
-						const fIdx = this.resolveFuncIndex(embedMethodName);
-						const paramGoTypes = this.getFuncParamGoTypes(embedMethodName);
-						const paramWTypes = this.getFuncParamTypes(embedMethodName);
-						const isPtrRecv = paramGoTypes[0]?.kind === "pointer";
-						const embedSInfo = this.getStructType(embedType);
-
-						const ptrKey = `ptr:${sName}`;
-						if (!seenKeys.has(ptrKey)) {
-							seenKeys.add(ptrKey);
-							candidates.push({
-								recvTypeName: sName,
-								testTypeIndex: sInfo.typeIndex,
-								isBoxedValue: false,
-								needsValueDeref: !isPtrRecv,
-								embedPath: [
-									{
-										parentTypeIndex: sInfo.typeIndex,
-										fieldIndex: embed.fieldIndex,
-									},
-								],
-								funcIndex: fIdx,
-								targetParamTypes: paramWTypes,
-								targetRecvWType: paramWTypes[0],
-								structInfo: embedSInfo,
-							});
-						}
+			const promoted = this._findPromotedMethod(sInfo, methodName);
+			if (promoted?.iface) {
+				this._addIfaceEmbedCandidates(
+					candidates,
+					seenKeys,
+					sName,
+					sInfo,
+					promoted.embedPath,
+				);
+			} else if (promoted) {
+				const { embedType, embedPath, viaPointer } = promoted;
+				const embedMethodName = `${embedType}.${methodName}`;
+				const fIdx = this.resolveFuncIndex(embedMethodName);
+				const paramGoTypes = this.getFuncParamGoTypes(embedMethodName);
+				const paramWTypes = this.getFuncParamTypes(embedMethodName);
+				const isPtrRecv = paramGoTypes[0]?.kind === "pointer";
+				const embedSInfo = this.getStructType(embedType);
+
+				const ptrKey = `ptr:${sName}`;
+				if (!seenKeys.has(ptrKey)) {
+					seenKeys.add(ptrKey);
+					candidates.push({
+						recvTypeName: sName,
+						testTypeIndex: sInfo.typeIndex,
+						isBoxedValue: false,
+						needsValueDeref: !isPtrRecv,
+						embedPath,
+						nilCheckLast: !isPtrRecv,
+						funcIndex: fIdx,
+						targetParamTypes: paramWTypes,
+						targetRecvWType: paramWTypes[0],
+						structInfo: embedSInfo,
+					});
+				}
 
-						if (!isPtrRecv) {
-							const box = this.getIfaceBoxType({ kind: "named", name: sName });
-							const valKey = `val:${sName}`;
-							if (box && !seenKeys.has(valKey)) {
-								seenKeys.add(valKey);
-								candidates.push({
-									recvTypeName: sName,
-									testTypeIndex: box.typeIndex,
-									isBoxedValue: true,
-									needsValueDeref: false,
-									embedPath: [
-										{
-											parentTypeIndex: sInfo.typeIndex,
-											fieldIndex: embed.fieldIndex,
-										},
-									],
-									funcIndex: fIdx,
-									targetParamTypes: paramWTypes,
-									targetRecvWType: paramWTypes[0],
-									structInfo: embedSInfo,
-								});
-							}
-						}
+				// A pointer-receiver method is in the value's method set only
+				// when it is reached through an embedded pointer.
+				if (!isPtrRecv || viaPointer) {
+					const box = this.getIfaceBoxType({ kind: "named", name: sName });
+					const valKey = `val:${sName}`;
+					if (box && !seenKeys.has(valKey)) {
+						seenKeys.add(valKey);
+						candidates.push({
+							recvTypeName: sName,
+							testTypeIndex: box.typeIndex,
+							isBoxedValue: true,
+							needsValueDeref: false,
+							embedPath,
+							nilCheckLast: !isPtrRecv,
+							funcIndex: fIdx,
+							targetParamTypes: paramWTypes,
+							targetRecvWType: paramWTypes[0],
+							structInfo: embedSInfo,
+						});
 					}
 				}
 			}
@@ -1495,6 +1512,116 @@ export class ModuleEmitter {
 		return candidates;
 	}
 
+	// Whether `goType`, the type of an embedded field, is an interface whose
+	// method set has `methodName`.
+	embeddedInterfaceHas(goType, methodName) {
+		let t = goType;
+		for (let i = 0; i < 8 && t; i++) {
+			if (t.kind === "TypeName" || t.kind === "Ident") {
+				const named = this.checker?.types?.get(t.name);
+				if (!named) return t.name === "error" && methodName === "Error";
+				t = named;
+			} else if (t.kind === "named") {
+				t = t.underlying ?? this.checker?.types?.get(t.name)?.underlying;
+			} else if (t.kind === "interface") {
+				return t.methods?.has?.(methodName) ?? false;
+			} else if (t.kind === "InterfaceType") {
+				return (t.methods ?? []).some((m) => (m.name ?? m) === methodName);
+			} else {
+				return false;
+			}
+		}
+		return false;
+	}
+
+	// Dispatch candidates for a method `sName` promotes from an embedded
+	// interface: the embedded value is loaded and dispatched again through the
+	// same dispatcher (`selfDispatch`).
+	_addIfaceEmbedCandidates(candidates, seenKeys, sName, sInfo, embedPath) {
+		const base = {
+			recvTypeName: sName,
+			needsValueDeref: false,
+			embedPath,
+			selfDispatch: true,
+			structInfo: sInfo,
+		};
+		const ptrKey = `ptr:${sName}`;
+		if (!seenKeys.has(ptrKey)) {
+			seenKeys.add(ptrKey);
+			candidates.push({
+				...base,
+				testTypeIndex: sInfo.typeIndex,
+				isBoxedValue: false,
+			});
+		}
+		const box = this.getIfaceBoxType({ kind: "named", name: sName });
+		const valKey = `val:${sName}`;
+		if (box && !seenKeys.has(valKey)) {
+			seenKeys.add(valKey);
+			candidates.push({
+				...base,
+				testTypeIndex: box.typeIndex,
+				isBoxedValue: true,
+			});
+		}
+	}
+
+	// The shallowest embedded type of `sInfo` (any depth) that declares
+	// `methodName`: its name, the field path to reach it from an `sInfo`
+	// struct, and whether that path goes through an embedded pointer. Null
+	// when two embeds at that depth declare it (ambiguous, as in Go).
+	_findPromotedMethod(sInfo, methodName) {
+		let level = [{ info: sInfo, path: [], viaPointer: false }];
+		const seen = new Set([sInfo]);
+		while (level.length > 0) {
+			const next = [];
+			const hits = [];
+			for (const { info, path, viaPointer } of level) {
+				for (const embed of info.embeds ?? []) {
+					const embedType = embed.typeName ?? embed.name;
+					const goType = info.fields?.[embed.fieldIndex]?.goType;
+					const isPtr =
+						goType?.kind === "PointerType" || goType?.kind === "pointer";
+					const step = {
+						path: [
+							...path,
+							{
+								parentTypeIndex: info.typeIndex,
+								fieldIndex: embed.fieldIndex,
+								// An embedded pointer may be nil: reading through it
+								// is a recoverable nil dereference.
+								...(isPtr && {
+									ptrWType: info.fields[embed.fieldIndex].wType,
+								}),
+							},
+						],
+						viaPointer: viaPointer || isPtr,
+					};
+					if (this.embeddedInterfaceHas(goType, methodName)) {
+						hits.push({ iface: true, embedPath: step.path, viaPointer: false });
+						continue;
+					}
+					if (this.funcMap.has(`${embedType}.${methodName}`)) {
+						hits.push({
+							embedType,
+							embedPath: step.path,
+							viaPointer: step.viaPointer,
+						});
+						continue;
+					}
+					// A type reached twice at one depth stays twice in the next
+					// level, so a diamond's method is ambiguous there too.
+					const inner = this.structTypes.get(embedType);
+					if (inner && !seen.has(inner)) next.push({ info: inner, ...step });
+				}
+			}
+			if (hits.length > 0) return hits.length === 1 ? hits[0] : null;
+			for (const n of next) seen.add(n.info);
+			level = next;
+		}
+		return null;
+	}
+
 	// A value-receiver method of a named scalar is also in the method set of
 	// the pointer: `var g Getter = &x` holds a pointer box whose target is read
 	// before the call.
@@ -1560,7 +1687,7 @@ export class ModuleEmitter {
 			}
 
 			// Check struct value (boxed)
-			if (this.checker?.implements?.(namedType, ifaceResolved)) {
+			if (this._valueImplements(namedType, ifaceResolved)) {
 				const box = this.getIfaceBoxType(namedType);
 				if (box && !seen.has(box.typeIndex)) {
 					seen.add(box.typeIndex);
@@ -1578,7 +1705,7 @@ export class ModuleEmitter {
 					tVal.underlying?.kind !== "interface"
 				) {
 					if (this.checker?.implements?.(tVal, ifaceResolved)) {
-						const box = this.getIfaceBoxType(tVal);
+						const box = this._namedValueBox(tVal);
 						if (box && !seen.has(box.typeIndex)) {
 							seen.add(box.typeIndex);
 							candidates.push({ name: tName, typeIndex: box.typeIndex });
@@ -1598,6 +1725,33 @@ export class ModuleEmitter {
 		return candidates;
 	}
 
+	// The WebAssembly type a value of the named non-struct type `tVal` takes
+	// inside an interface: a defined slice type is a tagged slice (see
+	// getTaggedSliceType), anything else an interface box.
+	_namedValueBox(tVal) {
+		if (!isSliceType(tVal, this.checker)) return this.getIfaceBoxType(tVal);
+		const elem = getSliceElemType(tVal, this.checker);
+		return elem ? this.getTaggedSliceType(tVal, elem) : null;
+	}
+
+	// Whether the struct value `namedType` implements `iface`, including when its
+	// pointer-receiver methods are promoted through an embedded pointer, which
+	// puts them in the value's method set (`struct{ *Inner }`).
+	_valueImplements(namedType, iface) {
+		const checker = this.checker;
+		if (checker?.implements?.(namedType, iface)) return true;
+		const ptr = { kind: "pointer", base: namedType };
+		if (!checker?.implements?.(ptr, iface)) return false;
+		const st = checker.resolveType(namedType.underlying);
+		const methods = st?.methods?.size ? st.methods : namedType.methods;
+		const names = [...(iface.methods?.keys() ?? [])];
+		return names.every(
+			(n) =>
+				!methods?.get(n)?._ptrRecv ||
+				checker._promotedThroughPointer(namedType, n),
+		);
+	}
+
 	// `*T` of a named scalar or slice is boxed apart from `T`.
 	_addPtrNamedImplementor(tVal, tName, ifaceResolved, seen, candidates) {
 		const ptrType = { kind: "pointer", base: tVal };

package/src/backend/wasm/monomorph.js

@@ -73,9 +73,20 @@ function rawTypeKey(t) {
 	if (t.kind === "map" || t.kind === "MapType") {
 		return `map_${typeKey(t.key)}_${typeKey(t.value)}`;
 	}
-	if (t.kind === "func" || t.kind === "FuncType") {
+	if (t.kind === "func") {
 		const params = (t.params ?? []).map(typeKey).join("_");
-		const rets = (t.returns ?? []).map(typeKey).join("_");
+		const rets = (t.returns ?? [])
+			.filter((r) => !(r?.kind === "basic" && r.name === "void"))
+			.map(typeKey)
+			.join("_");
+		return `fn_${params}_ret_${rets}`;
+	}
+	if (t.kind === "FuncType") {
+		const params = (t.params ?? []).map((p) => typeKey(p.type)).join("_");
+		const rt = t.returnType;
+		const rets = rt
+			? (rt.kind === "TupleType" ? rt.types : [rt]).map(typeKey).join("_")
+			: "";
 		return `fn_${params}_ret_${rets}`;
 	}
 	if (t.name) return t.name;
@@ -135,9 +146,32 @@ export function typeToTypeNode(t) {
 		};
 	}
 	if (t.kind === "typeParam") return { kind: "TypeName", name: t.name };
+	// Without this a func type argument fell through to `any`, so a
+	// `map[string]V` built in `mk[func()]` was a `map[string]any`.
+	if (t.kind === "func") return funcTypeNode(t);
 	return { kind: "TypeName", name: t.name ?? "any" };
 }
 
+// A checker func type as a `FuncType` node (several results as a `TupleType`).
+function funcTypeNode(t) {
+	// A variadic func lists its last parameter by element type.
+	const params = (t.params ?? []).map((p, i, all) => ({
+		name: "_",
+		type: typeToTypeNode(p),
+		variadic: !!t.variadic && i === all.length - 1,
+	}));
+	const rets = (t.returns ?? []).filter(
+		(r) => !(r?.kind === "basic" && r.name === "void"),
+	);
+	// Several results come as one tuple type or as a list.
+	const results = rets.length === 1 && rets[0]?.types ? rets[0].types : rets;
+	let returnType = null;
+	if (results.length === 1) returnType = typeToTypeNode(results[0]);
+	else if (results.length > 1)
+		returnType = { kind: "TupleType", types: results.map(typeToTypeNode) };
+	return { kind: "FuncType", params, returnType };
+}
+
 // Replaces the type parameters inside a checker type (`[]E`, `map[K]V`,
 // `Box[E]`) by their type arguments; the result mixes checker types and the
 // AST type nodes of the substitution, which `typeKey` and `typeToTypeNode`

package/src/backend/wasm/natives.js

@@ -175,6 +175,10 @@ const WASM_INTRINSICS = {
 			mod.getOrAddFuncImport("env", "fmt_ptr_id", [EXT], ["i32"]),
 		emit: (e) => {
 			e.pushInstruction({ op: "local.get", index: 0 });
+			e.pushInstruction({
+				op: "call",
+				funcIndex: e.mod.resolveFuncIndex("__any_ref"),
+			});
 			e.pushInstruction("extern.convert_any");
 			e.pushInstruction({
 				op: "call",

package/src/backend/wasm/types.js

@@ -407,6 +407,24 @@ export function goTypeKey(t) {
 	if (t.kind === "map" || t.kind === "MapType") {
 		return `map_${goTypeKey(t.key ?? t.keyType)}_${goTypeKey(t.value ?? t.val ?? t.elem ?? t.valueType ?? t.valType)}`;
 	}
+	// Func types differ by signature (`[2]func()` is not `[2]func(int) bool`).
+	// A checker func lists the element type of a variadic parameter, like a
+	// parsed `FuncType`.
+	if (t.kind === "func" || t.kind === "FuncType") {
+		const parsed = t.kind === "FuncType";
+		const params = (t.params ?? []).map((p) => goTypeKey(parsed ? p.type : p));
+		const variadic = parsed ? t.params?.at(-1)?.variadic : t.variadic;
+		const rets = parsed
+			? t.returnType
+				? [t.returnType]
+				: []
+			: (t.returns ?? []).filter(
+					(r) => !(r?.kind === "basic" && r.name === "void"),
+				);
+		return `fn_${variadic ? "v" : ""}${params.join(",")}_${rets.map(goTypeKey).join(",")}`;
+	}
+	if (t.kind === "tuple" || t.kind === "TupleType")
+		return `tup_${(t.types ?? []).map(goTypeKey).join(",")}`;
 	if (t.kind === "struct" || t.kind === "StructType") {
 		if (t.name) return t.name;
 		const rawFields = [];
@@ -480,6 +498,7 @@ function isReplaceableRef(goType, checker) {
 	return (
 		isSliceType(goType, checker) ||
 		isMapType(goType, checker) ||
+		isComplex(goType) ||
 		t?.kind === "pointer" ||
 		t?.kind === "PointerType"
 	);
@@ -523,8 +542,14 @@ export function isSliceType(goType, checker = null) {
 }
 
 // Element kinds whose slices share one WebAssembly representation (a slice of
-// i32), so `[]bool`, `[]byte` and `[]rune` cannot be told apart by `ref.test`.
+// i32, or of i64 for the 64-bit integers), so `[]bool`, `[]byte`, `[]rune` and
+// `[]int` vs `[]int64` cannot be told apart by `ref.test`.
 const TAGGED_SLICE_ELEMS = new Set([
+	"int",
+	"int64",
+	"uint",
+	"uint64",
+	"uintptr",
 	"bool",
 	"int8",
 	"int16",
@@ -536,8 +561,8 @@ const TAGGED_SLICE_ELEMS = new Set([
 	"rune",
 ]);
 
-// True for a defined slice type or a slice of booleans or integers of at
-// most 32 bits.  In an
+// True for a defined slice type, a slice of booleans or integers, or a slice
+// of a method interface.  In an
 // interface such a value carries a per-Go-type tag (see getTaggedSliceType).
 export function isTaggedSliceType(goType, checker = null) {
 	if (!isSliceType(goType, checker)) return false;
@@ -560,6 +585,10 @@ export function isTaggedSliceType(goType, checker = null) {
 			};
 		else break;
 	}
+	// A slice of a method interface (`[]error`) is a slice of `anyref` like
+	// `[]any`, and `[]fmt.Stringer` another one.  `[]any` and `[]interface{}`
+	// are the same type, so neither is tagged.
+	if (isNonEmptyInterface(elem, checker)) return true;
 	return elem?.kind === "basic" && TAGGED_SLICE_ELEMS.has(elem.name);
 }
 

package/src/backend/wasm/variadic.js

@@ -26,13 +26,17 @@ function isStdlibCall(call) {
 }
 
 function packCallArgs(call) {
-	if (call._multiForward || isStdlibCall(call)) return false;
+	// A call node can be reachable twice (`defer f(x)` lowers to a wrapper
+	// whose body lists the same call under `stmts` and `list`): pack it once.
+	if (call._variadicPacked || call._multiForward || isStdlibCall(call))
+		return false;
 	const fn = variadicFuncType(call.func?._type);
 	if (!fn) return false;
 	const n = fn.params.length;
 	const args = call.args ?? [];
 	if (args.length === n && args[n - 1]?._spread) {
 		args[n - 1]._spread = false;
+		call._variadicPacked = true;
 		return true;
 	}
 	if (args.length < n - 1) return false;
@@ -62,6 +66,7 @@ function packCallArgs(call) {
 			_col: call._col,
 		},
 	];
+	call._variadicPacked = true;
 	return true;
 }