gofront 1.8.0 → 1.9.1

package/src/backend/wasm/emit-builtins.js

@@ -2,13 +2,16 @@
 // FunctionEmitter mixin: panic/recover, Go builtins (len, append, make, …) and
 // call expression dispatch (static, method, closure, package).
 
+import { hasCallOrReceive } from "../../lower/walk.js";
+import { goTypeName } from "../shared/fmt-types.js";
 import {
 	anonIfaceName,
+	ERROR_STRUCT,
 	getMapKeyValTypes,
 	isArrayType,
-	isBoolGoType,
 	isComplex,
 	isComplex64,
+	isFuncType,
 	isMapType,
 	isNonEmptyInterface,
 	isScalarType,
@@ -16,7 +19,8 @@ import {
 	isSliceType,
 	isStringType,
 	isStructType,
-	isTestingT,
+	isUnhashableGoType,
+	printOperandKind,
 	toWasmType,
 } from "./types.js";
 
@@ -26,13 +30,32 @@ export class BuiltinsEmitter {
 		const funcIdx = this.mod.getStringImportIndex();
 		this.pushInstruction({ op: "i32.const", value: strIdx });
 		this.pushInstruction({ op: "call", funcIndex: funcIdx });
-		this.pushInstruction("any.convert_extern");
-		this.emitPanicThrow();
+		this.emitRuntimePanicThrow();
 	}
 
-	// Consumes the anyref message on the stack, pushes a PanicNode, and raises the panic via
-	// `env.panic`; `unreachable` tells the validator control never returns.
-	emitPanicThrow() {
+	// Raises a Go runtime error from the externref message on the stack.  A
+	// program that uses `error` recovers it as an `error` value (as Go's
+	// `runtime.Error`); the host still reports the message text.
+	emitRuntimePanicThrow() {
+		if (!this.mod.hasErrorType) {
+			this.pushInstruction("any.convert_extern");
+			this.emitPanicThrow();
+			return;
+		}
+		const msgTmp = this.acquireTemp("externref");
+		this.pushInstruction({ op: "local.tee", index: msgTmp });
+		this.pushInstruction({
+			op: "call",
+			funcIndex: this.mod.resolveFuncIndex("__mk_error"),
+		});
+		this.emitPanicThrow(msgTmp);
+		this.releaseTemp(msgTmp, "externref");
+	}
+
+	// Consumes the anyref value on the stack, pushes a PanicNode, and raises the
+	// panic via `env.panic` (with the value, or the externref message in
+	// `hostMsgTmp`); `unreachable` tells the validator control never returns.
+	emitPanicThrow(hostMsgTmp = null) {
 		const panicNodeTypeIndex = this.mod.getPanicNodeTypeIndex();
 		const panicGlobal = this.mod.getPanicGlobalIndex();
 		const tmpVal = this.acquireTemp("anyref");
@@ -49,8 +72,12 @@ export class BuiltinsEmitter {
 		this.pushInstruction({ op: "global.set", index: panicGlobal });
 
 		// Prepare externref for env.panic
-		this.pushInstruction({ op: "local.get", index: tmpVal });
-		this.pushInstruction("extern.convert_any");
+		if (hostMsgTmp !== null) {
+			this.pushInstruction({ op: "local.get", index: hostMsgTmp });
+		} else {
+			this.pushInstruction({ op: "local.get", index: tmpVal });
+			this.pushInstruction("extern.convert_any");
+		}
 		this.pushInstruction({
 			op: "call",
 			funcIndex: this.mod.getPanicImportIndex(),
@@ -71,9 +98,32 @@ export class BuiltinsEmitter {
 		return null;
 	}
 
+	// `len`/`cap` of an array or array pointer: the constant length.  An
+	// operand containing a call or receive is still evaluated, and its value
+	// (a nil array pointer included) is dropped without being dereferenced.
+	_emitConstArrayLen(call, targetWasmType) {
+		const arg = call.args[0];
+		if (hasCallOrReceive(arg)) {
+			this.emitExpr(
+				arg,
+				this.toWasmType(arg._type ?? this._resolveExprGoType(arg)),
+			);
+			this.pushInstruction("drop");
+		}
+		this.pushInstruction({ op: "i32.const", value: call._constLen });
+		if ((targetWasmType ?? "i64") === "i64")
+			this.pushInstruction("i64.extend_i32_u");
+	}
+
 	_emitBuiltinLen(call, targetWasmType) {
 		const arg = call.args[0];
 		const argType = arg._type ?? this._resolveExprGoType(arg);
+		// `len` of an array (or a pointer to one) is a constant, and the
+		// operand is not evaluated unless it contains a call or a receive.
+		if (call._constLen != null) {
+			this._emitConstArrayLen(call, targetWasmType);
+			return;
+		}
 		if (this._sharedInfo(argType)) {
 			this.emitSharedLen(arg, targetWasmType);
 			return;
@@ -141,6 +191,10 @@ export class BuiltinsEmitter {
 	_emitBuiltinCap(call, targetWasmType) {
 		const arg = call.args[0];
 		const argType = arg._type;
+		if (call._constLen != null) {
+			this._emitConstArrayLen(call, targetWasmType);
+			return;
+		}
 		if (isSliceType(argType, this.mod.checker)) {
 			const elemType = this._getSliceElemType(argType);
 			const sliceInfo = this.mod.getSliceType(elemType);
@@ -223,16 +277,19 @@ export class BuiltinsEmitter {
 				this.pushInstruction({ op: "local.set", index: capTmp });
 			}
 
+			// Go: a negative len is a len panic; otherwise cap < len is a cap panic.
 			this.pushInstruction({ op: "local.get", index: lenTmp });
-			this.pushInstruction({ op: "local.get", index: capTmp });
-			this.pushInstruction("i32.gt_u");
-			this.pushInstruction({ op: "local.get", index: capTmp });
 			this.pushInstruction({ op: "i32.const", value: 0 });
 			this.pushInstruction("i32.lt_s");
-			this.pushInstruction("i32.or");
 			this.pushInstruction({ op: "if", blockType: "void" });
 			this.emitPanic("runtime error: makeslice: len out of range");
 			this.pushInstruction("end");
+			this.pushInstruction({ op: "local.get", index: capTmp });
+			this.pushInstruction({ op: "local.get", index: lenTmp });
+			this.pushInstruction("i32.lt_s");
+			this.pushInstruction({ op: "if", blockType: "void" });
+			this.emitPanic("runtime error: makeslice: cap out of range");
+			this.pushInstruction("end");
 
 			if (
 				isStructType(elemGoType, this.mod.checker, this.mod) ||
@@ -294,11 +351,9 @@ export class BuiltinsEmitter {
 					typeIndex: arrInfo.typeIndex,
 				});
 			} else {
-				this.pushInstruction({ op: "local.get", index: capTmp });
-				this.pushInstruction({
-					op: "array.new_default",
-					typeIndex: arrInfo.typeIndex,
-				});
+				this._emitNewArray(elemGoType, arrInfo, () =>
+					this.pushInstruction({ op: "local.get", index: capTmp }),
+				);
 				this.pushInstruction({ op: "i32.const", value: 0 });
 				this.pushInstruction({ op: "local.get", index: lenTmp });
 				this.pushInstruction({ op: "local.get", index: capTmp });
@@ -397,11 +452,9 @@ export class BuiltinsEmitter {
 		this.pushInstruction({ op: "local.set", index: newCapTmp });
 		this.pushInstruction("end");
 
-		this.pushInstruction({ op: "local.get", index: newCapTmp });
-		this.pushInstruction({
-			op: "array.new_default",
-			typeIndex: arrInfo.typeIndex,
-		});
+		this._emitNewArray(elemGoType, arrInfo, () =>
+			this.pushInstruction({ op: "local.get", index: newCapTmp }),
+		);
 		this.pushInstruction({ op: "local.set", index: newArrTmp });
 		this.pushInstruction({ op: "i32.const", value: 0 });
 		this.pushInstruction({ op: "local.set", index: newOffTmp });
@@ -731,13 +784,21 @@ export class BuiltinsEmitter {
 		for (let i = 0; i < args.length; i++) {
 			const arg = args[i];
 			const isLast = i === args.length - 1 && isPrintln;
-			const isBool =
-				isBoolGoType(arg._type) ||
-				(arg.kind === "BasicLit" && arg.litKind === "BOOL");
-			const wType = toWasmType(arg._type, this.mod.checker);
-			this.emitExpr(arg, wType);
+			const { wType, isBool, widen } = printOperandKind(arg, this.mod.checker);
+			this.emitExpr(
+				arg,
+				widen ? "i32" : toWasmType(arg._type, this.mod.checker),
+			);
+			if (widen) this.pushInstruction("i64.extend_i32_u");
 			const logFuncIdx = this.mod.getLogImportIndex(wType, isLast, isBool);
 			this.pushInstruction({ op: "call", funcIndex: logFuncIdx });
+			// `print` never separates operands; `println` always does.
+			if (!isPrintln) {
+				this.pushInstruction({
+					op: "call",
+					funcIndex: this.mod.getPrintResetIndex(),
+				});
+			}
 		}
 	}
 
@@ -753,7 +814,11 @@ export class BuiltinsEmitter {
 		} else {
 			const goType = this._resolveExprGoType(arg);
 			const wType = toWasmType(goType, this.mod.checker);
-			if (
+			if (goType?.kind === "named" && wType === "externref") {
+				// A defined string type keeps its identity (and methods) in the
+				// panic value, so `recover()` returns it, not the bare string.
+				this.emitExpr(arg, "anyref");
+			} else if (
 				isStringType(goType, this.mod.checker) ||
 				(arg.kind === "BasicLit" && arg.litKind === "STRING") ||
 				wType === "externref"
@@ -868,7 +933,7 @@ export class BuiltinsEmitter {
 			callType?.name === "complex64" ||
 			arg0._type?.name === "float32" ||
 			arg1._type?.name === "float32" ||
-			targetWasmType?.typeName === "$complex64";
+			this._isComplex64Target(targetWasmType);
 		const complexName = is64 ? "complex64" : "complex128";
 		const info = this.mod.getComplexType(complexName);
 		this.emitExpr(arg0, info.elemWType);
@@ -1052,10 +1117,6 @@ export class BuiltinsEmitter {
 	_emitPackageCall(call, targetWasmType) {
 		const { func, args } = call;
 		if (func.kind !== "SelectorExpr") return false;
-		if (isTestingT(func.expr?._type)) {
-			this.emitTestingCall(func, args);
-			return true;
-		}
 		if (
 			func.expr?.name &&
 			(this.resolveLocal(func.expr.name) ||
@@ -1064,97 +1125,9 @@ export class BuiltinsEmitter {
 			return false;
 		const pkgName = func.expr?.name;
 		switch (pkgName) {
-			case "math":
-				this.emitMathCall(func.field, args);
-				return true;
-			case "bits":
-				this.emitBitsCall(func.field, args);
-				return true;
-			case "maps":
-				this.emitMapsCall(func.field, args, targetWasmType);
-				return true;
-			case "slices":
-				this.emitSlicesCall(func.field, args, targetWasmType);
-				return true;
-			case "strings":
-				if (func.field === "NewReader") {
-					this.emitStringsNewReader(call, targetWasmType);
-					return true;
-				}
-				this.emitStringsCall(func.field, args, targetWasmType);
-				return true;
-			case "strconv":
-				this.emitStrconvCall(func.field, args);
-				return true;
-			case "fmt":
-				if (func.field.startsWith("Fprint")) {
-					this.emitFprintCall(func.field, call, targetWasmType);
-					return true;
-				}
-				if (func.field.startsWith("Sscan")) {
-					this.emitSscanCall(func.field, call, targetWasmType);
-					return true;
-				}
-				this.emitFmtCall(func.field, args);
-				return true;
-			case "errors":
-				this.emitErrorsCall(func.field, args);
-				return true;
-			case "utf8":
-				this.emitUtf8Call(func.field, args, targetWasmType);
-				return true;
-			case "sort":
-				this.emitSortCall(func.field, args, targetWasmType);
-				return true;
 			case "shared":
 				this.emitSharedNew(func.field, args);
 				return true;
-			case "unicode":
-				this.emitUnicodeCall(func.field, args, targetWasmType);
-				return true;
-			case "rand":
-				this.emitRandCall(func.field, args, targetWasmType);
-				return true;
-			case "bytes":
-				if (func.field === "NewReader") {
-					this.emitBytesNewReader(call, targetWasmType);
-					return true;
-				}
-				if (func.field === "NewBuffer") {
-					this.emitBytesNewBuffer(call, targetWasmType);
-					return true;
-				}
-				if (func.field === "NewBufferString") {
-					this.emitBytesNewBufferString(call, targetWasmType);
-					return true;
-				}
-				this.emitBytesCall(func.field, args, targetWasmType);
-				return true;
-			case "path":
-			case "filepath":
-				this.emitPathCall(func.field, args);
-				return true;
-			case "html":
-				this.emitHtmlCall(func.field, args);
-				return true;
-			case "io":
-				this.emitIoCall(func.field, call, targetWasmType);
-				return true;
-			case "time":
-				this.emitTimeCall(func.field, call, targetWasmType);
-				return true;
-			case "binary":
-				this.emitBinaryCall(func.field, call, targetWasmType);
-				return true;
-			case "sha256":
-				this.emitSha256Call(func.field, call, targetWasmType);
-				return true;
-			case "hex":
-				this.emitHexCall(func.field, call, targetWasmType);
-				return true;
-			case "base64":
-				this.emitBase64Call(func.field, call, targetWasmType);
-				return true;
 			case "simd":
 				this.emitSimdPackageCall(func.field, args, targetWasmType);
 				return true;
@@ -1191,25 +1164,6 @@ export class BuiltinsEmitter {
 					recvType?.simd === "Mask32x4",
 			);
 		}
-		if (
-			this._emitStdlibReceiverMethod(
-				recvTypeName,
-				func.field,
-				func.expr,
-				args,
-				targetWasmType,
-			)
-		) {
-			return true;
-		}
-		if (recvTypeName === "strings.Builder") {
-			this.emitBuilderMethodCall(func.field, func.expr, args);
-			return true;
-		}
-		if (recvTypeName === "strings.Replacer") {
-			this.emitReplacerMethodCall(func.field, func.expr, args);
-			return true;
-		}
 		if (isNonEmptyInterface(recvType, this.mod.checker)) {
 			const ifaceName = recvTypeName ?? anonIfaceName(recvType);
 			const dispatchName = `__dispatch_${ifaceName}_${func.field}`;
@@ -1303,128 +1257,72 @@ export class BuiltinsEmitter {
 		};
 	}
 
-	_emitStdlibReceiverMethod(
-		recvTypeName,
-		field,
-		expr,
-		args,
-		targetWasmType = null,
-	) {
-		if (recvTypeName === "strings.Builder") {
-			this.emitBuilderMethodCall(field, expr, args, targetWasmType);
-			return true;
-		}
-		if (recvTypeName === "strings.Replacer") {
-			this.emitReplacerMethodCall(field, expr, args);
-			return true;
-		}
-		if (recvTypeName === "bytes.Buffer") {
-			this.emitBytesBufferMethodCall(field, expr, args, targetWasmType);
-			return true;
-		}
-		if (recvTypeName === "strings.Reader") {
-			this.emitStringsReaderMethodCall(field, expr, args, targetWasmType);
-			return true;
-		}
-		if (recvTypeName === "bytes.Reader") {
-			this.emitBytesReaderMethodCall(field, expr, args, targetWasmType);
-			return true;
-		}
-		if (recvTypeName === "time.Time") {
-			this.emitTimeMethodCall(field, expr, args, targetWasmType);
-			return true;
-		}
-		if (recvTypeName === "time.Duration") {
-			this.emitDurationMethodCall(field, expr, args, targetWasmType);
-			return true;
-		}
-		if (
-			recvTypeName === "time.Month" ||
-			recvTypeName === "time.Weekday" ||
-			recvTypeName === "time.Location"
-		) {
-			this.emitTimeAuxMethodCall(
-				recvTypeName,
-				field,
-				expr,
-				args,
-				targetWasmType,
-			);
-			return true;
-		}
-		if (recvTypeName === "io.LimitedReader") {
-			this.emitIoLimitedReaderMethodCall(field, expr, args, targetWasmType);
-			return true;
-		}
-		if (
-			(recvTypeName === "sync.Mutex" || recvTypeName === "sync.RWMutex") &&
-			field !== "RLocker"
-		) {
-			this.emitSyncMutexMethodCall(field, expr, args, targetWasmType);
-			return true;
-		}
-		if (recvTypeName === "sync.Once") {
-			this.emitSyncOnceMethodCall(field, expr, args, targetWasmType);
-			return true;
-		}
-		if (recvTypeName === "sync.WaitGroup") {
-			this.emitSyncWaitGroupMethodCall(field, expr, args, targetWasmType);
-			return true;
-		}
-		if (
-			recvTypeName === "binary.LittleEndian" ||
-			recvTypeName === "binary.BigEndian" ||
-			recvTypeName === "encoding/binary.LittleEndian" ||
-			recvTypeName === "encoding/binary.BigEndian" ||
-			recvTypeName === "binary.ByteOrder" ||
-			recvTypeName === "encoding/binary.ByteOrder"
-		) {
-			this.emitBinaryOrderMethodCall(
-				recvTypeName,
-				field,
-				expr,
-				args,
-				targetWasmType,
-			);
-			return true;
+	// The embedded struct (possibly several levels down) that declares or
+	// forwards `method`: the chain of embeds to follow and the method's name.
+	_findEmbeddedMethod(structInfo, method, seen = new Set()) {
+		if (seen.has(structInfo)) return null;
+		seen.add(structInfo);
+		for (const embed of structInfo.embeds ?? []) {
+			const typeName = embed.typeName ?? embed.name;
+			const methodName = `${typeName}.${method}`;
+			const ifaceType = structInfo.fields[embed.fieldIndex]?.goType;
+			if (this.mod.embeddedInterfaceHas(ifaceType, method))
+				return { chain: [{ structInfo, embed }], ifaceType };
+			if (this.mod.resolveFuncIndex(methodName) !== null)
+				return { chain: [{ structInfo, embed }], methodName };
+			const inner = this.mod.getStructType(typeName);
+			const deeper = inner && this._findEmbeddedMethod(inner, method, seen);
+			if (deeper)
+				return {
+					...deeper,
+					chain: [{ structInfo, embed }, ...deeper.chain],
+				};
 		}
-		if (
-			recvTypeName === "base64.Encoding" ||
-			recvTypeName === "encoding/base64.Encoding"
-		) {
-			this.emitBase64EncodingMethodCall(field, expr, args, targetWasmType);
-			return true;
-		}
-		return false;
+		return null;
 	}
 
 	_emitEmbeddedMethodCall(recvTypeName, func, args, recvType) {
 		const structInfo = this.mod.getStructType(recvTypeName);
 		if (!structInfo) return false;
-		for (const embed of structInfo.embeds) {
-			const embedMethodName = `${embed.name}.${func.field}`;
-			const subIdx = this.mod.resolveFuncIndex(embedMethodName);
-			if (subIdx !== null) {
-				const targetParamTypes = this.mod.getFuncParamTypes(embedMethodName);
-				const baseWType = this.toWasmType(recvType);
-				this.emitExpr(func.expr, baseWType);
-				this.pushInstruction({
-					op: "struct.get",
-					typeIndex: structInfo.typeIndex,
-					fieldIndex: embed.fieldIndex,
-				});
-				for (let i = 0; i < args.length; i++) {
-					const pType = targetParamTypes[i + 1] ?? null;
-					this.emitExpr(args[i], pType);
-				}
-				this.pushInstruction({
-					op: "call",
-					funcIndex: subIdx,
-				});
-				return true;
-			}
+		const found = this._findEmbeddedMethod(structInfo, func.field);
+		if (!found) return false;
+		const { chain, methodName, ifaceType } = found;
+		// A method promoted from an embedded interface is dispatched on the
+		// interface value the last embed holds.
+		const dispatchName = ifaceType
+			? `__dispatch_${this._getReceiverTypeName(ifaceType)}_${func.field}`
+			: null;
+		const subName = dispatchName ?? methodName;
+		const subIdx = this.mod.resolveFuncIndex(subName);
+		if (subIdx === null)
+			throw new Error(`internal: no interface dispatcher ${subName}`);
+		const targetParamTypes = this.mod.getFuncParamTypes(subName);
+		const valueRecv =
+			!ifaceType &&
+			this.mod.getFuncParamGoTypes(methodName)[0]?.kind !== "pointer";
+		this.emitExpr(func.expr, this.toWasmType(recvType));
+		this._emitNilCheck(func.expr._type);
+		for (const [i, { structInfo: owner, embed }] of chain.entries()) {
+			this.pushInstruction({
+				op: "struct.get",
+				typeIndex: owner.typeIndex,
+				fieldIndex: embed.fieldIndex,
+			});
+			// Reading through an embedded nil pointer (to the next embedded
+			// struct, or as a value receiver) is a recoverable nil dereference.
+			const ft = owner.fields[embed.fieldIndex]?.goType;
+			const isPtr = ft?.kind === "pointer" || ft?.kind === "PointerType";
+			if (isPtr && (i < chain.length - 1 || valueRecv)) this._emitNilBranch();
 		}
-		return false;
+		for (let i = 0; i < args.length; i++) {
+			const pType = targetParamTypes[i + 1] ?? null;
+			this.emitExpr(args[i], pType);
+		}
+		this.pushInstruction({
+			op: "call",
+			funcIndex: subIdx,
+		});
+		return true;
 	}
 
 	_emitStaticCall(call) {
@@ -1437,6 +1335,12 @@ export class BuiltinsEmitter {
 			if (targetFuncIdx !== null) {
 				const paramTypes = this.mod.getFuncParamTypes(func.name);
 				const paramGoTypes = this.mod.getFuncParamGoTypes(func.name);
+				if (call._multiForward) {
+					// `f(g())`: g's results are f's arguments as they come.
+					this.emitExpr(args[0], null);
+					this.pushInstruction({ op: "call", funcIndex: targetFuncIdx });
+					return true;
+				}
 				for (let i = 0; i < args.length; i++) {
 					const arg = args[i];
 					const pType = paramTypes[i] ?? null;
@@ -1501,6 +1405,41 @@ export class BuiltinsEmitter {
 		this.releaseTemp(closureTmp, closureWType);
 	}
 
+	// `g(f())` that lowering left unsplit (it splits only statement operands):
+	// f's results go into locals, and g is called with idents carrying each
+	// element's interface-box marks, so each is boxed like any argument. Also
+	// used for method calls, whose argument path expects one value per
+	// parameter. Only when g's callee evaluates no call, so f() still runs
+	// before anything else the call evaluates.
+	_splitForwardedArgs(call) {
+		if (!call._multiForward || call.args?.length !== 1) return null;
+		const inner = call.args[0];
+		const types = inner?._type?.types;
+		if (!Array.isArray(types) || types.length === 0) return null;
+		const holders =
+			inner._fwdIface?.length === types.length ? inner._fwdIface : null;
+		const isMethod =
+			call.func?.kind === "SelectorExpr" &&
+			call.func.expr?._type?.kind !== "namespace";
+		if (!holders && !isMethod) return null;
+		if (hasCallOrReceive(call.func)) return null;
+		this.emitExpr(inner, null);
+		this._fwdArgCounter = (this._fwdArgCounter ?? 0) + 1;
+		const names = types.map((_, i) => `__fwdarg$${this._fwdArgCounter}$${i}`);
+		const locals = types.map((t, i) =>
+			this.allocLocal(names[i], this.toWasmType(t), t, true),
+		);
+		for (let i = locals.length - 1; i >= 0; i--)
+			this.pushInstruction({ op: "local.set", index: locals[i] });
+		const args = names.map((name, i) => ({
+			kind: "Ident",
+			name,
+			_type: types[i],
+			...(holders?.[i] ?? {}),
+		}));
+		return { ...call, args, _multiForward: false };
+	}
+
 	emitCallExpr(call, targetWasmType = null) {
 		if (call._isTypeConversion) {
 			this.emitTypeConversion({
@@ -1520,6 +1459,12 @@ export class BuiltinsEmitter {
 			return;
 		}
 
+		const forwarded = this._splitForwardedArgs(call);
+		if (forwarded) {
+			this.emitCallExpr(forwarded, targetWasmType);
+			return;
+		}
+
 		if (this._emitPackageCall(call, targetWasmType)) {
 			return;
 		}
@@ -1534,4 +1479,687 @@ export class BuiltinsEmitter {
 
 		this._emitClosureCall(call);
 	}
+
+	emitSliceClear(arg, argType) {
+		const elemGoType = this._getSliceElemType(argType);
+		const sliceInfo = this.mod.getSliceType(elemGoType);
+		const arrInfo = sliceInfo.arrInfo;
+
+		const sliceTmp = this.acquireTemp({
+			kind: "ref",
+			nullable: true,
+			typeIndex: sliceInfo.typeIndex,
+		});
+		this.emitExpr(arg, {
+			kind: "ref",
+			nullable: true,
+			typeIndex: sliceInfo.typeIndex,
+		});
+		this.pushInstruction({ op: "local.set", index: sliceTmp });
+
+		this.pushInstruction({ op: "block", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: sliceTmp });
+		this.pushInstruction("ref.is_null");
+		this.pushInstruction({ op: "br_if", depth: 0 });
+
+		const arrTmp = this.acquireTemp({
+			kind: "ref",
+			nullable: true,
+			typeIndex: arrInfo.typeIndex,
+		});
+		const offTmp = this.acquireTemp("i32");
+		const lenTmp = this.acquireTemp("i32");
+		const iLoc = this.acquireTemp("i32");
+
+		this._emitSliceUnpack(sliceTmp, sliceInfo, {
+			arr: arrTmp,
+			off: offTmp,
+			len: lenTmp,
+		});
+
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: iLoc });
+
+		this.pushInstruction({ op: "block", blockType: "void" });
+		this.pushInstruction({ op: "loop", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: iLoc });
+		this.pushInstruction({ op: "local.get", index: lenTmp });
+		this.pushInstruction("i32.ge_s");
+		this.pushInstruction({ op: "br_if", depth: 1 });
+
+		this.pushInstruction({ op: "local.get", index: arrTmp });
+		this.pushInstruction({ op: "local.get", index: offTmp });
+		this.pushInstruction({ op: "local.get", index: iLoc });
+		this.pushInstruction("i32.add");
+		this.emitZeroValue(elemGoType, arrInfo.elemWType);
+		this.pushInstruction({ op: "array.set", typeIndex: arrInfo.typeIndex });
+
+		this.pushInstruction({ op: "local.get", index: iLoc });
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: iLoc });
+		this.pushInstruction({ op: "br", depth: 0 });
+		this.pushInstruction("end");
+		this.pushInstruction("end");
+
+		this.releaseTemp(iLoc, "i32");
+		this.releaseTemp(lenTmp, "i32");
+		this.releaseTemp(offTmp, "i32");
+		this.releaseTemp(arrTmp, {
+			kind: "ref",
+			nullable: true,
+			typeIndex: arrInfo.typeIndex,
+		});
+
+		this.pushInstruction("end");
+		this.releaseTemp(sliceTmp, {
+			kind: "ref",
+			nullable: true,
+			typeIndex: sliceInfo.typeIndex,
+		});
+	}
+
+	// Pushes an integer-ish argument as i32 (Go ints are i64 in this backend).
+	_emitI32Arg(arg) {
+		const wType = toWasmType(arg?._type, this.mod.checker);
+		if (wType === "i64") {
+			this.emitExpr(arg, "i64");
+			this.pushInstruction("i32.wrap_i64");
+		} else {
+			this.emitExpr(arg, "i32");
+		}
+	}
+
+	// `a == b` for two anyref operands (interface values).  `ref.eq` only
+	// accepts eqref, so host strings (internalised externs) are compared via
+	// `str_eq` and anything else by identity.
+	_emitAnyEq() {
+		const idx = this.mod.resolveFuncIndex("__any_eq");
+		if (idx === null) {
+			throw new Error(
+				"internal: anyref equality emitted but __any_eq was not declared (usesAnyEq scan missed a site)",
+			);
+		}
+		this.pushInstruction({ op: "call", funcIndex: idx });
+	}
+
+	// Every `[wasm type index, Go type name]` an `any` can hold in this module,
+	// more specific types last so they overwrite their supertypes.
+	_dynamicTypeNames() {
+		const named = (name) => {
+			const i = name.indexOf("$$");
+			return i < 0
+				? goTypeName({ kind: "named", name })
+				: `${name.slice(i + 2)}.${name.slice(0, i)}`;
+		};
+		const mod = this.mod;
+		const names = [];
+		for (const s of mod.sliceTypes.values())
+			names.push([
+				s.typeIndex,
+				goTypeName({ kind: "slice", elem: s.elemGoType }),
+			]);
+		for (const m of mod.mapTypes.values())
+			names.push([
+				m.typeIndex,
+				goTypeName({ kind: "map", key: m.keyGoType, value: m.valGoType }),
+			]);
+		for (const info of new Set(mod.structTypes.values())) {
+			if (info.isAnon) continue;
+			names.push([
+				info.typeIndex,
+				info.name === ERROR_STRUCT
+					? "*errors.errorString"
+					: `*${named(info.name)}`,
+			]);
+		}
+		for (const c of mod.closureTypes.values())
+			names.push([
+				c.typeIndex,
+				goTypeName({
+					kind: "func",
+					params: c.sig.params,
+					returns: c.sig.returns,
+				}),
+			]);
+		for (const box of mod.ifaceBoxTypes.values())
+			names.push([box.typeIndex, goTypeName(box.goType)]);
+		for (const info of mod.taggedSliceTypes.values())
+			names.push([info.typeIndex, goTypeName(info.goType)]);
+		for (const info of mod.nilBoxTypes.values())
+			names.push([info.typeIndex, goTypeName(info.goType)]);
+		return names;
+	}
+
+	// Body of `__ta_fail(v any, src string, target string, iface int32)`: panics
+	// with Go's failed type assertion message, naming the dynamic type of `v`
+	// from the types the module knows (`src` is the static interface type, or
+	// the first method the target interface needs when `iface` is 1).
+	_emitTypeAssertFail() {
+		const strConst = (text) => {
+			this.pushInstruction({
+				op: "i32.const",
+				value: this.mod.internString(text),
+			});
+			this.pushInstruction({
+				op: "call",
+				funcIndex: this.mod.getStringImportIndex(),
+			});
+		};
+		const concat = () =>
+			this.pushInstruction({
+				op: "call",
+				funcIndex: this.mod.getStringConcatImportIndex(),
+			});
+		const dyn = this.allocLocal(null, "externref");
+		strConst("interface {}");
+		this.pushInstruction({ op: "local.set", index: dyn });
+		const when = (typeIndex, text) => {
+			this.pushInstruction({ op: "local.get", index: 0 });
+			this.pushInstruction({ op: "ref.test", typeIndex });
+			this.pushInstruction({ op: "if", blockType: "void" });
+			strConst(text);
+			this.pushInstruction({ op: "local.set", index: dyn });
+			this.pushInstruction("end");
+		};
+		for (const [typeIndex, text] of this._dynamicTypeNames())
+			when(typeIndex, text);
+		this.pushInstruction({ op: "local.get", index: 0 });
+		this.pushInstruction({
+			op: "call",
+			funcIndex: this.mod.getIsStringImportIndex(),
+		});
+		this.pushInstruction({ op: "if", blockType: "void" });
+		strConst("string");
+		this.pushInstruction({ op: "local.set", index: dyn });
+		this.pushInstruction("end");
+		this.pushInstruction({ op: "local.get", index: 0 });
+		this.pushInstruction("ref.is_null");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		strConst("nil");
+		this.pushInstruction({ op: "local.set", index: dyn });
+		this.pushInstruction("end");
+
+		// An interface target: `<dyn> is not <target>: missing method <M>`.
+		this.pushInstruction({ op: "local.get", index: 3 });
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: 0 });
+		this.pushInstruction("ref.is_null");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		strConst("interface conversion: interface is nil, not ");
+		this.pushInstruction({ op: "local.get", index: 2 });
+		concat();
+		this.emitRuntimePanicThrow();
+		this.pushInstruction("end");
+		strConst("interface conversion: ");
+		this.pushInstruction({ op: "local.get", index: dyn });
+		concat();
+		strConst(" is not ");
+		concat();
+		this.pushInstruction({ op: "local.get", index: 2 });
+		concat();
+		strConst(": missing method ");
+		concat();
+		this.pushInstruction({ op: "local.get", index: 1 });
+		concat();
+		this.emitRuntimePanicThrow();
+		this.pushInstruction("end");
+
+		strConst("interface conversion: ");
+		this.pushInstruction({ op: "local.get", index: 1 });
+		concat();
+		strConst(" is ");
+		concat();
+		this.pushInstruction({ op: "local.get", index: dyn });
+		concat();
+		strConst(", not ");
+		concat();
+		this.pushInstruction({ op: "local.get", index: 2 });
+		concat();
+		this.emitRuntimePanicThrow();
+	}
+
+	// `any_eq` arm for two arrays of one wasm array type (an array stored in
+	// an interface is the array ref itself): equal lengths and elements.
+	_emitAnyArrayEqArm(arrInfo) {
+		const ref = { kind: "ref", nullable: true, typeIndex: arrInfo.typeIndex };
+		for (const idx of [0, 1]) {
+			this.pushInstruction({ op: "local.get", index: idx });
+			this.pushInstruction({ op: "ref.test", typeIndex: arrInfo.typeIndex });
+		}
+		this.pushInstruction("i32.and");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		const a1 = this.allocLocal(null, ref);
+		const a2 = this.allocLocal(null, ref);
+		for (const [src, dst] of [
+			[0, a1],
+			[1, a2],
+		]) {
+			this.pushInstruction({ op: "local.get", index: src });
+			this.pushInstruction({ op: "ref.cast", typeIndex: arrInfo.typeIndex });
+			this.pushInstruction({ op: "local.set", index: dst });
+		}
+		const len = this.allocLocal(null, "i32");
+		this.pushInstruction({ op: "local.get", index: a1 });
+		this.pushInstruction("array.len");
+		this.pushInstruction({ op: "local.tee", index: len });
+		this.pushInstruction({ op: "local.get", index: a2 });
+		this.pushInstruction("array.len");
+		this.pushInstruction("i32.ne");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction("return");
+		this.pushInstruction("end");
+		const i = this.allocLocal(null, "i32");
+		const e1 = this.allocLocal(null, arrInfo.elemWType);
+		const e2 = this.allocLocal(null, arrInfo.elemWType);
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: i });
+		this.pushInstruction({ op: "block", blockType: "void" });
+		this.pushInstruction({ op: "loop", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: i });
+		this.pushInstruction({ op: "local.get", index: len });
+		this.pushInstruction("i32.ge_u");
+		this.pushInstruction({ op: "br_if", depth: 1 });
+		for (const [arr, dst] of [
+			[a1, e1],
+			[a2, e2],
+		]) {
+			this.pushInstruction({ op: "local.get", index: arr });
+			this.pushInstruction({ op: "local.get", index: i });
+			this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+			this.pushInstruction({ op: "local.set", index: dst });
+		}
+		this.emitKeyEq(e1, e2, arrInfo.elemGoType);
+		this.pushInstruction("i32.eqz");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction("return");
+		this.pushInstruction("end");
+		this.pushInstruction({ op: "local.get", index: i });
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: i });
+		this.pushInstruction({ op: "br", depth: 0 });
+		this.pushInstruction("end");
+		this.pushInstruction("end");
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction("return");
+		this.pushInstruction("end");
+	}
+
+	// `any_hash` arm for an array: the wasm array type, then each element,
+	// as `emitKeyHash` combines a static array key (so equal arrays under
+	// `any_eq` hash equal).
+	_emitAnyArrayHashArm(arrInfo) {
+		const ref = { kind: "ref", nullable: true, typeIndex: arrInfo.typeIndex };
+		this.pushInstruction({ op: "local.get", index: 0 });
+		this.pushInstruction({ op: "ref.test", typeIndex: arrInfo.typeIndex });
+		this.pushInstruction({ op: "if", blockType: "void" });
+		const arr = this.allocLocal(null, ref);
+		const h = this.allocLocal(null, "i32");
+		const i = this.allocLocal(null, "i32");
+		const e = this.allocLocal(null, arrInfo.elemWType);
+		this.pushInstruction({ op: "local.get", index: 0 });
+		this.pushInstruction({ op: "ref.cast", typeIndex: arrInfo.typeIndex });
+		this.pushInstruction({ op: "local.set", index: arr });
+		this.pushInstruction({ op: "i32.const", value: arrInfo.typeIndex });
+		this.pushInstruction({ op: "local.set", index: h });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: i });
+		this.pushInstruction({ op: "block", blockType: "void" });
+		this.pushInstruction({ op: "loop", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: i });
+		this.pushInstruction({ op: "local.get", index: arr });
+		this.pushInstruction("array.len");
+		this.pushInstruction("i32.ge_u");
+		this.pushInstruction({ op: "br_if", depth: 1 });
+		this.pushInstruction({ op: "local.get", index: arr });
+		this.pushInstruction({ op: "local.get", index: i });
+		this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+		this.pushInstruction({ op: "local.set", index: e });
+		this.pushInstruction({ op: "local.get", index: h });
+		this.pushInstruction({ op: "i32.const", value: 31 });
+		this.pushInstruction("i32.mul");
+		this.emitKeyHash(e, arrInfo.elemGoType);
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: h });
+		this.pushInstruction({ op: "local.get", index: i });
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: i });
+		this.pushInstruction({ op: "br", depth: 0 });
+		this.pushInstruction("end");
+		this.pushInstruction("end");
+		this.pushInstruction({ op: "local.get", index: h });
+		this.pushInstruction("return");
+		this.pushInstruction("end");
+	}
+
+	emitRuntimeHelper(fn) {
+		const errInfo = this.mod.getStructType(ERROR_STRUCT);
+		switch (fn._isRuntimeHelper) {
+			case "any_eq": {
+				const bothNull = () => {
+					this.pushInstruction({ op: "local.get", index: 0 });
+					this.pushInstruction("ref.is_null");
+					this.pushInstruction({ op: "local.get", index: 1 });
+					this.pushInstruction("ref.is_null");
+				};
+				bothNull();
+				this.pushInstruction("i32.and");
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.pushInstruction({ op: "i32.const", value: 1 });
+				this.pushInstruction("return");
+				this.pushInstruction("end");
+				bothNull();
+				this.pushInstruction("i32.or");
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction("return");
+				this.pushInstruction("end");
+
+				// Check unhashable / uncomparable types
+				const checkUncomparable = (typeIndex) => {
+					this.pushInstruction({ op: "local.get", index: 0 });
+					this.pushInstruction({ op: "ref.test", typeIndex });
+					this.pushInstruction({ op: "local.get", index: 1 });
+					this.pushInstruction({ op: "ref.test", typeIndex });
+					this.pushInstruction("i32.or");
+					this.pushInstruction({ op: "if", blockType: "void" });
+					this.emitPanic("runtime error: comparing uncomparable type");
+					this.pushInstruction("end");
+				};
+				for (const s of this.mod.sliceTypes.values())
+					checkUncomparable(s.typeIndex);
+				for (const m of this.mod.mapTypes.values())
+					checkUncomparable(m.typeIndex);
+				for (const c of this.mod.closureTypes.values())
+					checkUncomparable(c.typeIndex);
+				for (const b of this.mod.ifaceBoxTypes.values()) {
+					if (isUnhashableGoType(b.goType, this.mod.checker))
+						checkUncomparable(b.typeIndex);
+				}
+				for (const a of this.mod.arrayTypes.values()) {
+					if (isUnhashableGoType(a.elemGoType, this.mod.checker))
+						checkUncomparable(a.typeIndex);
+				}
+
+				// Boxed values compare by value (Go: any(3) == any(3), struct values, etc.).
+				for (const box of this.mod.ifaceBoxTypes.values()) {
+					if (isUnhashableGoType(box.goType, this.mod.checker)) continue;
+					for (const idx of [0, 1]) {
+						this.pushInstruction({ op: "local.get", index: idx });
+						this.pushInstruction({ op: "ref.test", typeIndex: box.typeIndex });
+					}
+					this.pushInstruction("i32.and");
+					this.pushInstruction({ op: "if", blockType: "void" });
+					const f1 = this.allocLocal(null, box.wType);
+					const f2 = this.allocLocal(null, box.wType);
+					for (const [src, dst] of [
+						[0, f1],
+						[1, f2],
+					]) {
+						this.pushInstruction({ op: "local.get", index: src });
+						this.pushInstruction({ op: "ref.cast", typeIndex: box.typeIndex });
+						this.pushInstruction({
+							op: "struct.get",
+							typeIndex: box.typeIndex,
+							fieldIndex: 0,
+						});
+						this.pushInstruction({ op: "local.set", index: dst });
+					}
+					this.emitKeyEq(f1, f2, box.goType);
+					this.pushInstruction("return");
+					this.pushInstruction("end");
+				}
+
+				// Arrays compare element by element.
+				for (const a of [...this.mod.arrayTypes.values()]) {
+					if (!isUnhashableGoType(a.elemGoType, this.mod.checker))
+						this._emitAnyArrayEqArm(a);
+				}
+
+				// Strings
+				this.pushInstruction({ op: "local.get", index: 0 });
+				this.pushInstruction({
+					op: "call",
+					funcIndex: this.mod.getIsStringImportIndex(),
+				});
+				this.pushInstruction({ op: "local.get", index: 1 });
+				this.pushInstruction({
+					op: "call",
+					funcIndex: this.mod.getIsStringImportIndex(),
+				});
+				this.pushInstruction("i32.and");
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.pushInstruction({ op: "local.get", index: 0 });
+				this.pushInstruction("extern.convert_any");
+				this.pushInstruction({ op: "local.get", index: 1 });
+				this.pushInstruction("extern.convert_any");
+				this.pushInstruction({
+					op: "call",
+					funcIndex: this.mod.getStringCmpImportIndex("=="),
+				});
+				this.pushInstruction("return");
+				this.pushInstruction("end");
+
+				// Heap reference equality
+				this.pushInstruction({ op: "local.get", index: 0 });
+				this.pushInstruction({ op: "ref.test", heapType: "eq" });
+				this.pushInstruction({ op: "local.get", index: 1 });
+				this.pushInstruction({ op: "ref.test", heapType: "eq" });
+				this.pushInstruction("i32.and");
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.pushInstruction({ op: "local.get", index: 0 });
+				this.pushInstruction({ op: "ref.cast", heapType: "eq" });
+				this.pushInstruction({ op: "local.get", index: 1 });
+				this.pushInstruction({ op: "ref.cast", heapType: "eq" });
+				this.pushInstruction("ref.eq");
+				this.pushInstruction("return");
+				this.pushInstruction("end");
+
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction("return");
+				return;
+			}
+			case "any_ref": {
+				// A tagged slice is a fresh header on each conversion to an `any`:
+				// its backing array is the identity every copy shares.
+				for (const info of this.mod.taggedSliceTypes.values()) {
+					this.pushInstruction({ op: "local.get", index: 0 });
+					this.pushInstruction({ op: "ref.test", typeIndex: info.typeIndex });
+					this.pushInstruction({ op: "if", blockType: "void" });
+					this.pushInstruction({ op: "local.get", index: 0 });
+					this.pushInstruction({ op: "ref.cast", typeIndex: info.typeIndex });
+					this.pushInstruction({
+						op: "struct.get",
+						typeIndex: info.typeIndex,
+						fieldIndex: 0,
+					});
+					this.pushInstruction("return");
+					this.pushInstruction("end");
+				}
+				// A boxed defined map or func value: the reference inside the box.
+				for (const box of this.mod.ifaceBoxTypes.values()) {
+					if (
+						!isMapType(box.goType, this.mod.checker) &&
+						!isFuncType(box.goType, this.mod.checker)
+					)
+						continue;
+					this.pushInstruction({ op: "local.get", index: 0 });
+					this.pushInstruction({ op: "ref.test", typeIndex: box.typeIndex });
+					this.pushInstruction({ op: "if", blockType: "void" });
+					this.pushInstruction({ op: "local.get", index: 0 });
+					this.pushInstruction({ op: "ref.cast", typeIndex: box.typeIndex });
+					this.pushInstruction({
+						op: "struct.get",
+						typeIndex: box.typeIndex,
+						fieldIndex: 0,
+					});
+					this.pushInstruction("return");
+					this.pushInstruction("end");
+				}
+				this.pushInstruction({ op: "local.get", index: 0 });
+				this.pushInstruction("return");
+				return;
+			}
+			case "any_hash": {
+				this.pushInstruction({ op: "local.get", index: 0 });
+				this.pushInstruction("ref.is_null");
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction("return");
+				this.pushInstruction("end");
+
+				// Check unhashable types.  `goType` names the dynamic type in the
+				// panic, as Go does (`main.S`, `main.L`, `func()`).
+				const checkUnhashable = (typeIndex, goType) => {
+					this.pushInstruction({ op: "local.get", index: 0 });
+					this.pushInstruction({ op: "ref.test", typeIndex });
+					this.pushInstruction({ op: "if", blockType: "void" });
+					this.emitPanic(
+						goType
+							? `runtime error: hash of unhashable type ${goTypeName(goType)}`
+							: "runtime error: hash of unhashable type",
+					);
+					this.pushInstruction("end");
+				};
+				// A slice type first built from source syntax (a `TypeName`) names
+				// its element as written.
+				const spelled = (t) =>
+					t?.kind === "TypeName" ? { kind: "basic", name: t.name } : t;
+				// Tagged slices (a defined slice type in an interface) are subtypes
+				// of the plain slice type, so they are tested first.
+				for (const info of this.mod.taggedSliceTypes.values())
+					checkUnhashable(info.typeIndex, info.goType);
+				for (const sliceInfo of this.mod.sliceTypes.values())
+					checkUnhashable(sliceInfo.typeIndex, {
+						kind: "slice",
+						elem: spelled(sliceInfo.elemGoType),
+					});
+				for (const mapInfo of this.mod.mapTypes.values())
+					checkUnhashable(mapInfo.typeIndex, {
+						kind: "map",
+						key: mapInfo.keyGoType,
+						value: mapInfo.valGoType,
+					});
+				for (const closureInfo of this.mod.closureTypes.values())
+					checkUnhashable(closureInfo.typeIndex, {
+						kind: "func",
+						params: closureInfo.sig.params,
+						returns: closureInfo.sig.returns,
+					});
+				for (const box of this.mod.ifaceBoxTypes.values()) {
+					if (isUnhashableGoType(box.goType, this.mod.checker))
+						checkUnhashable(box.typeIndex, box.goType);
+				}
+				for (const arrInfo of this.mod.arrayTypes.values()) {
+					if (isUnhashableGoType(arrInfo.elemGoType, this.mod.checker))
+						checkUnhashable(arrInfo.typeIndex);
+				}
+
+				// Check boxed values (scalars, struct values)
+				for (const box of this.mod.ifaceBoxTypes.values()) {
+					if (isUnhashableGoType(box.goType, this.mod.checker)) continue;
+					this.pushInstruction({ op: "local.get", index: 0 });
+					this.pushInstruction({ op: "ref.test", typeIndex: box.typeIndex });
+					this.pushInstruction({ op: "if", blockType: "void" });
+					const valLoc = this.allocLocal(null, box.wType);
+					this.pushInstruction({ op: "local.get", index: 0 });
+					this.pushInstruction({ op: "ref.cast", typeIndex: box.typeIndex });
+					this.pushInstruction({
+						op: "struct.get",
+						typeIndex: box.typeIndex,
+						fieldIndex: 0,
+					});
+					this.pushInstruction({ op: "local.set", index: valLoc });
+					this.pushInstruction({ op: "i32.const", value: box.typeIndex });
+					this.pushInstruction({ op: "i32.const", value: 31 });
+					this.pushInstruction("i32.mul");
+					this.emitKeyHash(valLoc, box.goType);
+					this.pushInstruction("i32.add");
+					this.pushInstruction("return");
+					this.pushInstruction("end");
+				}
+
+				// Arrays hash element by element.
+				for (const a of [...this.mod.arrayTypes.values()]) {
+					if (!isUnhashableGoType(a.elemGoType, this.mod.checker))
+						this._emitAnyArrayHashArm(a);
+				}
+
+				// Check string
+				this.pushInstruction({ op: "local.get", index: 0 });
+				this.pushInstruction({
+					op: "call",
+					funcIndex: this.mod.getIsStringImportIndex(),
+				});
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.pushInstruction({ op: "local.get", index: 0 });
+				this.pushInstruction("extern.convert_any");
+				this.pushInstruction({
+					op: "call",
+					funcIndex: this.mod.getStringHashImportIndex(),
+				});
+				this.pushInstruction("return");
+				this.pushInstruction("end");
+
+				this.pushInstruction({ op: "i32.const", value: 0 });
+				this.pushInstruction("return");
+				return;
+			}
+			case "ta_fail":
+				this._emitTypeAssertFail();
+				return;
+			case "error_msg":
+				this.pushInstruction({ op: "local.get", index: 0 });
+				this.pushInstruction({
+					op: "struct.get",
+					typeIndex: errInfo.typeIndex,
+					fieldIndex: 0,
+				});
+				this.pushInstruction("return");
+				return;
+			case "mk_error":
+				// nil message (strconv success) → nil error
+				this.pushInstruction({ op: "local.get", index: 0 });
+				this.pushInstruction("any.convert_extern");
+				this.pushInstruction("ref.is_null");
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.pushInstruction({ op: "ref.null", heapType: "any" });
+				this.pushInstruction("return");
+				this.pushInstruction("end");
+				this.pushInstruction({ op: "local.get", index: 0 });
+				this.pushInstruction({
+					op: "struct.new",
+					typeIndex: errInfo.typeIndex,
+				});
+				this.pushInstruction("return");
+				return;
+			case "error_str":
+				this.pushInstruction({ op: "local.get", index: 0 });
+				this.pushInstruction("ref.is_null");
+				this.pushInstruction({ op: "if", blockType: "void" });
+				this.pushInstruction({
+					op: "i32.const",
+					value: this.mod.internString("<nil>"),
+				});
+				this.pushInstruction({
+					op: "call",
+					funcIndex: this.mod.getStringImportIndex(),
+				});
+				this.pushInstruction("return");
+				this.pushInstruction("end");
+				this.pushInstruction({ op: "local.get", index: 0 });
+				this.pushInstruction({
+					op: "call",
+					funcIndex: this.mod.resolveFuncIndex("__dispatch_error_Error"),
+				});
+				this.pushInstruction("return");
+				return;
+			default:
+				throw new Error(`Unknown runtime helper: ${fn._isRuntimeHelper}`);
+		}
+	}
 }