gofront 1.7.0 → 1.9.0

package/src/backend/js/statements.js

@@ -1,16 +1,147 @@
 import {
 	bodyRedeclares,
+	forEachChild,
+	hasCallOrReceive,
 	isIntRangeType,
 	isMapRangeType,
 	isRangeFor,
 	isSimpleIntRange,
 	isStringRangeType,
-	nodeAssigns,
+	loopVarsCapturedInLoop,
+	someChild,
 } from "../../lower/index.js";
-import { isComplex } from "../../typechecker/types.js";
+import {
+	is64BitInt,
+	isComplex,
+	isTypedArraySlice,
+} from "../../typechecker/types.js";
 
 /** @typedef {import('./index.js').CodeGen} CodeGen */
 
+// The same variable or field chain (`x`, `n.Children`) on both sides.
+const sameChain = (a, b) =>
+	a.kind === b.kind &&
+	(a.kind === "Ident"
+		? a.name === b.name && a.name !== "_"
+		: a.kind === "SelectorExpr" &&
+			a.field === b.field &&
+			sameChain(a.expr, b.expr));
+
+// `x = x[lo:hi]` (no max) with the same chain on both sides.
+const isSelfResliceShape = (stmt) =>
+	stmt.op === "=" &&
+	stmt.lhs.length === 1 &&
+	stmt.rhs.length === 1 &&
+	stmt.rhs[0].kind === "SliceExpr" &&
+	!stmt.rhs[0].max &&
+	sameChain(stmt.lhs[0], stmt.rhs[0].expr);
+
+// Pure expressions (the slice chain of a `__rcs` sync) that read the same
+// value after the write as before it: literals, variables and fields not
+// assigned by the statement, `len` and `cap`, and arithmetic over those.
+const isStableIndex = (e, assigned) => {
+	switch (e?.kind) {
+		case "BasicLit":
+			return true;
+		case "Ident":
+			return !assigned.has(e.name);
+		case "SelectorExpr":
+			return !e._isMethodValue && isStableIndex(e.expr, assigned);
+		case "ParenExpr":
+			return isStableIndex(e.expr, assigned);
+		case "UnaryExpr":
+			return e.op !== "<-" && isStableIndex(e.operand, assigned);
+		case "BinaryExpr":
+			return (
+				isStableIndex(e.left, assigned) && isStableIndex(e.right, assigned)
+			);
+		case "CallExpr":
+			return (
+				e.func?.kind === "Ident" &&
+				(e.func.name === "len" || e.func.name === "cap") &&
+				e.args.every((a) => isStableIndex(a, assigned))
+			);
+		default:
+			return false;
+	}
+};
+
+const isLenCap = (e) =>
+	e.kind === "CallExpr" &&
+	e.func?.kind === "Ident" &&
+	(e.func.name === "len" || e.func.name === "cap");
+
+// A call (other than `len`/`cap`), receive or await in `n` (not inside a
+// function literal): it may change variables and fields.
+const hasCall = (n) => {
+	if (Array.isArray(n)) return n.some(hasCall);
+	if (!n || typeof n !== "object" || typeof n.kind !== "string") return false;
+	if (n.kind === "FuncLit") return false;
+	if (n.kind === "AwaitExpr" || (n.kind === "CallExpr" && !isLenCap(n)))
+		return true;
+	if (n.kind === "UnaryExpr" && n.op === "<-") return true;
+	return someChild(n, hasCall);
+};
+
+// A call in a left-hand index or on the right-hand side of the statement.
+const stmtHasCall = (lhs, stmt) =>
+	lhs.some((e) => hasCall(e.index)) ||
+	(stmt.kind === "AssignStmt" && hasCall(stmt.rhs));
+
+// A multi-assign with a field or `*p` left-hand side: it may reassign the
+// slice chain of an index write, whose sync must then use the old slice.
+const reassignsChains = (lhs, stmt) =>
+	stmt.kind === "AssignStmt" &&
+	lhs.length > 1 &&
+	lhs.some(
+		(e) =>
+			e.kind === "SelectorExpr" || (e.kind === "UnaryExpr" && e.op === "*"),
+	);
+
+// Index of a `__rcs` sync that can be evaluated again after the write:
+// constants, and, when `vars` (a single-LHS statement without calls), unboxed
+// variables, with `len`/`cap` and arithmetic over those.  Any other index
+// is bound to a temporary first, so the write and the sync use one value.
+const isReusableIndex = (e, vars, boxed) => {
+	if (e?._const || e?.kind === "BasicLit") return true;
+	switch (e?.kind) {
+		case "Ident":
+			return vars && !boxed.has(e.name);
+		case "ParenExpr":
+			return isReusableIndex(e.expr, vars, boxed);
+		case "UnaryExpr":
+			return (
+				(e.op === "-" || e.op === "+" || e.op === "^") &&
+				isReusableIndex(e.operand, vars, boxed)
+			);
+		case "BinaryExpr":
+			return (
+				isReusableIndex(e.left, vars, boxed) &&
+				isReusableIndex(e.right, vars, boxed)
+			);
+		case "CallExpr":
+			return (
+				isLenCap(e) && e.args.every((a) => isReusableIndex(a, vars, boxed))
+			);
+		default:
+			return false;
+	}
+};
+
+// Adds the name of every identifier under `n` to `into`.
+const collectIdentNames = (n, into) => {
+	if (Array.isArray(n)) {
+		for (const c of n) collectIdentNames(c, into);
+		return;
+	}
+	if (!n || typeof n !== "object") return;
+	if (n.kind === "Ident") into.add(n.name);
+	someChild(n, (c) => {
+		collectIdentNames(c, into);
+		return false;
+	});
+};
+
 // Method-name dispatch for genStmt — string values add no static call edges.
 const STMT_GEN_DELEGATE = {
 	VarDecl: "genVarDecl",
@@ -22,26 +153,141 @@ const STMT_GEN_DELEGATE = {
 	SwitchStmt: "genSwitch",
 	TypeSwitchStmt: "genTypeSwitch",
 	BranchStmt: "_genBranchStmt",
+	TemplMount: "_genTemplMountStmt",
 };
 
 /** @type {ThisType<CodeGen>} */
 export const statementGenMethods = {
 	genBlock(block) {
-		for (const stmt of block.stmts) this.genStmt(stmt);
+		let nested = 0;
+		const earlier = new Set();
+		for (const stmt of block.stmts) {
+			if (this._definesShadowedRead(stmt)) {
+				this._genShadowingDefine(stmt);
+				nested++;
+			} else if (this._definesAfterOuterUse(stmt, earlier)) {
+				this.line("{");
+				this.indent++;
+				nested++;
+				this.genStmt(stmt);
+			} else {
+				this.genStmt(stmt);
+			}
+			collectIdentNames(stmt, earlier);
+		}
+		for (; nested > 0; nested--) {
+			this.indent--;
+			this.line("}");
+		}
+	},
+
+	// `err = nil; _, err := g()` where `err` is an outer variable used earlier
+	// in this block: JS `let` would put those uses in its temporal dead zone,
+	// so the rest of the block moves into a nested block.
+	_definesAfterOuterUse(stmt, earlier) {
+		if (stmt.kind !== "DefineStmt" || earlier.size === 0) return false;
+		return stmt.lhs.some(
+			(l) => !l._redecl && l.name !== "_" && earlier.has(l.name),
+		);
+	},
+
+	// `x := f(x)` declaring a new `x` that its own right-hand side reads (the
+	// outer `x`): JS `let` would put the read in its temporal dead zone.
+	_definesShadowedRead(stmt) {
+		if (stmt.kind !== "DefineStmt") return false;
+		const names = new Set(
+			stmt.lhs.filter((l) => !l._redecl && l.name !== "_").map((l) => l.name),
+		);
+		if (names.size === 0) return false;
+		const reads = (n) => {
+			if (Array.isArray(n)) return n.some(reads);
+			if (!n || typeof n !== "object") return false;
+			if (n.kind === "Ident" && names.has(n.name)) return true;
+			return someChild(n, reads);
+		};
+		return stmt.rhs.some(reads);
+	},
+
+	// Emits an `if`/`switch` init statement, then `body`; an init that reads the
+	// name it declares goes through `_genShadowingDefine`.
+	_genScopedInit(init, body) {
+		const shadowing = this._definesShadowedRead(init);
+		if (shadowing) this._genShadowingDefine(init);
+		else this.genStmt(init);
+		body();
+		if (shadowing) {
+			this.indent--;
+			this.line("}");
+		}
+	},
+
+	// Evaluates the right-hand side in the enclosing scope, then opens a nested
+	// block (closed at the end of the enclosing block) that declares the names.
+	_genShadowingDefine(stmt) {
+		if (this._isCommaOkMapExpr(stmt, stmt.rhs[0])) {
+			const node = stmt.rhs[0];
+			this._tmpCounter = (this._tmpCounter ?? 0) + 1;
+			const m = `__sm${this._tmpCounter}`;
+			const k = `__sk${this._tmpCounter}`;
+			this.line(
+				`const ${m} = ${this.genExpr(node.expr)}, ${k} = ${this.genExpr(node.index)};`,
+			);
+			this.line("{");
+			this.indent++;
+			this._genCommaOkMapIndex(stmt, node, true, { map: m, key: k });
+			return;
+		}
+		const rhs = this._defineRhs(stmt);
+		this._tmpCounter = (this._tmpCounter ?? 0) + 1;
+		const tmp = `__t${this._tmpCounter}`;
+		const all = rhs.length === 1 ? rhs[0] : `[${rhs.join(", ")}]`;
+		this.line(`const ${tmp} = ${all};`);
+		this.line("{");
+		this.indent++;
+		this._genDefineStmt(
+			stmt,
+			rhs.length === 1 ? [tmp] : rhs.map((_, i) => `${tmp}[${i}]`),
+		);
+	},
+
+	// `m[k]` of a non-strict comma-ok: a missing key reads as the scalar zero
+	// value, not `undefined`.
+	_nonStrictMapRead(mapExpr, keyExpr, valType, copyVal) {
+		const zero = valType ? this.zeroValueForType(valType) : "";
+		const read = `${mapExpr}[${keyExpr}]`;
+		if (/^(0n?|""|false)$/.test(zero)) return `(${read} ?? ${zero})`;
+		return copyVal(
+			this._aggregateBase(valType) ? `(${read} ?? ${zero})` : read,
+		);
 	},
 
 	// Shared helper for comma-ok map index in both DefineStmt and AssignStmt.
-	_genCommaOkMapIndex(stmt, rhsNode, isDefine) {
-		const mapExpr = this.genExpr(rhsNode.expr);
-		const keyExpr = this.genExpr(rhsNode.index);
+	// `pre` carries the map and key already evaluated (a shadowing declaration
+	// reads them before its names exist).
+	_genCommaOkMapIndex(stmt, rhsNode, isDefine, pre = null) {
+		const mapExpr = pre?.map ?? this.genExpr(rhsNode.expr);
+		const keyExpr = pre?.key ?? this.genExpr(rhsNode.index);
 		const [vName, okName] = stmt.lhs.map((e) => e.name ?? this.genExpr(e));
-		const decl = isDefine ? "let " : "";
+		// A name `:=` reuses is assigned, not declared again; an address-taken
+		// variable lives in a `{ value }` box.
+		const bind = (l, name, js) => {
+			const boxed = this._boxedVars.has(name);
+			if (isDefine && !l._redecl)
+				return `let ${name} = ${boxed ? `{ value: ${js} }` : js};`;
+			return `${name}${boxed ? ".value" : ""} = ${js};`;
+		};
+		const [vL, okL] = stmt.lhs;
+		// A struct or array map value is a copy, not the stored value.
+		const valType = rhsNode._mapValueType;
+		const copyVal = (js) =>
+			this._aggregateBase(valType) ? this._cloneJs(valType, js) : js;
 		if (isDefine && !this.strict) {
 			if (vName !== "_") {
-				this.line(`let ${vName} = ${mapExpr}[${keyExpr}];`);
+				const val = this._nonStrictMapRead(mapExpr, keyExpr, valType, copyVal);
+				this.line(bind(vL, vName, val));
 			}
 			if (okName !== "_") {
-				this.line(`let ${okName} = (${keyExpr}) in ${mapExpr};`);
+				this.line(bind(okL, okName, `(${keyExpr}) in ${mapExpr}`));
 			}
 			return;
 		}
@@ -54,11 +300,15 @@ export const statementGenMethods = {
 		this.line(`const ${mTmp} = ${mapExpr}, ${kTmp} = ${keyExpr};`);
 		if (vName !== "_") {
 			this.line(
-				`${decl}${vName} = (${mTmp} && (${kTmp} in ${mTmp})) ? ${mTmp}[${kTmp}] : ${zero};`,
+				bind(
+					vL,
+					vName,
+					`(${mTmp} && (${kTmp} in ${mTmp})) ? ${copyVal(`${mTmp}[${kTmp}]`)} : ${zero}`,
+				),
 			);
 		}
 		if (okName !== "_") {
-			this.line(`${decl}${okName} = Boolean(${mTmp} && (${kTmp} in ${mTmp}));`);
+			this.line(bind(okL, okName, `Boolean(${mTmp} && (${kTmp} in ${mTmp}))`));
 		}
 	},
 
@@ -66,11 +316,24 @@ export const statementGenMethods = {
 		// Record source mapping for the first line this statement produces
 		const srcLine = stmt._line ?? null;
 		const _line0 = this.out.length;
+		const restore = [];
+		const syncs =
+			stmt.kind === "AssignStmt"
+				? this._resliceSyncs(stmt.lhs, stmt, false, restore)
+				: stmt.kind === "IncDecStmt"
+					? this._resliceSyncs([stmt.expr], stmt, false, restore)
+					: null;
 		switch (stmt.kind) {
 			case "TypeDecl":
-				this.genTypeDeclWithMethods(stmt, []);
+				{
+					const start = this.out.length;
+					this.genTypeDeclWithMethods(stmt, []);
+					this._hoistLocalClass(stmt, start);
+				}
 				break;
 			case "IncDecStmt": {
+				this._markIndexLvalues([stmt.expr]);
+				this._markDerefOpTarget(stmt.expr);
 				if (stmt.expr.kind === "IndexExpr" && stmt.expr._mapValueType) {
 					const zero = this.zeroValueForType(stmt.expr._mapValueType);
 					const wrapField = this._namedWrapperField(
@@ -82,28 +345,47 @@ export const statementGenMethods = {
 						: this.genExpr(stmt.expr.expr);
 					const idx = this.genExpr(stmt.expr.index);
 					const op = stmt.op === "++" ? "+" : "-";
+					const is64Val = is64BitInt(stmt.expr._mapValueType);
+					const delta = is64Val ? "1n" : "1";
 					if (
 						this._hasCallExpr(stmt.expr.expr) ||
 						this._hasCallExpr(stmt.expr.index)
 					) {
+						const rhs = is64Val
+							? this._gen64BitBinary(
+									op,
+									`(__m[__k] ?? ${zero})`,
+									delta,
+									stmt.expr._mapValueType,
+								)
+							: `(__m[__k] ?? ${zero}) ${op} 1`;
 						this.line(
-							`((__m, __k) => { __m[__k] = (__m[__k] ?? ${zero}) ${op} 1; })(${base}, ${idx});`,
+							`((__m, __k) => { ${this._genMapWriteBase("__m")}[__k] = ${rhs}; })(${base}, ${idx});`,
 							srcLine,
 						);
 					} else {
+						const rhs = is64Val
+							? this._gen64BitBinary(
+									op,
+									`(${base}[${idx}] ?? ${zero})`,
+									delta,
+									stmt.expr._mapValueType,
+								)
+							: `(${base}[${idx}] ?? ${zero}) ${op} 1`;
 						this.line(
-							`${base}[${idx}] = (${base}[${idx}] ?? ${zero}) ${op} 1;`,
+							`${this._genMapWriteBase(base)}[${idx}] = ${rhs};`,
 							srcLine,
 						);
 					}
 					break;
 				}
+				const is64 = is64BitInt(stmt.expr._type);
 				if (
-					this.strict &&
+					(this.strict || is64 || this._isFloat32(stmt.expr._type)) &&
 					this._genStrictCompound(
 						stmt.expr,
 						stmt.op === "++" ? "+" : "-",
-						"1",
+						is64 ? "1n" : "1",
 						srcLine,
 					)
 				)
@@ -118,8 +400,7 @@ export const statementGenMethods = {
 				if (stmt.init) {
 					this.line("{");
 					this.indented(() => {
-						this.genStmt(stmt.init);
-						this._genIf(stmt);
+						this._genScopedInit(stmt.init, () => this._genIf(stmt));
 					});
 					this.line("}");
 				} else {
@@ -127,12 +408,26 @@ export const statementGenMethods = {
 				}
 				break;
 			case "DeferStmt":
-				this.line(`__defers.push(() => { ${this.genExpr(stmt.call)}; });`);
+				// A deferred native call runs the Go body.
+				this._withoutNatives(() =>
+					this.line(`__defers.push(() => { ${this.genExpr(stmt.call)}; });`),
+				);
 				break;
-			case "LabeledStmt":
-				this.line(`${stmt.label}:`);
-				this.genStmt(stmt.body);
+			case "LabeledStmt": {
+				// Stacked labels (`a: b: for ...`) all stay attached to the loop.
+				const labels = [stmt.label];
+				let body = stmt.body;
+				while (body?.kind === "LabeledStmt") {
+					labels.push(body.label);
+					body = body.body;
+				}
+				if (body?.kind === "ForStmt") body.label = labels[labels.length - 1];
+				const hoisted = this._hoistForInit(body);
+				for (const label of labels) this.line(`${label}:`);
+				this.genStmt(body);
+				if (hoisted) this._closeHoistedForInit();
 				break;
+			}
 			case "Block":
 				this.line("{");
 				this.indented(() => this.genBlock(stmt));
@@ -147,6 +442,9 @@ export const statementGenMethods = {
 				throw new Error(`CodeGen: unhandled statement kind '${stmt.kind}'`);
 			}
 		}
+		this._emitResliceSyncs(syncs);
+		// The AST is shared with the WASM backend: undo the temporaries.
+		for (const [node, key, v] of restore) node[key] = v;
 		// Record source mapping: first output line this statement produced
 		if (srcLine != null && this.out.length > _line0) {
 			this._srcMappings.push({
@@ -158,11 +456,14 @@ export const statementGenMethods = {
 	},
 
 	_isCommaOkMapExpr(stmt, rhsNode) {
+		if (stmt._commaOkMap) return true;
+		const t = rhsNode?.expr?._type;
+		const underlying = t?.kind === "named" ? t.underlying : t;
 		return (
 			stmt.rhs.length === 1 &&
 			stmt.lhs.length === 2 &&
 			rhsNode?.kind === "IndexExpr" &&
-			rhsNode.expr?._type?.kind === "map"
+			underlying?.kind === "map"
 		);
 	},
 
@@ -178,22 +479,14 @@ export const statementGenMethods = {
 	},
 
 	_genDefineMixedRedecl(lhs, rhs, redecls) {
-		if (rhs.length === 1 && lhs.length > 1) {
-			this._tmpCounter = (this._tmpCounter ?? 0) + 1;
-			const tmp = `__t${this._tmpCounter}`;
-			this.line(`const ${tmp} = ${rhs[0]};`);
-			for (let i = 0; i < lhs.length; i++) {
-				if (lhs[i] === "_") continue;
-				this._genDefineSingleVar([lhs[i]], [`${tmp}[${i}]`], [redecls[i]]);
-			}
-		} else {
-			for (let i = 0; i < lhs.length; i++) {
-				if (lhs[i] === "_") {
-					this.line(`${rhs[i]};`);
-					continue;
-				}
-				this._genDefineSingleVar([lhs[i]], [rhs[i]], [redecls[i]]);
-			}
+		// `x, y := 2, x` reads the old `x`: evaluate every value first.
+		this._tmpCounter = (this._tmpCounter ?? 0) + 1;
+		const tmp = `__t${this._tmpCounter}`;
+		const all = rhs.length === 1 ? rhs[0] : `[${rhs.join(", ")}]`;
+		this.line(`const ${tmp} = ${all};`);
+		for (let i = 0; i < lhs.length; i++) {
+			if (lhs[i] === "_") continue;
+			this._genDefineSingleVar([lhs[i]], [`${tmp}[${i}]`], [redecls[i]]);
 		}
 	},
 
@@ -206,19 +499,23 @@ export const statementGenMethods = {
 		}
 	},
 
-	_genDefineStmt(stmt) {
-		const rhsNode = stmt.rhs[0];
-		if (this._isCommaOkMapExpr(stmt, rhsNode)) {
-			this._genCommaOkMapIndex(stmt, rhsNode, true);
-			return;
-		}
+	_defineRhs(stmt) {
 		const paired = stmt.rhs.length === stmt.lhs.length;
-		const rhs = stmt.rhs.map((e, i) => {
+		return stmt.rhs.map((e, i) => {
 			const l = paired ? stmt.lhs[i] : null;
 			if (!l || l.name === "_") return this.genExpr(e);
 			if (l._redecl) return this.genValueExpr(e);
 			return this._genDeclValue(l.name, e);
 		});
+	},
+
+	_genDefineStmt(stmt, preEvaluated = null) {
+		const rhsNode = stmt.rhs[0];
+		if (this._isCommaOkMapExpr(stmt, rhsNode)) {
+			this._genCommaOkMapIndex(stmt, rhsNode, true);
+			return;
+		}
+		const rhs = preEvaluated ?? this._defineRhs(stmt);
 		const lhs = stmt.lhs.map((e) => e.name ?? this.genExpr(e));
 		const redecls = stmt.lhs.map((e) => !!e._redecl);
 		const anyRedecl = redecls.some((r) => r);
@@ -249,6 +546,68 @@ export const statementGenMethods = {
 		);
 	},
 
+	// `*p = v` where `p` points at a type parameter: erased, so the pointer is
+	// either a struct (copy into it) or a get/set wrapper.
+	_isTypeParamDerefAssign(stmt) {
+		if (stmt.lhs.length !== 1 || stmt.rhs.length !== 1 || stmt.op !== "=")
+			return false;
+		const l = stmt.lhs[0];
+		return (
+			l.kind === "UnaryExpr" &&
+			l.op === "*" &&
+			l.operand?._type?.base?.kind === "typeParam"
+		);
+	},
+
+	_isTypeParamDerefTarget(l) {
+		return (
+			l.kind === "UnaryExpr" &&
+			l.op === "*" &&
+			l.operand?._type?.base?.kind === "typeParam"
+		);
+	},
+
+	// `*a, *b = *b, *a` with type-parameter pointers: `*p` is not a settable
+	// JS destructuring target, so evaluate the right-hand side into temporaries
+	// and assign each target on its own.
+	_hasTypeParamDerefTarget(stmt) {
+		return (
+			stmt.op === "=" &&
+			stmt.lhs.length > 1 &&
+			stmt.lhs.some((l) => this._isTypeParamDerefTarget(l))
+		);
+	},
+
+	_genTypeParamDerefMultiAssign(stmt) {
+		const n = stmt.lhs.length;
+		const names = stmt.lhs.map((_, i) => `__t${i}`);
+		this.line("{");
+		this.indented(() => {
+			if (stmt.rhs.length === n) {
+				const vals = stmt.rhs.map((e, i) =>
+					stmt.lhs[i].name !== "_" ? this.genValueExpr(e) : this.genExpr(e),
+				);
+				this.line(`const [${names.join(", ")}] = [${vals.join(", ")}];`);
+			} else {
+				this.line(
+					`const [${names.join(", ")}] = ${this.genExpr(stmt.rhs[0])};`,
+				);
+			}
+			stmt.lhs.forEach((l, i) => {
+				if (l.name === "_") return;
+				if (this._isTypeParamDerefTarget(l)) {
+					const isStruct = this._typeParamIsStructJs(l.operand._type.base.name);
+					this.line(
+						`((__p, __v) => { if (${isStruct}) Object.assign(__p, __v); else __p.value = __v; })(${this.genExpr(l.operand)}, ${names[i]});`,
+					);
+				} else {
+					this.line(`${this._genAssignLhsExpr(l)} = ${names[i]};`);
+				}
+			});
+		});
+		this.line("}");
+	},
+
 	_isStructDerefAssign(stmt) {
 		if (stmt.lhs.length !== 1 || stmt.rhs.length !== 1 || stmt.op !== "=")
 			return false;
@@ -270,6 +629,13 @@ export const statementGenMethods = {
 		for (const e of exprs) if (e.kind === "IndexExpr") e._lvalue = true;
 	},
 
+	// Op-assign / inc-dec through a type-parameter pointer needs a settable
+	// target: the erased pointer is a get/set wrapper (struct instantiations
+	// cannot be op-assigned), so target `.value` directly.
+	_markDerefOpTarget(e) {
+		if (this._isTypeParamDerefTarget(e)) e._derefOpTarget = true;
+	},
+
 	_genAssignMulti(stmt, lhs, rhs, active, pairs) {
 		const rhsStr = rhs.length === 1 ? rhs[0] : `[${rhs.join(", ")}]`;
 		if (active.length === pairs.length) {
@@ -279,7 +645,132 @@ export const statementGenMethods = {
 		}
 	},
 
+	// `x = x[lo:hi]` with the same variable or field chain on both sides:
+	// the old value of `x` is replaced, so `_genSliceExpr` may copy instead
+	// of building a slice view (`__reslice`).
+	_markSelfReslice(stmt) {
+		if (stmt.op !== "=" || stmt.lhs.length !== 1 || stmt.rhs.length !== 1)
+			return;
+		const r = stmt.rhs[0];
+		if (r.kind !== "SliceExpr" || r.max) return;
+		// A parameter or named result may alias the caller's slice: keep the
+		// view.  Field chains (`n.Children = n.Children[:k]`) still copy.
+		const lhs = stmt.lhs[0];
+		if (lhs.kind === "Ident" && this._fnCtx?.params.has(lhs.name)) return;
+		if (sameChain(stmt.lhs[0], r.expr)) r._selfReslice = true;
+	},
+
+	// Names of the variables and fields (`.F`) that some `x = x[lo:hi]` in the
+	// program may turn into a `__reslice` copy (`_resliceSyncs`).
+	_collectResliceNames(program) {
+		const names = new Set();
+		const visit = (n) => {
+			if (Array.isArray(n)) {
+				for (const c of n) visit(c);
+				return;
+			}
+			if (!n || typeof n !== "object" || typeof n.kind !== "string") return;
+			if (n.kind === "AssignStmt" && isSelfResliceShape(n)) {
+				const l = n.lhs[0];
+				names.add(l.kind === "Ident" ? l.name : `.${l.field}`);
+			}
+			forEachChild(n, visit);
+		};
+		visit(program.decls);
+		this._resliceNames = names;
+	},
+
+	// Index writes in `lhs` whose slice may be a `__reslice` copy: each is
+	// followed by `__rcs(x, i)` (`_emitResliceSyncs`), which writes the element
+	// through to the copy's old array, so writes through the copy and through
+	// other slices of that array keep Go's order.  An index that the statement
+	// could change (`isReusableIndex`) is first bound to a temporary (not in
+	// `inline` for-clause statements, which skip the sync: the write-back on
+	// extension still applies).  Not covered: writes through other references to the copy.
+	// Once one index is bound, every left-hand index with a call is bound too,
+	// in source order and each after its operand, and so is the slice operand
+	// of a synced write in a statement with a call or one that may reassign
+	// the chain through a field or `*p` (`reassignsChains`; inline statements
+	// skip that sync) — Go evaluates both before the right-hand side.
+	// `restore` collects the replaced nodes for the caller to put back.
+	_resliceSyncs(lhs, stmt, inline = false, restore = []) {
+		if (!this._resliceNames?.size) return null;
+		const targets = this._resliceTargets(lhs, stmt);
+		if (targets.size === 0) return null;
+		const called = stmtHasCall(lhs, stmt);
+		const moved = reassignsChains(lhs, stmt);
+		const vars = lhs.length === 1 && !called;
+		const reusable = (e) => isReusableIndex(e.index, vars, this._boxedVars);
+		const out = [...targets].filter((e) => !inline || (!moved && reusable(e)));
+		const operands = called || moved;
+		if (!inline && (operands || out.some((e) => !reusable(e))))
+			this._bindResliceOperands(lhs, targets, operands, reusable, restore);
+		if (out.length === 0) return null;
+		this.useHelper("slice");
+		return out.map((e) => {
+			const wrapField = this._namedWrapperField(e.expr._type, e.expr);
+			const base = wrapField
+				? `${this.genExpr(e.expr)}.${wrapField}`
+				: this.genExpr(e.expr);
+			return `__rcs(${base}, ${this.genExpr(e.index)})`;
+		});
+	},
+
+	// The `_isResliceSyncTarget` writes in `lhs`.
+	_resliceTargets(lhs, stmt) {
+		const assigned = new Set();
+		if (stmt.kind === "AssignStmt" && stmt.lhs.length > 1)
+			for (const e of stmt.lhs) if (e.kind === "Ident") assigned.add(e.name);
+		return new Set(lhs.filter((e) => this._isResliceSyncTarget(e, assigned)));
+	},
+
+	// Binds the left-hand operands that `_resliceSyncs` must not evaluate
+	// twice to temporaries, in source order: an index after its operand, and
+	// the operand of every synced write when `operands`.
+	_bindResliceOperands(lhs, targets, operands, reusable, restore) {
+		const bind = (e, key) => {
+			this._tmpCounter = (this._tmpCounter ?? 0) + 1;
+			const tmp = `__rci${this._tmpCounter}`;
+			this.line(`const ${tmp} = ${this.genExpr(e[key])};`);
+			restore.push([e, key, e[key]]);
+			e[key] = { kind: "Ident", name: tmp, _type: e[key]._type };
+		};
+		for (const e of lhs) {
+			if (e.kind !== "IndexExpr") continue;
+			const t = targets.has(e);
+			const index = (t && !reusable(e)) || hasCall(e.index);
+			if ((t && operands) || index) bind(e, "expr");
+			if (index) bind(e, "index");
+		}
+	},
+
+	// `x[i]` on a plain slice held by a chain in `_resliceNames` whose root
+	// variable the statement does not reassign.
+	_isResliceSyncTarget(e, assigned) {
+		if (e.kind !== "IndexExpr" || e._mapValueType) return false;
+		const c = e.expr;
+		if (c.kind !== "Ident" && c.kind !== "SelectorExpr") return false;
+		if (!this._resliceNames.has(c.kind === "Ident" ? c.name : `.${c.field}`))
+			return false;
+		const u = c._type?.kind === "named" ? c._type.underlying : c._type;
+		if (u?.kind !== "slice" || isTypedArraySlice(c._type)) return false;
+		let root = c;
+		while (root.kind === "SelectorExpr") root = root.expr;
+		return (
+			root.kind === "Ident" &&
+			!assigned.has(root.name) &&
+			isStableIndex(c, assigned)
+		);
+	},
+
+	_emitResliceSyncs(syncs) {
+		if (syncs) for (const s of syncs) this.line(`${s};`);
+	},
+
 	_genAssignStmt(stmt) {
+		this._markIndexLvalues(stmt.lhs);
+		if (stmt.op !== "=") for (const l of stmt.lhs) this._markDerefOpTarget(l);
+		this._markSelfReslice(stmt);
 		if (this._isComplexCompoundAssign(stmt)) {
 			this._genComplexCompoundAssign(stmt);
 			return;
@@ -292,18 +783,42 @@ export const statementGenMethods = {
 			this._genCommaOkTypeAssert(stmt);
 			return;
 		}
+		if (this._isTypeParamDerefAssign(stmt)) {
+			const ptr = this.genExpr(stmt.lhs[0].operand);
+			const val = this.genValueExpr(stmt.rhs[0]);
+			const isStruct = this._typeParamIsStructJs(
+				stmt.lhs[0].operand._type.base.name,
+			);
+			this.line(
+				`((__p, __v) => { if (${isStruct}) Object.assign(__p, __v); else __p.value = __v; })(${ptr}, ${val});`,
+			);
+			return;
+		}
+		if (this._hasTypeParamDerefTarget(stmt)) {
+			this._genTypeParamDerefMultiAssign(stmt);
+			return;
+		}
 		if (this._isStructDerefAssign(stmt)) {
 			this._genStructDerefAssign(stmt);
 			return;
 		}
+		if (this._isStableWholeAssign(stmt)) {
+			this._genStableWholeAssign(stmt);
+			return;
+		}
+		if (this._isStableTupleAssign(stmt)) {
+			this._genStableTupleAssign(stmt);
+			return;
+		}
 		const paired = stmt.rhs.length === stmt.lhs.length && stmt.op === "=";
 		const rhs = stmt.rhs.map((e, i) =>
 			paired && stmt.lhs[i].name !== "_"
 				? this.genValueExpr(e)
 				: this.genExpr(e),
 		);
-		this._markIndexLvalues(stmt.lhs);
+		const hoisted = this._hoistLhsOperands(stmt);
 		const lhs = stmt.lhs.map((e) => this._genAssignLhsExpr(e));
+		hoisted?.restore();
 		const pairs = lhs.map((l, i) => ({ l, r: rhs[i] ?? rhs[0] }));
 		const active = pairs.filter((p) => p.l !== "_");
 		if (active.length === 0) {
@@ -324,42 +839,139 @@ export const statementGenMethods = {
 					: this.genExpr(stmt.lhs[0].expr);
 				const idx = this.genExpr(stmt.lhs[0].index);
 				const binOp = stmt.op.slice(0, -1);
+				const is64Val = is64BitInt(stmt.lhs[0]._mapValueType);
+				let rhsVal = active[0].r;
+				if (
+					is64Val &&
+					stmt.rhs[0]?._type?.kind === "untyped" &&
+					!rhsVal.endsWith("n") &&
+					/^-?\d+$/.test(rhsVal)
+				) {
+					rhsVal = `${rhsVal}n`;
+				}
+				const rhsExpr = is64Val
+					? this._gen64BitBinary(
+							binOp,
+							`(__m[__k] ?? ${zero})`,
+							rhsVal,
+							stmt.lhs[0]._mapValueType,
+						)
+					: `(__m[__k] ?? ${zero}) ${binOp === "&^" ? "& ~" : binOp} (${rhsVal})`;
+				const rhsExprDirect = is64Val
+					? this._gen64BitBinary(
+							binOp,
+							`(${base}[${idx}] ?? ${zero})`,
+							rhsVal,
+							stmt.lhs[0]._mapValueType,
+						)
+					: `(${base}[${idx}] ?? ${zero}) ${binOp === "&^" ? "& ~" : binOp} (${rhsVal})`;
 				if (
 					this._hasCallExpr(stmt.lhs[0].expr) ||
 					this._hasCallExpr(stmt.lhs[0].index)
 				) {
 					this.line(
-						`((__m, __k) => { __m[__k] = (__m[__k] ?? ${zero}) ${binOp} (${active[0].r}); })(${base}, ${idx});`,
+						`((__m, __k) => { ${this._genMapWriteBase("__m")}[__k] = ${rhsExpr}; })(${base}, ${idx});`,
 					);
 				} else {
 					this.line(
-						`${base}[${idx}] = (${base}[${idx}] ?? ${zero}) ${binOp} (${active[0].r});`,
+						`${this._genMapWriteBase(base)}[${idx}] = ${rhsExprDirect};`,
 					);
 				}
 				return;
 			}
+			const is64 = is64BitInt(stmt.lhs[0]._type);
+			let rhsVal = active[0].r;
 			if (
-				this.strict &&
-				stmt.op !== "=" &&
+				is64 &&
+				stmt.rhs[0]?._type?.kind === "untyped" &&
+				!rhsVal.endsWith("n") &&
+				/^-?\d+$/.test(rhsVal)
+			) {
+				rhsVal = `${rhsVal}n`;
+			}
+			if (
+				this._needsStrictCompoundStmt(stmt, is64) &&
 				this._genStrictCompound(
 					stmt.lhs[0],
 					stmt.op.slice(0, -1),
-					active[0].r,
+					rhsVal,
 					null,
 					active[0].l,
+					stmt.rhs[0]?._type,
 				)
 			) {
 				return;
 			}
-			this.line(`${active[0].l} ${stmt.op} ${active[0].r};`);
+			const targetL =
+				active[0].l.startsWith("{") && !active[0].l.startsWith("({")
+					? `(${active[0].l})`
+					: active[0].l;
+			if (stmt.op === "&^=") this.line(`${targetL} &= ~(${rhsVal});`);
+			else this.line(`${targetL} ${stmt.op} ${rhsVal};`);
+		} else if (hoisted) {
+			this.line("{");
+			this.indented(() => {
+				for (const l of hoisted.lines) this.line(l);
+				this._genAssignMulti(stmt, lhs, rhs, active, pairs);
+			});
+			this.line("}");
 		} else {
 			this._genAssignMulti(stmt, lhs, rhs, active, pairs);
 		}
 	},
 
+	// `k, xs[k] = 1, 5`: Go evaluates the operands of every index and field
+	// target before any assignment, but a JS destructuring target reads its
+	// operands after the earlier ones are stored.  Operands that mention a
+	// variable assigned by the same statement are bound to temporaries first.
+	_hoistLhsOperands(stmt) {
+		if (stmt.op !== "=" || stmt.lhs.length < 2) return null;
+		const assigned = new Set(
+			stmt.lhs
+				.filter((l) => l.kind === "Ident" && l.name !== "_")
+				.map((l) => l.name),
+		);
+		if (assigned.size === 0) return null;
+		const mentions = (n) =>
+			!!n &&
+			typeof n === "object" &&
+			((n.kind === "Ident" && assigned.has(n.name)) || someChild(n, mentions));
+		const lines = [];
+		const undo = [];
+		const visit = (l) => {
+			let keys;
+			if (l.kind === "IndexExpr") keys = ["expr", "index"];
+			else if (l.kind === "SelectorExpr" && !l._isMethodExpr) keys = ["expr"];
+			else return;
+			for (const key of keys) {
+				const operand = l[key];
+				if (!mentions(operand)) continue;
+				// 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._aggregateBase(operand._type)) {
+					visit(operand);
+					continue;
+				}
+				this._tmpCounter = (this._tmpCounter ?? 0) + 1;
+				const name = `__h${this._tmpCounter}`;
+				lines.push(`const ${name} = ${this.genExpr(operand)};`);
+				undo.push([l, key, operand]);
+				l[key] = { kind: "Ident", name, _type: operand._type };
+			}
+		};
+		for (const l of stmt.lhs) visit(l);
+		if (lines.length === 0) return null;
+		return {
+			lines,
+			restore: () => {
+				for (const [node, key, v] of undo) node[key] = v;
+			},
+		};
+	},
+
 	_genCommaOkTypeAssert(stmt) {
 		const val = this.genExpr(stmt.rhs[0]);
-		const [vName, okName] = stmt.lhs.map((e) => e.name ?? this.genExpr(e));
+		const [vName, okName] = stmt.lhs.map((e) => this._genAssignLhsExpr(e));
 		this._tmpCounter = (this._tmpCounter ?? 0) + 1;
 		const tmp = `__ta${this._tmpCounter}`;
 		this.line(`const ${tmp} = ${val};`);
@@ -367,6 +979,118 @@ export const statementGenMethods = {
 		if (okName !== "_") this.line(`${okName} = ${tmp}[1];`);
 	},
 
+	// `a = [3]int{...}` / `s = S{...}` on a variable whose address (or an
+	// element's or field's address) is taken must write into the existing
+	// storage so those pointers see the new value (Task 0.33).
+	_isStableWholeAssign(stmt) {
+		if (stmt.op !== "=" || stmt.lhs.length !== 1 || stmt.rhs.length !== 1)
+			return false;
+		return this._isStableTarget(stmt.lhs[0], stmt.rhs[0]);
+	},
+
+	// `l = rhs` writes into the existing storage of `l` (see above).  When the
+	// program takes `&xs[i]` anywhere, an element of a slice does too: any
+	// callee may hold the pointer.
+	_isStableTarget(l, rhs) {
+		if (l.kind === "IndexExpr" && l._mapValueType) return false;
+		if (
+			l.kind !== "Ident" &&
+			l.kind !== "SelectorExpr" &&
+			l.kind !== "IndexExpr"
+		)
+			return false;
+		if (l.kind === "Ident" && l.name === "_") return false;
+		if (!this._aggregateBase(l._type) || !this._aggregateBase(rhs._type))
+			return false;
+		if (this._elemAddrTaken && this._isSliceElemTarget(l)) return true;
+		const root = this._rootIdentName(l);
+		return root !== null && this._fnMutates(root, true);
+	},
+
+	// `xs[i]` on a plain slice (not a typed array, array or map).
+	_isSliceElemTarget(l) {
+		if (l.kind !== "IndexExpr" || l._mapValueType) return false;
+		const u =
+			l.expr._type?.kind === "named" ? l.expr._type.underlying : l.expr._type;
+		return u?.kind === "slice" && !isTypedArraySlice(l.expr._type);
+	},
+
+	// `a, b = x, y` where a target is stored in place: every right-hand value
+	// is evaluated (and copied) first, then each target is assigned in order.
+	_isStableTupleAssign(stmt) {
+		return (
+			stmt.op === "=" &&
+			stmt.lhs.length > 1 &&
+			stmt.rhs.length === stmt.lhs.length &&
+			stmt.lhs.some((l, i) => this._isStableTarget(l, stmt.rhs[i]))
+		);
+	},
+
+	_genStableTupleAssign(stmt) {
+		const hoisted = this._hoistLhsOperands(stmt);
+		const stable = stmt.lhs.map((l, i) => this._isStableTarget(l, stmt.rhs[i]));
+		this.line("{");
+		this.indented(() => {
+			for (const l of hoisted?.lines ?? []) this.line(l);
+			const base = (this._tmpCounter ?? 0) + 1;
+			this._tmpCounter = base + stmt.lhs.length;
+			const val = (i) => `__s${base + i}`;
+			const dst = (i) => `__d${base + i}`;
+			stmt.rhs.forEach((r, i) => {
+				this.line(`const ${val(i)} = ${this.genValueExpr(r)};`);
+			});
+			stmt.lhs.forEach((l, i) => {
+				if (stable[i])
+					this.line(`const ${dst(i)} = ${this._genAssignLhsExpr(l)};`);
+			});
+			stmt.lhs.forEach((l, i) => {
+				if (stable[i]) this._emitCopyInto(dst(i), val(i), l._type);
+				else if (!(l.kind === "Ident" && l.name === "_"))
+					this.line(`${this._genAssignLhsExpr(l)} = ${val(i)};`);
+			});
+		});
+		this.line("}");
+		hoisted?.restore();
+	},
+
+	_genStableWholeAssign(stmt) {
+		let target = this._genAssignLhsExpr(stmt.lhs[0]);
+		const type = stmt.lhs[0]._type;
+		this._tmpCounter = (this._tmpCounter ?? 0) + 1;
+		const src = `__s${this._tmpCounter}`;
+		this.line(`{ const ${src} = ${this.genExpr(stmt.rhs[0])};`);
+		if (stmt.lhs[0].kind === "IndexExpr") {
+			// Evaluate the element reference once.
+			target = `__d${this._tmpCounter}`;
+			this.line(`const ${target} = ${this._genAssignLhsExpr(stmt.lhs[0])};`);
+		}
+		this._emitCopyInto(target, src, type);
+		this.line("}");
+	},
+
+	// Copies aggregate `src` into the storage `dst` element by element, going
+	// into nested arrays and structs so pointers to inner parts stay valid.
+	_emitCopyInto(dst, src, type) {
+		const base = this._aggregateBase(type);
+		if (base.kind === "struct") {
+			for (const [name, ft] of base.fields) {
+				if (name === "_") continue;
+				const f = `.${name}`;
+				if (this._aggregateBase(ft))
+					this._emitCopyInto(`${dst}${f}`, `${src}${f}`, ft);
+				else this.line(`${dst}${f} = ${src}${f};`);
+			}
+			return;
+		}
+		this._tmpCounter = (this._tmpCounter ?? 0) + 1;
+		const k = `__k${this._tmpCounter}`;
+		this.line(`for (let ${k} = 0; ${k} < ${src}.length; ${k}++) {`);
+		if (this._aggregateBase(base.elem))
+			this._emitCopyInto(`${dst}[${k}]`, `${src}[${k}]`, base.elem);
+		else this.line(`${dst}[${k}] = ${src}[${k}];`);
+		this.line("}");
+	},
+
 	_genStructDerefAssign(stmt) {
 		const target = this.genExpr(stmt.lhs[0].operand);
 		const rhsNode = stmt.rhs[0];
@@ -393,31 +1117,45 @@ export const statementGenMethods = {
 	},
 
 	_genComplexCompoundAssign(stmt) {
-		const lhsStr = stmt.lhs[0].name ?? this.genExpr(stmt.lhs[0]);
+		const l = stmt.lhs[0];
+		let lhsTarget;
+		let lhsRead;
+		if (l.kind === "IndexExpr" && l._mapValueType) {
+			const wrapField = this._namedWrapperField(l.expr._type, l.expr);
+			const base = wrapField
+				? `${this.genExpr(l.expr)}.${wrapField}`
+				: this.genExpr(l.expr);
+			const idx = this.genExpr(l.index);
+			lhsTarget = `${this._genMapWriteBase(base)}[${idx}]`;
+			lhsRead = `(${base}[${idx}] ?? { re: 0, im: 0 })`;
+		} else {
+			lhsTarget = l.name ?? this.genExpr(l);
+			lhsRead = lhsTarget;
+		}
 		const rhsExpr = this._genComplexOperand(stmt.rhs[0]);
 		const baseOp = stmt.op.slice(0, -1); // "+=" → "+"
 		let result;
 		switch (baseOp) {
 			case "+":
-				result = `{ re: ${lhsStr}.re + ${rhsExpr}.re, im: ${lhsStr}.im + ${rhsExpr}.im }`;
+				result = `{ re: ${lhsRead}.re + ${rhsExpr}.re, im: ${lhsRead}.im + ${rhsExpr}.im }`;
 				break;
 			case "-":
-				result = `{ re: ${lhsStr}.re - ${rhsExpr}.re, im: ${lhsStr}.im - ${rhsExpr}.im }`;
+				result = `{ re: ${lhsRead}.re - ${rhsExpr}.re, im: ${lhsRead}.im - ${rhsExpr}.im }`;
 				break;
 			case "*":
 				this.useHelper("cmul");
-				result = `__cmul(${lhsStr}, ${rhsExpr})`;
+				result = `__cmul(${lhsRead}, ${rhsExpr})`;
 				break;
 			case "/":
 				this.useHelper("cdiv");
-				result = `__cdiv(${lhsStr}, ${rhsExpr})`;
+				result = `__cdiv(${lhsRead}, ${rhsExpr})`;
 				break;
 			default:
 				throw new Error(
 					`unsupported complex compound assignment operator: ${stmt.op}`,
 				);
 		}
-		this.line(`${lhsStr} = ${result};`);
+		this.line(`${lhsTarget} = ${result};`);
 	},
 
 	_genIteratorReturn(stmt) {
@@ -476,8 +1214,12 @@ export const statementGenMethods = {
 		}
 	},
 
-	_genBranchStmt(stmt) {
-		if (this._inIteratorBody && !stmt.label) {
+	_genIteratorBranchStmt(stmt) {
+		if (!stmt.label) {
+			if (this._iterLoopDepth > 0) {
+				if (stmt.keyword !== "fallthrough") this.line(`${stmt.keyword};`);
+				return;
+			}
 			if (stmt.keyword === "break") {
 				this.line(`${this._iterBreakFlag} = true; return false;`);
 				return;
@@ -486,6 +1228,29 @@ export const statementGenMethods = {
 				this.line("return true;");
 				return;
 			}
+			return;
+		}
+		if (this._innerLoopLabels?.has(stmt.label)) {
+			if (stmt.keyword !== "fallthrough")
+				this.line(`${stmt.keyword} ${stmt.label};`);
+			return;
+		}
+		if (
+			stmt.keyword === "continue" &&
+			stmt.label === this._currentIterLoopLabel
+		) {
+			this.line("return true;");
+			return;
+		}
+		this.line(
+			`${this._iterTargetFlag} = "${stmt.keyword}$${stmt.label}"; return false;`,
+		);
+	},
+
+	_genBranchStmt(stmt) {
+		if (this._inIteratorBody) {
+			this._genIteratorBranchStmt(stmt);
+			return;
 		}
 		if (stmt.keyword !== "fallthrough")
 			this.line(
@@ -505,7 +1270,12 @@ export const statementGenMethods = {
 			this.line("}");
 			return;
 		}
-		if (elseBody.kind === "IfStmt") {
+		if (elseBody.kind === "IfStmt" && elseBody.init) {
+			// `else if init; cond`: the init runs only when this branch is taken.
+			this.line("} else {");
+			this.indented(() => this.genStmt(elseBody));
+			this.line("}");
+		} else if (elseBody.kind === "IfStmt") {
 			this.line(`} else if (${this.genExpr(elseBody.cond)}) {`);
 			this.indented(() => this.genBlock(elseBody.body));
 			this._genElse(elseBody.elseBody);
@@ -518,7 +1288,8 @@ export const statementGenMethods = {
 
 	_rangeExprLimit(iterType, iteree) {
 		if (this._isIntRangeType(iterType)) return iteree;
-		if (this._isMapRangeType(iterType)) return `Object.keys(${iteree}).length`;
+		if (this._isMapRangeType(iterType))
+			return `Object.keys(${iteree} ?? {}).length`;
 		return `(${iteree} ? ${iteree}.length : 0)`;
 	},
 
@@ -527,7 +1298,7 @@ export const statementGenMethods = {
 			this.genIteratorForCond(stmt);
 			return;
 		}
-		const iterType = stmt.cond.expr._type;
+		const iterType = stmt.cond.expr._coreType ?? stmt.cond.expr._type;
 		const iteree = this.genExpr(stmt.cond.expr);
 		const limit = this._rangeExprLimit(iterType, iteree);
 		this.line(`for (let _$ = 0; _$ < ${limit}; _$++) {`);
@@ -545,32 +1316,114 @@ export const statementGenMethods = {
 		this.line("}");
 	},
 
+	// `for n := n; ...` declares a loop variable its own initialiser reads: the
+	// initialiser values are evaluated into temporaries ahead of the loop.
+	_hoistForInit(stmt) {
+		const init = stmt.kind === "ForStmt" && stmt.init;
+		if (
+			!init ||
+			stmt._initPre ||
+			init.kind !== "DefineStmt" ||
+			this.isRangeFor(stmt) ||
+			stmt.cond?.kind === "RangeExpr" ||
+			!this._definesShadowedRead(init)
+		)
+			return false;
+		this._tmpCounter = (this._tmpCounter ?? 0) + 1;
+		const values = this._defineRhs(init);
+		const names = values.map((_, i) => `__fi${this._tmpCounter}_${i}`);
+		this.line("{");
+		this.indent++;
+		this.line(
+			`const ${values.map((v, i) => `${names[i]} = ${v}`).join(", ")};`,
+		);
+		stmt._initPre = names;
+		return true;
+	},
+
+	_closeHoistedForInit() {
+		this.indent--;
+		this.line("}");
+	},
+
 	genFor(stmt) {
-		if (this.isRangeFor(stmt)) {
-			if (stmt.init.rhs[0]._isIterator) this.genIteratorFor(stmt);
-			else this.genRangeFor(stmt);
-			return;
+		const hoisted = this._hoistForInit(stmt);
+		try {
+			this._genForLoop(stmt);
+		} finally {
+			delete stmt._initPre;
 		}
-		if (stmt.cond?.kind === "RangeExpr") {
-			this._genRangeExprFor(stmt);
-			return;
+		if (hoisted) this._closeHoistedForInit();
+	},
+
+	_genForLoop(stmt) {
+		const isInner = this._inIteratorBody;
+		if (isInner) {
+			this._iterLoopDepth = (this._iterLoopDepth ?? 0) + 1;
+			if (stmt.label) {
+				this._innerLoopLabels = this._innerLoopLabels ?? new Set();
+				this._innerLoopLabels.add(stmt.label);
+			}
 		}
-		if (!stmt.init && !stmt.post) {
-			this._genSimpleWhileFor(stmt);
-			return;
+		try {
+			if (this.isRangeFor(stmt)) {
+				if (stmt.init.rhs[0]._isIterator) this.genIteratorFor(stmt);
+				else this.genRangeFor(stmt);
+				return;
+			}
+			if (stmt.cond?.kind === "RangeExpr") {
+				this._genRangeExprFor(stmt);
+				return;
+			}
+			if (!stmt.init && !stmt.post) {
+				this._genSimpleWhileFor(stmt);
+				return;
+			}
+			const init = stmt.init ? this.stmtInline(stmt.init, stmt._initPre) : "";
+			const cond = stmt.cond ? this.genExpr(stmt.cond) : "";
+			const post = this._perIterationClones(
+				stmt,
+				stmt.post ? this.stmtInline(stmt.post) : "",
+			);
+			this.line(`for (${init}; ${cond}; ${post}) {`);
+			this.indented(() => this.genBlock(stmt.body));
+			this.line("}");
+		} finally {
+			if (isInner) {
+				this._iterLoopDepth--;
+				if (stmt.label) this._innerLoopLabels.delete(stmt.label);
+			}
 		}
-		const init = stmt.init ? this.stmtInline(stmt.init) : "";
-		const cond = stmt.cond ? this.genExpr(stmt.cond) : "";
-		const post = stmt.post ? this.stmtInline(stmt.post) : "";
-		this.line(`for (${init}; ${cond}; ${post}) {`);
-		this.indented(() => this.genBlock(stmt.body));
-		this.line("}");
 	},
 
 	isRangeFor(stmt) {
 		return isRangeFor(stmt);
 	},
 
+	// Go 1.22 per-iteration loop variables.  `let` gives each iteration its
+	// own binding, but a struct or array variable is a reference and an
+	// address-taken scalar is a `{ value }` box: replace it at the start of
+	// the post step (which runs in the next iteration's binding), so closures
+	// and pointers from the finished iteration keep their own variable.
+	_perIterationClones(stmt, post) {
+		const clones = [];
+		for (const name of loopVarsCapturedInLoop(stmt)) {
+			const i = stmt.init.lhs.findIndex((e) => e.name === name);
+			const t = stmt.init.lhs[i]?._type ?? stmt.init.rhs?.[i]?._type;
+			if (this._boxedVars?.has(name)) {
+				const v = `${name}.value`;
+				const copy = this._aggregateBase(t) ? this._cloneJs(t, v) : v;
+				clones.push(`${name} = { value: ${copy} }`);
+				continue;
+			}
+			if (!this._aggregateBase(t)) continue;
+			clones.push(`${name} = ${this._cloneJs(t, name)}`);
+		}
+		if (clones.length === 0) return post;
+		const tail = post.replace(/;\s*$/, "");
+		return tail ? `${clones.join(", ")}, ${tail}` : clones.join(", ");
+	},
+
 	_isIntRangeType(iterType) {
 		return isIntRangeType(iterType);
 	},
@@ -617,10 +1470,14 @@ export const statementGenMethods = {
 		const iterType = iterNode._type;
 		const base = iterType?.kind === "named" ? iterType.underlying : iterType;
 		const elemType = base?.elem;
-		if (!valNode || !this._aggregateBase(elemType)) return js;
-		if (isAssign || valNode.kind !== "Ident")
+		if (
+			!valNode ||
+			(!this._aggregateBase(elemType) && !this._typeParamClone(elemType, js))
+		)
+			return js;
+		if (valNode.kind === "Ident" && valNode.name === "_") return js;
+		if (isAssign || valNode.kind !== "Ident" || elemType?.kind === "typeParam")
 			return this._cloneJs(elemType, js);
-		if (valNode.name === "_") return js;
 		const root = this._rootIdentName(iterNode);
 		const mutated =
 			this._fnMutates(valNode.name) ||
@@ -629,21 +1486,33 @@ export const statementGenMethods = {
 		return mutated ? this._cloneJs(elemType, js) : js;
 	},
 
-	_genSliceRangeFor(stmt, iteree, isAssign) {
+	_genSliceRangeFor(stmt, iteree, isAssign, unwrapView = false) {
 		this._loopDepth = this._loopDepth ?? 0;
 		const d = this._loopDepth++;
 		const [idxNode, valNode] = stmt.init.lhs;
 		const i = `__i${d}`;
 		const arr = `__arr${d}`;
 		const len = `__len${d}`;
-		this.line(
-			`for (let ${i} = 0, ${arr} = ${iteree}, ${len} = ${arr} ? ${arr}.length : 0; ${i} < ${len}; ${i}++) {`,
-		);
+		let elem = `${arr}[${i}]`;
+		if (unwrapView) {
+			// A partial view of a plain array is a Proxy (`__slice`): read the
+			// elements from its backing array `b` at offset `o` instead.
+			this.useHelper("sv");
+			const [v, b, o] = [`__v${d}`, `__b${d}`, `__o${d}`];
+			this.line(
+				`for (let ${i} = 0, ${arr} = ${iteree}, ${v} = ${arr}?.[__sv], ${b} = ${v} === undefined ? ${arr} : ${v}.b, ${o} = ${v} === undefined ? 0 : ${v}.o, ${len} = ${v} !== undefined ? ${v}.n : ${arr} ? ${arr}.length : 0; ${i} < ${len}; ${i}++) {`,
+			);
+			elem = `${b}[${o} + ${i}]`;
+		} else {
+			this.line(
+				`for (let ${i} = 0, ${arr} = ${iteree}, ${len} = ${arr} ? ${arr}.length : 0; ${i} < ${len}; ${i}++) {`,
+			);
+		}
 		this.indented(() => {
 			this._emitRangeVar(idxNode, i, isAssign);
 			this._emitRangeVar(
 				valNode,
-				this._rangeElemValue(stmt, valNode, `${arr}[${i}]`, isAssign),
+				this._rangeElemValue(stmt, valNode, elem, isAssign),
 				isAssign,
 			);
 			const declared = isAssign
@@ -699,11 +1568,6 @@ export const statementGenMethods = {
 		this._loopDepth--;
 	},
 
-	// True when `node` contains an assignment or ++/-- targeting identifier `name`.
-	_nodeAssigns(node, name) {
-		return nodeAssigns(node, name);
-	},
-
 	_genStringRangeFor(stmt, iteree, isAssign) {
 		this._loopDepth = this._loopDepth ?? 0;
 		const d = this._loopDepth++;
@@ -711,13 +1575,17 @@ export const statementGenMethods = {
 		const s = `__s${d}`;
 		const i = `__i${d}`;
 		const cp = `__cp${d}`;
+		const w = `__w${d}`;
+		// The index is a UTF-16 offset (an astral rune is two units) so `s[i:]`
+		// agrees with the WebAssembly string layout.
 		this.line(
-			`for (let ${i} = 0, ${s} = Array.from(${iteree} ?? ""); ${i} < ${s}.length; ${i}++) {`,
+			`for (let ${i} = 0, ${s} = ${iteree} ?? "", ${w} = 0; ${i} < ${s}.length; ${i} += ${w}) {`,
 		);
 		this.indented(() => {
+			this.line(`const ${cp} = ${s}.codePointAt(${i});`);
+			this.line(`${w} = ${cp} > 0xffff ? 2 : 1;`);
 			this._emitRangeVar(idxNode, i, isAssign);
 			if (valNode && valNode.name !== "_") {
-				this.line(`const ${cp} = ${s}[${i}].codePointAt(0);`);
 				this._emitRangeVar(valNode, cp, isAssign);
 			}
 			const declared = isAssign
@@ -739,23 +1607,108 @@ export const statementGenMethods = {
 
 	_genIterFor(init, iterType, iteree, lhs, body) {
 		const iterExpr = this._genRangeIterExpr(iterType, iteree, lhs);
+		const keyDecode = this._structKeyRange(iterType);
+		const paramKey = this._typeParamKeyRange(iterType);
+		const is64Key = this._is64BitMapRange(iterType);
+		const scalarKey = this._scalarKeyRange(iterType);
+		const isAssign = init.kind === "AssignStmt";
+		// `for _, v = range m` assigns existing variables, where a blank is a
+		// hole in the destructuring pattern; a lone blank still needs a binding.
+		const blank = isAssign && lhs.length > 1 ? "" : "_$";
 		const binding =
 			lhs.length === 1
 				? lhs[0] === "_"
 					? "_$"
 					: lhs[0]
-				: `[${lhs.map((n) => (n === "_" ? "_$" : n)).join(", ")}]`;
-		const kw = init.kind === "AssignStmt" ? "" : "let ";
+				: `[${lhs.map((n) => (n === "_" ? blank : n)).join(", ")}]`;
+		const kw = !isAssign || binding === "_$" ? "let " : "";
 		this.line(`for (${kw}${binding} of ${iterExpr}) {`);
-		this.indented(() => this.genBlock(body));
+		this.indented(() => {
+			if (paramKey && lhs[0] !== "_")
+				this.line(`${lhs[0]} = __kdt(${paramKey}, ${lhs[0]});`);
+			else if (keyDecode && lhs[0] !== "_")
+				this.line(`${lhs[0]} = __kd(${lhs[0]}, true);`);
+			else if (is64Key && lhs[0] !== "_")
+				this.line(`${lhs[0]} = BigInt(${lhs[0]});`);
+			else if (scalarKey && lhs[0] !== "_")
+				this.line(
+					scalarKey === "bool"
+						? `${lhs[0]} = ${lhs[0]} === "true";`
+						: `${lhs[0]} = Number(${lhs[0]});`,
+				);
+			this._cloneMapRangeValue(init, iterType, lhs[1]);
+			this.genBlock(body);
+		});
 		this.line("}");
 	},
 
+	_is64BitMapRange(iterType) {
+		if (!this._isMapRangeType(iterType)) return false;
+		const base = iterType?.kind === "named" ? iterType.underlying : iterType;
+		const key = base?.kind === "map" ? base.key : null;
+		return is64BitInt(key);
+	},
+
+	// Ranging over a map with plain int, float or bool keys: object property
+	// names are strings, so the key variable is converted back.
+	_scalarKeyRange(iterType) {
+		if (!this._isMapRangeType(iterType)) return null;
+		const base = iterType?.kind === "named" ? iterType.underlying : iterType;
+		const key = base?.kind === "map" ? base.key : null;
+		if (!key || key.kind === "typeParam") return null;
+		const u = this._underlyingOf(key);
+		if (u?.kind !== "basic" || this._is64BitInt(key)) return null;
+		if (u.name === "bool") return "bool";
+		return /^(u?int\d*|uintptr|float(32|64))$/.test(u.name) ? "num" : null;
+	},
+
+	// Ranging over a map whose key type is a type parameter: the key is decoded
+	// from its property string by the instantiated key type's zero factory.
+	_typeParamKeyRange(iterType) {
+		if (!this._isMapRangeType(iterType)) return null;
+		const base = iterType?.kind === "named" ? iterType.underlying : iterType;
+		const key = base?.kind === "map" ? base.key : null;
+		if (key?.kind !== "typeParam") return null;
+		const factory = this._typeParamZeroFactory(key.name);
+		if (!factory) return null;
+		this.useHelper("structKey");
+		return factory;
+	},
+
+	// Ranging over a map whose keys are structs: the key variable is decoded
+	// from its encoded string (see HELPER_STRUCT_KEY).
+	_structKeyRange(iterType) {
+		if (!this._isMapRangeType(iterType)) return false;
+		const base = iterType?.kind === "named" ? iterType.underlying : iterType;
+		const key = base?.kind === "map" ? base.key : null;
+		const keyBase = key?.kind === "named" ? key.underlying : key;
+		if (
+			keyBase?.kind !== "struct" &&
+			keyBase?.kind !== "array" &&
+			keyBase?.kind !== "pointer" &&
+			!this._isIfaceType(key)
+		)
+			return false;
+		this.useHelper("structKey");
+		return true;
+	},
+
+	// A map range value of array or struct type is a copy: clone it when the
+	// body may mutate it (it otherwise aliases the stored value).
+	_cloneMapRangeValue(init, iterType, name) {
+		if (!name || name === "_" || !this._isMapRangeType(iterType)) return;
+		const base = iterType?.kind === "named" ? iterType.underlying : iterType;
+		const valType = base?.value ?? base?.elem;
+		if (!this._aggregateBase(valType)) return;
+		if (init.kind !== "AssignStmt" && !this._fnMutates(name)) return;
+		this.line(`${name} = ${this._cloneJs(valType, name)};`);
+	},
+
 	genRangeFor(stmt) {
 		const init = stmt.init;
 		const range = init.rhs[0];
 		const lhs = init.lhs.map((e) => e.name ?? this.genExpr(e));
-		const iterType = range.expr._type;
+		const iterType = range.expr._coreType ?? range.expr._type;
 		const wrapField = this._namedWrapperField(iterType, range.expr);
 		const iteree = wrapField
 			? `${this.genExpr(range.expr)}.${wrapField}`
@@ -776,20 +1729,74 @@ export const statementGenMethods = {
 			return;
 		}
 
-		this._genSliceRangeFor(stmt, iteree, init.kind === "AssignStmt");
+		// Go ranges over a copy of an array: the range expression is evaluated
+		// once, so writes to the array inside the body do not reach `v`.
+		const valNode = init.lhs[1];
+		const rangesArrayValue =
+			valNode &&
+			valNode.name !== "_" &&
+			this._aggregateBase(iterType)?.kind === "array";
+		const iterBase =
+			iterType?.kind === "named" ? iterType.underlying : iterType;
+		const unwrapView =
+			valNode?.name !== "_" &&
+			!!valNode &&
+			iterBase?.kind === "slice" &&
+			!isTypedArraySlice(iterType);
+		// Ranging over an array for its indexes only does not evaluate the
+		// array (`range p` on a nil array pointer is valid): the length is the
+		// type's.
+		const arrayLen = this._aggregateBase(iterType)?.size;
+		const indexOnlyArray =
+			(!valNode || valNode.name === "_") &&
+			typeof arrayLen === "number" &&
+			this._aggregateBase(iterType)?.kind === "array" &&
+			!hasCallOrReceive(range.expr);
+		this._genSliceRangeFor(
+			stmt,
+			indexOnlyArray
+				? `({ length: ${arrayLen} })`
+				: rangesArrayValue
+					? this._cloneJs(iterType, iteree)
+					: iteree,
+			init.kind === "AssignStmt",
+			unwrapView,
+		);
 	},
 
 	_genRangeIterExpr(iterType, iteree, lhs) {
 		if (this._isMapRangeType(iterType)) {
-			if (lhs.length === 1) return `Object.keys(${iteree})`;
-			return `Object.entries(${iteree})`;
+			// A nil map is `null`; ranging over it runs zero iterations.
+			if (lhs.length === 1) return `Object.keys(${iteree} ?? {})`;
+			return `Object.entries(${iteree} ?? {})`;
 		}
 		this.useHelper("sliceGuard");
 		if (lhs.length === 1) return `__s(${iteree}).keys()`;
 		return `__s(${iteree}).entries()`;
 	},
 
-	_genIteratorLoop(itereeExpr, paramsStr, body) {
+	_emitIterTargetDispatch(targetFlag) {
+		const labels = this._functionLabels ?? [];
+		this.line(`if (${targetFlag}) {`);
+		this.indented(() => {
+			for (const lbl of labels) {
+				this.line(`if (${targetFlag} === "break$${lbl}") break ${lbl};`);
+				this.line(`if (${targetFlag} === "continue$${lbl}") continue ${lbl};`);
+			}
+			if (this._inIteratorBody) {
+				this.line(`${this._iterTargetFlag} = ${targetFlag}; return false;`);
+			}
+		});
+		this.line("}");
+	},
+
+	_genIteratorLoop(
+		itereeExpr,
+		paramsStr,
+		body,
+		assignPreamble = null,
+		loopLabel = null,
+	) {
 		let iteree = this.genExpr(itereeExpr);
 		if (itereeExpr.kind === "FuncLit") {
 			iteree = `(${iteree})`;
@@ -799,38 +1806,61 @@ export const statementGenMethods = {
 		const breakFlag = `__broke${d}`;
 		const retFlag = `__returned${d}`;
 		const retVar = `__retVal${d}`;
+		const targetFlag = `__target${d}`;
 
 		this.line("{");
 		this.indented(() => {
 			this.line(`let ${breakFlag} = false;`);
 			this.line(`let ${retFlag} = false;`);
 			this.line(`let ${retVar};`);
+			this.line(`let ${targetFlag} = null;`);
 
 			this.line(`${iteree}(function(${paramsStr}) {`);
 			this.indented(() => {
-				this.line(`if (${breakFlag}) return false;`);
+				this.line(`if (${breakFlag} || ${retFlag} || ${targetFlag}) {`);
+				this.indented(() => {
+					if (this.strict) {
+						this.line(
+							`throw new Error("range function continued iteration after function for loop body returned false");`,
+						);
+					} else {
+						this.line("return false;");
+					}
+				});
+				this.line("}");
 				const prev = {
 					in: this._inIteratorBody,
 					break: this._iterBreakFlag,
 					ret: this._iterReturnFlag,
 					retVar: this._iterReturnVar,
+					target: this._iterTargetFlag,
+					loopLabel: this._currentIterLoopLabel,
+					loopDepth: this._iterLoopDepth,
 				};
 				this._inIteratorBody = true;
 				this._iterBreakFlag = breakFlag;
 				this._iterReturnFlag = retFlag;
 				this._iterReturnVar = retVar;
+				this._iterTargetFlag = targetFlag;
+				this._currentIterLoopLabel = loopLabel;
+				this._iterLoopDepth = 0;
 
+				if (assignPreamble) assignPreamble();
 				this.genBlock(body);
 
 				this._inIteratorBody = prev.in;
 				this._iterBreakFlag = prev.break;
 				this._iterReturnFlag = prev.ret;
 				this._iterReturnVar = prev.retVar;
+				this._iterTargetFlag = prev.target;
+				this._currentIterLoopLabel = prev.loopLabel;
+				this._iterLoopDepth = prev.loopDepth;
 
 				this.line("return true;");
 			});
 			this.line("});");
 			this.line(`if (${retFlag}) return ${retVar};`);
+			this._emitIterTargetDispatch(targetFlag);
 		});
 		this.line("}");
 		this._iterDepth--;
@@ -838,32 +1868,100 @@ export const statementGenMethods = {
 
 	genIteratorFor(stmt) {
 		const range = stmt.init.rhs[0];
+		const isAssign = stmt.init.kind === "AssignStmt";
 		const lhs = stmt.init.lhs.map((e) => e.name ?? this.genExpr(e));
+		const yieldTypes = range._yieldParams ?? [];
+		if (isAssign) {
+			const cbParams = lhs.map((_, i) => `__p${i}`);
+			const params = yieldTypes.length === 0 ? "" : cbParams.join(", ");
+			const assignPreamble = () => {
+				for (let i = 0; i < lhs.length; i++) {
+					if (lhs[i] !== "_") {
+						const yType = yieldTypes[i];
+						const isStruct =
+							this._isStructType(yType) ||
+							this._isStructType(stmt.init.lhs[i]?._type);
+						if (isStruct) {
+							this.useHelper("sclone");
+							this.line(`${lhs[i]} = __sclone(${cbParams[i]});`);
+						} else {
+							this.line(`${lhs[i]} = ${cbParams[i]};`);
+						}
+					}
+				}
+			};
+			this._genIteratorLoop(
+				range.expr,
+				params,
+				stmt.body,
+				assignPreamble,
+				stmt.label ?? null,
+			);
+			return;
+		}
 		const cbParams = lhs.map((n, i) => (n === "_" ? `_$${i}` : n));
-		const params = range._yieldParams.length === 0 ? "" : cbParams.join(", ");
-		this._genIteratorLoop(range.expr, params, stmt.body);
+		const params = yieldTypes.length === 0 ? "" : cbParams.join(", ");
+		const clonePreamble = () => {
+			for (let i = 0; i < lhs.length; i++) {
+				if (lhs[i] !== "_") {
+					const yType = yieldTypes[i];
+					const isStruct =
+						this._isStructType(yType) ||
+						this._isStructType(stmt.init.lhs[i]?._type);
+					if (isStruct) {
+						this.useHelper("sclone");
+						this.line(`${cbParams[i]} = __sclone(${cbParams[i]});`);
+					}
+				}
+			}
+		};
+		this._genIteratorLoop(
+			range.expr,
+			params,
+			stmt.body,
+			clonePreamble,
+			stmt.label ?? null,
+		);
 	},
 
 	// 0-param iterator: for range iter { body }
 	genIteratorForCond(stmt) {
-		this._genIteratorLoop(stmt.cond.expr, "", stmt.body);
+		this._genIteratorLoop(
+			stmt.cond.expr,
+			"",
+			stmt.body,
+			null,
+			stmt.label ?? null,
+		);
 	},
 
 	// Inline a statement as a for-init/post string (no semicolon)
-	stmtInline(stmt) {
+	stmtInline(stmt, pre = null) {
 		switch (stmt.kind) {
-			case "DefineStmt": {
-				const rhs = stmt.rhs.map((e) => this.genExpr(e)).join(", ");
-				const lhs = stmt.lhs.map((e) => e.name ?? this.genExpr(e)).join(", ");
-				return `let ${lhs} = ${rhs}`;
-			}
-			case "AssignStmt": {
-				const rhs = stmt.rhs.map((e) => this.genExpr(e)).join(", ");
-				const lhs = stmt.lhs.map((e) => this.genExpr(e)).join(", ");
-				return `${lhs} ${stmt.op} ${rhs}`;
-			}
-			case "IncDecStmt":
-				return `${this.genExpr(stmt.expr)}${stmt.op}`;
+			case "DefineStmt":
+				return this._inlineDefine(stmt, pre);
+			case "AssignStmt":
+				return this._withInlineSyncs(
+					this._resliceSyncs(stmt.lhs, stmt, true),
+					this._inlineAssign(stmt),
+				);
+			case "IncDecStmt": {
+				const syncs = this._resliceSyncs([stmt.expr], stmt, true);
+				this._markIndexLvalues([stmt.expr]);
+				this._markDerefOpTarget(stmt.expr);
+				if (is64BitInt(stmt.expr._type)) {
+					const l = this.genExpr(stmt.expr);
+					const binOp = stmt.op === "++" ? "+" : "-";
+					return this._withInlineSyncs(
+						syncs,
+						`${l} = ${this._gen64BitBinary(binOp, l, "1n", stmt.expr._type)}`,
+					);
+				}
+				return this._withInlineSyncs(
+					syncs,
+					`${this.genExpr(stmt.expr)}${stmt.op}`,
+				);
+			}
 			case "ExprStmt":
 				return this.genExpr(stmt.expr);
 			default:
@@ -871,9 +1969,110 @@ export const statementGenMethods = {
 		}
 	},
 
+	_withInlineSyncs(syncs, js) {
+		return syncs ? `${js}, ${syncs.join(", ")}` : js;
+	},
+
+	_inlineDefine(stmt, pre = null) {
+		const boxed =
+			stmt.lhs.length === 1 &&
+			stmt.rhs.length === 1 &&
+			this._boxedVars.has(stmt.lhs[0].name);
+		if (boxed)
+			return `let ${stmt.lhs[0].name} = { value: ${pre ? pre[0] : this.genValueExpr(stmt.rhs[0])} }`;
+		const rhs = pre ?? stmt.rhs.map((e) => this.genExpr(e));
+		const lhs = stmt.lhs.map((e) => e.name ?? this.genExpr(e));
+		if (lhs.length === 1) return `let ${lhs[0]} = ${rhs[0]}`;
+		// `for i, j := 0, 10`: one declarator per variable.
+		if (rhs.length === lhs.length) {
+			const decls = lhs.map((n, i) =>
+				this._boxedVars.has(n)
+					? `${n} = { value: ${rhs[i]} }`
+					: `${n} = ${rhs[i]}`,
+			);
+			return `let ${decls.join(", ")}`;
+		}
+		return `let [${lhs.map((n) => (n === "_" ? "" : n)).join(", ")}] = ${rhs[0]}`;
+	},
+
+	// Compound assignments that need more than the JS operator: strict
+	// numeric wrapping, 64-bit and float32 arithmetic, and integer `/=`.
+	_needsStrictCompoundStmt(stmt, is64) {
+		if (stmt.op === "=") return false;
+		const t = stmt.lhs[0]._type;
+		return (
+			this.strict ||
+			is64 ||
+			this._isFloat32(t) ||
+			(stmt.op === "/=" && this.isIntType(t))
+		);
+	},
+
+	// The single-expression form of `_genStrictCompound` for `for` post
+	// statements: the emitted statement is lifted back out of the output.
+	_inlineStrictCompound(stmt, rhsJs) {
+		const mark = this.out.length;
+		const handled = this._genStrictCompound(
+			stmt.lhs[0],
+			stmt.op.slice(0, -1),
+			rhsJs,
+			null,
+			null,
+			stmt.rhs[0]?._type,
+		);
+		const emitted = this.out.splice(mark).map((l) => l.trim());
+		if (!handled) return null;
+		const js = emitted.join(" ").replace(/;$/, "");
+		return js.startsWith("{") ? `(() => ${js})()` : js;
+	},
+
+	_inlineAssign(stmt) {
+		this._markIndexLvalues(stmt.lhs);
+		const rhs = stmt.rhs.map((e) => this.genExpr(e));
+		if (stmt.lhs.length === 1) {
+			if (stmt.op !== "=" && is64BitInt(stmt.lhs[0]._type)) {
+				const binOp = stmt.op.slice(0, -1);
+				let r = rhs[0];
+				if (
+					stmt.rhs[0]?._type?.kind === "untyped" &&
+					!r.endsWith("n") &&
+					/^-?\d+$/.test(r)
+				) {
+					r = `${r}n`;
+				}
+				const l = this.genExpr(stmt.lhs[0]);
+				return `${l} = ${this._gen64BitBinary(binOp, l, r, stmt.lhs[0]._type)}`;
+			}
+			if (this._needsStrictCompoundStmt(stmt, is64BitInt(stmt.lhs[0]._type))) {
+				const strict = this._inlineStrictCompound(stmt, rhs[0]);
+				if (strict) return strict;
+			}
+			if (stmt.op === "&^=")
+				return `${this.genExpr(stmt.lhs[0])} &= ~(${rhs[0]})`;
+			return `${this.genExpr(stmt.lhs[0])} ${stmt.op} ${rhs[0]}`;
+		}
+		// `i, j = i+1, j-1`: every right-hand side is evaluated first.
+		const lhs = stmt.lhs.map((e) =>
+			e.name === "_" ? "" : this._genAssignLhsExpr(e),
+		);
+		const r = rhs.length === 1 ? rhs[0] : `[${rhs.join(", ")}]`;
+		return `[${lhs.join(", ")}] = ${r}`;
+	},
+
 	// Interface-typed tags may hold boxed named values; cases compare with __ifeq.
 	_switchTagAndCases(stmt) {
 		const tag = stmt.tag ? this.genExpr(stmt.tag) : "true";
+		if (stmt.tag && this._isStructOrArrayType(stmt.tag._type)) {
+			// Struct and array tags compare by value, not by reference.
+			this.useHelper("equal");
+			this._swCounter = (this._swCounter ?? 0) + 1;
+			const tmp = `__sw${this._swCounter}`;
+			this.line(`const ${tmp} = ${tag};`);
+			return {
+				tag: "true",
+				caseExpr: (e) => `__equal(${tmp}, ${this.genExpr(e)})`,
+			};
+		}
 		if (!stmt.tag || !this._isIfaceType(stmt.tag._type))
 			return { tag, caseExpr: (e) => this.genExpr(e) };
 		this.useHelper("ifeq");
@@ -901,7 +2100,7 @@ export const statementGenMethods = {
 					// across sibling cases (JS switch shares one block scope).
 					this.line("{");
 					this.indented(() => {
-						for (const s of c.stmts) this.genStmt(s);
+						this.genBlock(c);
 						// Go doesn't fall through by default — add break unless last stmt is return/break
 						const last = c.stmts[c.stmts.length - 1];
 						if (
@@ -920,10 +2119,18 @@ export const statementGenMethods = {
 		if (stmt.init) {
 			this.line("{");
 			this.indented(() => {
-				this.genStmt(stmt.init);
-				genBody();
+				this._genScopedInit(stmt.init, genBody);
 			});
 			this.line("}");
+		} else if (
+			stmt.tag &&
+			(this._isStructOrArrayType(stmt.tag._type) ||
+				this._isIfaceType(stmt.tag._type))
+		) {
+			// The tag temporary is a `const`, which cannot directly follow a label.
+			this.line("{");
+			this.indented(genBody);
+			this.line("}");
 		} else {
 			genBody();
 		}
@@ -934,7 +2141,13 @@ export const statementGenMethods = {
 		this.indented(() => {
 			const val = this.genExpr(stmt.expr);
 			this.line(`const __tsw = ${val};`);
-			if (stmt.assign) this.line(`let ${stmt.assign} = __tsw;`);
+			// The binding is declared per clause, after the switch expression
+			// was evaluated (`switch x := any(x).(type)` reads the outer `x`).
+			const boxedBind = stmt.assign && this._boxedVars.has(stmt.assign);
+			const bind = (valueJs) =>
+				this.line(
+					`let ${stmt.assign} = ${boxedBind ? `{ value: ${valueJs} }` : valueJs};`,
+				);
 
 			let first = true;
 			let hasDefault = false;
@@ -949,13 +2162,16 @@ export const statementGenMethods = {
 					.join(" || ");
 				this.line(`${first ? "if" : "else if"} (${cond}) {`);
 				this.indented(() => {
-					// A single named non-struct case binds the unboxed value.
-					if (
-						stmt.assign &&
-						c.types.length === 1 &&
-						this._isNamedBoxTypeNode(c.types[0])
-					)
-						this.line(`const ${stmt.assign} = __tsw.__gfUnbox();`);
+					if (stmt.assign) {
+						const only = c.types.length === 1 ? c.types[0] : null;
+						// A single named non-struct case binds the unboxed value.
+						if (only && this._assertedValueJs(only, "__tsw") !== "__tsw")
+							bind(this._assertedValueJs(only, "__tsw"));
+						// An array case binds a copy of the boxed value.
+						else if (only && this._typeFromNode(only)?.kind === "array")
+							bind(this._cloneJs(this._typeFromNode(only), "__tsw"));
+						else bind("__tsw");
+					}
 					for (const s of c.stmts) this.genStmt(s);
 				});
 				this.line("}");
@@ -964,6 +2180,7 @@ export const statementGenMethods = {
 			if (hasDefault) {
 				this.line(first ? "{" : "else {");
 				this.indented(() => {
+					if (stmt.assign) bind("__tsw");
 					for (const s of hasDefault.stmts) this.genStmt(s);
 				});
 				this.line("}");