gofront 0.0.9 → 1.0.1

package/src/codegen/statements.js

@@ -2,6 +2,22 @@
 
 import { isComplex } from "../typechecker/types.js";
 
+/** @typedef {import('./index.js').CodeGen} CodeGen */
+
+// Method-name dispatch for genStmt — string values add no static call edges.
+const STMT_GEN_DELEGATE = {
+	VarDecl: "genVarDecl",
+	ConstDecl: "genConstDecl",
+	DefineStmt: "_genDefineStmt",
+	AssignStmt: "_genAssignStmt",
+	ReturnStmt: "_genReturnStmt",
+	ForStmt: "genFor",
+	SwitchStmt: "genSwitch",
+	TypeSwitchStmt: "genTypeSwitch",
+	BranchStmt: "_genBranchStmt",
+};
+
+/** @type {ThisType<CodeGen>} */
 export const statementGenMethods = {
 	genBlock(block) {
 		for (const stmt of block.stmts) this.genStmt(stmt);
@@ -36,210 +52,17 @@ export const statementGenMethods = {
 		const srcLine = stmt._line ?? null;
 		const _line0 = this.out.length;
 		switch (stmt.kind) {
-			case "VarDecl":
-				this.genVarDecl(stmt);
-				break;
-			case "ConstDecl":
-				this.genConstDecl(stmt);
-				break;
 			case "TypeDecl":
 				this.genTypeDeclWithMethods(stmt, []);
 				break;
-
-			case "DefineStmt": {
-				// Map comma-ok: v, ok := m[key]  →  let v = m[key]; let ok = key in m;
-				const rhsNode = stmt.rhs[0];
-				if (
-					stmt.rhs.length === 1 &&
-					stmt.lhs.length === 2 &&
-					rhsNode?.kind === "IndexExpr" &&
-					rhsNode.expr?._type?.kind === "map"
-				) {
-					this._genCommaOkMapIndex(stmt, rhsNode, true);
-					break;
-				}
-				const rhs = stmt.rhs.map((e) => this.genExpr(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);
-				if (lhs.length === 1) {
-					const isBoxed = this._boxedVars.has(lhs[0]);
-					const val = isBoxed && !redecls[0] ? `{ value: ${rhs[0]} }` : rhs[0];
-					if (redecls[0]) {
-						if (isBoxed) {
-							this.line(`${lhs[0]}.value = ${rhs[0]};`);
-						} else {
-							this.line(`${lhs[0]} = ${val};`);
-						}
-					} else {
-						this.line(`let ${lhs[0]} = ${val};`);
-					}
-				} else if (!anyRedecl) {
-					// All new: let [a, b] = ...
-					const rhsStr = rhs.length === 1 ? rhs[0] : `[${rhs.join(", ")}]`;
-					this.line(`let [${lhs.join(", ")}] = ${rhsStr};`);
-				} else {
-					// Mixed new/existing: emit separate statements
-					// First compute the tuple into a temp if needed
-					if (rhs.length === 1 && lhs.length > 1) {
-						const tmp = "__t";
-						this.line(`let ${tmp} = ${rhs[0]};`);
-						for (let i = 0; i < lhs.length; i++) {
-							const prefix = redecls[i] ? "" : "let ";
-							this.line(`${prefix}${lhs[i]} = ${tmp}[${i}];`);
-						}
-					} else {
-						for (let i = 0; i < lhs.length; i++) {
-							const prefix = redecls[i] ? "" : "let ";
-							this.line(`${prefix}${lhs[i]} = ${rhs[i]};`);
-						}
-					}
-				}
-				break;
-			}
-
-			case "AssignStmt": {
-				// Complex compound assignment: z += w → z = z + w (with complex codegen)
-				if (
-					stmt.op !== "=" &&
-					stmt.lhs.length === 1 &&
-					stmt.rhs.length === 1 &&
-					isComplex(stmt.lhs[0]._type)
-				) {
-					const lhsStr = stmt.lhs[0].name ?? this.genExpr(stmt.lhs[0]);
-					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 }`;
-							break;
-						case "-":
-							result = `{ re: ${lhsStr}.re - ${rhsExpr}.re, im: ${lhsStr}.im - ${rhsExpr}.im }`;
-							break;
-						case "*":
-							this._usesCmul = true;
-							result = `__cmul(${lhsStr}, ${rhsExpr})`;
-							break;
-						case "/":
-							this._usesCdiv = true;
-							result = `__cdiv(${lhsStr}, ${rhsExpr})`;
-							break;
-						default:
-							result = rhsExpr;
-					}
-					this.line(`${lhsStr} = ${result};`);
-					break;
-				}
-				// comma-ok map index: v, ok = m["key"]
-				if (stmt._commaOkMap) {
-					this._genCommaOkMapIndex(stmt, stmt.rhs[0], false);
-					break;
-				}
-				// comma-ok type assertion: v, ok = x.(T)
-				if (
-					stmt.lhs.length === 2 &&
-					stmt.rhs.length === 1 &&
-					stmt.rhs[0]._commaOk
-				) {
-					const val = this.genExpr(stmt.rhs[0]);
-					const [vName, okName] = stmt.lhs.map(
-						(e) => e.name ?? this.genExpr(e),
-					);
-					const tmp = "__ta";
-					this.line(`let ${tmp} = ${val};`);
-					if (vName !== "_") this.line(`${vName} = ${tmp}[0];`);
-					if (okName !== "_") this.line(`${okName} = ${tmp}[1];`);
-					break;
-				}
-				const rhs = stmt.rhs.map((e) => this.genExpr(e));
-				for (const e of stmt.lhs) if (e.kind === "IndexExpr") e._lvalue = true;
-				const lhs = stmt.lhs.map((e) => {
-					if (
-						e.kind === "Ident" &&
-						e.name !== "_" &&
-						this._boxedVars.has(e.name)
-					)
-						return `${e.name}.value`;
-					return e.name ?? this.genExpr(e);
-				});
-				// Filter out blank identifier assignments entirely
-				const pairs = lhs.map((l, i) => ({ l, r: rhs[i] ?? rhs[0] }));
-				const active = pairs.filter((p) => p.l !== "_");
-				if (active.length === 0) {
-					// All _ — still need to evaluate rhs for side effects
-					if (rhs.length > 0) this.line(`${rhs[0]};`);
-				} else if (lhs.length === 1) {
-					this.line(`${active[0].l} ${stmt.op} ${active[0].r};`);
-				} else {
-					// multi-assign: emit only non-blank targets
-					const rhsStr = rhs.length === 1 ? rhs[0] : `[${rhs.join(", ")}]`;
-					if (active.length === pairs.length) {
-						this.line(`[${lhs.join(", ")}] = ${rhsStr};`);
-					} else {
-						// Some blanks — use temp and assign only non-blank
-						const tmp = "__t";
-						this.line(`let ${tmp} = ${rhsStr};`);
-						for (let i = 0; i < lhs.length; i++) {
-							if (lhs[i] !== "_") {
-								const src = rhs.length === 1 ? `${tmp}[${i}]` : rhs[i];
-								this.line(`${lhs[i]} ${stmt.op} ${src};`);
-							}
-						}
-					}
-				}
-				break;
-			}
-
 			case "IncDecStmt":
 				this.line(`${this.genExpr(stmt.expr)}${stmt.op};`);
 				break;
-
 			case "ExprStmt":
 				this.line(`${this.genExpr(stmt.expr)};`);
 				break;
-
-			case "ReturnStmt": {
-				if (this._inIteratorBody) {
-					if (stmt.values.length === 0 && !this.namedReturnVars?.length) {
-						this.line(`${this._iterReturnFlag} = true; return false;`);
-					} else {
-						const vals =
-							stmt.values.length > 0
-								? stmt.values.map((v) => this.genExpr(v))
-								: (this.namedReturnVars ?? []);
-						const stored = vals.length === 1 ? vals[0] : `[${vals.join(", ")}]`;
-						this.line(
-							`${this._iterReturnFlag} = true; ${this._iterReturnVar} = ${stored}; return false;`,
-						);
-					}
-					break;
-				}
-				if (stmt.values.length === 0) {
-					// bare return — emit named return vars if present
-					if (this.namedReturnVars?.length > 0) {
-						const vars = this.namedReturnVars;
-						this.line(
-							vars.length === 1
-								? `return ${vars[0]};`
-								: `return [${vars.join(", ")}];`,
-						);
-					} else {
-						this.line("return;");
-					}
-				} else if (stmt.values.length === 1) {
-					this.line(`return ${this.genExpr(stmt.values[0])};`);
-				} else {
-					this.line(
-						`return [${stmt.values.map((v) => this.genExpr(v)).join(", ")}];`,
-					);
-				}
-				break;
-			}
-
-			case "IfStmt": {
+			case "IfStmt":
 				if (stmt.init) {
-					// Wrap in a block so init variable is scoped
 					this.line("{");
 					this.indented(() => {
 						this.genStmt(stmt.init);
@@ -250,55 +73,26 @@ export const statementGenMethods = {
 					this._genIf(stmt);
 				}
 				break;
-			}
-
-			case "ForStmt":
-				this.genFor(stmt);
-				break;
-
-			case "SwitchStmt":
-				this.genSwitch(stmt);
-				break;
-
-			case "TypeSwitchStmt":
-				this.genTypeSwitch(stmt);
-				break;
-
 			case "DeferStmt":
 				this.line(`__defers.push(() => { ${this.genExpr(stmt.call)}; });`);
 				break;
-
 			case "LabeledStmt":
 				this.line(`${stmt.label}:`);
 				this.genStmt(stmt.body);
 				break;
-
-			case "BranchStmt":
-				if (this._inIteratorBody && !stmt.label) {
-					if (stmt.keyword === "break") {
-						this.line(`${this._iterBreakFlag} = true; return false;`);
-						break;
-					}
-					if (stmt.keyword === "continue") {
-						this.line("return true;");
-						break;
-					}
-				}
-				if (stmt.keyword !== "fallthrough")
-					this.line(
-						stmt.label ? `${stmt.keyword} ${stmt.label};` : `${stmt.keyword};`,
-					);
-				// fallthrough: omit — JS switch falls through naturally without a break
-				break;
-
 			case "Block":
 				this.line("{");
 				this.indented(() => this.genBlock(stmt));
 				this.line("}");
 				break;
-
-			default:
+			default: {
+				const m = STMT_GEN_DELEGATE[stmt.kind];
+				if (m) {
+					this[m](stmt);
+					break;
+				}
 				throw new Error(`CodeGen: unhandled statement kind '${stmt.kind}'`);
+			}
 		}
 		// Record source mapping: first output line this statement produced
 		if (srcLine != null && this.out.length > _line0) {
@@ -306,6 +100,229 @@ export const statementGenMethods = {
 		}
 	},
 
+	_isCommaOkMapExpr(stmt, rhsNode) {
+		return (
+			stmt.rhs.length === 1 &&
+			stmt.lhs.length === 2 &&
+			rhsNode?.kind === "IndexExpr" &&
+			rhsNode.expr?._type?.kind === "map"
+		);
+	},
+
+	_genDefineSingleVar(lhs, rhs, redecls) {
+		const isBoxed = this._boxedVars.has(lhs[0]);
+		const val = isBoxed && !redecls[0] ? `{ value: ${rhs[0]} }` : rhs[0];
+		if (redecls[0]) {
+			if (isBoxed) this.line(`${lhs[0]}.value = ${rhs[0]};`);
+			else this.line(`${lhs[0]} = ${val};`);
+		} else {
+			this.line(`let ${lhs[0]} = ${val};`);
+		}
+	},
+
+	_genDefineMixedRedecl(lhs, rhs, redecls) {
+		if (rhs.length === 1 && lhs.length > 1) {
+			const tmp = "__t";
+			this.line(`let ${tmp} = ${rhs[0]};`);
+			for (let i = 0; i < lhs.length; i++) {
+				const prefix = redecls[i] ? "" : "let ";
+				this.line(`${prefix}${lhs[i]} = ${tmp}[${i}];`);
+			}
+		} else {
+			for (let i = 0; i < lhs.length; i++) {
+				const prefix = redecls[i] ? "" : "let ";
+				this.line(`${prefix}${lhs[i]} = ${rhs[i]};`);
+			}
+		}
+	},
+
+	_genDefineStmt(stmt) {
+		const rhsNode = stmt.rhs[0];
+		if (this._isCommaOkMapExpr(stmt, rhsNode)) {
+			this._genCommaOkMapIndex(stmt, rhsNode, true);
+			return;
+		}
+		const rhs = stmt.rhs.map((e) => this.genExpr(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);
+		if (lhs.length === 1) {
+			this._genDefineSingleVar(lhs, rhs, redecls);
+		} else if (!anyRedecl) {
+			const rhsStr = rhs.length === 1 ? rhs[0] : `[${rhs.join(", ")}]`;
+			this.line(`let [${lhs.join(", ")}] = ${rhsStr};`);
+		} else {
+			this._genDefineMixedRedecl(lhs, rhs, redecls);
+		}
+	},
+
+	_isComplexCompoundAssign(stmt) {
+		return (
+			stmt.op !== "=" &&
+			stmt.lhs.length === 1 &&
+			stmt.rhs.length === 1 &&
+			isComplex(stmt.lhs[0]._type)
+		);
+	},
+
+	_isCommaOkAssertStmt(stmt) {
+		return (
+			stmt.lhs.length === 2 && stmt.rhs.length === 1 && stmt.rhs[0]._commaOk
+		);
+	},
+
+	_genAssignLhsExpr(e) {
+		if (e.kind === "Ident" && e.name !== "_" && this._boxedVars.has(e.name))
+			return `${e.name}.value`;
+		return e.name ?? this.genExpr(e);
+	},
+
+	_markIndexLvalues(exprs) {
+		for (const e of exprs) if (e.kind === "IndexExpr") e._lvalue = true;
+	},
+
+	_genAssignMulti(stmt, lhs, rhs, active, pairs) {
+		const rhsStr = rhs.length === 1 ? rhs[0] : `[${rhs.join(", ")}]`;
+		if (active.length === pairs.length) {
+			this.line(`[${lhs.join(", ")}] = ${rhsStr};`);
+		} else {
+			this._genMultiAssignWithBlanks(stmt, lhs, rhs, rhsStr);
+		}
+	},
+
+	_genAssignStmt(stmt) {
+		if (this._isComplexCompoundAssign(stmt)) {
+			this._genComplexCompoundAssign(stmt);
+			return;
+		}
+		if (stmt._commaOkMap) {
+			this._genCommaOkMapIndex(stmt, stmt.rhs[0], false);
+			return;
+		}
+		if (this._isCommaOkAssertStmt(stmt)) {
+			this._genCommaOkTypeAssert(stmt);
+			return;
+		}
+		const rhs = stmt.rhs.map((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] }));
+		const active = pairs.filter((p) => p.l !== "_");
+		if (active.length === 0) {
+			if (rhs.length > 0) this.line(`${rhs[0]};`);
+		} else if (lhs.length === 1) {
+			this.line(`${active[0].l} ${stmt.op} ${active[0].r};`);
+		} else {
+			this._genAssignMulti(stmt, lhs, rhs, active, pairs);
+		}
+	},
+
+	_genCommaOkTypeAssert(stmt) {
+		const val = this.genExpr(stmt.rhs[0]);
+		const [vName, okName] = stmt.lhs.map((e) => e.name ?? this.genExpr(e));
+		const tmp = "__ta";
+		this.line(`let ${tmp} = ${val};`);
+		if (vName !== "_") this.line(`${vName} = ${tmp}[0];`);
+		if (okName !== "_") this.line(`${okName} = ${tmp}[1];`);
+	},
+
+	_genMultiAssignWithBlanks(stmt, lhs, rhs, rhsStr) {
+		const tmp = "__t";
+		this.line(`let ${tmp} = ${rhsStr};`);
+		for (let i = 0; i < lhs.length; i++) {
+			if (lhs[i] !== "_") {
+				const src = rhs.length === 1 ? `${tmp}[${i}]` : rhs[i];
+				this.line(`${lhs[i]} ${stmt.op} ${src};`);
+			}
+		}
+	},
+
+	_genComplexCompoundAssign(stmt) {
+		const lhsStr = stmt.lhs[0].name ?? this.genExpr(stmt.lhs[0]);
+		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 }`;
+				break;
+			case "-":
+				result = `{ re: ${lhsStr}.re - ${rhsExpr}.re, im: ${lhsStr}.im - ${rhsExpr}.im }`;
+				break;
+			case "*":
+				this._usesCmul = true;
+				result = `__cmul(${lhsStr}, ${rhsExpr})`;
+				break;
+			case "/":
+				this._usesCdiv = true;
+				result = `__cdiv(${lhsStr}, ${rhsExpr})`;
+				break;
+			default:
+				throw new Error(
+					`unsupported complex compound assignment operator: ${stmt.op}`,
+				);
+		}
+		this.line(`${lhsStr} = ${result};`);
+	},
+
+	_genIteratorReturn(stmt) {
+		if (stmt.values.length === 0 && !this.namedReturnVars?.length) {
+			this.line(`${this._iterReturnFlag} = true; return false;`);
+			return;
+		}
+		const vals =
+			stmt.values.length > 0
+				? stmt.values.map((v) => this.genExpr(v))
+				: (this.namedReturnVars ?? []);
+		const stored = vals.length === 1 ? vals[0] : `[${vals.join(", ")}]`;
+		this.line(
+			`${this._iterReturnFlag} = true; ${this._iterReturnVar} = ${stored}; return false;`,
+		);
+	},
+
+	_genReturnStmt(stmt) {
+		if (this._inIteratorBody) {
+			this._genIteratorReturn(stmt);
+			return;
+		}
+		if (stmt.values.length === 0) {
+			if (this.namedReturnVars?.length > 0) {
+				const vars = this.namedReturnVars;
+				this.line(
+					vars.length === 1
+						? `return ${vars[0]};`
+						: `return [${vars.join(", ")}];`,
+				);
+			} else {
+				this.line("return;");
+			}
+		} else if (stmt.values.length === 1) {
+			this.line(`return ${this.genExpr(stmt.values[0])};`);
+		} else {
+			this.line(
+				`return [${stmt.values.map((v) => this.genExpr(v)).join(", ")}];`,
+			);
+		}
+	},
+
+	_genBranchStmt(stmt) {
+		if (this._inIteratorBody && !stmt.label) {
+			if (stmt.keyword === "break") {
+				this.line(`${this._iterBreakFlag} = true; return false;`);
+				return;
+			}
+			if (stmt.keyword === "continue") {
+				this.line("return true;");
+				return;
+			}
+		}
+		if (stmt.keyword !== "fallthrough")
+			this.line(
+				stmt.label ? `${stmt.keyword} ${stmt.label};` : `${stmt.keyword};`,
+			);
+		// fallthrough: omit — JS switch falls through naturally without a break
+	},
+
 	_genIf(stmt) {
 		this.line(`if (${this.genExpr(stmt.cond)}) {`);
 		this.indented(() => this.genBlock(stmt.body));
@@ -328,43 +345,41 @@ export const statementGenMethods = {
 		}
 	},
 
+	_genRangeExprFor(stmt) {
+		if (stmt.cond._isIterator) {
+			this.genIteratorForCond(stmt);
+			return;
+		}
+		const iteree = this.genExpr(stmt.cond.expr);
+		this.line(`for (let _$ = 0; _$ < ${iteree}; _$++) {`);
+		this.indented(() => this.genBlock(stmt.body));
+		this.line("}");
+	},
+
+	_genSimpleWhileFor(stmt) {
+		if (!stmt.cond) {
+			this.line("while (true) {");
+		} else {
+			this.line(`while (${this.genExpr(stmt.cond)}) {`);
+		}
+		this.indented(() => this.genBlock(stmt.body));
+		this.line("}");
+	},
+
 	genFor(stmt) {
-		// Detect range: init is DefineStmt/AssignStmt with rhs[0] being a RangeExpr
 		if (this.isRangeFor(stmt)) {
-			if (stmt.init.rhs[0]._isIterator) {
-				this.genIteratorFor(stmt);
-			} else {
-				this.genRangeFor(stmt);
-			}
+			if (stmt.init.rhs[0]._isIterator) this.genIteratorFor(stmt);
+			else this.genRangeFor(stmt);
 			return;
 		}
-
-		// for range expr — no variable; could be int range or 0-param iterator
 		if (stmt.cond?.kind === "RangeExpr") {
-			if (stmt.cond._isIterator) {
-				this.genIteratorForCond(stmt);
-				return;
-			}
-			const iteree = this.genExpr(stmt.cond.expr);
-			this.line(`for (let _$ = 0; _$ < ${iteree}; _$++) {`);
-			this.indented(() => this.genBlock(stmt.body));
-			this.line("}");
+			this._genRangeExprFor(stmt);
 			return;
 		}
-
 		if (!stmt.init && !stmt.post) {
-			if (!stmt.cond) {
-				// infinite loop
-				this.line("while (true) {");
-			} else {
-				this.line(`while (${this.genExpr(stmt.cond)}) {`);
-			}
-			this.indented(() => this.genBlock(stmt.body));
-			this.line("}");
+			this._genSimpleWhileFor(stmt);
 			return;
 		}
-
-		// Standard C-style for
 		const init = stmt.init ? this.stmtInline(stmt.init) : "";
 		const cond = stmt.cond ? this.genExpr(stmt.cond) : "";
 		const post = stmt.post ? this.stmtInline(stmt.post) : "";
@@ -380,6 +395,29 @@ export const statementGenMethods = {
 		return init.rhs?.[0]?.kind === "RangeExpr";
 	},
 
+	_isIntRangeType(iterType) {
+		return (
+			(iterType?.kind === "basic" &&
+				(iterType.name === "int" || iterType.name === "float64")) ||
+			(iterType?.kind === "untyped" &&
+				(iterType.base === "int" || iterType.base === "float64"))
+		);
+	},
+
+	_isMapRangeType(iterType) {
+		return (
+			iterType?.kind === "map" ||
+			(iterType?.kind === "named" && iterType.underlying?.kind === "map")
+		);
+	},
+
+	_isStringRangeType(iterType) {
+		return (
+			(iterType?.kind === "basic" && iterType.name === "string") ||
+			(iterType?.kind === "untyped" && iterType.base === "string")
+		);
+	},
+
 	genRangeFor(stmt) {
 		const init = stmt.init;
 		const range = init.rhs[0];
@@ -390,62 +428,36 @@ export const statementGenMethods = {
 			? `${this.genExpr(range.expr)}.${wrapField}`
 			: this.genExpr(range.expr);
 
-		let iterExpr;
-		if (
-			lhs.length <= 1 &&
-			((iterType?.kind === "basic" &&
-				(iterType.name === "int" || iterType.name === "float64")) ||
-				(iterType?.kind === "untyped" &&
-					(iterType.base === "int" || iterType.base === "float64")))
-		) {
-			// integer range (Go 1.22): for i := range n  → C-style for loop
+		if (lhs.length <= 1 && this._isIntRangeType(iterType)) {
 			const v = lhs[0] === "_" ? "_$" : lhs[0];
 			this.line(`for (let ${v} = 0; ${v} < ${iteree}; ${v}++) {`);
 			this.indented(() => this.genBlock(stmt.body));
 			this.line("}");
 			return;
 		}
-		if (
-			iterType?.kind === "map" ||
-			(iterType?.kind === "named" && iterType.underlying?.kind === "map")
-		) {
-			// map: for k, v := range m  → for (const [k, v] of Object.entries(m))
-			iterExpr = `Object.entries(${iteree})`;
-		} else if (
-			(iterType?.kind === "basic" && iterType.name === "string") ||
-			(iterType?.kind === "untyped" && iterType.base === "string")
-		) {
-			// string: for i, r := range s  → rune (code point), not JS character
-			// Go spec: iterating a string yields (byte-index, rune) pairs
-			if (lhs.length === 1) {
-				iterExpr = `Array.from(${iteree}).keys()`;
-			} else {
-				// Wrap code points so the value is an integer (rune), not a JS string
-				iterExpr = `Array.from(${iteree}, (__c, __i) => [__i, __c.codePointAt(0)])`;
-			}
-		} else {
-			// slice/array: for i, v := range arr → for (const [i, v] of __s(arr).entries())
-			// null-guard handles nil slices (zero value) gracefully.
-			this._usesSliceGuard = true;
-			if (lhs.length === 1) {
-				iterExpr = `__s(${iteree}).keys()`;
-			} else {
-				iterExpr = `__s(${iteree}).entries()`;
-			}
-		}
-
+		const iterExpr = this._genRangeIterExpr(iterType, iteree, lhs);
 		const binding =
 			lhs.length === 1
 				? lhs[0] === "_"
 					? "_$"
 					: lhs[0]
 				: `[${lhs.map((n) => (n === "_" ? "_$" : n)).join(", ")}]`;
-
 		this.line(`for (const ${binding} of ${iterExpr}) {`);
 		this.indented(() => this.genBlock(stmt.body));
 		this.line("}");
 	},
 
+	_genRangeIterExpr(iterType, iteree, lhs) {
+		if (this._isMapRangeType(iterType)) return `Object.entries(${iteree})`;
+		if (this._isStringRangeType(iterType)) {
+			if (lhs.length === 1) return `Array.from(${iteree}).keys()`;
+			return `Array.from(${iteree}, (__c, __i) => [__i, __c.codePointAt(0)])`;
+		}
+		this._usesSliceGuard = true;
+		if (lhs.length === 1) return `__s(${iteree}).keys()`;
+		return `__s(${iteree}).entries()`;
+	},
+
 	genIteratorFor(stmt) {
 		const range = stmt.init.rhs[0];
 		const lhs = stmt.init.lhs.map((e) => e.name ?? this.genExpr(e));