gofront 1.3.5 → 1.3.6

package/src/codegen/index.js

@@ -26,9 +26,11 @@ import {
 	HELPER_EQUAL,
 	HELPER_ERROR,
 	HELPER_ERROR_IS,
+	HELPER_IFACE_BOX,
 	HELPER_LEN,
 	HELPER_PATH_CLEAN,
 	HELPER_S,
+	HELPER_SCLONE,
 	HELPER_SPRINTF,
 	HELPER_TESTING,
 	HELPER_TIME_FMT,
@@ -39,6 +41,46 @@ import { statementGenMethods } from "./statements.js";
 import { stdlibGenMethods } from "./stdlib/index.js";
 import { templGenMethods } from "./templ.js";
 
+// Valid Go identifiers that cannot be used as JS bindings; emitted with a `$` suffix.
+const JS_RESERVED = new Set([
+	"arguments",
+	"await",
+	"catch",
+	"class",
+	"debugger",
+	"delete",
+	"do",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"finally",
+	"function",
+	"implements",
+	"in",
+	"instanceof",
+	"let",
+	"new",
+	"null",
+	"private",
+	"protected",
+	"public",
+	"static",
+	"super",
+	"this",
+	"throw",
+	"try",
+	"typeof",
+	"undefined",
+	"void",
+	"while",
+	"with",
+	"yield",
+]);
+
+const jsSafeName = (n) =>
+	typeof n === "string" && JS_RESERVED.has(n) ? `${n}$` : n;
+
 export class CodeGen {
 	// jsImports:       Map<importPath, string[]> — npm package imports to emit at top of file
 	// bundledPackages: Set<string>               — GoFront package names bundled inline;
@@ -74,6 +116,10 @@ export class CodeGen {
 		this._usesTimeFmt = false;
 		this._usesTimeParse = false;
 		this._usesTesting = false;
+		this._usesSClone = false;
+		this._usesIfaceBox = false;
+		// Per-function context for Go value semantics (see _withFnCtx)
+		this._fnCtx = null;
 		// Iterator (range-over-func) context
 		this._inIteratorBody = false;
 		this._iterDepth = 0;
@@ -153,6 +199,7 @@ export class CodeGen {
 
 	generate(program, options = {}) {
 		const isTest = options.isTest ?? false;
+		this._renameReservedIdents(program.decls);
 		const methods = this._collectDecls(program);
 		this._emitJsImports();
 		this._emitTypeDecls(program, methods);
@@ -189,6 +236,82 @@ export class CodeGen {
 		return initNames;
 	}
 
+	_renameParams(params) {
+		for (const p of params ?? []) p.name = jsSafeName(p.name);
+	}
+
+	_renameNamedReturns(node) {
+		for (const r of node.returnType?._namedReturns ?? [])
+			r.name = jsSafeName(r.name);
+	}
+
+	_renameSignature(node) {
+		this._renameParams(node.params);
+		this._renameNamedReturns(node);
+	}
+
+	_renameIdentNode(node) {
+		if (!node._isStructKey && node._type?.kind !== "builtin")
+			node.name = jsSafeName(node.name);
+	}
+
+	_renameFuncDeclNode(node) {
+		node.name = jsSafeName(node.name);
+		this._renameSignature(node);
+	}
+
+	_renameMethodDeclNode(node) {
+		node.recvName = jsSafeName(node.recvName);
+		this._renameSignature(node);
+	}
+
+	_renameDeclSpecs(node) {
+		for (const spec of node.decls ?? [])
+			spec.names = spec.names.map(jsSafeName);
+	}
+
+	_renameTypeSwitchNode(node) {
+		node.assign = jsSafeName(node.assign);
+	}
+
+	_markStructKeys(node) {
+		const isStruct =
+			this._isStructType(node._type) ||
+			node.elems?.some((e) => e._positionalField);
+		if (!isStruct) return;
+		for (const e of node.elems ?? [])
+			if (e.kind === "KeyValueExpr" && e.key?.kind === "Ident")
+				e.key._isStructKey = true;
+	}
+
+	static _RENAME_HANDLERS = {
+		Ident: "_renameIdentNode",
+		FuncDecl: "_renameFuncDeclNode",
+		MethodDecl: "_renameMethodDeclNode",
+		FuncLit: "_renameSignature",
+		TemplDecl: "_renameSignature",
+		VarDecl: "_renameDeclSpecs",
+		ConstDecl: "_renameDeclSpecs",
+		TypeSwitchStmt: "_renameTypeSwitchNode",
+		CompositeLit: "_markStructKeys",
+	};
+
+	_renameReservedIdents(node) {
+		if (!node || typeof node !== "object") return;
+		if (Array.isArray(node)) {
+			for (const n of node) this._renameReservedIdents(n);
+			return;
+		}
+		if (node._jsRenamed) return;
+		node._jsRenamed = true;
+		const handler = CodeGen._RENAME_HANDLERS[node.kind];
+		if (handler) this[handler](node);
+		for (const key of Object.keys(node)) {
+			if (key.startsWith("_")) continue;
+			this._renameReservedIdents(node[key]);
+		}
+	}
+
 	// Collects struct names, method map, and named wrapper names from program decls.
 	// Returns the method map (typeName → MethodDecl[]).
 	_collectStructNames(program) {
@@ -236,6 +359,8 @@ export class CodeGen {
 			[this._usesLen, HELPER_LEN],
 			[this._usesAppend, HELPER_APPEND],
 			[this._usesSliceGuard, HELPER_S],
+			[this._usesSClone, HELPER_SCLONE],
+			[this._usesIfaceBox, HELPER_IFACE_BOX],
 			[this._usesEqual, HELPER_EQUAL],
 			[this._usesCmul, HELPER_CMUL],
 			[this._usesCdiv, HELPER_CDIV],
@@ -357,13 +482,15 @@ export class CodeGen {
 		this.line(`constructor(${params}) {`);
 		this.indented(() => {
 			const first = binding(fields[0]);
-			const isFirstObj = fields[0].zero === "{}" || fields[0].zero === "null";
-			const optCheck = isFirstObj
-				? `("${fields[0].name}" in ${first})`
-				: "true";
-			this.line(
-				`if (typeof ${first} === "object" && ${first} !== null && ${first}.constructor === Object && ${optCheck}) { Object.assign(this, ${first}); return; }`,
-			);
+			// Legacy `new T({...})` support; only unambiguous when field 0 is a primitive.
+			if (/^(0|""|false)$/.test(fields[0].zero)) {
+				const pattern = fields
+					.map((f) => `${f.name}: ${binding(f)} = ${f.zero}`)
+					.join(", ");
+				this.line(
+					`if (typeof ${first} === "object" && ${first} !== null && ${first}.constructor === Object) ({ ${pattern} } = ${first});`,
+				);
+			}
 			for (const f of fields) {
 				this.line(`this.${f.name} = ${binding(f)};`);
 			}
@@ -371,6 +498,30 @@ export class CodeGen {
 		this.line("}");
 	}
 
+	_genStructClone(name, structTypeAst, fields) {
+		const resolved = this.checker?.types.get(name)?.underlying;
+		const astTypes = new Map();
+		for (const f of structTypeAst?.fields ?? [])
+			for (const n of f.names ?? []) astTypes.set(n, f.type);
+		const args = fields.map((f) => {
+			const t =
+				resolved?.fields?.get(f.name) ??
+				this._typeFromNode(astTypes.get(f.name));
+			return this._cloneJs(t, `this.${f.name}`);
+		});
+		this.blank();
+		this.line(`__clone() { return new ${name}(${args.join(", ")}); }`);
+	}
+
+	_structDefinesValue(name, fields, methodDecls) {
+		if (fields.some((f) => f.name === "value")) return true;
+		if (methodDecls.some((m) => m.name === "value")) return true;
+		const resolved = this.checker?.types.get(name)?.underlying;
+		return Boolean(
+			resolved?.fields?.has?.("value") || resolved?.methods?.has?.("value"),
+		);
+	}
+
 	genStruct(name, structTypeAst, methodDecls) {
 		const fields = this._collectStructFields(name, structTypeAst);
 		this.structFields.set(name, fields);
@@ -382,11 +533,15 @@ export class CodeGen {
 				this.genMethod(m);
 			}
 			this._genEmbeddedMethodStubs(name, methodDecls);
+			this._genStructClone(name, structTypeAst, fields);
 		});
 		this.line("}");
-		this.line(
-			`Object.defineProperty(${name}.prototype, "value", { get() { return this; }, set(v) { Object.assign(this, v); }, configurable: true });`,
-		);
+		// Lets generic `p.value` dereferences resolve to the struct itself.
+		if (!this._structDefinesValue(name, fields, methodDecls)) {
+			this.line(
+				`Object.defineProperty(${name}.prototype, "value", { get() { return this; }, set(v) { Object.assign(this, v); }, configurable: true });`,
+			);
+		}
 	}
 
 	_genSingleEmbedStubs(embed, declared) {
@@ -421,22 +576,40 @@ export class CodeGen {
 		this._boxedVars = new Set();
 		this._scanAddressTaken(decl.body);
 		const prevUnwrapped = this._unwrappedRecv;
-		this.indented(() => {
-			if (decl.recvName && decl.recvName !== "_") {
-				if (recvField) {
-					this.line(`const ${decl.recvName} = this.${recvField};`);
-					this._unwrappedRecv = decl.recvName;
-				} else {
-					this.line(`const ${decl.recvName} = this;`);
+		this._withFnCtx(decl.body, () =>
+			this.indented(() => {
+				if (decl.recvName && decl.recvName !== "_") {
+					if (recvField) {
+						this.line(`const ${decl.recvName} = this.${recvField};`);
+						this._unwrappedRecv = decl.recvName;
+					} else {
+						this.line(`const ${decl.recvName} = ${this._receiverValue(decl)};`);
+					}
 				}
-			}
-			this._withNamedReturns(decl, () => this._genBody(decl.body));
-		});
+				this._emitParamCopies(decl.params);
+				this._withNamedReturns(decl, () => this._genBody(decl.body));
+			}),
+		);
 		this._unwrappedRecv = prevUnwrapped;
 		this._boxedVars = prevBoxed;
 		this.line("}");
 	}
 
+	// Value receivers are copies in Go; only materialize the copy when the body mutates it.
+	_receiverValue(decl) {
+		const name = decl.recvName;
+		if (decl.recvPointer || !this.structNames.has(decl.recvType.name)) {
+			this._markOwnership(name, false);
+			return "this";
+		}
+		if (this._fnMutates(name)) {
+			this._markOwnership(name, true);
+			return "this.__clone()";
+		}
+		this._markOwnership(name, false);
+		return "this";
+	}
+
 	// Returns the wrapper field name ("_fn", "_items", "_map") if `type` is a named
 	// non-struct type emitted as a wrapper class, or null otherwise.
 	// Pass `expr` so we can skip unwrapping when the expression is the method receiver
@@ -470,8 +643,11 @@ export class CodeGen {
 		const prevBoxed = this._boxedVars;
 		this._boxedVars = new Set();
 		this._scanAddressTaken(decl.body);
-		this.indented(() =>
-			this._withNamedReturns(decl, () => this._genBody(decl.body)),
+		this._withFnCtx(decl.body, () =>
+			this.indented(() => {
+				this._emitParamCopies(decl.params);
+				this._withNamedReturns(decl, () => this._genBody(decl.body));
+			}),
 		);
 		this._boxedVars = prevBoxed;
 		this.line("}");
@@ -483,8 +659,10 @@ export class CodeGen {
 		if (named) {
 			// Emit zero-value declarations for named return vars
 			for (const { name, type } of named) {
-				if (name)
+				if (name) {
+					this._markOwnership(name, true);
 					this.line(`let ${name} = ${this.zeroValueForTypeNode(type)};`);
+				}
 			}
 			this.namedReturnVars = named.map((r) => r.name).filter(Boolean);
 		} else {
@@ -565,8 +743,11 @@ export class CodeGen {
 	genVarDecl(decl) {
 		for (const spec of decl.decls) {
 			if (spec.value) {
-				const vals = spec.value.map((v) => {
-					const js = this.genExpr(v);
+				const paired = spec.value.length === spec.names.length;
+				const vals = spec.value.map((v, i) => {
+					const js = paired
+						? this._genDeclValue(spec.names[i], v)
+						: this.genExpr(v);
 					// Wrap numeric values assigned to complex-typed vars
 					if (
 						spec.type?.name === "complex128" ||
@@ -590,6 +771,7 @@ export class CodeGen {
 			} else {
 				const zero = spec.type ? this.zeroValueForTypeNode(spec.type) : "null";
 				for (const name of spec.names) {
+					this._markOwnership(name, true);
 					const val = this._boxedVars.has(name) ? `{ value: ${zero} }` : zero;
 					this.line(`let ${name} = ${val};`);
 				}

package/src/codegen/runtime.js

@@ -3,7 +3,7 @@
 // multiple compiled files bundled together can safely repeat the declaration.
 
 export const HELPER_LEN = `var __len = __len || function(a) {
-  if (a && typeof a === 'object' && !Array.isArray(a)) return Object.keys(a).length;
+  if (a && typeof a === 'object' && !Array.isArray(a) && !ArrayBuffer.isView(a)) return Object.keys(a).length;
   return a?.length ?? 0;
 };`;
 
@@ -19,6 +19,27 @@ export const HELPER_APPEND = `var __append = __append || function(a, ...b) {
 
 export const HELPER_S = "var __s = __s || function(a) { return a || []; };";
 
+// Copy of a struct value whose class is not statically known.
+export const HELPER_SCLONE = `var __sclone = __sclone || function(x) {
+  if (x === null || typeof x !== "object") return x;
+  if (typeof x.__clone === "function") return x.__clone();
+  return Object.assign(Object.create(Object.getPrototypeOf(x)), x);
+};`;
+
+// Interface boxing: tag struct values (__v) vs struct pointers (__p) so type
+// switches can tell T from *T; tags are non-enumerable so __equal/JSON ignore them.
+export const HELPER_IFACE_BOX = `var __ifv = __ifv || function(x) {
+  if (x === null || typeof x !== "object") return x;
+  const c = typeof x.__clone === "function" ? x.__clone() : Object.assign(Object.create(Object.getPrototypeOf(x)), x);
+  Object.defineProperty(c, "__v", { value: true, configurable: true });
+  return c;
+};
+var __ifp = __ifp || function(x) {
+  if (x !== null && typeof x === "object" && x.__p !== true && Object.isExtensible(x))
+    Object.defineProperty(x, "__p", { value: true, configurable: true });
+  return x;
+};`;
+
 export const HELPER_EQUAL = `var __equal = __equal || function __equal(a, b) {
   if (a === b) return true;
   if (a === null || b === null) return false;

package/src/codegen/statements.js

@@ -1,6 +1,6 @@
 // CodeGen statement methods — installed as a mixin on CodeGen.prototype.
 
-import { isComplex } from "../typechecker/types.js";
+import { isComplex, isNumeric } from "../typechecker/types.js";
 
 /** @typedef {import('./index.js').CodeGen} CodeGen */
 
@@ -122,14 +122,20 @@ export const statementGenMethods = {
 
 	_genDefineMixedRedecl(lhs, rhs, redecls) {
 		if (rhs.length === 1 && lhs.length > 1) {
-			const tmp = "__t";
-			this.line(`let ${tmp} = ${rhs[0]};`);
+			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;
 				const prefix = redecls[i] ? "" : "let ";
 				this.line(`${prefix}${lhs[i]} = ${tmp}[${i}];`);
 			}
 		} else {
 			for (let i = 0; i < lhs.length; i++) {
+				if (lhs[i] === "_") {
+					this.line(`${rhs[i]};`);
+					continue;
+				}
 				const prefix = redecls[i] ? "" : "let ";
 				this.line(`${prefix}${lhs[i]} = ${rhs[i]};`);
 			}
@@ -142,7 +148,13 @@ export const statementGenMethods = {
 			this._genCommaOkMapIndex(stmt, rhsNode, true);
 			return;
 		}
-		const rhs = stmt.rhs.map((e) => this.genExpr(e));
+		const paired = stmt.rhs.length === stmt.lhs.length;
+		const rhs = 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);
+		});
 		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);
@@ -150,7 +162,8 @@ export const statementGenMethods = {
 			this._genDefineSingleVar(lhs, rhs, redecls);
 		} else if (!anyRedecl) {
 			const rhsStr = rhs.length === 1 ? rhs[0] : `[${rhs.join(", ")}]`;
-			this.line(`let [${lhs.join(", ")}] = ${rhsStr};`);
+			const names = lhs.map((n) => (n === "_" ? "" : n));
+			this.line(`let [${names.join(", ")}] = ${rhsStr};`);
 		} else {
 			this._genDefineMixedRedecl(lhs, rhs, redecls);
 		}
@@ -218,7 +231,12 @@ export const statementGenMethods = {
 			this._genStructDerefAssign(stmt);
 			return;
 		}
-		const rhs = stmt.rhs.map((e) => this.genExpr(e));
+		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 lhs = stmt.lhs.map((e) => this._genAssignLhsExpr(e));
 		const pairs = lhs.map((l, i) => ({ l, r: rhs[i] ?? rhs[0] }));
@@ -243,7 +261,14 @@ export const statementGenMethods = {
 
 	_genStructDerefAssign(stmt) {
 		const target = this.genExpr(stmt.lhs[0].operand);
-		const source = this.genExpr(stmt.rhs[0]);
+		const rhsNode = stmt.rhs[0];
+		const fields = this._aggregateBase(rhsNode._type)?.fields;
+		const shallowOk =
+			fields instanceof Map &&
+			![...fields.values()].some((t) => this._aggregateBase(t));
+		const source = shallowOk
+			? this.genExpr(rhsNode)
+			: this.genValueExpr(rhsNode);
 		this.line(`Object.assign(${target}, ${source});`);
 	},
 
@@ -293,7 +318,7 @@ export const statementGenMethods = {
 		}
 		const vals =
 			stmt.values.length > 0
-				? stmt.values.map((v) => this.genExpr(v))
+				? stmt.values.map((v) => this._genReturnValue(v))
 				: (this.namedReturnVars ?? []);
 		const stored = vals.length === 1 ? vals[0] : `[${vals.join(", ")}]`;
 		this.line(
@@ -318,10 +343,10 @@ export const statementGenMethods = {
 				this.line("return;");
 			}
 		} else if (stmt.values.length === 1) {
-			this.line(`return ${this.genExpr(stmt.values[0])};`);
+			this.line(`return ${this._genReturnValue(stmt.values[0])};`);
 		} else {
 			this.line(
-				`return [${stmt.values.map((v) => this.genExpr(v)).join(", ")}];`,
+				`return [${stmt.values.map((v) => this._genReturnValue(v)).join(", ")}];`,
 			);
 		}
 	},
@@ -425,12 +450,7 @@ export const statementGenMethods = {
 	},
 
 	_isIntRangeType(iterType) {
-		return (
-			(iterType?.kind === "basic" &&
-				(iterType.name === "int" || iterType.name === "float64")) ||
-			(iterType?.kind === "untyped" &&
-				(iterType.base === "int" || iterType.base === "float64"))
-		);
+		return isNumeric(iterType);
 	},
 
 	_isMapRangeType(iterType) {
@@ -447,47 +467,152 @@ export const statementGenMethods = {
 		);
 	},
 
-	_emitSliceLoopHeader(rawIdx, iteree, isAssign, d) {
+	_rangeVarTarget(e, isAssign) {
+		if (e.kind === "Ident") {
+			if (e.name === "_") return null;
+			const boxed = this._boxedVars.has(e.name);
+			if (isAssign) return boxed ? `${e.name}.value = ` : `${e.name} = `;
+			return boxed ? { name: e.name, boxed } : { name: e.name };
+		}
+		this._markIndexLvalues([e]);
+		return `${this._genAssignLhsExpr(e)} = `;
+	},
+
+	_emitRangeVar(e, valueJs, isAssign) {
+		if (!e) return;
+		const target = this._rangeVarTarget(e, isAssign);
+		if (target === null) return;
+		if (typeof target === "string") {
+			this.line(`${target}${valueJs};`);
+			return;
+		}
+		const v = target.boxed ? `{ value: ${valueJs} }` : valueJs;
+		this.line(`let ${target.name} = ${v};`);
+	},
+
+	// True when the body re-declares one of `names` at its top level (legal Go shadowing).
+	_bodyRedeclares(body, names) {
+		if (names.length === 0) return false;
+		for (const s of body.stmts ?? []) {
+			if (s.kind === "DefineStmt" && s.lhs.some((e) => names.includes(e.name)))
+				return true;
+			if (
+				(s.kind === "VarDecl" || s.kind === "ConstDecl") &&
+				s.decls?.some((d) => d.names?.some((n) => names.includes(n)))
+			)
+				return true;
+		}
+		return false;
+	},
+
+	// Range value variable: aliases the element unless the body writes the variable or the collection.
+	_rangeElemValue(stmt, valNode, js, isAssign) {
+		const iterNode = stmt.init.rhs[0].expr;
+		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")
+			return this._cloneJs(elemType, js);
+		if (valNode.name === "_") return js;
+		const root = this._rootIdentName(iterNode);
+		const mutated =
+			this._fnMutates(valNode.name) ||
+			(root !== null && this._nodeMutatesVar(stmt.body, root));
+		this._markOwnership(valNode.name, mutated);
+		return mutated ? this._cloneJs(elemType, js) : js;
+	},
+
+	_genSliceRangeFor(stmt, iteree, isAssign) {
+		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}`;
-		const hasIdx = rawIdx && rawIdx !== "_";
-		if (isAssign && hasIdx) {
-			this.line(`const ${arr} = ${iteree};`);
-			this.line(`const ${len} = ${arr} ? ${arr}.length : 0;`);
-			this.line(`for (${rawIdx} = 0; ${rawIdx} < ${len}; ${rawIdx}++) {`);
-		} else {
-			const idx = hasIdx ? rawIdx : `__i${d}`;
-			this.line(
-				`for (let ${idx} = 0, ${arr} = ${iteree}, ${len} = ${arr} ? ${arr}.length : 0; ${idx} < ${len}; ${idx}++) {`,
+		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),
+				isAssign,
 			);
-		}
+			const declared = isAssign
+				? []
+				: [idxNode, valNode]
+						.filter((e) => e?.kind === "Ident" && e.name !== "_")
+						.map((e) => e.name);
+			if (this._bodyRedeclares(stmt.body, declared)) {
+				this.line("{");
+				this.indented(() => this.genBlock(stmt.body));
+				this.line("}");
+			} else {
+				this.genBlock(stmt.body);
+			}
+		});
+		this.line("}");
+		this._loopDepth--;
 	},
 
-	_emitSliceValAssign(rawIdx, rawVal, isAssign, d) {
-		if (!rawVal || rawVal === "_") return;
-		const idx = rawIdx && rawIdx !== "_" ? rawIdx : `__i${d}`;
-		const kw = isAssign ? "" : "let ";
-		this.line(`${kw}${rawVal} = __arr${d}[${idx}];`);
+	// Whether `for i := range n` can be emitted as a plain `for (let i = 0; …)` without hidden registers.
+	_isSimpleIntRange(stmt, name, isAssign) {
+		if (isAssign) return false;
+		if (!name || name === "_") return true;
+		return !this._boxedVars.has(name) && !this._nodeAssigns(stmt.body, name);
 	},
 
-	_genSliceRangeFor(stmt, iteree, lhs, isAssign) {
+	_genIntRangeBody(stmt, name, isAssign) {
+		const wrap = !isAssign && name && this._bodyRedeclares(stmt.body, [name]);
+		if (!wrap) return this.genBlock(stmt.body);
+		this.line("{");
+		this.indented(() => this.genBlock(stmt.body));
+		this.line("}");
+	},
+
+	_genIntRangeFor(stmt, iteree, isAssign) {
+		const varNode = stmt.init.lhs[0];
+		const name = varNode?.kind === "Ident" ? varNode.name : null;
+		if (this._isSimpleIntRange(stmt, name, isAssign)) {
+			const v = !name || name === "_" ? "_$" : name;
+			this.line(`for (let ${v} = 0; ${v} < ${iteree}; ${v}++) {`);
+			this.indented(() => this.genBlock(stmt.body));
+			this.line("}");
+			return;
+		}
 		this._loopDepth = this._loopDepth ?? 0;
-		const d = this._loopDepth;
-		this._loopDepth++;
-		this._emitSliceLoopHeader(lhs[0], iteree, isAssign, d);
+		const d = this._loopDepth++;
+		const i = `__i${d}`;
+		const n = `__n${d}`;
+		this.line(`for (let ${i} = 0, ${n} = ${iteree}; ${i} < ${n}; ${i}++) {`);
 		this.indented(() => {
-			this._emitSliceValAssign(lhs[0], lhs[1], isAssign, d);
-			this.genBlock(stmt.body);
+			this._emitRangeVar(varNode, i, isAssign);
+			this._genIntRangeBody(stmt, name, isAssign);
 		});
 		this.line("}");
 		this._loopDepth--;
 	},
 
-	_genIntRangeFor(rawVar, iteree, body) {
-		const v = rawVar === "_" ? "_$" : rawVar;
-		this.line(`for (let ${v} = 0; ${v} < ${iteree}; ${v}++) {`);
-		this.indented(() => this.genBlock(body));
-		this.line("}");
+	// True when `node` contains an assignment or ++/-- targeting identifier `name`.
+	_nodeAssigns(node, name) {
+		if (!node || typeof node !== "object") return false;
+		if (Array.isArray(node))
+			return node.some((n) => this._nodeAssigns(n, name));
+		if (
+			(node.kind === "AssignStmt" &&
+				node.lhs.some((e) => e.kind === "Ident" && e.name === name)) ||
+			(node.kind === "IncDecStmt" &&
+				node.expr.kind === "Ident" &&
+				node.expr.name === name)
+		)
+			return true;
+		for (const key of Object.keys(node)) {
+			if (key.startsWith("_")) continue;
+			if (this._nodeAssigns(node[key], name)) return true;
+		}
+		return false;
 	},
 
 	_genIterFor(init, iterType, iteree, lhs, body) {
@@ -515,12 +640,12 @@ export const statementGenMethods = {
 			: this.genExpr(range.expr);
 
 		if (lhs.length <= 1 && this._isIntRangeType(iterType)) {
-			this._genIntRangeFor(lhs[0], iteree, stmt.body);
+			this._genIntRangeFor(stmt, iteree, init.kind === "AssignStmt");
 			return;
 		}
 
 		if (!this._isMapRangeType(iterType) && !this._isStringRangeType(iterType)) {
-			this._genSliceRangeFor(stmt, iteree, lhs, init.kind === "AssignStmt");
+			this._genSliceRangeFor(stmt, iteree, init.kind === "AssignStmt");
 			return;
 		}