gofront 1.7.0 → 1.9.0

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

@@ -2,15 +2,25 @@
 // FunctionEmitter mixin: panic/recover, Go builtins (len, append, make, …) and
 // call expression dispatch (static, method, closure, package).
 
+import { hasCallOrReceive } from "../../lower/walk.js";
+import { typeStr } from "../../typechecker/types.js";
+import { goTypeName } from "../shared/fmt-types.js";
 import {
+	anonIfaceName,
+	ERROR_STRUCT,
 	getMapKeyValTypes,
 	isArrayType,
+	isComplex,
+	isComplex64,
 	isMapType,
 	isNonEmptyInterface,
+	isScalarType,
+	isSigned,
 	isSliceType,
 	isStringType,
 	isStructType,
-	isTestingT,
+	isUnhashableGoType,
+	printOperandKind,
 	toWasmType,
 } from "./types.js";
 
@@ -20,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();
+	}
+
+	// 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 message on the stack, pushes a PanicNode, and raises the panic via
-	// `env.panic`; `unreachable` tells the validator control never returns.
-	emitPanicThrow() {
+	// 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");
@@ -43,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(),
@@ -65,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;
@@ -135,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);
@@ -217,18 +277,26 @@ 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)) {
+			if (
+				isStructType(elemGoType, this.mod.checker, this.mod) ||
+				isComplex(elemGoType) ||
+				(elemGoType?.kind !== "pointer" &&
+					isArrayType(elemGoType, this.mod.checker))
+			) {
 				const arrTmp = this.acquireTemp({
 					kind: "ref",
 					nullable: true,
@@ -283,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 });
@@ -302,6 +368,49 @@ export class BuiltinsEmitter {
 		}
 	}
 
+	_emitBuiltinNew(call) {
+		const targetType =
+			call._type?.base ??
+			(call.args[0]?.kind === "TypeExpr"
+				? call.args[0].type
+				: call.args[0]?._type) ??
+			call.args[0];
+		if (isStructType(targetType, this.mod.checker, this.mod)) {
+			let structInfo = this._resolveStructInfo({ _type: targetType });
+			if (!structInfo) {
+				const typeName =
+					targetType.kind === "named" ? targetType.name : targetType.name;
+				if (typeName) structInfo = this.mod.getStructType(typeName);
+			}
+			if (!structInfo) {
+				throw new Error(
+					`Unknown struct in new: ${targetType.name ?? targetType}`,
+				);
+			}
+			for (const f of structInfo.fields) {
+				this.emitZeroValue(f.goType, f.wType);
+			}
+			this.pushInstruction({
+				op: "struct.new",
+				typeIndex: structInfo.typeIndex,
+			});
+			return;
+		}
+		if (isArrayType(targetType, this.mod.checker)) {
+			const wType = this.toWasmType(targetType);
+			this.emitZeroValue(targetType, wType);
+			return;
+		}
+		const box = this.mod.getBoxType(targetType);
+		const valWType = this.toWasmType(targetType);
+		this.emitZeroValue(targetType, valWType);
+		this.pushInstruction({
+			op: "struct.new",
+			typeIndex: box.typeIndex,
+			typeName: box.name,
+		});
+	}
+
 	// With `newLen` already computed: when it exceeds the old capacity, allocate
 	// a doubled (min 2, at least newLen) backing array and copy the old elements
 	// into it at offset 0; otherwise reuse the old array, offset and capacity.
@@ -343,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 });
@@ -374,6 +481,17 @@ export class BuiltinsEmitter {
 		this.pushInstruction("end");
 	}
 
+	// The source operand of `append(b, x...)` and `copy(b, x)`: a string
+	// (the only non-slice form Go allows) is converted to a fresh byte slice.
+	_emitSliceOperand(node, elemGoType, sliceWType) {
+		if (isStringType(node._type, this.mod.checker)) {
+			this.emitExpr(node, "externref");
+			this._emitStringToByteSlice({ kind: "slice", elem: elemGoType });
+			return;
+		}
+		this.emitExpr(node, sliceWType);
+	}
+
 	_emitBuiltinAppend(call) {
 		const { args } = call;
 		const sNode = args[0];
@@ -428,7 +546,7 @@ export class BuiltinsEmitter {
 
 		if (args.length === 2 && args[1]._spread) {
 			const s2Tmp = this.acquireTemp(sliceWType);
-			this.emitExpr(args[1], sliceWType);
+			this._emitSliceOperand(args[1], elemGoType, sliceWType);
 			this.pushInstruction({ op: "local.set", index: s2Tmp });
 
 			const s2ArrTmp = this.acquireTemp(arrWType);
@@ -487,7 +605,7 @@ export class BuiltinsEmitter {
 					this.pushInstruction("i32.add");
 				}
 				this.emitExpr(elemNode, arrInfo.elemWType);
-				this._emitCopyIfValueStruct(elemNode, elemGoType, arrInfo.elemWType);
+				this._emitCopyIfValue(elemNode, elemGoType, arrInfo.elemWType);
 				this.pushInstruction({
 					op: "array.set",
 					typeIndex: arrInfo.typeIndex,
@@ -538,7 +656,7 @@ export class BuiltinsEmitter {
 		this.pushInstruction({ op: "local.set", index: dstTmp });
 
 		const srcTmp = this.acquireTemp(sliceWType);
-		this.emitExpr(srcNode, sliceWType);
+		this._emitSliceOperand(srcNode, elemGoType, sliceWType);
 		this.pushInstruction({ op: "local.set", index: srcTmp });
 
 		const nTmp = this.acquireTemp("i32");
@@ -666,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 =
-				arg._type?.name === "bool" ||
-				(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(),
+				});
+			}
 		}
 	}
 
@@ -688,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"
@@ -795,6 +925,136 @@ export class BuiltinsEmitter {
 		}
 	}
 
+	_emitBuiltinComplex(call, targetWasmType) {
+		const arg0 = call.args[0];
+		const arg1 = call.args[1];
+		const callType = call._type;
+		const is64 =
+			callType?.name === "complex64" ||
+			arg0._type?.name === "float32" ||
+			arg1._type?.name === "float32" ||
+			this._isComplex64Target(targetWasmType);
+		const complexName = is64 ? "complex64" : "complex128";
+		const info = this.mod.getComplexType(complexName);
+		this.emitExpr(arg0, info.elemWType);
+		this.emitExpr(arg1, info.elemWType);
+		this.pushInstruction({
+			op: "struct.new",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+		});
+	}
+
+	_emitBuiltinReal(call, targetWasmType) {
+		const arg = call.args[0];
+		const argType = arg._type ?? this._resolveExprGoType(arg);
+		const is64 = isComplex64(argType);
+		const complexName = is64 ? "complex64" : "complex128";
+		const info = this.mod.getComplexType(complexName);
+		const complexWType = {
+			kind: "ref",
+			nullable: true,
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+		};
+		this.emitExpr(arg, complexWType);
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 0,
+		});
+		if (targetWasmType && targetWasmType !== info.elemWType) {
+			if (info.elemWType === "f32" && targetWasmType === "f64") {
+				this.pushInstruction("f64.promote_f32");
+			} else if (info.elemWType === "f64" && targetWasmType === "f32") {
+				this.pushInstruction("f32.demote_f64");
+			}
+		}
+	}
+
+	_emitBuiltinImag(call, targetWasmType) {
+		const arg = call.args[0];
+		const argType = arg._type ?? this._resolveExprGoType(arg);
+		const is64 = isComplex64(argType);
+		const complexName = is64 ? "complex64" : "complex128";
+		const info = this.mod.getComplexType(complexName);
+		const complexWType = {
+			kind: "ref",
+			nullable: true,
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+		};
+		this.emitExpr(arg, complexWType);
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 1,
+		});
+		if (targetWasmType && targetWasmType !== info.elemWType) {
+			if (info.elemWType === "f32" && targetWasmType === "f64") {
+				this.pushInstruction("f64.promote_f32");
+			} else if (info.elemWType === "f64" && targetWasmType === "f32") {
+				this.pushInstruction("f32.demote_f64");
+			}
+		}
+	}
+
+	// min/max fold left over the operands: floats use f32/f64.min/max (NaN
+	// propagates, -0 < +0), integers `select` on lt/gt, strings compare via the
+	// string import.  A single operand is the result itself.
+	_emitBuiltinMinMax(call, targetWasmType) {
+		const isMin = call.func.name === "min";
+		const goType = call._type ?? this._resolveExprGoType(call.args[0]);
+		const wType =
+			goType?.kind === "untyped" && typeof targetWasmType === "string"
+				? targetWasmType
+				: toWasmType(goType, this.mod.checker);
+		const [first, ...rest] = call.args;
+		this.emitExpr(first, wType);
+		if (rest.length === 0) return;
+		const acc = this.acquireTemp(wType);
+		const next = this.acquireTemp(wType);
+		const isStr = isStringType(goType, this.mod.checker);
+		const isFloatType = wType === "f32" || wType === "f64";
+		const cmp = isMin ? "lt" : "gt";
+		for (const arg of rest) {
+			this.pushInstruction({ op: "local.set", index: acc });
+			this.emitExpr(arg, wType);
+			this.pushInstruction({ op: "local.set", index: next });
+			if (isFloatType) {
+				this.pushInstruction({ op: "local.get", index: acc });
+				this.pushInstruction({ op: "local.get", index: next });
+				this.pushInstruction(`${wType}.${isMin ? "min" : "max"}`);
+				continue;
+			}
+			if (isStr) {
+				// next < acc (min) / next > acc (max) ? next : acc
+				this.pushInstruction({ op: "local.get", index: next });
+				this.pushInstruction({ op: "local.get", index: acc });
+				this.pushInstruction({
+					op: "call",
+					funcIndex: this.mod.getStringCmpImportIndex(isMin ? "<" : ">"),
+				});
+				this.pushInstruction({ op: "if", blockType: wType });
+				this.pushInstruction({ op: "local.get", index: next });
+				this.pushInstruction("else");
+				this.pushInstruction({ op: "local.get", index: acc });
+				this.pushInstruction("end");
+				continue;
+			}
+			this.pushInstruction({ op: "local.get", index: next });
+			this.pushInstruction({ op: "local.get", index: acc });
+			this.pushInstruction({ op: "local.get", index: next });
+			this.pushInstruction({ op: "local.get", index: acc });
+			this.pushInstruction(`${wType}.${cmp}_${isSigned(goType) ? "s" : "u"}`);
+			this.pushInstruction("select");
+		}
+		this.releaseTemp(next, wType);
+		this.releaseTemp(acc, wType);
+	}
+
 	_emitBuiltinCall(call, targetWasmType) {
 		const { func } = call;
 		if (func.kind !== "Ident") return false;
@@ -808,6 +1068,9 @@ export class BuiltinsEmitter {
 			case "cap":
 				this._emitBuiltinCap(call, targetWasmType);
 				return true;
+			case "new":
+				this._emitBuiltinNew(call);
+				return true;
 			case "make":
 				this._emitBuiltinMake(call);
 				return true;
@@ -833,6 +1096,19 @@ export class BuiltinsEmitter {
 			case "recover":
 				this._emitBuiltinRecover(call, targetWasmType);
 				return true;
+			case "complex":
+				this._emitBuiltinComplex(call, targetWasmType);
+				return true;
+			case "real":
+				this._emitBuiltinReal(call, targetWasmType);
+				return true;
+			case "imag":
+				this._emitBuiltinImag(call, targetWasmType);
+				return true;
+			case "min":
+			case "max":
+				this._emitBuiltinMinMax(call, targetWasmType);
+				return true;
 			default:
 				return false;
 		}
@@ -841,95 +1117,17 @@ 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) ||
+				this.mod.resolveGlobal(func.expr.name))
+		)
+			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;
-				}
-				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;
@@ -961,29 +1159,13 @@ export class BuiltinsEmitter {
 				func.expr,
 				args,
 				targetWasmType,
+				recvTypeName === "simd.Mask32x4" ||
+					recvType?.underlying?.simd === "Mask32x4" ||
+					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 ?? "anon";
+			const ifaceName = recvTypeName ?? anonIfaceName(recvType);
 			const dispatchName = `__dispatch_${ifaceName}_${func.field}`;
 			const targetFuncIdx = this.mod.resolveFuncIndex(dispatchName);
 			if (targetFuncIdx !== null) {
@@ -994,7 +1176,7 @@ export class BuiltinsEmitter {
 					const pType = targetParamTypes[i + 1] ?? null;
 					const pGoType = paramGoTypes[i + 1] ?? null;
 					this.emitExpr(args[i], pType);
-					this._emitCopyIfValueStruct(args[i], pGoType, pType);
+					this._emitCopyIfValue(args[i], pGoType, pType);
 				}
 				this.pushInstruction({ op: "call", funcIndex: targetFuncIdx });
 				return true;
@@ -1016,14 +1198,20 @@ export class BuiltinsEmitter {
 			if (targetFuncIdx !== null) {
 				const recvWType = targetParamTypes[0] ?? null;
 				const recvGoType = this.mod.getFuncParamGoTypes(methodName)[0] ?? null;
-				this.emitExpr(func.expr, recvWType);
-				this._emitCopyIfValueStruct(func.expr, recvGoType, recvWType);
+				this.emitExpr(this._recvOperand(func, recvGoType), recvWType);
+				// `p.M()` with a value receiver reads `*p`: a nil `p` panics here.
+				if (
+					recvGoType?.kind !== "pointer" &&
+					isStructType(recvGoType, this.mod.checker, this.mod)
+				)
+					this._emitNilCheck(func.expr._type);
+				this._emitCopyIfValue(func.expr, recvGoType, recvWType);
 				const paramGoTypes = this.mod.getFuncParamGoTypes(methodName);
 				for (let i = 0; i < args.length; i++) {
 					const pType = targetParamTypes[i + 1] ?? null;
 					const pGoType = paramGoTypes[i + 1] ?? null;
 					this.emitExpr(args[i], pType);
-					this._emitCopyIfValueStruct(args[i], pGoType, pType);
+					this._emitCopyIfValue(args[i], pGoType, pType);
 				}
 				this.pushInstruction({ op: "call", funcIndex: targetFuncIdx });
 				return true;
@@ -1032,111 +1220,97 @@ export class BuiltinsEmitter {
 		return false;
 	}
 
-	_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 === "io.LimitedReader") {
-			this.emitIoLimitedReaderMethodCall(field, expr, args, targetWasmType);
-			return true;
-		}
-		if (recvTypeName === "sync.Mutex" || recvTypeName === "sync.RWMutex") {
-			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;
+	// The receiver operand of a method call: `p.Get()` with a value receiver
+	// and `p *N` (a named scalar or slice) passes `*p`.
+	_recvOperand(func, recvGoType) {
+		const t = func.expr._type;
+		// A pointer receiver on `*p` gets `p` itself, so the method mutates *p.
+		if (recvGoType?.kind === "pointer") {
+			const pointer = this._structDerefPointer(func.expr);
+			if (pointer) return pointer;
 		}
 		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;
-		}
+			t?.kind === "pointer" &&
+			recvGoType?.kind !== "pointer" &&
+			(isScalarType(t.base, this.mod.checker, this.mod) ||
+				isSliceType(t.base, this.mod.checker))
+		)
+			return { kind: "UnaryExpr", op: "*", operand: func.expr, _type: t.base };
+		return this._ptrRecvOperand(func);
+	}
+
+	// `x.M()` with a pointer receiver on a named scalar value passes `&x`
+	// (the typechecker boxed `x`).
+	_ptrRecvOperand(func) {
+		const t = func.expr._type;
+		if (!func._type?._ptrRecv || t?.kind !== "named") return func.expr;
 		if (
-			recvTypeName === "base64.Encoding" ||
-			recvTypeName === "encoding/base64.Encoding"
-		) {
-			this.emitBase64EncodingMethodCall(field, expr, args, targetWasmType);
-			return true;
+			!isScalarType(t, this.mod.checker, this.mod) &&
+			!isSliceType(t, this.mod.checker)
+		)
+			return func.expr;
+		return {
+			kind: "UnaryExpr",
+			op: "&",
+			operand: func.expr,
+			_type: { kind: "pointer", base: t },
+		};
+	}
+
+	// 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}`;
+			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 {
+					chain: [{ structInfo, embed }, ...deeper.chain],
+					methodName: deeper.methodName,
+				};
 		}
-		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 } = found;
+		const subIdx = this.mod.resolveFuncIndex(methodName);
+		const targetParamTypes = this.mod.getFuncParamTypes(methodName);
+		const valueRecv =
+			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) {
@@ -1149,12 +1323,18 @@ 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;
 					const pGoType = paramGoTypes[i] ?? null;
 					this.emitExpr(arg, pType);
-					this._emitCopyIfValueStruct(arg, pGoType, pType);
+					this._emitCopyIfValue(arg, pGoType, pType);
 				}
 				this.pushInstruction({ op: "call", funcIndex: targetFuncIdx });
 				return true;
@@ -1175,6 +1355,8 @@ export class BuiltinsEmitter {
 
 		const closureTmp = this.acquireTemp(closureWType);
 		this.emitExpr(func, closureWType);
+		// Calling a nil func value panics like a nil pointer dereference.
+		this._emitNilBranch();
 		this.pushInstruction({ op: "local.set", index: closureTmp });
 
 		// Push param 0: env (anyref)
@@ -1191,7 +1373,7 @@ export class BuiltinsEmitter {
 			const pWType = closureInfo.paramWTypes[i] ?? null;
 			const pGoType = closureInfo.sig.params[i] ?? null;
 			this.emitExpr(arg, pWType);
-			this._emitCopyIfValueStruct(arg, pGoType, pWType);
+			this._emitCopyIfValue(arg, pGoType, pWType);
 		}
 
 		// Push funcref
@@ -1244,4 +1426,499 @@ 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 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();
+	}
+
+	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");
+				}
+
+				// 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_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
+				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 ${typeStr(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;
+				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);
+				for (const box of this.mod.ifaceBoxTypes.values()) {
+					if (isUnhashableGoType(box.goType, this.mod.checker))
+						checkUnhashable(box.typeIndex);
+				}
+				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");
+				}
+
+				// 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}`);
+		}
+	}
 }