gofront 1.7.0 → 1.9.0

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

@@ -1,21 +1,55 @@
 // src/backend/wasm/emit-exprs.js
 // FunctionEmitter mixin: expression emission (literals, operators, indexing, conversions).
 
-import { foldConstExpr } from "./const-fold.js";
 import {
+	constFromLit,
+	constIntValue,
+	constToLit,
+	foldConstExpr,
+} from "../../typechecker/const-fold.js";
+import {
+	compositeLitIndices,
+	compositeLitMaxIndex,
+} from "../../typechecker/types.js";
+import { goTypeName } from "../shared/fmt-types.js";
+import { emitWasmNative } from "./natives.js";
+import {
+	getInterfaceMethodList,
 	getMapKeyValTypes,
 	isAnyType,
 	isArrayType,
+	isComplex,
+	isComplex64,
 	isFuncType,
 	isMapType,
+	isNonEmptyInterface,
 	isPointerToStruct,
+	isRuneSlice,
+	isScalarType,
 	isSigned,
 	isSliceType,
 	isStringType,
 	isStructType,
+	isTaggedSliceType,
 	toWasmType,
 } from "./types.js";
 
+// Engine limit on `array.new_fixed` operands.
+const MAX_NEW_FIXED = 10000;
+
+// An untyped integral float constant (`1e18 + 1`) in an integer context is
+// emitted from its exact integer value.
+function constLitFor(val, targetWasmType) {
+	const i = constIntValue(val);
+	if (
+		val.k === "FLOAT" &&
+		i !== null &&
+		(targetWasmType === "i64" || targetWasmType === "i32")
+	)
+		return constToLit({ k: "INT", v: i });
+	return constToLit(val);
+}
+
 export class ExprsEmitter {
 	emitExpr(expr, targetWasmType = null) {
 		if (!expr) return;
@@ -36,7 +70,7 @@ export class ExprsEmitter {
 			}
 
 			if (
-				isStringType(goType, this.mod.checker) ||
+				(isStringType(goType, this.mod.checker) && goType?.kind !== "named") ||
 				(expr.kind === "BasicLit" && expr.litKind === "STRING")
 			) {
 				this._emitRawExpr(expr, "externref");
@@ -50,6 +84,7 @@ export class ExprsEmitter {
 			// for type switches and assertions.
 			if (isPointerToStruct(goType, this.mod.checker, this.mod)) {
 				this._emitRawExpr(expr, this.toWasmType(goType));
+				this._emitNilAwareAny(goType, expr);
 				return;
 			}
 			if (isStructType(goType, this.mod.checker, this.mod)) {
@@ -70,6 +105,15 @@ export class ExprsEmitter {
 				return;
 			}
 
+			// A defined func or map type with methods is boxed to keep its identity,
+			// so interface dispatch can tell it from the plain func or map type.
+			if (this._isMethodNamedRef(goType)) {
+				const box = this.mod.getIfaceBoxType(this._resolveTestTarget(goType));
+				this._emitRawExpr(expr, box.wType);
+				this._emitBoxValue(box);
+				return;
+			}
+
 			if (
 				isSliceType(goType, this.mod.checker) ||
 				isArrayType(goType, this.mod.checker) ||
@@ -78,6 +122,16 @@ export class ExprsEmitter {
 			) {
 				const refWType = this.toWasmType(goType);
 				this._emitRawExpr(expr, refWType);
+				// An array stored in an interface is a copy.
+				if (isArrayType(goType, this.mod.checker))
+					this._emitCopyIfValue(expr, goType, refWType);
+				if (isTaggedSliceType(goType, this.mod.checker))
+					this._emitTagSlice(goType, refWType);
+				if (
+					isFuncType(goType, this.mod.checker) ||
+					isMapType(goType, this.mod.checker)
+				)
+					this._emitNilAwareAny(goType, expr);
 				return;
 			}
 
@@ -92,6 +146,102 @@ export class ExprsEmitter {
 		this._emitRawExpr(expr, targetWasmType);
 	}
 
+	// Panics with Go's failed type assertion message: the static interface
+	// type, the dynamic type of the value in `anyTmp` and the target type.
+	_emitTypeAssertPanic(expr, anyTmp) {
+		const checker = this.mod.checker;
+		const target = this._resolveTestTarget(expr._type ?? expr.type);
+		const iface = isNonEmptyInterface(target, checker);
+		this.pushInstruction({ op: "local.get", index: anyTmp });
+		if (iface) {
+			const names = getInterfaceMethodList(target.underlying ?? target)
+				.map((m) => m.name)
+				.sort();
+			this._pushStringConst(names[0] ?? "");
+		} else {
+			this._pushStringConst(this._assertSrcName(expr.expr?._type));
+		}
+		this._pushStringConst(
+			target.name === "error" ? "error" : goTypeName(target),
+		);
+		this.pushInstruction({ op: "i32.const", value: iface ? 1 : 0 });
+		this.pushInstruction({
+			op: "call",
+			funcIndex: this.mod.resolveFuncIndex("__ta_fail"),
+		});
+		this.pushInstruction("unreachable");
+	}
+
+	// The static interface type of an assertion operand as Go names it.
+	_assertSrcName(srcType) {
+		if (!srcType || !isNonEmptyInterface(srcType, this.mod.checker))
+			return "interface {}";
+		return srcType.name === "error" ? "error" : goTypeName(srcType);
+	}
+
+	// Pushes the interned string `text` as an externref.
+	_pushStringConst(text) {
+		this.pushInstruction({
+			op: "i32.const",
+			value: this.mod.internString(text),
+		});
+		this.pushInstruction({
+			op: "call",
+			funcIndex: this.mod.getStringImportIndex(),
+		});
+	}
+
+	// The slice on the stack becomes the tagged subtype of its Go type, so a
+	// type test can tell `[]byte` from `[]bool` (see getTaggedSliceType).  The
+	// copy shares the backing array; slice headers are immutable.
+	_emitTagSlice(goType, refWType) {
+		const tagged = this.mod.getTaggedSliceType(
+			goType,
+			this._getSliceElemType(goType),
+		);
+		const base = tagged.base;
+		const tmp = this.acquireTemp(refWType);
+		this.pushInstruction({ op: "local.tee", index: tmp });
+		this.pushInstruction("ref.is_null");
+		this.pushInstruction({
+			op: "if",
+			blockType: { kind: "ref", nullable: true, typeIndex: base.typeIndex },
+		});
+		this.pushInstruction({ op: "global.get", index: base.emptyGlobalIndex });
+		this.pushInstruction("else");
+		this.pushInstruction({ op: "local.get", index: tmp });
+		this.pushInstruction("end");
+		this.pushInstruction({ op: "local.set", index: tmp });
+		for (let i = 0; i < 4; i++) {
+			this.pushInstruction({ op: "local.get", index: tmp });
+			this.pushInstruction({
+				op: "struct.get",
+				typeIndex: base.typeIndex,
+				fieldIndex: i,
+			});
+		}
+		this.pushInstruction({ op: "ref.null", heapType: tagged.tagTypeIndex });
+		this.pushInstruction({ op: "struct.new", typeIndex: tagged.typeIndex });
+		this.releaseTemp(tmp, refWType);
+	}
+
+	// The nullable ref on the stack becomes an interface value: a nil map, func
+	// or pointer turns into the marker of its type (never a nil interface).
+	_emitNilAwareAny(goType, expr) {
+		if (expr.kind === "UnaryExpr" && expr.op === "&") return;
+		if (expr.kind === "CompositeLit" || expr.kind === "FuncLit") return;
+		const nilBox = this.mod.getNilBoxType(goType);
+		const tmp = this.acquireTemp(this.toWasmType(goType));
+		this.pushInstruction({ op: "local.tee", index: tmp });
+		this.pushInstruction("ref.is_null");
+		this.pushInstruction({ op: "if", blockType: "anyref" });
+		this.pushInstruction({ op: "global.get", index: nilBox.globalIndex });
+		this.pushInstruction("else");
+		this.pushInstruction({ op: "local.get", index: tmp });
+		this.pushInstruction("end");
+		this.releaseTemp(tmp, this.toWasmType(goType));
+	}
+
 	_emitBoxValue(box) {
 		this.pushInstruction({
 			op: "ref.null",
@@ -116,6 +266,9 @@ export class ExprsEmitter {
 					return { kind: "nil", name: "nil" };
 			}
 		}
+		if (expr.kind === "ImagLit") {
+			return { kind: "untyped", base: "complex128" };
+		}
 		if (expr.kind === "Ident") {
 			const local = this.resolveLocal(expr.name);
 			if (local) return local.goType;
@@ -128,23 +281,46 @@ export class ExprsEmitter {
 		return null;
 	}
 
+	_emitLocalConst(ident, targetWasmType) {
+		const lit = constLitFor(ident._const, targetWasmType);
+		if (!lit) return false;
+		lit._type = ident._type;
+		this.emitBasicLit(lit, targetWasmType);
+		return true;
+	}
+
 	_emitRawExpr(expr, targetWasmType = null) {
 		if (expr.kind === "BinaryExpr" || expr.kind === "UnaryExpr") {
-			const folded = foldConstExpr(expr, (name) =>
-				this.mod.pkgConsts?.get(name),
-			);
+			// The checker's exact value (src/typechecker/const-fold.js) when it has one.
+			const folded = expr._const
+				? constLitFor(expr._const, targetWasmType)
+				: foldConstExpr(expr, (name) => this.mod.pkgConsts?.get(name));
 			if (folded) {
 				folded._type = expr._type;
 				this.emitBasicLit(folded, targetWasmType);
 				return;
 			}
 		}
+		// A function-local constant is a local slot (so closures can capture it)
+		// but reads as the checker's exact value, which adapts to the context.
+		if (
+			expr.kind === "Ident" &&
+			expr._const &&
+			this.resolveLocal(expr.name) &&
+			this._emitLocalConst(expr, targetWasmType)
+		)
+			return;
+		if (this._emitFoldedIntConversion(expr, targetWasmType)) return;
 
 		switch (expr.kind) {
 			case "BasicLit":
 				this.emitBasicLit(expr, targetWasmType);
 				break;
 
+			case "ImagLit":
+				this.emitImagLit(expr, targetWasmType);
+				break;
+
 			case "Ident":
 				this.emitIdent(expr, targetWasmType);
 				break;
@@ -158,7 +334,8 @@ export class ExprsEmitter {
 				break;
 
 			case "CallExpr":
-				this.emitCallExpr(expr, targetWasmType);
+				if (!emitWasmNative(this, expr, targetWasmType))
+					this.emitCallExpr(expr, targetWasmType);
 				break;
 
 			case "TypeConversion":
@@ -172,20 +349,6 @@ export class ExprsEmitter {
 			case "SelectorExpr": {
 				const deq = this._dequalify(expr);
 				if (deq) this.emitIdent(deq, targetWasmType);
-				else if (this._isMathConst(expr))
-					this.emitMathConst(expr.field, targetWasmType);
-				else if (this._isUtf8Const(expr))
-					this.emitUtf8Const(expr.field, targetWasmType);
-				else if (this._isStrconvConst(expr))
-					this.emitStrconvConst(expr.field, targetWasmType);
-				else if (this._isPathConst(expr))
-					this.emitPathConst(expr.field, targetWasmType);
-				else if (this._isIoConst(expr))
-					this.emitIoConst(expr.field, targetWasmType);
-				else if (this._isTimeConst(expr))
-					this.emitTimeConst(expr.field, targetWasmType);
-				else if (this._isExtendedPkgConst?.(expr))
-					this.emitExtendedPkgConst(expr, targetWasmType);
 				else this.emitSelectorExpr(expr);
 				break;
 			}
@@ -217,7 +380,7 @@ export class ExprsEmitter {
 				this._emitTypeTest(targetGoType);
 				this.pushInstruction("i32.eqz");
 				this.pushInstruction({ op: "if", blockType: "void" });
-				this.emitPanic("interface conversion: type assertion failed");
+				this._emitTypeAssertPanic(expr, anyTmp);
 				this.pushInstruction("end");
 
 				this.pushInstruction({ op: "local.get", index: anyTmp });
@@ -247,7 +410,7 @@ export class ExprsEmitter {
 		if (capturedNames.length === 0) {
 			this.pushInstruction({ op: "ref.null", heapType: "any" });
 		} else {
-			const envFields = this._buildEnvFields(capturedNames);
+			const envFields = this._buildEnvFields(capturedNames, funcLit);
 			const envInfo = this.mod.getEnvType(envFields);
 
 			for (const field of envFields) {
@@ -302,7 +465,7 @@ export class ExprsEmitter {
 					this.pushInstruction({ op: "local.get", index: mTmp });
 					this.emitExpr(elem.key, mapInfo.keyWType);
 					this.emitExpr(elem.value, mapInfo.valWType);
-					this._emitCopyIfValueStruct(elem.value, valType, mapInfo.valWType);
+					this._emitCopyIfValue(elem.value, valType, mapInfo.valWType);
 					this.pushInstruction({
 						op: "call",
 						funcIndex: this.mod.resolveFuncIndex(mapInfo.setFuncName),
@@ -315,33 +478,11 @@ export class ExprsEmitter {
 		}
 
 		if (isSliceType(litType, this.mod.checker)) {
-			const elemType = litType.elem;
+			const elemType = this._getArrayElemType(litType);
 			const sliceInfo = this.mod.getSliceType(elemType);
-			const count = lit.elems?.length ?? 0;
-			if (count === 0) {
-				this.pushInstruction({ op: "i32.const", value: 0 });
-				this.pushInstruction({
-					op: "array.new_default",
-					typeIndex: sliceInfo.arrInfo.typeIndex,
-				});
-				this.pushInstruction({ op: "i32.const", value: 0 }); // offset
-				this.pushInstruction({ op: "i32.const", value: 0 }); // len
-				this.pushInstruction({ op: "i32.const", value: 0 }); // cap
-				this.pushInstruction({
-					op: "struct.new",
-					typeIndex: sliceInfo.typeIndex,
-				});
-				return;
-			}
-			for (const elem of lit.elems) {
-				this.emitExpr(elem, sliceInfo.elemWType);
-				this._emitCopyIfValueStruct(elem, elem._type, sliceInfo.elemWType);
-			}
-			this.pushInstruction({
-				op: "array.new_fixed",
-				typeIndex: sliceInfo.arrInfo.typeIndex,
-				size: count,
-			});
+			const elems = lit.elems ?? [];
+			const count = compositeLitMaxIndex(elems) + 1;
+			this._emitArrayLitElems(elems, elemType, sliceInfo.arrInfo, count);
 			this.pushInstruction({ op: "i32.const", value: 0 }); // offset
 			this.pushInstruction({ op: "i32.const", value: count }); // len
 			this.pushInstruction({ op: "i32.const", value: count }); // cap
@@ -353,22 +494,12 @@ export class ExprsEmitter {
 		}
 
 		if (isArrayType(litType, this.mod.checker)) {
-			const elemType = litType.elem;
+			const elemType = this._getArrayElemType(litType);
 			const arrInfo = this.mod.getArrayType(elemType);
-			const count = lit.elems?.length ?? 0;
+			const elems = lit.elems ?? [];
+			const count = compositeLitMaxIndex(elems) + 1;
 			const targetSize = this._getArraySize(litType, count);
-			for (const elem of lit.elems ?? []) {
-				this.emitExpr(elem, arrInfo.elemWType);
-				this._emitCopyIfValueStruct(elem, elem._type, arrInfo.elemWType);
-			}
-			for (let i = count; i < targetSize; i++) {
-				this.emitZeroValue(elemType, arrInfo.elemWType);
-			}
-			this.pushInstruction({
-				op: "array.new_fixed",
-				typeIndex: arrInfo.typeIndex,
-				size: targetSize,
-			});
+			this._emitArrayLitElems(elems, elemType, arrInfo, targetSize);
 			return;
 		}
 
@@ -398,13 +529,13 @@ export class ExprsEmitter {
 			const f = fields[i];
 			if (isKeyed) {
 				if (map.has(f.name)) {
-					this.emitExpr(map.get(f.name), f.wType);
+					this._emitFieldInit(map.get(f.name), f);
 				} else {
 					this.emitZeroValue(f.goType, f.wType);
 				}
 			} else {
 				if (i < (lit.elems?.length ?? 0)) {
-					this.emitExpr(lit.elems[i], f.wType);
+					this._emitFieldInit(lit.elems[i], f);
 				} else {
 					this.emitZeroValue(f.goType, f.wType);
 				}
@@ -417,9 +548,121 @@ export class ExprsEmitter {
 		});
 	}
 
+	// Pushes a new array of `size` elements built from literal `elems`.
+	// Keyed elements (`{2: 7}`) go to their index; every other slot is the
+	// element zero value.  With ascending keys and at most
+	// MAX_NEW_FIXED elements this is one `array.new_fixed`; otherwise the
+	// array is allocated first and the elements are stored in source order
+	// (Go evaluates them left to right whatever their keys).
+	_emitArrayLitElems(elems, elemType, arrInfo, size) {
+		const indices = compositeLitIndices(elems);
+		const ascending = indices.every((v, i) => i === 0 || v > indices[i - 1]);
+		const value = (e) => (e.kind === "KeyValueExpr" ? e.value : e);
+		const emitElem = (e) => {
+			this.emitExpr(e, arrInfo.elemWType);
+			// Copy by the element type: a struct stored in an `any` element
+			// is already boxed, and a keyed element wraps its value.
+			this._emitCopyIfValue(e, elemType, arrInfo.elemWType);
+		};
+		if (ascending && size <= MAX_NEW_FIXED) {
+			const slots = new Array(size).fill(null);
+			elems.forEach((e, i) => {
+				slots[indices[i]] = value(e);
+			});
+			for (const e of slots) {
+				if (e) emitElem(e);
+				else this.emitZeroValue(elemType, arrInfo.elemWType);
+			}
+			this.pushInstruction({
+				op: "array.new_fixed",
+				typeIndex: arrInfo.typeIndex,
+				size,
+			});
+			return;
+		}
+		const wType = { kind: "ref", nullable: true, typeIndex: arrInfo.typeIndex };
+		const arr = this.acquireTemp(wType);
+		const set = (idx, emit) => {
+			this.pushInstruction({ op: "local.get", index: arr });
+			this.pushInstruction({ op: "i32.const", value: idx });
+			emit();
+			this.pushInstruction({ op: "array.set", typeIndex: arrInfo.typeIndex });
+		};
+		this.pushInstruction({ op: "i32.const", value: size });
+		this.pushInstruction({
+			op: "array.new_default",
+			typeIndex: arrInfo.typeIndex,
+		});
+		this.pushInstruction({ op: "local.set", index: arr });
+		// Numeric zero values are the array default; others are stored.
+		if (typeof arrInfo.elemWType !== "string") {
+			const given = new Set(indices);
+			for (let i = 0; i < size; i++)
+				if (!given.has(i))
+					set(i, () => this.emitZeroValue(elemType, arrInfo.elemWType));
+		}
+		elems.forEach((e, i) => {
+			set(indices[i], () => emitElem(value(e)));
+		});
+		this.pushInstruction({ op: "local.get", index: arr });
+		this.releaseTemp(arr, wType);
+	}
+
+	// A struct literal field initialiser; array values are copied in.
+	_emitFieldInit(value, f) {
+		this.emitExpr(value, f.wType);
+		if (f.goType?.kind !== "pointer" && isArrayType(f.goType, this.mod.checker))
+			this._emitCopyIfValue(value, f.goType, f.wType);
+	}
+
+	// With a pointer on the stack, branches to the function's `nil` block
+	// (_openNilBlock) when it is null.  Outside one, the access traps.
+	_emitNilCheck(goType) {
+		if (goType?.kind !== "pointer") return;
+		this._emitNilBranch();
+	}
+
+	_emitNilBranch() {
+		const depth = this.resolveBranchDepthToRole("nil");
+		if (depth == null) return;
+		this.pushInstruction({ op: "br_on_null", depth });
+	}
+
+	// Emits the struct (or struct pointer) a field access or store goes
+	// through, nil-checked.  A `*p` base is the pointee itself, not the copy a
+	// value read of `*p` makes, so a store through it lands in the pointee.
+	// Every selector read and every field store/op-assign/inc-dec starts here.
+	emitSelectorBase(node, wType = null, goType = node._type) {
+		const pointer = this._structDerefPointer(node);
+		if (pointer) {
+			this.emitSelectorBase(pointer);
+			return;
+		}
+		this.emitExpr(node, wType ?? this.toWasmType(goType));
+		this._emitNilCheck(goType);
+	}
+
+	// For `*p` (possibly parenthesised) with `p` pointing at a struct, the
+	// pointer `p`, which is the struct's own reference; otherwise null.
+	_structDerefPointer(node) {
+		let base = node;
+		while (base?.kind === "ParenExpr") base = base.expr;
+		if (
+			(base?.kind !== "UnaryExpr" || base.op !== "*") &&
+			base?.kind !== "StarExpr"
+		)
+			return null;
+		const operand = base.operand ?? base.expr;
+		return this._derefStructInfo(operand) ? operand : null;
+	}
+
 	emitSelectorExpr(expr) {
 		const structInfo = this._resolveStructInfo(expr.expr);
 		if (!structInfo) {
+			if (expr.expr?.kind === "Ident" && expr.expr._type?.kind === "namespace")
+				throw new Error(
+					`${expr.expr.name}.${expr.field} cannot be used as a value in WASM`,
+				);
 			throw new Error(`Cannot resolve struct for selector: ${expr.field}`);
 		}
 		const path = this._resolveFieldPath(structInfo, expr.field);
@@ -429,8 +672,7 @@ export class ExprsEmitter {
 			);
 		}
 
-		const baseWType = this.toWasmType(expr.expr._type);
-		this.emitExpr(expr.expr, baseWType);
+		this.emitSelectorBase(expr.expr);
 
 		for (let i = 0; i < path.length; i++) {
 			const step = path[i];
@@ -506,11 +748,9 @@ export class ExprsEmitter {
 			);
 		}
 
-		const elemGoType = isSlice
-			? baseType.elem
-			: isPtrToArr
-				? baseType.base.elem
-				: baseType.elem;
+		const elemGoType = this._getArrayElemType(
+			isPtrToArr ? baseType.base : baseType,
+		);
 		const arrInfo = this.mod.getArrayType(elemGoType);
 		const sliceInfo = isSlice ? this.mod.getSliceType(elemGoType) : null;
 
@@ -604,11 +844,9 @@ export class ExprsEmitter {
 			);
 		}
 
-		const elemGoType = isSlice
-			? baseType.elem
-			: isPtrToArr
-				? baseType.base.elem
-				: baseType.elem;
+		const elemGoType = this._getArrayElemType(
+			isPtrToArr ? baseType.base : baseType,
+		);
 		const arrInfo = this.mod.getArrayType(elemGoType);
 		const sliceInfo = this.mod.getSliceType(elemGoType);
 
@@ -757,8 +995,11 @@ export class ExprsEmitter {
 		const isValStruct =
 			isStructType(elemGoType, this.mod.checker, this.mod) &&
 			!isPointerToStruct(elemGoType, this.mod.checker, this.mod);
+		const isValArray =
+			elemGoType?.kind !== "pointer" &&
+			isArrayType(elemGoType, this.mod.checker);
 
-		if (!isValStruct) {
+		if (!isValStruct && !isValArray) {
 			this.pushInstruction({
 				op: "array.copy",
 				typeIndexDst: arrInfo.typeIndex,
@@ -831,7 +1072,9 @@ export class ExprsEmitter {
 		this.pushInstruction("i32.add");
 		this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
 
-		if (sInfo) {
+		if (isValArray) {
+			this.emitCopyArray(elemGoType);
+		} else if (sInfo) {
 			this.emitCloneStruct(sInfo, arrInfo.elemWType);
 		}
 
@@ -869,7 +1112,9 @@ export class ExprsEmitter {
 		this.pushInstruction("i32.add");
 		this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
 
-		if (sInfo) {
+		if (isValArray) {
+			this.emitCopyArray(elemGoType);
+		} else if (sInfo) {
 			this.emitCloneStruct(sInfo, arrInfo.elemWType);
 		}
 
@@ -942,53 +1187,95 @@ export class ExprsEmitter {
 		return this.toWasmType(expr._type) === "i32";
 	}
 
+	// Panics with the generic out-of-range message (shared buffers, SIMD
+	// loads) when the condition on the stack is true.
 	_emitBoundsBranch() {
-		const oobDepth = this.resolveBranchDepthToOob();
-		if (oobDepth !== null) {
-			this.pushInstruction({ op: "br_if", depth: oobDepth });
-		} else {
-			this.pushInstruction({ op: "if", blockType: "void" });
-			this.pushInstruction({
-				op: "call",
-				funcIndex: this.mod.getBoundsPanicFuncIndex(),
-			});
-			this.pushInstruction("unreachable");
-			this.pushInstruction("end");
-		}
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({
+			op: "call",
+			funcIndex: this.mod.getBoundsPanicFuncIndex(),
+		});
+		this.pushInstruction("unreachable");
+		this.pushInstruction("end");
+	}
+
+	// If the condition on the stack is true, panics with Go's index message;
+	// `pushIdx64` and `emitLen` push the i64 index and the i32 length.
+	_emitIndexPanicIf(pushIdx64, emitLen) {
+		this.pushInstruction({ op: "if", blockType: "void" });
+		pushIdx64();
+		emitLen();
+		this.pushInstruction({
+			op: "call",
+			funcIndex: this.mod.getIndexPanicFuncIndex(),
+		});
+		this.pushInstruction("unreachable");
+		this.pushInstruction("end");
+	}
+
+	// Registers an index-check site and pushes its id: a failing check
+	// carries the index and this id to the handler, which re-emits `emitLen`
+	// for that site (its temps still hold the operand at the branch).
+	_pushOobSite(emitLen) {
+		this.oobSites ??= [];
+		this.oobSites.push(emitLen);
+		this.pushInstruction({ op: "i32.const", value: this.oobSites.length - 1 });
 	}
 
 	// Pushes the bounds-checked i32 index onto the stack. `emitLen` must push
-	// the i32 length. Constant and plain-local indexes are re-emitted instead
-	// of spilled; everything else goes through one temp.
+	// the i32 length.  Inside a function body a failing check branches to the
+	// shared handler (`_closeOobBlocks`) with the index and a site id, and the
+	// handler reports Go's message; elsewhere the check panics inline.
 	_emitCheckedIndex(indexNode, emitLen) {
-		const simple =
-			(indexNode.kind === "BasicLit" && indexNode.litKind === "INT") ||
-			(indexNode.kind === "Ident" && this.resolveLocal(indexNode.name));
+		const depth32 = this.resolveBranchDepthToOob(32);
 		if (this._isI32IndexExpr(indexNode)) {
+			const idx = this.acquireTemp("i32");
 			this.emitExpr(indexNode, "i32");
-			let tmp = null;
-			if (simple) {
-				this.emitExpr(indexNode, "i32");
+			this.pushInstruction({ op: "local.tee", index: idx });
+			if (depth32 !== null) {
+				this._pushOobSite(emitLen);
+				this.pushInstruction({ op: "local.get", index: idx });
+				emitLen();
+				this.pushInstruction("i32.ge_u");
+				this.pushInstruction({ op: "br_if", depth: depth32 });
+				this.pushInstruction("drop");
 			} else {
-				tmp = this.acquireTemp("i32");
-				this.pushInstruction({ op: "local.tee", index: tmp });
-				this.pushInstruction({ op: "local.get", index: tmp });
+				this.pushInstruction({ op: "local.get", index: idx });
+				emitLen();
+				this.pushInstruction("i32.ge_u");
+				this._emitIndexPanicIf(() => {
+					this.pushInstruction({ op: "local.get", index: idx });
+					this.pushInstruction("i64.extend_i32_s");
+				}, emitLen);
 			}
-			emitLen();
-			this.pushInstruction("i32.ge_u");
-			this._emitBoundsBranch();
-			if (tmp !== null) this.releaseTemp(tmp, "i32");
+			this.releaseTemp(idx, "i32");
 			return;
 		}
 
 		const idx64 = this.acquireTemp("i64");
 		this.emitExpr(indexNode, "i64");
 		this.pushInstruction({ op: "local.tee", index: idx64 });
-		emitLen();
-		this.pushInstruction("i64.extend_i32_u");
-		this.pushInstruction("i64.ge_u");
-		this._emitBoundsBranch();
-		this.pushInstruction({ op: "local.get", index: idx64 });
+		if (depth32 !== null) {
+			this._pushOobSite(emitLen);
+			this.pushInstruction({ op: "local.get", index: idx64 });
+			emitLen();
+			this.pushInstruction("i64.extend_i32_u");
+			this.pushInstruction("i64.ge_u");
+			this.pushInstruction({
+				op: "br_if",
+				depth: this.resolveBranchDepthToOob(64),
+			});
+			this.pushInstruction("drop");
+		} else {
+			emitLen();
+			this.pushInstruction("i64.extend_i32_u");
+			this.pushInstruction("i64.ge_u");
+			this._emitIndexPanicIf(
+				() => this.pushInstruction({ op: "local.get", index: idx64 }),
+				emitLen,
+			);
+			this.pushInstruction({ op: "local.get", index: idx64 });
+		}
 		this.pushInstruction("i32.wrap_i64");
 		this.releaseTemp(idx64, "i64");
 	}
@@ -1055,12 +1342,14 @@ export class ExprsEmitter {
 			constIdx < arrayLen
 		) {
 			this.emitExpr(baseNode, arrWType);
+			this._emitNilCheck(rawBaseType);
 			this.pushInstruction({ op: "i32.const", value: constIdx });
 			return;
 		}
 
 		const arrTmp = this.acquireTemp(arrWType);
 		this.emitExpr(baseNode, arrWType);
+		this._emitNilCheck(rawBaseType);
 		this.pushInstruction({ op: "local.tee", index: arrTmp });
 		this._emitCheckedIndex(indexNode, () => {
 			this.pushInstruction({ op: "local.get", index: arrTmp });
@@ -1086,7 +1375,92 @@ export class ExprsEmitter {
 		}
 	}
 
+	// Integer conversions of constants (`int64(1e18 + 1)`) keep the exact value.
+	_emitFoldedIntConversion(expr, targetWasmType) {
+		if (expr.kind !== "TypeConversion" && expr.kind !== "CallExpr")
+			return false;
+		if (expr._const?.k !== "INT") return false;
+		if (
+			targetWasmType != null &&
+			targetWasmType !== "i32" &&
+			targetWasmType !== "i64"
+		)
+			return false;
+		const lit = constToLit(expr._const);
+		lit._type = expr._type;
+		this.emitBasicLit(lit, targetWasmType);
+		return true;
+	}
+
+	// A float literal; an integral one in an integer context (`var y int = 2.0`)
+	// emits its exact integer value.
+	_emitFloatLit(lit, wType) {
+		const i =
+			wType === "i32" || wType === "i64"
+				? constIntValue(constFromLit(lit) ?? {})
+				: null;
+		if (i !== null) {
+			this.pushInstruction(
+				wType === "i32"
+					? { op: "i32.const", value: Number(BigInt.asIntN(32, i)) }
+					: { op: "i64.const", value: BigInt.asIntN(64, i) },
+			);
+			return;
+		}
+		const n = Number(lit.value);
+		if (wType === "f32") {
+			this.pushInstruction({ op: "f32.const", value: n });
+		} else {
+			this.pushInstruction({ op: "f64.const", value: n });
+		}
+	}
+
+	// "complex64" | "complex128" when `w` is the struct type of a complex value.
+	_complexKindOfWType(w) {
+		if (typeof w?.typeIndex !== "number") return null;
+		for (const [kind, info] of this.mod.complexTypes) {
+			if (info.typeIndex === w.typeIndex) return kind;
+		}
+		return null;
+	}
+
+	// True when the target wasm type is the `$complex64` struct, whether it is
+	// named or only carries the struct's type index.
+	_isComplex64Target(w) {
+		return (
+			w?.typeName === "$complex64" ||
+			this._complexKindOfWType(w) === "complex64"
+		);
+	}
+
 	emitBasicLit(lit, targetWasmType) {
+		const targetComplex = this._complexKindOfWType(targetWasmType);
+		const isTargetComplex64 =
+			lit._type?.name === "complex64" ||
+			targetWasmType?.typeName === "$complex64" ||
+			targetComplex === "complex64";
+		const isTargetComplex128 =
+			lit._type?.name === "complex128" ||
+			lit._type?.base === "complex128" ||
+			targetWasmType?.typeName === "$complex128" ||
+			targetComplex === "complex128";
+		if (isTargetComplex64 || isTargetComplex128) {
+			const info = this.mod.getComplexType(
+				isTargetComplex64 ? "complex64" : "complex128",
+			);
+			const s = String(lit.value);
+			const clean = /^0[0-7]+$/.test(s) ? `0o${s.slice(1)}` : s;
+			const n = Number(clean);
+			this.pushInstruction({ op: `${info.elemWType}.const`, value: n });
+			this.pushInstruction({ op: `${info.elemWType}.const`, value: 0.0 });
+			this.pushInstruction({
+				op: "struct.new",
+				typeIndex: info.typeIndex,
+				typeName: info.name,
+			});
+			return;
+		}
+
 		const wType =
 			targetWasmType ??
 			toWasmType(lit._type, this.mod.checker) ??
@@ -1108,12 +1482,7 @@ export class ExprsEmitter {
 		}
 
 		if (lit.litKind === "FLOAT") {
-			const n = Number(lit.value);
-			if (wType === "f32") {
-				this.pushInstruction({ op: "f32.const", value: n });
-			} else {
-				this.pushInstruction({ op: "f64.const", value: n });
-			}
+			this._emitFloatLit(lit, wType);
 			return;
 		}
 
@@ -1141,6 +1510,22 @@ export class ExprsEmitter {
 		}
 	}
 
+	emitImagLit(lit, targetWasmType) {
+		const is64 =
+			lit._type?.name === "complex64" ||
+			this._isComplex64Target(targetWasmType);
+		const complexName = is64 ? "complex64" : "complex128";
+		const info = this.mod.getComplexType(complexName);
+		const imVal = Number(lit.value);
+		this.pushInstruction({ op: `${info.elemWType}.const`, value: 0.0 });
+		this.pushInstruction({ op: `${info.elemWType}.const`, value: imVal });
+		this.pushInstruction({
+			op: "struct.new",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+		});
+	}
+
 	_emitNilValue(goType, targetWasmType) {
 		const effectiveType = targetWasmType ?? this.toWasmType(goType);
 		if (
@@ -1264,6 +1649,11 @@ export class ExprsEmitter {
 	emitUnaryExpr(expr, targetWasmType = null) {
 		const { op, operand } = expr;
 
+		if (isComplex(expr._type) || isComplex(operand._type)) {
+			this._emitComplexUnary(expr, op, operand, targetWasmType);
+			return;
+		}
+
 		// Optimize negative numeric literals directly
 		if (op === "-" && operand.kind === "BasicLit") {
 			if (operand.litKind === "INT" || operand.litKind === "FLOAT") {
@@ -1321,91 +1711,470 @@ export class ExprsEmitter {
 				}
 				break;
 
-			case "&": {
-				if (operand.kind === "Ident") {
-					const loc = this.resolveLocal(operand.name);
-					if (loc?.isBoxed) {
-						this.pushInstruction({ op: "local.get", index: loc.index });
-						return;
-					}
-				}
-				if (operand.kind === "CompositeLit") {
-					this.emitExpr(operand);
-					return;
-				}
-				const structInfo = this._resolveStructInfo(operand);
-				if (structInfo) {
-					this.emitExpr(operand);
-					return;
-				}
-				const opWType = this.toWasmType(operand._type);
-				const box = this.mod.getBoxType(operand._type);
-				this.emitExpr(operand, opWType);
-				this.pushInstruction({ op: "struct.new", typeIndex: box.typeIndex });
+			case "&":
+				return this._emitAddressOf(operand);
+
+			case "*":
+				return this._emitDerefExpr(operand);
+
+			default:
+				throw new Error(`Unsupported unary operator: ${op}`);
+		}
+	}
+
+	_emitComplexUnary(expr, op, operand, targetWasmType) {
+		if (op === "+") {
+			this.emitExpr(operand, targetWasmType);
+			return;
+		}
+		if (op === "-") {
+			if (operand.kind === "ImagLit") {
+				this.emitImagLit(
+					{ ...operand, value: `-${operand.value}` },
+					targetWasmType,
+				);
 				return;
 			}
+			const is64 =
+				isComplex64(expr._type) ||
+				isComplex64(operand._type) ||
+				this._isComplex64Target(targetWasmType);
+			const info = this.mod.getComplexType(is64 ? "complex64" : "complex128");
+			const cWType = {
+				kind: "ref",
+				nullable: true,
+				typeIndex: info.typeIndex,
+				typeName: info.name,
+			};
+			const opTmp = this.acquireTemp(cWType);
+			this.emitExpr(operand, cWType);
+			this.pushInstruction({ op: "local.set", index: opTmp });
 
-			case "*": {
-				const structInfo = this._resolveStructInfo(operand);
-				if (structInfo) {
-					const baseWType = this.toWasmType(operand._type);
-					this.emitExpr(operand, baseWType);
-					this.emitCloneStruct(structInfo, baseWType);
-					return;
-				}
-				const box = this.mod.getBoxType(operand._type?.base ?? operand._type);
-				const baseWType = {
-					kind: "ref",
-					nullable: true,
-					typeIndex: box.typeIndex,
-				};
-				this.emitExpr(operand, baseWType);
+			for (let i = 0; i < 2; i++) {
+				this.pushInstruction({ op: "local.get", index: opTmp });
 				this.pushInstruction({
 					op: "struct.get",
-					typeIndex: box.typeIndex,
-					fieldIndex: 0,
+					typeIndex: info.typeIndex,
+					typeName: info.name,
+					fieldIndex: i,
 				});
-				return;
+				this.pushInstruction(`${info.elemWType}.neg`);
 			}
 
-			default:
-				throw new Error(`Unsupported unary operator: ${op}`);
+			this.pushInstruction({
+				op: "struct.new",
+				typeIndex: info.typeIndex,
+				typeName: info.name,
+			});
+			this.releaseTemp(opTmp, cWType);
 		}
 	}
 
-	emitBinaryExpr(expr, targetWasmType = null) {
-		const { op, left, right } = expr;
-
-		// Short-circuiting logical operators
-		if (op === "&&") {
-			this.emitExpr(left, "i32");
-			this.pushInstruction({ op: "if", blockType: "i32" });
-			this.emitExpr(right, "i32");
-			this.pushInstruction("else");
-			this.pushInstruction({ op: "i32.const", value: 0 });
-			this.pushInstruction("end");
+	_emitAddressOf(operand) {
+		if (operand.kind === "Ident") {
+			const loc = this.resolveLocal(operand.name);
+			if (loc?.isBoxed) {
+				this.pushInstruction({ op: "local.get", index: loc.index });
+				// A pointer to an array or struct is its reference itself.
+				const t = loc.goType;
+				if (
+					this._isValueArray(t) ||
+					(t?.kind !== "pointer" &&
+						isStructType(t, this.mod.checker, this.mod) &&
+						!isPointerToStruct(t, this.mod.checker, this.mod))
+				)
+					this.pushInstruction({
+						op: "struct.get",
+						typeIndex: loc.boxInfo.typeIndex,
+						fieldIndex: 0,
+					});
+				return;
+			}
+		}
+		if (operand.kind === "CompositeLit") {
+			if (isStructType(operand._type, this.mod.checker, this.mod)) {
+				this.emitExpr(operand);
+				return;
+			}
+		}
+		const structInfo = this._resolveStructInfo(operand);
+		if (structInfo) {
+			this.emitExpr(operand);
 			return;
 		}
-
-		if (op === "||") {
-			this.emitExpr(left, "i32");
-			this.pushInstruction({ op: "if", blockType: "i32" });
-			this.pushInstruction({ op: "i32.const", value: 1 });
-			this.pushInstruction("else");
-			this.emitExpr(right, "i32");
-			this.pushInstruction("end");
+		const opWType = this.toWasmType(operand._type);
+		if (!isScalarType(operand._type, this.mod.checker, this.mod)) {
+			this.emitExpr(operand, opWType);
 			return;
 		}
+		const box = this.mod.getBoxType(operand._type);
+		this.emitExpr(operand, opWType);
+		this.pushInstruction({
+			op: "struct.new",
+			typeIndex: box.typeIndex,
+			typeName: box.name,
+		});
+	}
 
-		// Division & Modulo with zero-guard and overflow-guard
-		if (op === "/" || op === "%") {
-			this.emitDivRem(op, left, right, targetWasmType);
+	_isPointerGoType(t) {
+		let x = t;
+		if (x?.kind === "named" && x.underlying) x = x.underlying;
+		return x?.kind === "pointer" || x?.kind === "PointerType";
+	}
+
+	_ptrBaseType(t) {
+		let x = t;
+		if (x?.kind === "named" && x.underlying) x = x.underlying;
+		return x?.kind === "pointer" ? x.base : null;
+	}
+
+	// The struct a `*operand` reads or writes, or null when the operand points
+	// at something else: `*pp` with `pp **T` loads a pointer, not a struct.
+	_derefStructInfo(operand) {
+		if (this._isPointerGoType(this._ptrBaseType(operand._type))) return null;
+		return this._resolveStructInfo(operand);
+	}
+
+	_emitDerefExpr(operand) {
+		const structInfo = this._derefStructInfo(operand);
+		if (structInfo) {
+			const baseWType = this.toWasmType(operand._type);
+			this.emitExpr(operand, baseWType);
+			this._emitNilCheck(operand._type);
+			this.emitCloneStruct(structInfo, baseWType);
 			return;
 		}
-
-		// Shifts with Go semantics
-		if (op === "<<" || op === ">>") {
-			this.emitShift(op, left, right, targetWasmType);
+		const operandGoType =
+			operand._type ??
+			(operand.kind === "Ident"
+				? this.resolveLocal(operand.name)?.goType
+				: null) ??
+			this._resolveExprGoType(operand);
+		const baseGoType = operandGoType?.base ?? operandGoType;
+		if (!isScalarType(baseGoType, this.mod.checker, this.mod)) {
+			const baseWType = this.toWasmType(baseGoType);
+			this.emitExpr(operand, baseWType);
+			this._emitNilCheck(operandGoType);
+			return;
+		}
+		const box = this.mod.getBoxType(baseGoType);
+		const ptr = this.mod.getPtrType(baseGoType);
+		const ptrWType = {
+			kind: "ref",
+			nullable: true,
+			typeIndex: ptr.typeIndex,
+			typeName: ptr.name,
+		};
+		this.emitExpr(operand, ptrWType);
+		this._emitNilCheck(operandGoType);
+		this.pushInstruction({
+			op: "ref.cast",
+			typeIndex: box.typeIndex,
+			typeName: box.name,
+		});
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: box.typeIndex,
+			typeName: box.name,
+			fieldIndex: 0,
+		});
+	}
+
+	_emitComplexEq(aTmp, bTmp, info, f, op) {
+		for (let i = 0; i < 2; i++) {
+			this.pushInstruction({ op: "local.get", index: aTmp });
+			this.pushInstruction({
+				op: "struct.get",
+				typeIndex: info.typeIndex,
+				typeName: info.name,
+				fieldIndex: i,
+			});
+			this.pushInstruction({ op: "local.get", index: bTmp });
+			this.pushInstruction({
+				op: "struct.get",
+				typeIndex: info.typeIndex,
+				typeName: info.name,
+				fieldIndex: i,
+			});
+			this.pushInstruction(`${f}.eq`);
+		}
+		this.pushInstruction("i32.and");
+		if (op === "!=") this.pushInstruction("i32.eqz");
+	}
+
+	_emitComplexAddSub(aTmp, bTmp, info, f, op) {
+		const wasmOp = op === "+" ? `${f}.add` : `${f}.sub`;
+		for (let i = 0; i < 2; i++) {
+			this.pushInstruction({ op: "local.get", index: aTmp });
+			this.pushInstruction({
+				op: "struct.get",
+				typeIndex: info.typeIndex,
+				typeName: info.name,
+				fieldIndex: i,
+			});
+			this.pushInstruction({ op: "local.get", index: bTmp });
+			this.pushInstruction({
+				op: "struct.get",
+				typeIndex: info.typeIndex,
+				typeName: info.name,
+				fieldIndex: i,
+			});
+			this.pushInstruction(wasmOp);
+		}
+		this.pushInstruction({
+			op: "struct.new",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+		});
+	}
+
+	_emitComplexMul(aTmp, bTmp, info, f) {
+		this.pushInstruction({ op: "local.get", index: aTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 0,
+		});
+		this.pushInstruction({ op: "local.get", index: bTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 0,
+		});
+		this.pushInstruction(`${f}.mul`);
+		this.pushInstruction({ op: "local.get", index: aTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 1,
+		});
+		this.pushInstruction({ op: "local.get", index: bTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 1,
+		});
+		this.pushInstruction(`${f}.mul`);
+		this.pushInstruction(`${f}.sub`);
+
+		this.pushInstruction({ op: "local.get", index: aTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 0,
+		});
+		this.pushInstruction({ op: "local.get", index: bTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 1,
+		});
+		this.pushInstruction(`${f}.mul`);
+		this.pushInstruction({ op: "local.get", index: aTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 1,
+		});
+		this.pushInstruction({ op: "local.get", index: bTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 0,
+		});
+		this.pushInstruction(`${f}.mul`);
+		this.pushInstruction(`${f}.add`);
+
+		this.pushInstruction({
+			op: "struct.new",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+		});
+	}
+
+	_emitComplexDiv(aTmp, bTmp, info, f) {
+		const dTmp = this.acquireTemp(f);
+		for (let i = 0; i < 2; i++) {
+			this.pushInstruction({ op: "local.get", index: bTmp });
+			this.pushInstruction({
+				op: "struct.get",
+				typeIndex: info.typeIndex,
+				typeName: info.name,
+				fieldIndex: i,
+			});
+			this.pushInstruction({ op: "local.get", index: bTmp });
+			this.pushInstruction({
+				op: "struct.get",
+				typeIndex: info.typeIndex,
+				typeName: info.name,
+				fieldIndex: i,
+			});
+			this.pushInstruction(`${f}.mul`);
+			if (i > 0) this.pushInstruction(`${f}.add`);
+		}
+		this.pushInstruction({ op: "local.set", index: dTmp });
+
+		this.pushInstruction({ op: "local.get", index: aTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 0,
+		});
+		this.pushInstruction({ op: "local.get", index: bTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 0,
+		});
+		this.pushInstruction(`${f}.mul`);
+		this.pushInstruction({ op: "local.get", index: aTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 1,
+		});
+		this.pushInstruction({ op: "local.get", index: bTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 1,
+		});
+		this.pushInstruction(`${f}.mul`);
+		this.pushInstruction(`${f}.add`);
+		this.pushInstruction({ op: "local.get", index: dTmp });
+		this.pushInstruction(`${f}.div`);
+
+		this.pushInstruction({ op: "local.get", index: aTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 1,
+		});
+		this.pushInstruction({ op: "local.get", index: bTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 0,
+		});
+		this.pushInstruction(`${f}.mul`);
+		this.pushInstruction({ op: "local.get", index: aTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 0,
+		});
+		this.pushInstruction({ op: "local.get", index: bTmp });
+		this.pushInstruction({
+			op: "struct.get",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+			fieldIndex: 1,
+		});
+		this.pushInstruction(`${f}.mul`);
+		this.pushInstruction(`${f}.sub`);
+		this.pushInstruction({ op: "local.get", index: dTmp });
+		this.pushInstruction(`${f}.div`);
+
+		this.pushInstruction({
+			op: "struct.new",
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+		});
+		this.releaseTemp(dTmp, f);
+	}
+
+	emitComplexBinary(expr, targetWasmType) {
+		const { op, left, right } = expr;
+		const is64 =
+			isComplex64(expr._type) ||
+			isComplex64(left._type) ||
+			isComplex64(right._type) ||
+			this._isComplex64Target(targetWasmType);
+		const info = this.mod.getComplexType(is64 ? "complex64" : "complex128");
+		const f = info.elemWType;
+		const cWType = {
+			kind: "ref",
+			nullable: true,
+			typeIndex: info.typeIndex,
+			typeName: info.name,
+		};
+		const aTmp = this.acquireTemp(cWType);
+		const bTmp = this.acquireTemp(cWType);
+		this.emitExpr(left, cWType);
+		this.pushInstruction({ op: "local.set", index: aTmp });
+		this.emitExpr(right, cWType);
+		this.pushInstruction({ op: "local.set", index: bTmp });
+
+		if (op === "==" || op === "!=") {
+			this._emitComplexEq(aTmp, bTmp, info, f, op);
+		} else if (op === "+" || op === "-") {
+			this._emitComplexAddSub(aTmp, bTmp, info, f, op);
+		} else if (op === "*") {
+			this._emitComplexMul(aTmp, bTmp, info, f);
+		} else if (op === "/") {
+			this._emitComplexDiv(aTmp, bTmp, info, f);
+		}
+		this.releaseTemp(bTmp, cWType);
+		this.releaseTemp(aTmp, cWType);
+	}
+
+	emitBinaryExpr(expr, targetWasmType = null) {
+		const { op, left, right } = expr;
+
+		if (
+			isComplex(expr._type) ||
+			isComplex(left._type) ||
+			isComplex(right._type)
+		) {
+			this.emitComplexBinary(expr, targetWasmType);
+			return;
+		}
+
+		// Short-circuiting logical operators
+		if (op === "&&") {
+			this.emitExpr(left, "i32");
+			this.pushInstruction({ op: "if", blockType: "i32" });
+			this.emitExpr(right, "i32");
+			this.pushInstruction("else");
+			this.pushInstruction({ op: "i32.const", value: 0 });
+			this.pushInstruction("end");
+			return;
+		}
+
+		if (op === "||") {
+			this.emitExpr(left, "i32");
+			this.pushInstruction({ op: "if", blockType: "i32" });
+			this.pushInstruction({ op: "i32.const", value: 1 });
+			this.pushInstruction("else");
+			this.emitExpr(right, "i32");
+			this.pushInstruction("end");
+			return;
+		}
+
+		// Division & Modulo with zero-guard and overflow-guard
+		if (op === "/" || op === "%") {
+			this.emitDivRem(op, left, right, targetWasmType);
+			return;
+		}
+
+		// Shifts with Go semantics
+		if (op === "<<" || op === ">>") {
+			this.emitShift(op, left, right, targetWasmType);
 			return;
 		}
 
@@ -1453,10 +2222,17 @@ export class ExprsEmitter {
 			return;
 		}
 
-		const leftType = left._type;
+		// An untyped constant operand takes the type of the typed one
+		// (`'a' < rune(b)`), so both sides share one wasm representation.
+		const leftType =
+			left._type?.kind === "untyped" &&
+			right._type &&
+			right._type.kind !== "untyped"
+				? right._type
+				: left._type;
 		const isLeftI32 = this._isI32IndexExpr(left);
 		const isRightI32 = this._isI32IndexExpr(right);
-		const leftGoType = left._type ?? this._resolveExprGoType(left);
+		const leftGoType = leftType ?? this._resolveExprGoType(left);
 		const isIntType =
 			!leftGoType ||
 			(leftGoType.kind === "basic" &&
@@ -1497,6 +2273,72 @@ export class ExprsEmitter {
 		this.emitBinaryOp(op, wType, leftType);
 	}
 
+	_findScalarPtrByWType(wType, map) {
+		if (!map) return null;
+		for (const info of map.values()) {
+			if (info.typeIndex === wType.typeIndex || info.name === wType.typeName) {
+				return info;
+			}
+		}
+		return null;
+	}
+
+	_getScalarPtrFromWType(wType) {
+		if (!wType || typeof wType !== "object") return null;
+		const ptr = this._findScalarPtrByWType(wType, this.mod.ptrTypes);
+		if (ptr) {
+			return {
+				ptr,
+				box: this.mod.getBoxType(ptr.goType),
+			};
+		}
+		const box = this._findScalarPtrByWType(wType, this.mod.boxTypes);
+		if (box) {
+			return {
+				ptr: this.mod.getPtrType(box.goType),
+				box,
+			};
+		}
+		return null;
+	}
+
+	_getScalarPtrFromGoType(goType) {
+		let g = goType;
+		if (g?.kind === "TypeName" && this.mod.checker?.types?.has(g.name)) {
+			g = this.mod.checker.types.get(g.name);
+		}
+		while (g?.kind === "named" && g.underlying) {
+			g = g.underlying;
+		}
+		const isPtr =
+			g?.kind === "pointer" ||
+			g?.kind === "PointerType" ||
+			g?.kind === "StarExpr";
+		if (!isPtr || (!g.base && !g.elem)) return null;
+		const base = g.base || g.elem;
+		if (!isScalarType(base, this.mod.checker, this.mod)) {
+			return null;
+		}
+		return {
+			ptr: this.mod.getPtrType(base),
+			box: this.mod.getBoxType(base),
+		};
+	}
+
+	_getScalarPtrInfo(wType, goType = null) {
+		return (
+			this._getScalarPtrFromGoType(goType) ?? this._getScalarPtrFromWType(wType)
+		);
+	}
+
+	_isScalarPtrType(goType, wType = null) {
+		return this._getScalarPtrInfo(wType, goType) !== null;
+	}
+
+	_emitScalarPtrEq(_ptrInfo) {
+		this.pushInstruction("ref.eq");
+	}
+
 	_emitStructEq(structInfo) {
 		const bTmp = this.acquireTemp({
 			kind: "ref",
@@ -1543,11 +2385,18 @@ export class ExprsEmitter {
 							(f.goType?.kind === "named" ? f.goType.name : null),
 					);
 				this._emitStructEq(sInfo);
+			} else if (this._isValueArray(f.goType)) {
+				this._emitArrayEq(f.goType);
 			} else if (isStringType(f.goType, this.mod.checker)) {
 				const cmpIdx = this.mod.getStringCmpImportIndex("==");
 				this.pushInstruction({ op: "call", funcIndex: cmpIdx });
+			} else if (f.wType === "v128") {
+				this._emitSimdEq(f.goType);
 			} else if (f.wType === "anyref") {
 				this._emitAnyEq();
+			} else if (this._isScalarPtrType(f.goType, f.wType)) {
+				const ptrInfo = this._getScalarPtrInfo(f.wType, f.goType);
+				this._emitScalarPtrEq(ptrInfo);
 			} else if (typeof f.wType === "object" && f.wType !== null) {
 				this.pushInstruction("ref.eq");
 			} else {
@@ -1578,7 +2427,110 @@ export class ExprsEmitter {
 		});
 	}
 
+	_isValueArray(goType) {
+		return goType?.kind !== "pointer" && isArrayType(goType, this.mod.checker);
+	}
+
+	// Go array equality: element-wise (arrays are values).  Pops two arrays
+	// and pushes an i32.  A null array (a never-written slot) is the zero
+	// array.
+	_emitArrayEq(goType) {
+		const elemType = this._getArrayElemType(goType);
+		const arrInfo = this.mod.getArrayType(elemType);
+		const arrWType = {
+			kind: "ref",
+			nullable: true,
+			typeIndex: arrInfo.typeIndex,
+		};
+		const bTmp = this.acquireTemp(arrWType);
+		const aTmp = this.acquireTemp(arrWType);
+		for (const tmp of [bTmp, aTmp]) {
+			this.pushInstruction({ op: "local.tee", index: tmp });
+			this.pushInstruction("ref.is_null");
+			this.pushInstruction({ op: "if", blockType: "void" });
+			this.emitZeroValue(goType, arrWType);
+			this.pushInstruction({ op: "local.set", index: tmp });
+			this.pushInstruction("end");
+		}
+		const i = this.acquireTemp("i32");
+		const resTmp = this.acquireTemp("i32");
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction({ op: "local.set", index: resTmp });
+		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: aTmp });
+		this.pushInstruction("array.len");
+		this.pushInstruction("i32.ge_u");
+		this.pushInstruction({ op: "br_if", depth: 1 });
+		for (const tmp of [aTmp, bTmp]) {
+			this.pushInstruction({ op: "local.get", index: tmp });
+			this.pushInstruction({ op: "local.get", index: i });
+			this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+		}
+		this._emitElemEq(elemType, arrInfo.elemWType);
+		this.pushInstruction("i32.eqz");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: resTmp });
+		this.pushInstruction({ op: "br", depth: 2 });
+		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: "local.get", index: resTmp });
+		this.releaseTemp(resTmp, "i32");
+		this.releaseTemp(i, "i32");
+		this.releaseTemp(aTmp, arrWType);
+		this.releaseTemp(bTmp, arrWType);
+	}
+
+	// Equality of two array elements on the stack -> i32.
+	_emitElemEq(goType, wType) {
+		if (this._isValueArray(goType)) {
+			this._emitArrayEq(goType);
+		} else if (
+			isStructType(goType, this.mod.checker, this.mod) &&
+			!isPointerToStruct(goType, this.mod.checker, this.mod)
+		) {
+			this._emitStructEq(this._resolveStructInfo({ _type: goType }));
+		} else {
+			this.emitBinaryOp("==", wType, goType);
+		}
+	}
+
 	emitBinaryOp(op, wType, goType) {
+		if ((op === "==" || op === "!=") && this._isValueArray(goType)) {
+			this._emitArrayEq(goType);
+			if (op === "!=") this.pushInstruction("i32.eqz");
+			return;
+		}
+		if (isComplex(goType)) {
+			const is64 = isComplex64(goType);
+			const info = this.mod.getComplexType(is64 ? "complex64" : "complex128");
+			const f = info.elemWType;
+			const bTmp = this.acquireTemp(wType);
+			const aTmp = this.acquireTemp(wType);
+			this.pushInstruction({ op: "local.set", index: bTmp });
+			this.pushInstruction({ op: "local.set", index: aTmp });
+			if (op === "+" || op === "-") {
+				this._emitComplexAddSub(aTmp, bTmp, info, f, op);
+			} else if (op === "*") {
+				this._emitComplexMul(aTmp, bTmp, info, f);
+			} else if (op === "/") {
+				this._emitComplexDiv(aTmp, bTmp, info, f);
+			}
+			this.releaseTemp(aTmp, wType);
+			this.releaseTemp(bTmp, wType);
+			return;
+		}
+
 		const signed = isSigned(goType);
 
 		switch (op) {
@@ -1646,8 +2598,13 @@ export class ExprsEmitter {
 				if (isStringType(goType, this.mod.checker) || wType === "externref") {
 					const cmpIdx = this.mod.getStringCmpImportIndex("==");
 					this.pushInstruction({ op: "call", funcIndex: cmpIdx });
+				} else if (wType === "v128") {
+					this._emitSimdEq(goType);
 				} else if (wType === "anyref") {
 					this._emitAnyEq();
+				} else if (this._isScalarPtrType(goType, wType)) {
+					const ptrInfo = this._getScalarPtrInfo(wType, goType);
+					this._emitScalarPtrEq(ptrInfo);
 				} else if (typeof wType === "object" && wType !== null) {
 					this.pushInstruction("ref.eq");
 				} else {
@@ -1658,9 +2615,16 @@ export class ExprsEmitter {
 				if (isStringType(goType, this.mod.checker) || wType === "externref") {
 					const cmpIdx = this.mod.getStringCmpImportIndex("!=");
 					this.pushInstruction({ op: "call", funcIndex: cmpIdx });
+				} else if (wType === "v128") {
+					this._emitSimdEq(goType);
+					this.pushInstruction("i32.eqz");
 				} else if (wType === "anyref") {
 					this._emitAnyEq();
 					this.pushInstruction("i32.eqz");
+				} else if (this._isScalarPtrType(goType, wType)) {
+					const ptrInfo = this._getScalarPtrInfo(wType, goType);
+					this._emitScalarPtrEq(ptrInfo);
+					this.pushInstruction("i32.eqz");
 				} else if (typeof wType === "object" && wType !== null) {
 					this.pushInstruction("ref.eq");
 					this.pushInstruction("i32.eqz");
@@ -1693,6 +2657,8 @@ export class ExprsEmitter {
 	emitNarrowIntWrap(goType) {
 		if (!goType) return;
 		if (goType.kind === "TypeName" || goType.kind === "Ident") {
+			const declared = this.mod.checker?.types?.get(goType.name);
+			if (declared?.kind === "named") return this.emitNarrowIntWrap(declared);
 			return this.emitNarrowIntWrap({ kind: "basic", name: goType.name });
 		}
 		if (goType.kind === "named" && goType.underlying) {
@@ -1720,7 +2686,14 @@ export class ExprsEmitter {
 	}
 
 	emitDivRem(op, left, right, targetWasmType = null) {
-		const goType = left._type;
+		// An untyped constant left operand takes the type of the typed right
+		// one (`(1<<31) % uint32(n)` divides unsigned).
+		const goType =
+			left._type?.kind === "untyped" &&
+			right._type &&
+			right._type.kind !== "untyped"
+				? right._type
+				: left._type;
 		const wType = targetWasmType ?? toWasmType(goType, this.mod.checker);
 
 		if (wType === "f32" || wType === "f64") {
@@ -1848,6 +2821,21 @@ export class ExprsEmitter {
 		this.pushInstruction({ op: "local.set", index: tmpVal });
 
 		this.emitExpr(right, rightWType);
+		// A negative signed count panics before the shift is evaluated.
+		if (isSigned(right._type) && right.kind !== "BasicLit") {
+			const tmpCount = this.acquireTemp(rightWType);
+			this.pushInstruction({ op: "local.tee", index: tmpCount });
+			this.pushInstruction({
+				op: `${rightWType}.const`,
+				value: rightWType === "i64" ? 0n : 0,
+			});
+			this.pushInstruction(`${rightWType}.lt_s`);
+			this.pushInstruction({ op: "if", blockType: "void" });
+			this.emitPanic("runtime error: negative shift amount");
+			this.pushInstruction("end");
+			this.pushInstruction({ op: "local.get", index: tmpCount });
+			this.releaseTemp(tmpCount, rightWType);
+		}
 		if (wType === "i64" && rightWType === "i32") {
 			this.pushInstruction("i64.extend_i32_u");
 		} else if (wType === "i32" && rightWType === "i64") {
@@ -1890,32 +2878,91 @@ export class ExprsEmitter {
 
 	emitTypeConversion(conv) {
 		const { targetType, expr } = conv;
-		const fromType = expr._type;
-		const fromWType = toWasmType(fromType, this.mod.checker);
-		const toWType = toWasmType(targetType, this.mod.checker);
+		const fromType = expr._type ?? this._resolveExprGoType(expr);
+		const fromWType = this.toWasmType(fromType);
+		const toWType = this.toWasmType(targetType);
+
+		// `[]T(nil)` and `(*T)(nil)`: the target type's nil, not a converted value.
+		if (
+			(expr.kind === "Ident" && expr.name === "nil") ||
+			(expr.kind === "BasicLit" && expr.litKind === "NIL")
+		) {
+			this._emitNilValue(targetType, toWType);
+			return;
+		}
+
+		// `any(x)` boxes x exactly like an assignment to an `any` variable.
+		if (isAnyType(targetType, this.mod.checker)) {
+			this.emitExpr(expr, "anyref");
+			return;
+		}
 
 		this.emitExpr(expr, fromWType);
 
+		if (isComplex(targetType)) {
+			this._emitComplexConversion(targetType, fromType, fromWType);
+			return;
+		}
+
+		// Struct to a different defined struct type: a copy in the target's type.
+		if (
+			isStructType(fromType, this.mod.checker, this.mod) &&
+			isStructType(targetType, this.mod.checker, this.mod) &&
+			!isPointerToStruct(fromType, this.mod.checker, this.mod) &&
+			!isPointerToStruct(targetType, this.mod.checker, this.mod)
+		) {
+			const src = this._resolveStructInfo({ _type: fromType });
+			const dst = this._resolveStructInfo({ _type: targetType });
+			if (src && dst && src.typeIndex !== dst.typeIndex) {
+				this.emitCloneStruct(src, fromWType, dst);
+				return;
+			}
+		}
+
 		if (fromWType === toWType) {
 			this.emitNarrowIntWrap(targetType);
 			return;
 		}
 
+		// A named byte slice (`type MyBytes []byte`) converts like `[]byte`.
+		const isByteElem = (t) => {
+			const elem = this._getSliceElemType(t);
+			return elem?.name === "byte" || elem?.name === "uint8";
+		};
 		if (
 			fromWType === "externref" &&
 			isSliceType(targetType, this.mod.checker) &&
-			(targetType.elem?.name === "byte" || targetType.elem?.name === "uint8")
+			isByteElem(targetType)
 		) {
-			this._emitStringToByteSlice(targetType);
+			this._emitStringToByteSlice({
+				kind: "slice",
+				elem: this._getSliceElemType(targetType),
+			});
 			return;
 		}
 
 		if (
 			toWType === "externref" &&
 			isSliceType(fromType, this.mod.checker) &&
-			(fromType.elem?.name === "byte" || fromType.elem?.name === "uint8")
+			isByteElem(fromType)
 		) {
-			this._emitByteSliceToString(fromType);
+			this._emitByteSliceToString({
+				kind: "slice",
+				elem: this._getSliceElemType(fromType),
+			});
+			return;
+		}
+
+		if (
+			fromWType === "externref" &&
+			isRuneSlice(targetType, this.mod.checker)
+		) {
+			this._emitStringToRuneSlice(targetType);
+			return;
+		}
+
+		if (toWType === "externref" && isRuneSlice(fromType, this.mod.checker)) {
+			this._emitRuneSliceToString(fromType);
 			return;
 		}
 
@@ -1960,6 +3007,64 @@ export class ExprsEmitter {
 		}
 	}
 
+	_emitComplexConversion(targetType, fromType, fromWType) {
+		const isTarget64 = isComplex64(targetType);
+		const targetInfo = this.mod.getComplexType(
+			isTarget64 ? "complex64" : "complex128",
+		);
+		if (isComplex(fromType)) {
+			const isFrom64 = isComplex64(fromType);
+			if (isTarget64 === isFrom64) return;
+			const fromInfo = this.mod.getComplexType(
+				isFrom64 ? "complex64" : "complex128",
+			);
+			const fromWTypeRef = {
+				kind: "ref",
+				nullable: true,
+				typeIndex: fromInfo.typeIndex,
+				typeName: fromInfo.name,
+			};
+			const cTmp = this.acquireTemp(fromWTypeRef);
+			this.pushInstruction({ op: "local.set", index: cTmp });
+
+			for (let i = 0; i < 2; i++) {
+				this.pushInstruction({ op: "local.get", index: cTmp });
+				this.pushInstruction({
+					op: "struct.get",
+					typeIndex: fromInfo.typeIndex,
+					typeName: fromInfo.name,
+					fieldIndex: i,
+				});
+				this.pushInstruction(isTarget64 ? "f32.demote_f64" : "f64.promote_f32");
+			}
+
+			this.pushInstruction({
+				op: "struct.new",
+				typeIndex: targetInfo.typeIndex,
+				typeName: targetInfo.name,
+			});
+			this.releaseTemp(cTmp, fromWTypeRef);
+			return;
+		}
+
+		// From numeric scalar
+		const targetF = targetInfo.elemWType;
+		const srcSign = isSigned(fromType) ? "s" : "u";
+		if (fromWType === "i32" || fromWType === "i64") {
+			this.pushInstruction(`${targetF}.convert_${fromWType}_${srcSign}`);
+		} else if (fromWType === "f32" && targetF === "f64") {
+			this.pushInstruction("f64.promote_f32");
+		} else if (fromWType === "f64" && targetF === "f32") {
+			this.pushInstruction("f32.demote_f64");
+		}
+		this.pushInstruction({ op: `${targetF}.const`, value: 0.0 });
+		this.pushInstruction({
+			op: "struct.new",
+			typeIndex: targetInfo.typeIndex,
+			typeName: targetInfo.name,
+		});
+	}
+
 	_emitStringToByteSlice(targetType) {
 		const elemGo = targetType.elem;
 		const sliceInfo = this.mod.getSliceType(elemGo);
@@ -2030,6 +3135,162 @@ export class ExprsEmitter {
 		this.releaseTemp(strTmp, "externref");
 	}
 
+	// Pushes the code point at UTF-16 index `iTmp` of `strTmp` into `cpTmp`
+	// and advances `iTmp` past it (two units for a surrogate pair).
+	_emitNextCodePoint(strTmp, iTmp, cpTmp) {
+		this.pushInstruction({ op: "local.get", index: strTmp });
+		this.pushInstruction({ op: "local.get", index: iTmp });
+		this.pushInstruction({
+			op: "call",
+			funcIndex: this.mod.getStringCodePointAtImportIndex(),
+		});
+		this.pushInstruction({ op: "local.set", index: cpTmp });
+		this.pushInstruction({ op: "local.get", index: iTmp });
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.get", index: cpTmp });
+		this.pushInstruction({ op: "i32.const", value: 0xffff });
+		this.pushInstruction("i32.gt_u");
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: iTmp });
+	}
+
+	// Emits `block loop (br_if 1 (i >= n)) body br 0 end end`.
+	_emitCountedLoop(iTmp, nTmp, body) {
+		this.pushInstruction({ op: "block", blockType: "void" });
+		this.pushInstruction({ op: "loop", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: iTmp });
+		this.pushInstruction({ op: "local.get", index: nTmp });
+		this.pushInstruction("i32.ge_s");
+		this.pushInstruction({ op: "br_if", depth: 1 });
+		body();
+		this.pushInstruction({ op: "br", depth: 0 });
+		this.pushInstruction("end");
+		this.pushInstruction("end");
+	}
+
+	// []rune(s): one pass counts the code points, a second fills an exactly
+	// sized array (cap == len, as for every slice GoFront creates).
+	_emitStringToRuneSlice(targetType) {
+		const sliceInfo = this.mod.getSliceType(this._getSliceElemType(targetType));
+		const arrInfo = sliceInfo.arrInfo;
+		const arrW = { kind: "ref", nullable: true, typeIndex: arrInfo.typeIndex };
+		const strTmp = this.acquireTemp("externref");
+		const unitsTmp = this.acquireTemp("i32");
+		const iTmp = this.acquireTemp("i32");
+		const kTmp = this.acquireTemp("i32");
+		const cpTmp = this.acquireTemp("i32");
+		const arrTmp = this.acquireTemp(arrW);
+		this.pushInstruction({ op: "local.tee", index: strTmp });
+		this.pushInstruction({
+			op: "call",
+			funcIndex: this.mod.getStringLenImportIndex(),
+		});
+		this.pushInstruction({ op: "local.set", index: unitsTmp });
+		const resetIndex = () => {
+			this.pushInstruction({ op: "i32.const", value: 0 });
+			this.pushInstruction({ op: "local.set", index: iTmp });
+			this.pushInstruction({ op: "i32.const", value: 0 });
+			this.pushInstruction({ op: "local.set", index: kTmp });
+		};
+		const bumpK = () => {
+			this.pushInstruction({ op: "local.get", index: kTmp });
+			this.pushInstruction({ op: "i32.const", value: 1 });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "local.set", index: kTmp });
+		};
+		resetIndex();
+		this._emitCountedLoop(iTmp, unitsTmp, () => {
+			this._emitNextCodePoint(strTmp, iTmp, cpTmp);
+			bumpK();
+		});
+		this.pushInstruction({ op: "local.get", index: kTmp });
+		this.pushInstruction({
+			op: "array.new_default",
+			typeIndex: arrInfo.typeIndex,
+		});
+		this.pushInstruction({ op: "local.set", index: arrTmp });
+		resetIndex();
+		this._emitCountedLoop(iTmp, unitsTmp, () => {
+			this._emitNextCodePoint(strTmp, iTmp, cpTmp);
+			this.pushInstruction({ op: "local.get", index: arrTmp });
+			this.pushInstruction({ op: "local.get", index: kTmp });
+			this.pushInstruction({ op: "local.get", index: cpTmp });
+			this.pushInstruction({ op: "array.set", typeIndex: arrInfo.typeIndex });
+			bumpK();
+		});
+		this.pushInstruction({ op: "local.get", index: arrTmp });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.get", index: kTmp });
+		this.pushInstruction({ op: "local.get", index: kTmp });
+		this.pushInstruction({ op: "struct.new", typeIndex: sliceInfo.typeIndex });
+		this.releaseTemp(arrTmp, arrW);
+		this.releaseTemp(cpTmp, "i32");
+		this.releaseTemp(kTmp, "i32");
+		this.releaseTemp(iTmp, "i32");
+		this.releaseTemp(unitsTmp, "i32");
+		this.releaseTemp(strTmp, "externref");
+	}
+
+	// string(runes): concatenates `str_from_code_point` of each element.
+	_emitRuneSliceToString(fromType) {
+		const sliceInfo = this.mod.getSliceType(this._getSliceElemType(fromType));
+		const arrInfo = sliceInfo.arrInfo;
+		const sliceW = {
+			kind: "ref",
+			nullable: true,
+			typeIndex: sliceInfo.typeIndex,
+		};
+		const arrW = { kind: "ref", nullable: true, typeIndex: arrInfo.typeIndex };
+		const sTmp = this.acquireTemp(sliceW);
+		this.pushInstruction({ op: "local.set", index: sTmp });
+		const arrTmp = this.acquireTemp(arrW);
+		const offTmp = this.acquireTemp("i32");
+		const lenTmp = this.acquireTemp("i32");
+		const capTmp = this.acquireTemp("i32");
+		this._emitSliceUnpack(sTmp, sliceInfo, {
+			arr: arrTmp,
+			off: offTmp,
+			len: lenTmp,
+			cap: capTmp,
+		});
+		this.releaseTemp(sTmp, sliceW);
+		this.releaseTemp(capTmp, "i32");
+		const accTmp = this.acquireTemp("externref");
+		this.emitBasicLit({ kind: "BasicLit", litKind: "STRING", value: "" });
+		this.pushInstruction({ op: "local.set", index: accTmp });
+		const iTmp = this.acquireTemp("i32");
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: iTmp });
+		this._emitCountedLoop(iTmp, lenTmp, () => {
+			this.pushInstruction({ op: "local.get", index: accTmp });
+			this.pushInstruction({ op: "local.get", index: arrTmp });
+			this.pushInstruction({ op: "local.get", index: offTmp });
+			this.pushInstruction({ op: "local.get", index: iTmp });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+			this.pushInstruction({
+				op: "call",
+				funcIndex: this.mod.getStringFromCodePointImportIndex(),
+			});
+			this.pushInstruction({
+				op: "call",
+				funcIndex: this.mod.getStringConcatImportIndex(),
+			});
+			this.pushInstruction({ op: "local.set", index: accTmp });
+			this.pushInstruction({ op: "local.get", index: iTmp });
+			this.pushInstruction({ op: "i32.const", value: 1 });
+			this.pushInstruction("i32.add");
+			this.pushInstruction({ op: "local.set", index: iTmp });
+		});
+		this.pushInstruction({ op: "local.get", index: accTmp });
+		this.releaseTemp(iTmp, "i32");
+		this.releaseTemp(accTmp, "externref");
+		this.releaseTemp(lenTmp, "i32");
+		this.releaseTemp(offTmp, "i32");
+		this.releaseTemp(arrTmp, arrW);
+	}
+
 	_emitByteSliceToString(fromType) {
 		const elemGo = fromType.elem;
 		const sliceInfo = this.mod.getSliceType(elemGo);