gofront 1.9.0 → 1.9.1

package/src/backend/shared/fmt-types.js

@@ -62,10 +62,39 @@ export function goTypeName(t, specialized = null) {
 			return `[]${go(t.elem)}`;
 		case "array":
 		case "ArrayType":
-			return `[${t.size ?? 0}]${go(t.elem)}`;
+			// A parsed array type carries its length as a literal node.
+			return `[${typeof t.size === "object" ? (t.size?.value ?? 0) : (t.size ?? 0)}]${go(t.elem)}`;
 		case "map":
 		case "MapType":
 			return `map[${go(t.key)}]${go(t.value)}`;
+		case "func": {
+			// A func without results is `func()`, not `func() void`.
+			const rets = (t.returns ?? [])
+				.filter((r) => !(r?.kind === "basic" && r.name === "void"))
+				.map(go);
+			const ret =
+				rets.length === 0
+					? ""
+					: rets.length === 1
+						? ` ${rets[0]}`
+						: ` (${rets.join(", ")})`;
+			return `func(${(t.params ?? []).map(go).join(", ")})${ret}`;
+		}
+		case "FuncType": {
+			// A parsed func type: parameters and the result as written.
+			const rt = t.returnType;
+			const rets = !rt ? [] : rt.kind === "TupleType" ? rt.types : [rt];
+			const ret =
+				rets.length === 0
+					? ""
+					: rets.length === 1
+						? ` ${go(rets[0])}`
+						: ` (${rets.map(go).join(", ")})`;
+			const params = (t.params ?? []).map((p) =>
+				p.variadic ? `...${go(p.type)}` : go(p.type),
+			);
+			return `func(${params.join(", ")})${ret}`;
+		}
 		default:
 			return "interface {}";
 	}

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

@@ -3,7 +3,6 @@
 // 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,
@@ -12,6 +11,7 @@ import {
 	isArrayType,
 	isComplex,
 	isComplex64,
+	isFuncType,
 	isMapType,
 	isNonEmptyInterface,
 	isScalarType,
@@ -1265,14 +1265,17 @@ export class BuiltinsEmitter {
 		for (const embed of structInfo.embeds ?? []) {
 			const typeName = embed.typeName ?? embed.name;
 			const methodName = `${typeName}.${method}`;
+			const ifaceType = structInfo.fields[embed.fieldIndex]?.goType;
+			if (this.mod.embeddedInterfaceHas(ifaceType, method))
+				return { chain: [{ structInfo, embed }], ifaceType };
 			if (this.mod.resolveFuncIndex(methodName) !== null)
 				return { chain: [{ structInfo, embed }], methodName };
 			const inner = this.mod.getStructType(typeName);
 			const deeper = inner && this._findEmbeddedMethod(inner, method, seen);
 			if (deeper)
 				return {
+					...deeper,
 					chain: [{ structInfo, embed }, ...deeper.chain],
-					methodName: deeper.methodName,
 				};
 		}
 		return null;
@@ -1283,10 +1286,19 @@ export class BuiltinsEmitter {
 		if (!structInfo) return false;
 		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 { chain, methodName, ifaceType } = found;
+		// A method promoted from an embedded interface is dispatched on the
+		// interface value the last embed holds.
+		const dispatchName = ifaceType
+			? `__dispatch_${this._getReceiverTypeName(ifaceType)}_${func.field}`
+			: null;
+		const subName = dispatchName ?? methodName;
+		const subIdx = this.mod.resolveFuncIndex(subName);
+		if (subIdx === null)
+			throw new Error(`internal: no interface dispatcher ${subName}`);
+		const targetParamTypes = this.mod.getFuncParamTypes(subName);
 		const valueRecv =
+			!ifaceType &&
 			this.mod.getFuncParamGoTypes(methodName)[0]?.kind !== "pointer";
 		this.emitExpr(func.expr, this.toWasmType(recvType));
 		this._emitNilCheck(func.expr._type);
@@ -1393,6 +1405,41 @@ export class BuiltinsEmitter {
 		this.releaseTemp(closureTmp, closureWType);
 	}
 
+	// `g(f())` that lowering left unsplit (it splits only statement operands):
+	// f's results go into locals, and g is called with idents carrying each
+	// element's interface-box marks, so each is boxed like any argument. Also
+	// used for method calls, whose argument path expects one value per
+	// parameter. Only when g's callee evaluates no call, so f() still runs
+	// before anything else the call evaluates.
+	_splitForwardedArgs(call) {
+		if (!call._multiForward || call.args?.length !== 1) return null;
+		const inner = call.args[0];
+		const types = inner?._type?.types;
+		if (!Array.isArray(types) || types.length === 0) return null;
+		const holders =
+			inner._fwdIface?.length === types.length ? inner._fwdIface : null;
+		const isMethod =
+			call.func?.kind === "SelectorExpr" &&
+			call.func.expr?._type?.kind !== "namespace";
+		if (!holders && !isMethod) return null;
+		if (hasCallOrReceive(call.func)) return null;
+		this.emitExpr(inner, null);
+		this._fwdArgCounter = (this._fwdArgCounter ?? 0) + 1;
+		const names = types.map((_, i) => `__fwdarg$${this._fwdArgCounter}$${i}`);
+		const locals = types.map((t, i) =>
+			this.allocLocal(names[i], this.toWasmType(t), t, true),
+		);
+		for (let i = locals.length - 1; i >= 0; i--)
+			this.pushInstruction({ op: "local.set", index: locals[i] });
+		const args = names.map((name, i) => ({
+			kind: "Ident",
+			name,
+			_type: types[i],
+			...(holders?.[i] ?? {}),
+		}));
+		return { ...call, args, _multiForward: false };
+	}
+
 	emitCallExpr(call, targetWasmType = null) {
 		if (call._isTypeConversion) {
 			this.emitTypeConversion({
@@ -1412,6 +1459,12 @@ export class BuiltinsEmitter {
 			return;
 		}
 
+		const forwarded = this._splitForwardedArgs(call);
+		if (forwarded) {
+			this.emitCallExpr(forwarded, targetWasmType);
+			return;
+		}
+
 		if (this._emitPackageCall(call, targetWasmType)) {
 			return;
 		}
@@ -1560,6 +1613,15 @@ export class BuiltinsEmitter {
 					: `*${named(info.name)}`,
 			]);
 		}
+		for (const c of mod.closureTypes.values())
+			names.push([
+				c.typeIndex,
+				goTypeName({
+					kind: "func",
+					params: c.sig.params,
+					returns: c.sig.returns,
+				}),
+			]);
 		for (const box of mod.ifaceBoxTypes.values())
 			names.push([box.typeIndex, goTypeName(box.goType)]);
 		for (const info of mod.taggedSliceTypes.values())
@@ -1657,6 +1719,123 @@ export class BuiltinsEmitter {
 		this.emitRuntimePanicThrow();
 	}
 
+	// `any_eq` arm for two arrays of one wasm array type (an array stored in
+	// an interface is the array ref itself): equal lengths and elements.
+	_emitAnyArrayEqArm(arrInfo) {
+		const ref = { kind: "ref", nullable: true, typeIndex: arrInfo.typeIndex };
+		for (const idx of [0, 1]) {
+			this.pushInstruction({ op: "local.get", index: idx });
+			this.pushInstruction({ op: "ref.test", typeIndex: arrInfo.typeIndex });
+		}
+		this.pushInstruction("i32.and");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		const a1 = this.allocLocal(null, ref);
+		const a2 = this.allocLocal(null, ref);
+		for (const [src, dst] of [
+			[0, a1],
+			[1, a2],
+		]) {
+			this.pushInstruction({ op: "local.get", index: src });
+			this.pushInstruction({ op: "ref.cast", typeIndex: arrInfo.typeIndex });
+			this.pushInstruction({ op: "local.set", index: dst });
+		}
+		const len = this.allocLocal(null, "i32");
+		this.pushInstruction({ op: "local.get", index: a1 });
+		this.pushInstruction("array.len");
+		this.pushInstruction({ op: "local.tee", index: len });
+		this.pushInstruction({ op: "local.get", index: a2 });
+		this.pushInstruction("array.len");
+		this.pushInstruction("i32.ne");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction("return");
+		this.pushInstruction("end");
+		const i = this.allocLocal(null, "i32");
+		const e1 = this.allocLocal(null, arrInfo.elemWType);
+		const e2 = this.allocLocal(null, arrInfo.elemWType);
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: i });
+		this.pushInstruction({ op: "block", blockType: "void" });
+		this.pushInstruction({ op: "loop", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: i });
+		this.pushInstruction({ op: "local.get", index: len });
+		this.pushInstruction("i32.ge_u");
+		this.pushInstruction({ op: "br_if", depth: 1 });
+		for (const [arr, dst] of [
+			[a1, e1],
+			[a2, e2],
+		]) {
+			this.pushInstruction({ op: "local.get", index: arr });
+			this.pushInstruction({ op: "local.get", index: i });
+			this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+			this.pushInstruction({ op: "local.set", index: dst });
+		}
+		this.emitKeyEq(e1, e2, arrInfo.elemGoType);
+		this.pushInstruction("i32.eqz");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction("return");
+		this.pushInstruction("end");
+		this.pushInstruction({ op: "local.get", index: i });
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: i });
+		this.pushInstruction({ op: "br", depth: 0 });
+		this.pushInstruction("end");
+		this.pushInstruction("end");
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction("return");
+		this.pushInstruction("end");
+	}
+
+	// `any_hash` arm for an array: the wasm array type, then each element,
+	// as `emitKeyHash` combines a static array key (so equal arrays under
+	// `any_eq` hash equal).
+	_emitAnyArrayHashArm(arrInfo) {
+		const ref = { kind: "ref", nullable: true, typeIndex: arrInfo.typeIndex };
+		this.pushInstruction({ op: "local.get", index: 0 });
+		this.pushInstruction({ op: "ref.test", typeIndex: arrInfo.typeIndex });
+		this.pushInstruction({ op: "if", blockType: "void" });
+		const arr = this.allocLocal(null, ref);
+		const h = this.allocLocal(null, "i32");
+		const i = this.allocLocal(null, "i32");
+		const e = this.allocLocal(null, arrInfo.elemWType);
+		this.pushInstruction({ op: "local.get", index: 0 });
+		this.pushInstruction({ op: "ref.cast", typeIndex: arrInfo.typeIndex });
+		this.pushInstruction({ op: "local.set", index: arr });
+		this.pushInstruction({ op: "i32.const", value: arrInfo.typeIndex });
+		this.pushInstruction({ op: "local.set", index: h });
+		this.pushInstruction({ op: "i32.const", value: 0 });
+		this.pushInstruction({ op: "local.set", index: i });
+		this.pushInstruction({ op: "block", blockType: "void" });
+		this.pushInstruction({ op: "loop", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: i });
+		this.pushInstruction({ op: "local.get", index: arr });
+		this.pushInstruction("array.len");
+		this.pushInstruction("i32.ge_u");
+		this.pushInstruction({ op: "br_if", depth: 1 });
+		this.pushInstruction({ op: "local.get", index: arr });
+		this.pushInstruction({ op: "local.get", index: i });
+		this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+		this.pushInstruction({ op: "local.set", index: e });
+		this.pushInstruction({ op: "local.get", index: h });
+		this.pushInstruction({ op: "i32.const", value: 31 });
+		this.pushInstruction("i32.mul");
+		this.emitKeyHash(e, arrInfo.elemGoType);
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: h });
+		this.pushInstruction({ op: "local.get", index: i });
+		this.pushInstruction({ op: "i32.const", value: 1 });
+		this.pushInstruction("i32.add");
+		this.pushInstruction({ op: "local.set", index: i });
+		this.pushInstruction({ op: "br", depth: 0 });
+		this.pushInstruction("end");
+		this.pushInstruction("end");
+		this.pushInstruction({ op: "local.get", index: h });
+		this.pushInstruction("return");
+		this.pushInstruction("end");
+	}
+
 	emitRuntimeHelper(fn) {
 		const errInfo = this.mod.getStructType(ERROR_STRUCT);
 		switch (fn._isRuntimeHelper) {
@@ -1735,6 +1914,12 @@ export class BuiltinsEmitter {
 					this.pushInstruction("end");
 				}
 
+				// Arrays compare element by element.
+				for (const a of [...this.mod.arrayTypes.values()]) {
+					if (!isUnhashableGoType(a.elemGoType, this.mod.checker))
+						this._emitAnyArrayEqArm(a);
+				}
+
 				// Strings
 				this.pushInstruction({ op: "local.get", index: 0 });
 				this.pushInstruction({
@@ -1778,6 +1963,47 @@ export class BuiltinsEmitter {
 				this.pushInstruction("return");
 				return;
 			}
+			case "any_ref": {
+				// A tagged slice is a fresh header on each conversion to an `any`:
+				// its backing array is the identity every copy shares.
+				for (const info of this.mod.taggedSliceTypes.values()) {
+					this.pushInstruction({ op: "local.get", index: 0 });
+					this.pushInstruction({ op: "ref.test", typeIndex: info.typeIndex });
+					this.pushInstruction({ op: "if", blockType: "void" });
+					this.pushInstruction({ op: "local.get", index: 0 });
+					this.pushInstruction({ op: "ref.cast", typeIndex: info.typeIndex });
+					this.pushInstruction({
+						op: "struct.get",
+						typeIndex: info.typeIndex,
+						fieldIndex: 0,
+					});
+					this.pushInstruction("return");
+					this.pushInstruction("end");
+				}
+				// A boxed defined map or func value: the reference inside the box.
+				for (const box of this.mod.ifaceBoxTypes.values()) {
+					if (
+						!isMapType(box.goType, this.mod.checker) &&
+						!isFuncType(box.goType, this.mod.checker)
+					)
+						continue;
+					this.pushInstruction({ op: "local.get", index: 0 });
+					this.pushInstruction({ op: "ref.test", typeIndex: box.typeIndex });
+					this.pushInstruction({ op: "if", blockType: "void" });
+					this.pushInstruction({ op: "local.get", index: 0 });
+					this.pushInstruction({ op: "ref.cast", typeIndex: box.typeIndex });
+					this.pushInstruction({
+						op: "struct.get",
+						typeIndex: box.typeIndex,
+						fieldIndex: 0,
+					});
+					this.pushInstruction("return");
+					this.pushInstruction("end");
+				}
+				this.pushInstruction({ op: "local.get", index: 0 });
+				this.pushInstruction("return");
+				return;
+			}
 			case "any_hash": {
 				this.pushInstruction({ op: "local.get", index: 0 });
 				this.pushInstruction("ref.is_null");
@@ -1786,14 +2012,15 @@ export class BuiltinsEmitter {
 				this.pushInstruction("return");
 				this.pushInstruction("end");
 
-				// Check unhashable types
+				// Check unhashable types.  `goType` names the dynamic type in the
+				// panic, as Go does (`main.S`, `main.L`, `func()`).
 				const checkUnhashable = (typeIndex, goType) => {
 					this.pushInstruction({ op: "local.get", index: 0 });
 					this.pushInstruction({ op: "ref.test", typeIndex });
 					this.pushInstruction({ op: "if", blockType: "void" });
 					this.emitPanic(
 						goType
-							? `runtime error: hash of unhashable type ${typeStr(goType)}`
+							? `runtime error: hash of unhashable type ${goTypeName(goType)}`
 							: "runtime error: hash of unhashable type",
 					);
 					this.pushInstruction("end");
@@ -1802,6 +2029,10 @@ export class BuiltinsEmitter {
 				// its element as written.
 				const spelled = (t) =>
 					t?.kind === "TypeName" ? { kind: "basic", name: t.name } : t;
+				// Tagged slices (a defined slice type in an interface) are subtypes
+				// of the plain slice type, so they are tested first.
+				for (const info of this.mod.taggedSliceTypes.values())
+					checkUnhashable(info.typeIndex, info.goType);
 				for (const sliceInfo of this.mod.sliceTypes.values())
 					checkUnhashable(sliceInfo.typeIndex, {
 						kind: "slice",
@@ -1814,10 +2045,14 @@ export class BuiltinsEmitter {
 						value: mapInfo.valGoType,
 					});
 				for (const closureInfo of this.mod.closureTypes.values())
-					checkUnhashable(closureInfo.typeIndex);
+					checkUnhashable(closureInfo.typeIndex, {
+						kind: "func",
+						params: closureInfo.sig.params,
+						returns: closureInfo.sig.returns,
+					});
 				for (const box of this.mod.ifaceBoxTypes.values()) {
 					if (isUnhashableGoType(box.goType, this.mod.checker))
-						checkUnhashable(box.typeIndex);
+						checkUnhashable(box.typeIndex, box.goType);
 				}
 				for (const arrInfo of this.mod.arrayTypes.values()) {
 					if (isUnhashableGoType(arrInfo.elemGoType, this.mod.checker))
@@ -1848,6 +2083,12 @@ export class BuiltinsEmitter {
 					this.pushInstruction("end");
 				}
 
+				// Arrays hash element by element.
+				for (const a of [...this.mod.arrayTypes.values()]) {
+					if (!isUnhashableGoType(a.elemGoType, this.mod.checker))
+						this._emitAnyArrayHashArm(a);
+				}
+
 				// Check string
 				this.pushInstruction({ op: "local.get", index: 0 });
 				this.pushInstruction({

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

@@ -105,38 +105,38 @@ 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.
+			// A defined func type, and every array and map type, is boxed to keep
+			// its identity: arrays and maps share one wasm type across Go types
+			// (`[2]int` and `[2]int64`), and a defined func type has methods that
+			// interface dispatch must tell from the plain func type.
 			if (this._isMethodNamedRef(goType)) {
 				const box = this.mod.getIfaceBoxType(this._resolveTestTarget(goType));
 				this._emitRawExpr(expr, box.wType);
+				// An array stored in an interface is a copy.
+				if (isArrayType(box.goType, this.mod.checker))
+					this._emitCopyIfValue(expr, goType, box.wType);
 				this._emitBoxValue(box);
 				return;
 			}
 
 			if (
 				isSliceType(goType, this.mod.checker) ||
-				isArrayType(goType, this.mod.checker) ||
-				isFuncType(goType, this.mod.checker) ||
-				isMapType(goType, this.mod.checker)
+				isFuncType(goType, this.mod.checker)
 			) {
 				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)
-				)
+				if (isFuncType(goType, this.mod.checker))
 					this._emitNilAwareAny(goType, expr);
 				return;
 			}
 
 			// Scalar type -> box into struct
-			const scalarType = goType ?? { kind: "basic", name: "int" };
+			// An untyped rune constant boxes as `rune` (int32), like Go.
+			const scalarType = goType?.rune
+				? { kind: "basic", name: "int32" }
+				: (goType ?? { kind: "basic", name: "int" });
 			const box = this.mod.getIfaceBoxType(scalarType);
 			this._emitRawExpr(expr, box.wType);
 			this._emitBoxValue(box);
@@ -421,6 +421,10 @@ export class ExprsEmitter {
 					);
 				}
 				this.pushInstruction({ op: "local.get", index: local.index });
+				// A non-escaping `range n` index lives in an i32 local, but a
+				// closure (such as a range-over-func body) sees a Go `int`.
+				if (!field.isBoxed && local.type === "i32" && field.wType === "i64")
+					this.pushInstruction("i64.extend_i32_s");
 			}
 
 			this.pushInstruction({
@@ -1575,6 +1579,13 @@ export class ExprsEmitter {
 			this._emitNilValue(ident._type, targetWasmType);
 			return;
 		}
+		// A named untyped complex constant that takes type complex64 is built
+		// from its initializer, like a complex literal, not read from its
+		// complex128 global.
+		if (ident._complexInit && this._isComplex64Target(targetWasmType)) {
+			this.emitExpr(ident._complexInit, targetWasmType);
+			return;
+		}
 
 		const localInfo = this.resolveLocal(ident.name);
 		if (localInfo) {
@@ -1646,10 +1657,17 @@ export class ExprsEmitter {
 		throw new Error(`Unresolved identifier: ${ident.name}`);
 	}
 
+	// Unary arithmetic on a complex value; `&c` and `*p` of one only move
+	// its pointer.
+	_isComplexArith(expr, op, operand) {
+		if (op === "&" || op === "*") return false;
+		return isComplex(expr._type) || isComplex(operand._type);
+	}
+
 	emitUnaryExpr(expr, targetWasmType = null) {
 		const { op, operand } = expr;
 
-		if (isComplex(expr._type) || isComplex(operand._type)) {
+		if (this._isComplexArith(expr, op, operand)) {
 			this._emitComplexUnary(expr, op, operand, targetWasmType);
 			return;
 		}
@@ -1770,19 +1788,25 @@ export class ExprsEmitter {
 		}
 	}
 
+	// True when a pointer to a `t` variable is the value's own reference (an
+	// array or struct) rather than a box around it (scalars and complex).
+	_isOwnPointerValue(t) {
+		if (this._isValueArray(t)) return true;
+		return (
+			t?.kind !== "pointer" &&
+			!isComplex(t) &&
+			isStructType(t, this.mod.checker, this.mod) &&
+			!isPointerToStruct(t, this.mod.checker, this.mod)
+		);
+	}
+
 	_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))
-				)
+				if (this._isOwnPointerValue(loc.goType))
 					this.pushInstruction({
 						op: "struct.get",
 						typeIndex: loc.boxInfo.typeIndex,
@@ -1831,7 +1855,8 @@ export class ExprsEmitter {
 	// 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;
+		const base = this._ptrBaseType(operand._type);
+		if (this._isPointerGoType(base) || isComplex(base)) return null;
 		return this._resolveStructInfo(operand);
 	}
 
@@ -2491,10 +2516,26 @@ export class ExprsEmitter {
 		this.releaseTemp(bTmp, arrWType);
 	}
 
+	// Equality of two complex values on the stack -> i32.
+	_emitComplexElemEq(goType, wType) {
+		const info = this.mod.getComplexType(
+			isComplex64(goType) ? "complex64" : "complex128",
+		);
+		const bTmp = this.acquireTemp(wType);
+		const aTmp = this.acquireTemp(wType);
+		this.pushInstruction({ op: "local.set", index: bTmp });
+		this.pushInstruction({ op: "local.set", index: aTmp });
+		this._emitComplexEq(aTmp, bTmp, info, info.elemWType, "==");
+		this.releaseTemp(aTmp, wType);
+		this.releaseTemp(bTmp, wType);
+	}
+
 	// Equality of two array elements on the stack -> i32.
 	_emitElemEq(goType, wType) {
 		if (this._isValueArray(goType)) {
 			this._emitArrayEq(goType);
+		} else if (isComplex(goType)) {
+			this._emitComplexElemEq(goType, wType);
 		} else if (
 			isStructType(goType, this.mod.checker, this.mod) &&
 			!isPointerToStruct(goType, this.mod.checker, this.mod)

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

@@ -381,7 +381,10 @@ export class SharedEmitter {
 			store(lhs[1], valLocalInfo);
 		}
 
-		if (bodyBlock) this.emitBlock(bodyBlock);
+		if (bodyBlock) {
+			this._emitRangeBoxes();
+			this.emitBlock(bodyBlock);
+		}
 
 		this.pushInstruction("end");
 		this.pushInstruction({ op: "local.get", index: idxTmp });