gofront 1.8.0 → 1.9.0

package/src/backend/js/statements.js

@@ -1,16 +1,20 @@
 import {
 	bodyRedeclares,
 	forEachChild,
+	hasCallOrReceive,
 	isIntRangeType,
 	isMapRangeType,
 	isRangeFor,
 	isSimpleIntRange,
 	isStringRangeType,
 	loopVarsCapturedInLoop,
-	nodeAssigns,
 	someChild,
 } from "../../lower/index.js";
-import { isComplex, isTypedArraySlice } from "../../typechecker/types.js";
+import {
+	is64BitInt,
+	isComplex,
+	isTypedArraySlice,
+} from "../../typechecker/types.js";
 
 /** @typedef {import('./index.js').CodeGen} CodeGen */
 
@@ -124,6 +128,20 @@ const isReusableIndex = (e, vars, boxed) => {
 	}
 };
 
+// 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",
@@ -135,19 +153,27 @@ const STMT_GEN_DELEGATE = {
 	SwitchStmt: "genSwitch",
 	TypeSwitchStmt: "genTypeSwitch",
 	BranchStmt: "_genBranchStmt",
+	TemplMount: "_genTemplMountStmt",
 };
 
 /** @type {ThisType<CodeGen>} */
 export const statementGenMethods = {
 	genBlock(block) {
 		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--;
@@ -155,11 +181,20 @@ export const statementGenMethods = {
 		}
 	},
 
+	// `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" || this._isCommaOkMapExpr(stmt, stmt.rhs[0]))
-			return false;
+		if (stmt.kind !== "DefineStmt") return false;
 		const names = new Set(
 			stmt.lhs.filter((l) => !l._redecl && l.name !== "_").map((l) => l.name),
 		);
@@ -173,9 +208,35 @@ export const statementGenMethods = {
 		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}`;
@@ -189,24 +250,44 @@ export const statementGenMethods = {
 		);
 	},
 
+	// `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 " : "";
-		// An array map value is a copy, not the stored array.
+		// 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)?.kind === "array"
-				? this._cloneJs(valType, js)
-				: js;
+			this._aggregateBase(valType) ? this._cloneJs(valType, js) : js;
 		if (isDefine && !this.strict) {
 			if (vName !== "_") {
-				this.line(`let ${vName} = ${copyVal(`${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;
 		}
@@ -219,11 +300,15 @@ export const statementGenMethods = {
 		this.line(`const ${mTmp} = ${mapExpr}, ${kTmp} = ${keyExpr};`);
 		if (vName !== "_") {
 			this.line(
-				`${decl}${vName} = (${mTmp} && (${kTmp} in ${mTmp})) ? ${copyVal(`${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}))`));
 		}
 	},
 
@@ -240,8 +325,11 @@ export const statementGenMethods = {
 					: null;
 		switch (stmt.kind) {
 			case "TypeDecl":
-				this.genTypeDeclWithMethods(stmt, []);
-				this._noteLocalTypeDecl(stmt);
+				{
+					const start = this.out.length;
+					this.genTypeDeclWithMethods(stmt, []);
+					this._hoistLocalClass(stmt, start);
+				}
 				break;
 			case "IncDecStmt": {
 				this._markIndexLvalues([stmt.expr]);
@@ -257,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) => { ${this._genMapWriteBase("__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(
-							`${this._genMapWriteBase(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,
 					)
 				)
@@ -293,14 +400,7 @@ export const statementGenMethods = {
 				if (stmt.init) {
 					this.line("{");
 					this.indented(() => {
-						const shadowing = this._definesShadowedRead(stmt.init);
-						if (shadowing) this._genShadowingDefine(stmt.init);
-						else this.genStmt(stmt.init);
-						this._genIf(stmt);
-						if (shadowing) {
-							this.indent--;
-							this.line("}");
-						}
+						this._genScopedInit(stmt.init, () => this._genIf(stmt));
 					});
 					this.line("}");
 				} else {
@@ -308,15 +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":
-				if (stmt.body && stmt.body.kind === "ForStmt") {
-					stmt.body.label = stmt.label;
+			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;
 				}
-				this.line(`${stmt.label}:`);
-				this.genStmt(stmt.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));
@@ -695,6 +806,10 @@ export const statementGenMethods = {
 			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 !== "_"
@@ -724,29 +839,65 @@ 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) => { ${this._genMapWriteBase("__m")}[__k] = (__m[__k] ?? ${zero}) ${binOp} (${active[0].r}); })(${base}, ${idx});`,
+						`((__m, __k) => { ${this._genMapWriteBase("__m")}[__k] = ${rhsExpr}; })(${base}, ${idx});`,
 					);
 				} else {
 					this.line(
-						`${this._genMapWriteBase(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;
@@ -755,7 +906,8 @@ export const statementGenMethods = {
 				active[0].l.startsWith("{") && !active[0].l.startsWith("({")
 					? `(${active[0].l})`
 					: active[0].l;
-			this.line(`${targetL} ${stmt.op} ${active[0].r};`);
+			if (stmt.op === "&^=") this.line(`${targetL} &= ~(${rhsVal});`);
+			else this.line(`${targetL} ${stmt.op} ${rhsVal};`);
 		} else if (hoisted) {
 			this.line("{");
 			this.indented(() => {
@@ -786,23 +938,28 @@ export const statementGenMethods = {
 			((n.kind === "Ident" && assigned.has(n.name)) || someChild(n, mentions));
 		const lines = [];
 		const undo = [];
-		for (const l of stmt.lhs) {
+		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 (!mentions(operand)) continue;
-				// A struct or array value names the variable's storage in Go.
-				if (key === "expr" && this._aggregateBase(operand._type)) 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,
@@ -814,7 +971,7 @@ export const statementGenMethods = {
 
 	_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};`);
@@ -828,7 +985,13 @@ export const statementGenMethods = {
 	_isStableWholeAssign(stmt) {
 		if (stmt.op !== "=" || stmt.lhs.length !== 1 || stmt.rhs.length !== 1)
 			return false;
-		const l = stmt.lhs[0];
+		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" &&
@@ -837,15 +1000,59 @@ export const statementGenMethods = {
 		)
 			return false;
 		if (l.kind === "Ident" && l.name === "_") return false;
-		if (
-			!this._aggregateBase(l._type) ||
-			!this._aggregateBase(stmt.rhs[0]._type)
-		)
+		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;
@@ -1063,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);
@@ -1076,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)`;
 	},
 
@@ -1085,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}; _$++) {`);
@@ -1103,7 +1316,47 @@ 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) {
+		const hoisted = this._hoistForInit(stmt);
+		try {
+			this._genForLoop(stmt);
+		} finally {
+			delete stmt._initPre;
+		}
+		if (hoisted) this._closeHoistedForInit();
+	},
+
+	_genForLoop(stmt) {
 		const isInner = this._inIteratorBody;
 		if (isInner) {
 			this._iterLoopDepth = (this._iterLoopDepth ?? 0) + 1;
@@ -1126,7 +1379,7 @@ export const statementGenMethods = {
 				this._genSimpleWhileFor(stmt);
 				return;
 			}
-			const init = stmt.init ? this.stmtInline(stmt.init) : "";
+			const init = stmt.init ? this.stmtInline(stmt.init, stmt._initPre) : "";
 			const cond = stmt.cond ? this.genExpr(stmt.cond) : "";
 			const post = this._perIterationClones(
 				stmt,
@@ -1217,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) ||
@@ -1311,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++;
@@ -1323,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
@@ -1352,23 +1608,73 @@ 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(() => {
-			if (keyDecode && lhs[0] !== "_")
+			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) {
@@ -1376,7 +1682,13 @@ export const statementGenMethods = {
 		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" && !this._isIfaceType(key)) return false;
+		if (
+			keyBase?.kind !== "struct" &&
+			keyBase?.kind !== "array" &&
+			keyBase?.kind !== "pointer" &&
+			!this._isIfaceType(key)
+		)
+			return false;
 		this.useHelper("structKey");
 		return true;
 	},
@@ -1396,7 +1708,7 @@ export const statementGenMethods = {
 		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}`
@@ -1431,9 +1743,22 @@ export const statementGenMethods = {
 			!!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,
-			rangesArrayValue ? this._cloneJs(iterType, iteree) : iteree,
+			indexOnlyArray
+				? `({ length: ${arrayLen} })`
+				: rangesArrayValue
+					? this._cloneJs(iterType, iteree)
+					: iteree,
 			init.kind === "AssignStmt",
 			unwrapView,
 		);
@@ -1441,8 +1766,9 @@ export const statementGenMethods = {
 
 	_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()`;
@@ -1610,10 +1936,10 @@ export const statementGenMethods = {
 	},
 
 	// Inline a statement as a for-init/post string (no semicolon)
-	stmtInline(stmt) {
+	stmtInline(stmt, pre = null) {
 		switch (stmt.kind) {
 			case "DefineStmt":
-				return this._inlineDefine(stmt);
+				return this._inlineDefine(stmt, pre);
 			case "AssignStmt":
 				return this._withInlineSyncs(
 					this._resliceSyncs(stmt.lhs, stmt, true),
@@ -1623,6 +1949,14 @@ export const statementGenMethods = {
 				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}`,
@@ -1639,14 +1973,14 @@ export const statementGenMethods = {
 		return syncs ? `${js}, ${syncs.join(", ")}` : js;
 	},
 
-	_inlineDefine(stmt) {
+	_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: ${this.genValueExpr(stmt.rhs[0])} }`;
-		const rhs = stmt.rhs.map((e) => this.genExpr(e));
+			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.
@@ -1661,11 +1995,62 @@ export const statementGenMethods = {
 		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.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),
@@ -1677,6 +2062,17 @@ export const statementGenMethods = {
 	// 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");
@@ -1704,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 (
@@ -1723,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();
 		}
@@ -1737,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;
@@ -1752,24 +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._assertedValueJs(c.types[0], "__tsw") !== "__tsw"
-					)
-						this.line(
-							`const ${stmt.assign} = ${this._assertedValueJs(c.types[0], "__tsw")};`,
-						);
-					// An array case binds a copy of the boxed value.
-					else if (
-						stmt.assign &&
-						c.types.length === 1 &&
-						this._typeFromNode(c.types[0])?.kind === "array"
-					)
-						this.line(
-							`let ${stmt.assign} = ${this._cloneJs(this._typeFromNode(c.types[0]), "__tsw")};`,
-						);
+					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("}");
@@ -1778,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("}");