gofront 1.8.0 → 1.9.1

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

@@ -9,7 +9,7 @@ import {
 	isIteratorRangeFor,
 	isRangeFor,
 } from "../../lower/range.js";
-import { someChild } from "../../lower/walk.js";
+import { hasCallOrReceive, someChild } from "../../lower/walk.js";
 import {
 	getMapKeyValTypes,
 	isArrayType,
@@ -24,6 +24,7 @@ import {
 	isSliceType,
 	isStringType,
 	isStructType,
+	isTaggedSliceType,
 } from "./types.js";
 
 function hasReturnInBlock(n) {
@@ -61,6 +62,15 @@ export class StmtsEmitter {
 			const names = spec.names ?? (spec.name ? [spec.name] : []);
 			const values = spec.value ?? (spec.init ? [spec.init] : []);
 
+			// `var a, b = f()` / `var v, ok = m[k]` bind like `a, b := ...`.
+			if (names.length > 1 && values.length === 1) {
+				this.emitDefineStmt({
+					lhs: names.map((name) => ({ kind: "Ident", name })),
+					rhs: values,
+				});
+				continue;
+			}
+
 			for (let i = 0; i < names.length; i++) {
 				const name = names[i];
 				const rawType = spec.type ?? values[i]?._type;
@@ -301,21 +311,24 @@ export class StmtsEmitter {
 		if (assigned.size === 0) return null;
 		const undo = [];
 		const names = [];
-		for (const l of lhsNodes) {
+		const visit = (l) => {
 			let keys;
 			if (l.kind === "IndexExpr") keys = ["expr", "index"];
 			else if (l.kind === "SelectorExpr" && !l._isMethodExpr) keys = ["expr"];
-			else continue;
+			else return;
 			for (const key of keys) {
 				const operand = l[key];
 				if (!this._mentions(operand, assigned)) continue;
 				const goType = operand._type ?? this._resolveExprGoType(operand);
-				// A struct or array value names the variable's storage in Go.
+				// A struct or array value names the variable's storage in Go: hoist
+				// the operands inside it (`ps[n].A`) instead of the value.
 				if (
 					key === "expr" &&
 					(this._isValueStruct(goType) || this._isValueArray(goType))
-				)
+				) {
+					visit(operand);
 					continue;
+				}
 				const wType = this.toWasmType(goType);
 				const name = `__lhs_tmp_${this.tempCounter++}`;
 				const idx = this.allocLocal(name, wType, goType, true);
@@ -325,7 +338,8 @@ export class StmtsEmitter {
 				names.push(name);
 				l[key] = { kind: "Ident", name, _type: goType, _parTmp: true };
 			}
-		}
+		};
+		for (const l of lhsNodes) visit(l);
 		if (undo.length === 0) return null;
 		return () => {
 			for (const [node, key, v] of undo) node[key] = v;
@@ -664,6 +678,10 @@ export class StmtsEmitter {
 			// A whole struct or array stored into an element whose address is
 			// taken writes into the existing element, so `p := &xs[0]` stays valid.
 			if (this._needsStableStore(l, elemGoType)) {
+				if (sliceInfo) {
+					this._emitSliceElemStableStore(l, elemGoType, r, sliceInfo, arrInfo);
+					return;
+				}
 				this._emitStableStore(elemGoType, r, () => {
 					this._emitElemAddr(baseNode, l.index, sliceInfo, arrInfo);
 					this.pushInstruction({
@@ -702,7 +720,95 @@ export class StmtsEmitter {
 		return idx;
 	}
 
+	// Stores the value `emitValue` pushes into the variable `name` that a range
+	// assignment (`for k, v = range m`) targets: a plain local, a boxed local
+	// (its address is taken or a closure mutates it), or a global.  When the
+	// target is an interface, `valueGoType` is the Go type of the ranged
+	// element and the value is boxed into the interface representation;
+	// `emitValue` is then called with the wasm type of `valueGoType`.
+	_emitRangeAssignStore(name, info, emitValue, valueGoType = null) {
+		const local = this.resolveLocal(name);
+		const boxIface =
+			valueGoType && this._rangeStoreWType(name, info) === "anyref";
+		const pushValue = () => {
+			if (boxIface) this._emitRangeValueToAny(emitValue, valueGoType);
+			else emitValue();
+		};
+		if (!local) {
+			pushValue();
+			this.pushInstruction({ op: "global.set", index: info.index });
+			return;
+		}
+		if (local.isBoxed) {
+			this.pushInstruction({ op: "local.get", index: local.index });
+			pushValue();
+			this.pushInstruction({
+				op: "struct.set",
+				typeIndex: local.boxInfo.typeIndex,
+				fieldIndex: 0,
+			});
+			return;
+		}
+		pushValue();
+		this.pushInstruction({ op: "local.set", index: info.index });
+	}
+
+	// Pushes a ranged element of Go type `goType` as an interface value.
+	// `emitValue(wType)` pushes the element in the wasm type of `goType`; an
+	// element that is already an interface needs no boxing.
+	_emitRangeValueToAny(emitValue, goType) {
+		const wType = this.toWasmType(goType);
+		if (wType === "anyref") {
+			emitValue(wType);
+			return;
+		}
+		const name = `__rangeval$${this.tempCounter++}`;
+		const idx = this.allocLocal(name, wType, goType, true);
+		emitValue(wType);
+		this.pushInstruction({ op: "local.set", index: idx });
+		this.emitExpr(
+			{ kind: "Ident", name, _type: goType, _parTmp: true },
+			"anyref",
+		);
+		this.locals.delete(name);
+	}
+
+	// The wasm type of the value a range assignment stores into `info`: the
+	// box's field type when the target local is boxed.
+	_rangeStoreWType(name, info) {
+		const local = this.resolveLocal(name);
+		return local?.isBoxed ? local.boxInfo.wType : info.type;
+	}
+
+	// `for _, out[0] = range xs`: an index, selector or dereference target is
+	// not a variable the loop can store into directly.  Each such target gets
+	// a hidden local that the loop writes (so conversions and interface
+	// boxing work as for a variable), and `_emitRangeBoxes` assigns it to the
+	// real target at the top of the body.  Returns `lhs` with those targets
+	// replaced by identifiers of the hidden locals.
+	_bindRangeAssignTargets(lhs) {
+		return lhs.map((node) => {
+			if (!node || node.kind === "Ident" || !node._type) return node;
+			const name = `__rangetarget$${this.tempCounter++}`;
+			const wType = this.toWasmType(node._type);
+			this.allocLocal(name, wType, node._type, true);
+			if (!this._pendingRangeTargets) this._pendingRangeTargets = [];
+			this._pendingRangeTargets.push({ node, name, goType: node._type });
+			return { kind: "Ident", name, _type: node._type };
+		});
+	}
+
 	_emitRangeBoxes() {
+		const targets = this._pendingRangeTargets ?? [];
+		this._pendingRangeTargets = [];
+		for (const { node, name, goType } of targets) {
+			this._emitAssignSingle(
+				node,
+				{ kind: "Ident", name, _type: goType, _parTmp: true },
+				"=",
+			);
+			this.locals.delete(name);
+		}
 		const pending = this._pendingRangeBoxes ?? [];
 		this._pendingRangeBoxes = [];
 		for (const { name, idx, wType, goType } of pending) {
@@ -823,6 +929,10 @@ export class StmtsEmitter {
 			)
 		)
 			return false;
+		// Any callee may hold `&xs[i]` of a slice element, so when the program
+		// takes one, a whole-value store into an element writes in place.
+		if (this.mod.lowerResult?.elemAddrTaken && this._isSliceElemTarget(l))
+			return true;
 		const root = rootIdentName(l);
 		if (!root) return false;
 		// Any code may hold the address of a package-level variable.
@@ -832,6 +942,45 @@ export class StmtsEmitter {
 		return Boolean(ctx?.fnMutates(root, true));
 	}
 
+	// `xs[i] = v` into a slice element in place.  Capacity beyond the length
+	// may hold null elements (a reslice exposes them), so a null element is
+	// first replaced by a zero value that the store then fills.
+	_emitSliceElemStableStore(l, elemGoType, r, sliceInfo, arrInfo) {
+		const arrT = {
+			kind: "ref",
+			nullable: true,
+			typeIndex: arrInfo.typeIndex,
+		};
+		const arr = this.acquireTemp(arrT);
+		const idx = this.acquireTemp("i32");
+		this._emitElemAddr(l.expr, l.index, sliceInfo, arrInfo);
+		this.pushInstruction({ op: "local.set", index: idx });
+		this.pushInstruction({ op: "local.set", index: arr });
+		const getElem = () => {
+			this.pushInstruction({ op: "local.get", index: arr });
+			this.pushInstruction({ op: "local.get", index: idx });
+			this.pushInstruction({ op: "array.get", typeIndex: arrInfo.typeIndex });
+		};
+		getElem();
+		this.pushInstruction("ref.is_null");
+		this.pushInstruction({ op: "if", blockType: "void" });
+		this.pushInstruction({ op: "local.get", index: arr });
+		this.pushInstruction({ op: "local.get", index: idx });
+		this.emitZeroValue(elemGoType, arrInfo.elemWType);
+		this.pushInstruction({ op: "array.set", typeIndex: arrInfo.typeIndex });
+		this.pushInstruction("end");
+		this._emitStableStore(elemGoType, r, getElem);
+		this.releaseTemp(idx, "i32");
+		this.releaseTemp(arr, arrT);
+	}
+
+	// True when `l` is `xs[i]` on a slice (not an array or map).
+	_isSliceElemTarget(l) {
+		if (l.kind !== "IndexExpr") return false;
+		const t = l.expr._type ?? this._resolveExprGoType(l.expr);
+		return isSliceType(t, this.mod.checker) && !this._sharedInfo(t);
+	}
+
 	_emitStableStore(goType, r, emitDst) {
 		if (this._isValueArray(goType)) {
 			this._emitArrayStoreInto(goType, r, emitDst);
@@ -921,6 +1070,7 @@ export class StmtsEmitter {
 		this.pushInstruction({ op: "local.set", index: tmpL });
 		this.emitExpr(r, baseWType);
 		this.pushInstruction({ op: "local.set", index: tmpR });
+		this._emitNilGuard(tmpL, operand._type);
 		for (let i = 0; i < structInfo.fields.length; i++) {
 			this.pushInstruction({ op: "local.get", index: tmpL });
 			this.pushInstruction({ op: "local.get", index: tmpR });
@@ -939,6 +1089,16 @@ export class StmtsEmitter {
 		this.releaseTemp(tmpL, baseWType);
 	}
 
+	// Raises Go's nil-dereference panic when the pointer held in `tmp` is nil
+	// (a plain cast or field write would trap, which `recover` cannot see).
+	_emitNilGuard(tmp, goType) {
+		if (goType?.kind !== "pointer") return;
+		if (this.resolveBranchDepthToRole("nil") == null) return;
+		this.pushInstruction({ op: "local.get", index: tmp });
+		this._emitNilBranch();
+		this.pushInstruction("drop");
+	}
+
 	_emitDerefAssign(l, r) {
 		const operand = l.operand ?? l.expr;
 		const structInfo = this._derefStructInfo(operand);
@@ -975,6 +1135,7 @@ export class StmtsEmitter {
 		const valTmp = this.acquireTemp(box.wType);
 		this.emitExpr(operand, ptrWType);
 		this.pushInstruction({ op: "local.set", index: ptrTmp });
+		this._emitNilGuard(ptrTmp, operandGoType);
 		this.emitExpr(r, box.wType);
 		this.pushInstruction({ op: "local.set", index: valTmp });
 
@@ -996,8 +1157,26 @@ export class StmtsEmitter {
 		this.releaseTemp(ptrTmp, ptrWType);
 	}
 
+	// A plain variable target of interface type receiving a concrete result
+	// (`var x any; x, y = two()`) needs the value converted first.
+	_needsTupleConversion(lhsNodes, tupleTypes) {
+		return lhsNodes.some((l, i) => {
+			if (l.kind !== "Ident" || l.name === "_") return false;
+			const dest = this.resolveLocal(l.name) ?? this.mod.resolveGlobal(l.name);
+			const checker = this.mod.checker;
+			return (
+				isInterfaceType(dest?.goType ?? l._type, checker) &&
+				!isInterfaceType(tupleTypes[i], checker)
+			);
+		});
+	}
+
 	_emitTupleAssign(lhsNodes, rhsNode, op) {
-		if (op === "=" && lhsNodes.some((l) => !this._isPlainTupleTarget(l))) {
+		if (
+			op === "=" &&
+			(lhsNodes.some((l) => !this._isPlainTupleTarget(l)) ||
+				this._needsTupleConversion(lhsNodes, rhsNode._type.types))
+		) {
 			this._emitTupleViaTemps(
 				lhsNodes,
 				rhsNode,
@@ -1093,16 +1272,79 @@ export class StmtsEmitter {
 		this.releaseTemp(okTmp, "i32");
 	}
 
-	// Pushes a comma-ok result (map value / asserted value).  An array is a
-	// value: the stored one must not alias the map entry or boxed interface.
+	// Copies the struct or array a map entry holds (a range key or value is a
+	// copy, not the stored value).
+	_emitCopyMapEntry(goType, wType) {
+		const isStruct =
+			isStructType(goType, this.mod.checker, this.mod) &&
+			!isPointerToStruct(goType, this.mod.checker, this.mod);
+		if (isStruct) {
+			const sInfo = this._resolveStructInfo({ _type: goType });
+			if (sInfo) this.emitCloneStruct(sInfo, wType);
+		} else if (
+			goType?.kind !== "pointer" &&
+			isArrayType(goType, this.mod.checker)
+		) {
+			this.emitCopyArray(goType);
+		}
+	}
+
+	// Pushes a comma-ok result (map value / asserted value).  An array or
+	// struct is a value: the stored one must not alias the map entry or boxed
+	// interface.
 	_emitGetTempValue(tempIdx, goType) {
 		this.pushInstruction({ op: "local.get", index: tempIdx });
 		if (goType?.kind !== "pointer" && isArrayType(goType, this.mod.checker))
 			this.emitCopyArray(goType);
+		else if (
+			isStructType(goType, this.mod.checker, this.mod) &&
+			!isPointerToStruct(goType, this.mod.checker, this.mod)
+		) {
+			// A struct read out of a map or an interface is a copy.
+			const info =
+				this._resolveStructInfo({ _type: goType }) ??
+				this.mod.getStructType(goType?.name);
+			if (info) this.emitCloneStruct(info, this.toWasmType(goType));
+		}
+	}
+
+	_storeTargetWType(lhsNode) {
+		if (lhsNode.kind !== "Ident") return null;
+		const local = this.resolveLocal(lhsNode.name);
+		if (local)
+			return local.isBoxed
+				? local.boxInfo?.typeEntry?.fields?.[0]?.type
+				: local.type;
+		return this.mod.resolveGlobal(lhsNode.name)?.type ?? null;
 	}
 
 	_emitStoreLhsFromTemp(lhsNode, tempIdx, wType, goType, isDefine) {
-		if (lhsNode.kind !== "Ident" || lhsNode.name === "_") return;
+		if (lhsNode.kind === "Ident" && lhsNode.name === "_") return;
+		const redeclared =
+			isDefine && lhsNode._redecl && this.resolveLocal(lhsNode.name);
+		// `var x any; x, ok = m[k]`: a scalar or struct result is boxed on the
+		// way into the interface-typed variable.
+		const target = isDefine ? null : this._storeTargetWType(lhsNode);
+		const boxesIntoAny = target === "anyref" && wType !== "anyref";
+		if (lhsNode.kind !== "Ident" || redeclared || boxesIntoAny) {
+			// An index, field or dereference target (or a name `:=` redeclares):
+			// assign from a named view of the temporary.
+			const name = `__ok_tmp_${this.tempCounter++}`;
+			this.locals.set(name, {
+				index: tempIdx,
+				type: wType,
+				goType,
+				isParam: false,
+				isBoxed: false,
+			});
+			this._emitAssignSingle(
+				lhsNode,
+				{ kind: "Ident", name, _type: goType, _parTmp: true },
+				"=",
+			);
+			this.locals.delete(name);
+			return;
+		}
 		if (isDefine) {
 			const idx = this.allocLocal(lhsNode.name, wType, goType);
 			const local = this.locals.get(lhsNode.name);
@@ -1192,7 +1434,36 @@ export class StmtsEmitter {
 		);
 	}
 
+	// A bare type name in a case list or assertion (`case L:`, `case error:`)
+	// is the declared type, not its underlying one: a defined string type is
+	// boxed apart from `string`, and `error` carries a method set.
+	_resolveTestTarget(t) {
+		// A composite type-switch case (`case func(int) string:`) carries the
+		// checker's type, which keys typed-nil markers like the boxed value.
+		if (t?._assertType) return t._assertType;
+		if ((t?.kind !== "TypeName" && t?.kind !== "Ident") || !t.name) return t;
+		if (t.name === "nil" || t.name === "any" || t.name === "interface{}")
+			return t;
+		return this.mod.checker?.types?.get(t.name) ?? t;
+	}
+
+	// A defined func, map or array type lives in `any` as a box (so
+	// `iter.Seq[int]` is not a plain `func(func(int) bool)`, `type M
+	// map[string]int` keeps its name in `%T` and unhashable-key panics, and
+	// `type A [2]int` is not a `[2]int` in a type switch).
+	_isMethodNamedRef(goType) {
+		const t = this._resolveTestTarget(goType);
+		if (
+			t &&
+			(isArrayType(t, this.mod.checker) || isMapType(t, this.mod.checker))
+		)
+			return true;
+		if (t?.kind !== "named") return false;
+		return isFuncType(t, this.mod.checker);
+	}
+
 	_emitTypeTest(targetGoType) {
+		targetGoType = this._resolveTestTarget(targetGoType);
 		if (!targetGoType) {
 			this.pushInstruction("drop");
 			this.pushInstruction({ op: "i32.const", value: 1 });
@@ -1211,31 +1482,7 @@ export class StmtsEmitter {
 		}
 
 		if (isNonEmptyInterface(targetGoType, this.mod.checker)) {
-			const candidates = this.mod.getTypesImplementingInterface(targetGoType);
-			if (candidates.length === 0) {
-				this.pushInstruction("drop");
-				this.pushInstruction({ op: "i32.const", value: 0 });
-				return;
-			}
-			const anyTmp = this.acquireTemp("anyref");
-			this.pushInstruction({ op: "local.set", index: anyTmp });
-
-			this.pushInstruction({ op: "local.get", index: anyTmp });
-			this.pushInstruction("ref.is_null");
-			this.pushInstruction("i32.eqz");
-
-			for (let i = 0; i < candidates.length; i++) {
-				this.pushInstruction({ op: "local.get", index: anyTmp });
-				this.pushInstruction({
-					op: "ref.test",
-					typeIndex: candidates[i].typeIndex,
-				});
-				if (i > 0) {
-					this.pushInstruction("i32.or");
-				}
-			}
-			this.pushInstruction("i32.and");
-			this.releaseTemp(anyTmp, "anyref");
+			this._emitInterfaceTypeTest(targetGoType);
 			return;
 		}
 
@@ -1247,6 +1494,12 @@ export class StmtsEmitter {
 			return;
 		}
 
+		if (this._isMethodNamedRef(targetGoType)) {
+			const box = this.mod.getIfaceBoxType(targetGoType);
+			this.pushInstruction({ op: "ref.test", typeIndex: box.typeIndex });
+			return;
+		}
+
 		if (isFuncType(targetGoType, this.mod.checker)) {
 			const closureInfo = this.mod.getClosureType(targetGoType);
 			this._emitRefTestOrNil(targetGoType, closureInfo.typeIndex);
@@ -1265,33 +1518,27 @@ export class StmtsEmitter {
 
 		if (isSliceType(targetGoType, this.mod.checker)) {
 			const elem = this._getSliceElemType(targetGoType);
+			if (isTaggedSliceType(targetGoType, this.mod.checker)) {
+				const tagged = this.mod.getTaggedSliceType(targetGoType, elem);
+				this.pushInstruction({ op: "ref.test", typeIndex: tagged.typeIndex });
+				return;
+			}
 			const sInfo = this.mod.getSliceType(elem);
 			if (sInfo) {
+				// The unnamed slice type is the bare one, not a tagged subtype.
+				const root = this.mod.getTaggedSliceRoot(sInfo);
+				const tmp = this.acquireTemp("anyref");
+				this.pushInstruction({ op: "local.tee", index: tmp });
 				this.pushInstruction({ op: "ref.test", typeIndex: sInfo.typeIndex });
+				this.pushInstruction({ op: "local.get", index: tmp });
+				this.pushInstruction({ op: "ref.test", typeIndex: root.typeIndex });
+				this.pushInstruction("i32.eqz");
+				this.pushInstruction("i32.and");
+				this.releaseTemp(tmp, "anyref");
 				return;
 			}
 		}
 
-		if (isArrayType(targetGoType, this.mod.checker)) {
-			const elem = this._getArrayElemType(targetGoType);
-			const aInfo = this.mod.getArrayType(elem);
-			if (aInfo) {
-				this.pushInstruction({ op: "ref.test", typeIndex: aInfo.typeIndex });
-				return;
-			}
-		}
-
-		// A map lives in `any` as its bare map struct.
-		if (isMapType(targetGoType, this.mod.checker)) {
-			const { keyType, valType } = getMapKeyValTypes(
-				targetGoType,
-				this.mod.checker,
-			);
-			const mInfo = this.mod.getMapType(keyType, valType);
-			this._emitRefTestOrNil(targetGoType, mInfo.typeIndex);
-			return;
-		}
-
 		// Scalar types
 		const box = this.mod.getIfaceBoxType(targetGoType);
 		if (box) {
@@ -1303,6 +1550,45 @@ export class StmtsEmitter {
 		this.pushInstruction({ op: "i32.const", value: 1 });
 	}
 
+	// Whether the interface value on the stack holds a type implementing the
+	// non-empty interface: a `ref.test` over every implementing type (a typed
+	// nil `*S` marker included).
+	_emitInterfaceTypeTest(targetGoType) {
+		const candidates = this.mod.getTypesImplementingInterface(targetGoType);
+		if (candidates.length === 0) {
+			this.pushInstruction("drop");
+			this.pushInstruction({ op: "i32.const", value: 0 });
+			return;
+		}
+		const anyTmp = this.acquireTemp("anyref");
+		this.pushInstruction({ op: "local.set", index: anyTmp });
+
+		this.pushInstruction({ op: "local.get", index: anyTmp });
+		this.pushInstruction("ref.is_null");
+		this.pushInstruction("i32.eqz");
+
+		for (let i = 0; i < candidates.length; i++) {
+			this.pushInstruction({ op: "local.get", index: anyTmp });
+			this.pushInstruction({
+				op: "ref.test",
+				typeIndex: candidates[i].typeIndex,
+			});
+			if (candidates[i].nilTypeIndex !== undefined) {
+				this.pushInstruction({ op: "local.get", index: anyTmp });
+				this.pushInstruction({
+					op: "ref.test",
+					typeIndex: candidates[i].nilTypeIndex,
+				});
+				this.pushInstruction("i32.or");
+			}
+			if (i > 0) {
+				this.pushInstruction("i32.or");
+			}
+		}
+		this.pushInstruction("i32.and");
+		this.releaseTemp(anyTmp, "anyref");
+	}
+
 	// `ref.test` for a map, func or `*T`, which also accepts the typed-nil
 	// marker of the same Go type (see getNilBoxType).
 	_emitRefTestOrNil(goType, typeIndex) {
@@ -1337,10 +1623,19 @@ export class StmtsEmitter {
 		this.releaseTemp(tmp, "anyref");
 	}
 
+	// An interface target keeps the value as is; a boxed defined func or map
+	// type is unboxed.  True when the cast is done.
+	_emitCastNoRepack(targetGoType) {
+		if (isInterfaceType(targetGoType, this.mod.checker)) return true;
+		if (!this._isMethodNamedRef(targetGoType)) return false;
+		this._emitUnbox(
+			this.mod.getIfaceBoxType(this._resolveTestTarget(targetGoType)),
+		);
+		return true;
+	}
+
 	_emitTypeCast(targetGoType, targetWType) {
-		if (isInterfaceType(targetGoType, this.mod.checker)) {
-			return;
-		}
+		if (this._emitCastNoRepack(targetGoType)) return;
 
 		if (isBareStringType(targetGoType, this.mod.checker)) {
 			this.pushInstruction("extern.convert_any");
@@ -1382,28 +1677,6 @@ export class StmtsEmitter {
 			}
 		}
 
-		if (isArrayType(targetGoType, this.mod.checker)) {
-			const elem = this._getArrayElemType(targetGoType);
-			const aInfo = this.mod.getArrayType(elem);
-			if (aInfo) {
-				this.pushInstruction({
-					op: "ref.cast_null",
-					typeIndex: aInfo.typeIndex,
-				});
-				return;
-			}
-		}
-
-		if (isMapType(targetGoType, this.mod.checker)) {
-			const { keyType, valType } = getMapKeyValTypes(
-				targetGoType,
-				this.mod.checker,
-			);
-			const mInfo = this.mod.getMapType(keyType, valType);
-			this._emitRefCastOrNil(targetGoType, mInfo.typeIndex);
-			return;
-		}
-
 		// Scalar types
 		const box = this.mod.getIfaceBoxType(targetGoType);
 		if (box) {
@@ -1632,6 +1905,7 @@ export class StmtsEmitter {
 				const ptrTmp = this.acquireTemp(ptrWType);
 				this.emitExpr(operand, ptrWType);
 				this.pushInstruction({ op: "local.set", index: ptrTmp });
+				this._emitNilGuard(ptrTmp, operandGoType);
 
 				this.pushInstruction({ op: "local.get", index: ptrTmp });
 				this.pushInstruction({
@@ -1770,6 +2044,7 @@ export class StmtsEmitter {
 					const ptrTmp = this.acquireTemp(ptrWType);
 					this.emitExpr(operand, ptrWType);
 					this.pushInstruction({ op: "local.set", index: ptrTmp });
+					this._emitNilGuard(ptrTmp, operandGoType);
 
 					this.pushInstruction({ op: "local.get", index: ptrTmp });
 					this.pushInstruction({
@@ -2020,7 +2295,9 @@ export class StmtsEmitter {
 		const rangeExpr =
 			stmt.cond?.kind === "RangeExpr" ? stmt.cond : stmt.init.rhs[0];
 		const isAssign = stmt.init?.kind === "AssignStmt";
-		const lhs = stmt.init?.lhs ?? [];
+		const lhs = isAssign
+			? this._bindRangeAssignTargets(stmt.init.lhs)
+			: (stmt.init?.lhs ?? []);
 		const iterExpr = rangeExpr.expr;
 		const iterType = iterExpr._type;
 
@@ -2087,21 +2364,21 @@ export class StmtsEmitter {
 
 			// Assign loop var if present
 			if (idxLocalInfo) {
-				this.pushInstruction({ op: "local.get", index: idxTmp });
-				if (idxLocalInfo.type === "i64") {
-					this.pushInstruction("i64.extend_i32_s");
-				}
-				if (this.resolveLocal(lhs[0].name)) {
-					this.pushInstruction({
-						op: "local.set",
-						index: idxLocalInfo.index,
-					});
-				} else {
-					this.pushInstruction({
-						op: "global.set",
-						index: idxLocalInfo.index,
-					});
-				}
+				const name = lhs[0].name;
+				const wType = this._rangeStoreWType(name, idxLocalInfo);
+				const idxGoType =
+					iterType?.kind === "untyped"
+						? { kind: "basic", name: "int" }
+						: iterType;
+				this._emitRangeAssignStore(
+					name,
+					idxLocalInfo,
+					(want = wType) => {
+						this.pushInstruction({ op: "local.get", index: idxTmp });
+						if (want === "i64") this.pushInstruction("i64.extend_i32_s");
+					},
+					idxGoType,
+				);
 			}
 
 			// Emit body
@@ -2212,38 +2489,30 @@ export class StmtsEmitter {
 
 			// Assign index variable
 			if (idxLocalInfo) {
-				this.pushInstruction({ op: "local.get", index: idxTmp });
-				this.pushInstruction("i64.extend_i32_s");
-				if (this.resolveLocal(lhs[0].name)) {
-					this.pushInstruction({
-						op: "local.set",
-						index: idxLocalInfo.index,
-					});
-				} else {
-					this.pushInstruction({
-						op: "global.set",
-						index: idxLocalInfo.index,
-					});
-				}
+				this._emitRangeAssignStore(
+					lhs[0].name,
+					idxLocalInfo,
+					() => {
+						this.pushInstruction({ op: "local.get", index: idxTmp });
+						this.pushInstruction("i64.extend_i32_s");
+					},
+					{ kind: "basic", name: "int" },
+				);
 			}
 
 			// Assign rune variable
 			if (valLocalInfo) {
-				this.pushInstruction({ op: "local.get", index: runeTmp });
-				if (valLocalInfo.type === "i64") {
-					this.pushInstruction("i64.extend_i32_u");
-				}
-				if (this.resolveLocal(lhs[1].name)) {
-					this.pushInstruction({
-						op: "local.set",
-						index: valLocalInfo.index,
-					});
-				} else {
-					this.pushInstruction({
-						op: "global.set",
-						index: valLocalInfo.index,
-					});
-				}
+				const name = lhs[1].name;
+				const wType = this._rangeStoreWType(name, valLocalInfo);
+				this._emitRangeAssignStore(
+					name,
+					valLocalInfo,
+					(want = wType) => {
+						this.pushInstruction({ op: "local.get", index: runeTmp });
+						if (want === "i64") this.pushInstruction("i64.extend_i32_u");
+					},
+					{ kind: "basic", name: "int32" },
+				);
 			}
 
 			// Body
@@ -2411,58 +2680,38 @@ export class StmtsEmitter {
 
 			// Assign key variable
 			if (keyLocalInfo) {
-				this.pushInstruction({ op: "local.get", index: entryTmp });
-				this.pushInstruction({
-					op: "struct.get",
-					typeIndex: mapInfo.entryTypeIndex,
-					fieldIndex: 0,
-				});
-				if (this.resolveLocal(lhs[0].name)) {
-					this.pushInstruction({
-						op: "local.set",
-						index: keyLocalInfo.index,
-					});
-				} else {
-					this.pushInstruction({
-						op: "global.set",
-						index: keyLocalInfo.index,
-					});
-				}
+				this._emitRangeAssignStore(
+					lhs[0].name,
+					keyLocalInfo,
+					() => {
+						this.pushInstruction({ op: "local.get", index: entryTmp });
+						this.pushInstruction({
+							op: "struct.get",
+							typeIndex: mapInfo.entryTypeIndex,
+							fieldIndex: 0,
+						});
+						this._emitCopyMapEntry(keyType, mapInfo.keyWType);
+					},
+					keyType,
+				);
 			}
 
 			// Assign val variable
 			if (valLocalInfo) {
-				this.pushInstruction({ op: "local.get", index: entryTmp });
-				this.pushInstruction({
-					op: "struct.get",
-					typeIndex: mapInfo.entryTypeIndex,
-					fieldIndex: 1,
-				});
-				const isValStruct =
-					isStructType(valType, this.mod.checker, this.mod) &&
-					!isPointerToStruct(valType, this.mod.checker, this.mod);
-				if (isValStruct) {
-					const sInfo = this._resolveStructInfo({ _type: valType });
-					if (sInfo) {
-						this.emitCloneStruct(sInfo, mapInfo.valWType);
-					}
-				} else if (
-					valType?.kind !== "pointer" &&
-					isArrayType(valType, this.mod.checker)
-				) {
-					this.emitCopyArray(valType);
-				}
-				if (this.resolveLocal(lhs[1].name)) {
-					this.pushInstruction({
-						op: "local.set",
-						index: valLocalInfo.index,
-					});
-				} else {
-					this.pushInstruction({
-						op: "global.set",
-						index: valLocalInfo.index,
-					});
-				}
+				this._emitRangeAssignStore(
+					lhs[1].name,
+					valLocalInfo,
+					() => {
+						this.pushInstruction({ op: "local.get", index: entryTmp });
+						this.pushInstruction({
+							op: "struct.get",
+							typeIndex: mapInfo.entryTypeIndex,
+							fieldIndex: 1,
+						});
+						this._emitCopyMapEntry(valType, mapInfo.valWType);
+					},
+					valType,
+				);
 			}
 
 			// Body
@@ -2551,6 +2800,15 @@ export class StmtsEmitter {
 				});
 			}
 			this.releaseTemp(sliceTmp, sliceWType);
+		} else if (!hasVal && !hasCallOrReceive(iterExpr)) {
+			// Ranging over an array for its indexes only does not evaluate it
+			// (`range p` on a nil array pointer is valid): the length is the
+			// type's.
+			this.pushInstruction({
+				op: "i32.const",
+				value: this._getArraySize(isPtrToArr ? iterType.base : iterType),
+			});
+			this.pushInstruction({ op: "local.set", index: lenTmp });
 		} else {
 			this.emitExpr(iterExpr, arrWType);
 			// Go ranges over a copy of an array (the range expression is
@@ -2627,52 +2885,50 @@ export class StmtsEmitter {
 
 		// Assign idx
 		if (idxLocalInfo) {
-			this.pushInstruction({ op: "local.get", index: idxTmp });
-			if (idxLocalInfo.type === "i64") {
-				this.pushInstruction("i64.extend_i32_s");
-			}
-			if (this.resolveLocal(lhs[0].name)) {
-				this.pushInstruction({ op: "local.set", index: idxLocalInfo.index });
-			} else {
-				this.pushInstruction({
-					op: "global.set",
-					index: idxLocalInfo.index,
-				});
-			}
+			const name = lhs[0].name;
+			const wType = this._rangeStoreWType(name, idxLocalInfo);
+			this._emitRangeAssignStore(
+				name,
+				idxLocalInfo,
+				(want = wType) => {
+					this.pushInstruction({ op: "local.get", index: idxTmp });
+					if (want === "i64") this.pushInstruction("i64.extend_i32_s");
+				},
+				{ kind: "basic", name: "int" },
+			);
 		}
 
 		// Assign val
 		if (valLocalInfo) {
-			this.pushInstruction({ op: "local.get", index: arrTmp });
-			this.pushInstruction({ op: "local.get", index: offTmp });
-			this.pushInstruction({ op: "local.get", index: idxTmp });
-			this.pushInstruction("i32.add");
-			this.pushInstruction({
-				op: "array.get",
-				typeIndex: arrInfo.typeIndex,
-			});
-			if (
-				isStructType(elemGoType, this.mod.checker, this.mod) &&
-				!isPointerToStruct(elemGoType, this.mod.checker, this.mod)
-			) {
-				const sInfo = this._resolveStructInfo({ _type: elemGoType });
-				if (sInfo) {
-					this.emitCloneStruct(sInfo, arrInfo.elemWType);
-				}
-			} else if (
-				elemGoType?.kind !== "pointer" &&
-				isArrayType(elemGoType, this.mod.checker)
-			) {
-				this.emitCopyArray(elemGoType);
-			}
-			if (this.resolveLocal(lhs[1].name)) {
-				this.pushInstruction({ op: "local.set", index: valLocalInfo.index });
-			} else {
-				this.pushInstruction({
-					op: "global.set",
-					index: valLocalInfo.index,
-				});
-			}
+			this._emitRangeAssignStore(
+				lhs[1].name,
+				valLocalInfo,
+				() => {
+					this.pushInstruction({ op: "local.get", index: arrTmp });
+					this.pushInstruction({ op: "local.get", index: offTmp });
+					this.pushInstruction({ op: "local.get", index: idxTmp });
+					this.pushInstruction("i32.add");
+					this.pushInstruction({
+						op: "array.get",
+						typeIndex: arrInfo.typeIndex,
+					});
+					if (
+						isStructType(elemGoType, this.mod.checker, this.mod) &&
+						!isPointerToStruct(elemGoType, this.mod.checker, this.mod)
+					) {
+						const sInfo = this._resolveStructInfo({ _type: elemGoType });
+						if (sInfo) {
+							this.emitCloneStruct(sInfo, arrInfo.elemWType);
+						}
+					} else if (
+						elemGoType?.kind !== "pointer" &&
+						isArrayType(elemGoType, this.mod.checker)
+					) {
+						this.emitCopyArray(elemGoType);
+					}
+				},
+				elemGoType,
+			);
 		}
 
 		// Body
@@ -3134,16 +3390,7 @@ export class StmtsEmitter {
 				defaultIdx = i;
 				continue;
 			}
-			for (let j = 0; j < vals.length; j++) {
-				if (stmt.tag) {
-					this.pushInstruction({ op: "local.get", index: tagTmp });
-					this.emitExpr(vals[j], tagWType);
-					this.emitBinaryOp("==", tagWType, tagGoType);
-				} else {
-					this.emitExpr(vals[j], "i32");
-				}
-				if (j > 0) this.pushInstruction("i32.or");
-			}
+			this._emitCaseListMatch(stmt, vals, tagTmp, tagWType, tagGoType);
 			// The innermost block ends the first clause, so clause i is depth i.
 			this.pushInstruction({ op: "br_if", depth: i });
 		}
@@ -3162,6 +3409,26 @@ export class StmtsEmitter {
 		this.pushInstruction("end");
 	}
 
+	// Leaves an i32 on the stack: whether any expression of a case list matches.
+	// Later expressions are not evaluated once one matches, as in Go.
+	_emitCaseListMatch(stmt, vals, tagTmp, tagWType, tagGoType) {
+		for (let j = 0; j < vals.length; j++) {
+			if (stmt.tag) {
+				this.pushInstruction({ op: "local.get", index: tagTmp });
+				this.emitExpr(vals[j], tagWType);
+				this._emitElemEq(tagGoType, tagWType);
+			} else {
+				this.emitExpr(vals[j], "i32");
+			}
+			if (j < vals.length - 1) {
+				this.pushInstruction({ op: "if", blockType: "i32" });
+				this.pushInstruction({ op: "i32.const", value: 1 });
+				this.pushInstruction("else");
+			}
+		}
+		for (let j = 0; j < vals.length - 1; j++) this.pushInstruction("end");
+	}
+
 	emitSwitchStmt(stmt) {
 		if (
 			(stmt.cases ?? []).some((c) => {
@@ -3202,16 +3469,7 @@ export class StmtsEmitter {
 		let ifCount = 0;
 		for (const c of nonDefaultCases) {
 			const vals = getCaseVals(c);
-			for (let i = 0; i < vals.length; i++) {
-				if (stmt.tag) {
-					this.pushInstruction({ op: "local.get", index: tagTmp });
-					this.emitExpr(vals[i], tagWType);
-					this.emitBinaryOp("==", tagWType, tagGoType);
-				} else {
-					this.emitExpr(vals[i], "i32");
-				}
-				if (i > 0) this.pushInstruction("i32.or");
-			}
+			this._emitCaseListMatch(stmt, vals, tagTmp, tagWType, tagGoType);
 			this.pushInstruction({ op: "if", blockType: "void" });
 			ifCount++;
 
@@ -3233,6 +3491,17 @@ export class StmtsEmitter {
 		this.pushInstruction("end");
 	}
 
+	// Wraps the value on the stack in a box when the just-declared local `name`
+	// is captured and mutated.
+	_emitBoxIfCaptured(name) {
+		const info = this.locals.get(name);
+		if (info?.isBoxed)
+			this.pushInstruction({
+				op: "struct.new",
+				typeIndex: info.boxInfo.typeIndex,
+			});
+	}
+
 	emitTypeSwitchStmt(stmt) {
 		this.pushInstruction({ op: "block", blockType: "void" });
 		this.pushControl("break", stmt.label);
@@ -3273,7 +3542,7 @@ export class StmtsEmitter {
 				const targetGoType = isNilCase
 					? (stmt.expr._type ?? { kind: "basic", name: "any" })
 					: types.length === 1
-						? (types[0]._type ?? types[0])
+						? (types[0]._type ?? this._resolveTestTarget(types[0]))
 						: { kind: "basic", name: "any" };
 				const targetWType = this.toWasmType(targetGoType);
 				const assignLocal = this.allocLocal(
@@ -3293,6 +3562,7 @@ export class StmtsEmitter {
 				} else {
 					this.pushInstruction({ op: "local.get", index: tswTmp });
 				}
+				this._emitBoxIfCaptured(stmt.assign);
 				this.pushInstruction({ op: "local.set", index: assignLocal });
 			}
 
@@ -3308,6 +3578,7 @@ export class StmtsEmitter {
 					name: "any",
 				});
 				this.pushInstruction({ op: "local.get", index: tswTmp });
+				this._emitBoxIfCaptured(stmt.assign);
 				this.pushInstruction({ op: "local.set", index: assignLocal });
 			}
 			this._emitClauseBody(defaultCase.stmts);
@@ -3379,13 +3650,24 @@ export class StmtsEmitter {
 			this.pushInstruction("i64.eq");
 			this.pushInstruction({ op: "if", blockType: "void" });
 			if (target.role !== "break" || stmt.label !== target.label) {
-				if (this.funcDecl._isYieldClosure) {
+				const isContinue = target.role === "continue";
+				const inScope = this.controlStack.some(
+					(c) => c.label === target.label && c.role === target.role,
+				);
+				if (
+					!inScope &&
+					isContinue &&
+					this.funcDecl._isYieldClosure &&
+					target.label === this.funcDecl._forStmt?.label
+				) {
+					// `continue L` where L labels the iterator loop whose body this
+					// yield closure is: resume that iterator.
+					this.pushInstruction({ op: "i32.const", value: 1 });
+					this.pushInstruction({ op: "return" });
+				} else if (!inScope && this.funcDecl._isYieldClosure) {
 					this._propagateYieldExit(BigInt(target.tag));
 				} else {
-					const depth = this.resolveBranchDepth(
-						target.label,
-						target.role === "continue",
-					);
+					const depth = this.resolveBranchDepth(target.label, isContinue);
 					this.pushInstruction({ op: "br", depth });
 				}
 			}
@@ -3510,6 +3792,8 @@ export class StmtsEmitter {
 	}
 
 	emitBranchStmt(stmt) {
+		const alias = stmt.label && this._stackedLabelAlias(stmt.label);
+		if (alias) stmt = { ...stmt, label: alias };
 		if (this._tryEmitYieldBranch(stmt)) return;
 		const isContinue = stmt.keyword === "continue";
 		const depth = this.resolveBranchDepth(stmt.label, isContinue);