gofront 1.2.3 → 1.3.1

package/src/codegen/expressions.js

@@ -1,6 +1,9 @@
-// CodeGen expression methods and helpers — installed as a mixin on CodeGen.prototype.
-
-import { ERROR, isComplex } from "../typechecker/types.js";
+import {
+	ERROR,
+	isComplex,
+	isTypedArraySlice,
+	typedArrayConstructorForElem,
+} from "../typechecker/types.js";
 
 /** @typedef {import('./index.js').CodeGen} CodeGen */
 
@@ -109,9 +112,21 @@ const BUILTIN_GEN = {
 	},
 	copy: (s, e) => {
 		const [dst, src] = e.args.map((a) => s.genExpr(a));
-		return `((__cd,__cs)=>{const n=Math.min(__cd.length,__cs.length);__cd.splice(0,n,...__cs.slice(0,n));return n;})(${dst},${src})`;
+		return `((__cd, __cs) => { if (!__cd || !__cs) return 0; const n = Math.min(__cd.length, __cs.length); if (__cd.set) { __cd.set(__cs.length === n ? __cs : (__cs.subarray ? __cs.subarray(0, n) : __cs.slice(0, n))); } else { __cd.splice(0, n, ...(__cs.slice ? __cs.slice(0, n) : __cs.subarray(0, n))); } return n; })(${dst}, ${src})`;
+	},
+	new: (s, e) => {
+		const arg = e.args[0];
+		const typeName = arg.name ?? s.getTypeName(arg);
+		if (typeName && s.structNames.has(typeName)) {
+			return `new ${typeName}()`;
+		}
+		const t = arg._type;
+		if (s._isStructType(t)) {
+			const name = t.name ?? (t.kind === "named" ? t.name : null);
+			if (name) return `new ${name}()`;
+		}
+		return `{ value: ${s.zeroValueForExpr(arg)} }`;
 	},
-	new: (s, e) => `{ value: ${s.zeroValueForExpr(e.args[0])} }`,
 	print: (s, e) => `console.log(${e.args.map((a) => s.genExpr(a)).join(", ")})`,
 	println: (s, e) =>
 		`console.log(${e.args.map((a) => s.genExpr(a)).join(", ")})`,
@@ -171,6 +186,36 @@ export const expressionGenMethods = {
 		}
 	},
 
+	_isStructType(t) {
+		if (!t) return false;
+		if (t.name && this.structNames.has(t.name)) return true;
+		const base =
+			t.kind === "named"
+				? (t.underlying ?? this.checker?.types.get(t.name)?.underlying)
+				: t;
+		if (base?.name && this.structNames.has(base.name)) return true;
+		return base?.kind === "struct";
+	},
+
+	_isStructPointerType(t) {
+		if (!t) return false;
+		const pt =
+			t.kind === "named"
+				? (t.underlying ?? this.checker?.types.get(t.name)?.underlying)
+				: t;
+		if (pt?.kind !== "pointer") return false;
+		return this._isStructType(pt.base);
+	},
+
+	_isStructExpr(expr) {
+		if (!expr) return false;
+		if (expr.kind === "CompositeLit") {
+			const typeName = expr.typeExpr ? this.getTypeName(expr.typeExpr) : null;
+			if (typeName && this.structNames.has(typeName)) return true;
+		}
+		return this._isStructType(expr._type);
+	},
+
 	_genUnaryExpr(expr) {
 		const op = expr.op === "^" ? "~" : expr.op; // bitwise NOT
 		// Address-of: &x
@@ -183,11 +228,22 @@ export const expressionGenMethods = {
 					return this.genExpr(expr.operand);
 				}
 			}
-			// For non-boxed vars (structs, etc.), wrap in { value: x }
+			if (
+				this._isStructType(expr.operand._type) ||
+				this._isStructExpr(expr.operand)
+			) {
+				return this.genExpr(expr.operand);
+			}
+			// For non-boxed vars (primitives, etc.), wrap in { value: x }
 			return `{ value: ${this.genExpr(expr.operand)} }`;
 		}
-		// Dereference: *p → p.value
-		if (op === "*") return `${this.genExpr(expr.operand)}.value`;
+		// Dereference: *p
+		if (op === "*") {
+			if (this._isStructPointerType(expr.operand._type)) {
+				return this.genExpr(expr.operand);
+			}
+			return `${this.genExpr(expr.operand)}.value`;
+		}
 		// Unary minus/plus on complex
 		if ((op === "-" || op === "+") && isComplex(expr.operand._type)) {
 			const inner = this.genExpr(expr.operand);
@@ -215,6 +271,11 @@ export const expressionGenMethods = {
 	},
 
 	_genPointerSelectorField(expr, base) {
+		if (this._isStructPointerType(expr.expr._type)) {
+			const sel = `${base}.${expr.field}`;
+			if (expr._isMethodValue && !expr._callee) return `${sel}.bind(${base})`;
+			return sel;
+		}
 		const sel = `${base}.value.${expr.field}`;
 		if (expr._isMethodValue && !expr._callee)
 			return `${sel}.bind(${base}.value)`;
@@ -253,10 +314,11 @@ export const expressionGenMethods = {
 		const base = this.genExpr(expr.expr);
 		const lo = expr.low ? this.genExpr(expr.low) : "";
 		const hi = expr.high ? this.genExpr(expr.high) : "";
-		if (!lo && !hi) return `${base}.slice()`;
-		if (!hi) return `${base}.slice(${lo})`;
-		if (!lo) return `${base}.slice(0, ${hi})`;
-		return `${base}.slice(${lo}, ${hi})`;
+		const method = isTypedArraySlice(expr.expr._type) ? "subarray" : "slice";
+		if (!lo && !hi) return `${base}.${method}()`;
+		if (!hi) return `${base}.${method}(${lo})`;
+		if (!lo) return `${base}.${method}(0, ${hi})`;
+		return `${base}.${method}(${lo}, ${hi})`;
 	},
 
 	_genFuncLit(expr) {
@@ -423,10 +485,21 @@ export const expressionGenMethods = {
 		const resolvedKind = typeArg._type?.kind;
 		if (typeNode.kind === "SliceType" || resolvedKind === "slice") {
 			const n = expr.args[1] ? this.genExpr(expr.args[1]) : "0";
-			// Use the proper zero value for the element type (e.g. new Point() not 0)
 			const elemNode = typeNode.kind === "SliceType" ? typeNode.elem : null;
 			const elemResolved =
 				typeArg._type?.kind === "slice" ? typeArg._type.elem : null;
+			const typedCtor =
+				typedArrayConstructorForElem(elemResolved) ??
+				(elemNode?.name
+					? typedArrayConstructorForElem({
+							kind: "basic",
+							name: elemNode.name,
+						})
+					: null);
+			if (typedCtor) {
+				return `new ${typedCtor}(${n})`;
+			}
+			// Use the proper zero value for the element type (e.g. new Point() not 0)
 			let zero = "null";
 			if (elemResolved) {
 				zero = this.zeroValueForType(elemResolved);
@@ -495,17 +568,93 @@ export const expressionGenMethods = {
 		return `[${expr.elems.map((e) => this.genExpr(e)).join(", ")}]`;
 	},
 
+	_fillPositionalStructElems(fields, expr, values) {
+		let maxIdx = -1;
+		for (let i = 0; i < expr.elems.length; i++) {
+			const e = expr.elems[i];
+			const name =
+				e._positionalField ??
+				(e.kind === "KeyValueExpr"
+					? (e.key.name ?? this.genExpr(e.key))
+					: null);
+			const idx = name ? fields.findIndex((f) => f.name === name) : i;
+			if (idx >= 0 && idx < fields.length) {
+				values[idx] = this.genExpr(e.kind === "KeyValueExpr" ? e.value : e);
+				if (idx > maxIdx) maxIdx = idx;
+			}
+		}
+		return maxIdx;
+	},
+
+	_fillEmbedField(fields, ef, e, values) {
+		const idx = fields.findIndex((f) => f.name === ef);
+		if (idx < 0) return -1;
+		if (e.value.kind === "CompositeLit") {
+			const match = e.value.elems.find(
+				(ce) => (ce._positionalField ?? ce.key?.name) === ef,
+			);
+			values[idx] = match
+				? this.genExpr(match.value ?? match)
+				: fields[idx].zero;
+		} else {
+			values[idx] = `${this.genExpr(e.value)}.${ef}`;
+		}
+		return idx;
+	},
+
+	_fillKeyedStructElems(fields, expr, values) {
+		let maxIdx = -1;
+		for (const e of expr.elems) {
+			if (e.kind !== "KeyValueExpr") continue;
+			const k = e.key.name ?? this.genExpr(e.key);
+			if (e._isEmbedInit) {
+				const embedType = this.checker?.types.get(k)?.underlying;
+				const embedFields =
+					embedType?.kind === "struct" ? [...embedType.fields.keys()] : [];
+				for (const ef of embedFields) {
+					const idx = this._fillEmbedField(fields, ef, e, values);
+					if (idx > maxIdx) maxIdx = idx;
+				}
+			} else {
+				const idx = fields.findIndex((f) => f.name === k);
+				if (idx >= 0) {
+					values[idx] = this.genExpr(e.value);
+					if (idx > maxIdx) maxIdx = idx;
+				}
+			}
+		}
+		return maxIdx;
+	},
+
+	_genPositionalStructLit(typeName, expr) {
+		const fields = this.getStructFields(typeName);
+		if (!fields || fields.length === 0 || expr.elems.length === 0) {
+			return `new ${typeName}()`;
+		}
+		const values = fields.map((f) => f.zero);
+		const hasPositional = expr.elems.some(
+			(e) => e._positionalField || e.kind !== "KeyValueExpr",
+		);
+		const maxExplicitIdx = hasPositional
+			? this._fillPositionalStructElems(fields, expr, values)
+			: this._fillKeyedStructElems(fields, expr, values);
+		if (maxExplicitIdx < 0) {
+			return `new ${typeName}()`;
+		}
+		const args = values.slice(0, maxExplicitIdx + 1);
+		return `new ${typeName}(${args.join(", ")})`;
+	},
+
 	genCompositeLit(expr) {
 		const t = expr.typeExpr;
 		if (t === null) return this._genImplicitCompositeLit(expr);
 		const typeName = this.getTypeName(t);
 		if (typeName && this.structNames.has(typeName))
-			return `new ${typeName}({ ${this._genStructFields(expr.elems)} })`;
+			return this._genPositionalStructLit(typeName, expr);
 		if (typeName && this.namedWrapperNames.has(typeName))
 			return this._genNamedWrapperLit(typeName, expr);
 		if (expr.elems.some((e) => e._positionalField)) {
-			if (typeName)
-				return `new ${typeName}({ ${this._genStructFields(expr.elems)} })`;
+			if (typeName) return this._genPositionalStructLit(typeName, expr);
 		}
 		if (this._isSliceOrArrayType(t)) {
 			const elems = expr.elems
@@ -513,6 +662,23 @@ export const expressionGenMethods = {
 					e.kind === "KeyValueExpr" ? this.genExpr(e.value) : this.genExpr(e),
 				)
 				.join(", ");
+			const elemNode =
+				t.kind === "SliceType" || t.kind === "ArrayType" ? t.elem : null;
+			const elemResolved =
+				expr._type?.kind === "slice" || expr._type?.kind === "array"
+					? expr._type.elem
+					: null;
+			const typedCtor =
+				typedArrayConstructorForElem(elemResolved) ??
+				(elemNode?.name
+					? typedArrayConstructorForElem({
+							kind: "basic",
+							name: elemNode.name,
+						})
+					: null);
+			if (typedCtor) {
+				return `new ${typedCtor}([${elems}])`;
+			}
 			return `[${elems}]`;
 		}
 		if (this._isMapTypeNode(t))
@@ -522,12 +688,12 @@ export const expressionGenMethods = {
 
 	_genImplicitCompositeLit(expr) {
 		const typeName = expr._type?.name ?? expr._type?.underlying?.name;
+		if (typeName && this.structNames.has(typeName)) {
+			return this._genPositionalStructLit(typeName, expr);
+		}
 		const hasPositional = expr.elems.some((e) => e._positionalField);
 		const hasKeyed = expr.elems.some((e) => e.kind === "KeyValueExpr");
 		if (hasPositional || hasKeyed) {
-			if (typeName && this.structNames.has(typeName)) {
-				return `new ${typeName}({ ${this._genStructFields(expr.elems)} })`;
-			}
 			const fields = expr.elems
 				.map((e) => {
 					if (e._positionalField)
@@ -537,7 +703,12 @@ export const expressionGenMethods = {
 				.join(", ");
 			return `{ ${fields} }`;
 		}
-		return `[${expr.elems.map((e) => this.genExpr(e)).join(", ")}]`;
+		const elems = expr.elems.map((e) => this.genExpr(e)).join(", ");
+		if (isTypedArraySlice(expr._type)) {
+			const typedCtor = typedArrayConstructorForElem(expr._type.elem);
+			if (typedCtor) return `new ${typedCtor}([${elems}])`;
+		}
+		return `[${elems}]`;
 	},
 
 	_genNamedWrapperLit(typeName, expr) {
@@ -804,8 +975,17 @@ export const expressionGenMethods = {
 
 	_genSliceTypeConversion(expr, inner, t) {
 		const elem = t.elem?.name;
-		if (elem === "byte" || elem === "uint8")
-			return `Array.from(new TextEncoder().encode(${inner}))`;
+		if (elem === "byte" || elem === "uint8") {
+			if (this._isStringSource(expr.expr._type))
+				return `new TextEncoder().encode(${inner})`;
+			return `new Uint8Array(${inner})`;
+		}
+		const typedCtor = typedArrayConstructorForElem(
+			t.elem ? { kind: "basic", name: t.elem.name } : null,
+		);
+		if (typedCtor) {
+			return `new ${typedCtor}(${inner})`;
+		}
 		if (elem === "rune" || elem === "int32" || elem === "int") {
 			if (this._isStringSource(expr.expr._type))
 				return `Array.from(${inner}, __c => __c.codePointAt(0))`;
@@ -813,20 +993,39 @@ export const expressionGenMethods = {
 		return `Array.from(${inner})`;
 	},
 
+	_genStringConversion(srcType, inner) {
+		if (srcType && this.isIntType(srcType))
+			return `String.fromCodePoint(${inner})`;
+		if (srcType?.kind === "slice") {
+			const elem = srcType.elem?.name;
+			if (elem === "byte" || elem === "uint8")
+				return `new TextDecoder().decode(new Uint8Array(${inner}))`;
+			if (elem === "rune" || elem === "int" || elem === "int32")
+				return `Array.from(${inner}, c => String.fromCodePoint(c)).join("")`;
+		}
+		return `String(${inner})`;
+	},
+
 	_genPrimitiveConversion(expr, inner, target) {
 		switch (target) {
-			case "string": {
-				const srcType = expr.expr._type;
-				if (srcType && this.isIntType(srcType))
-					return `String.fromCodePoint(${inner})`;
-				if (srcType?.kind === "slice" && srcType.elem?.name === "int")
-					return `${inner}.map(c => String.fromCharCode(c)).join("")`;
-				return `String(${inner})`;
-			}
+			case "string":
+				return this._genStringConversion(expr.expr._type, inner);
 			case "int":
+			case "int8":
+			case "int16":
+			case "int32":
+			case "int64":
+			case "uint":
+			case "uint8":
+			case "uint16":
+			case "uint32":
+			case "uint64":
+			case "uintptr":
 			case "byte":
 			case "rune":
 				return `Math.trunc(Number(${inner}))`;
+			case "float32":
+				return `Math.fround(Number(${inner}))`;
 			case "float64":
 				return `Number(${inner})`;
 			case "bool":

package/src/codegen/index.js

@@ -52,6 +52,7 @@ export class CodeGen {
 		this.out = [];
 		this.indent = 0;
 		this.structNames = new Set();
+		this.structFields = new Map();
 		this.namedWrapperNames = new Set();
 		this.jsImports = jsImports;
 		this.bundledPackages = bundledPackages;
@@ -329,34 +330,48 @@ export class CodeGen {
 		return fields;
 	}
 
+	getStructFields(typeName) {
+		if (this.structFields.has(typeName)) return this.structFields.get(typeName);
+		if (!this.checker) return [];
+		const resolved = this.checker.types.get(typeName)?.underlying;
+		if (resolved?.kind === "struct") {
+			const fields = [];
+			for (const [name, type] of resolved.fields.entries()) {
+				fields.push({ name, zero: this.zeroValueForType(type) });
+			}
+			this.structFields.set(typeName, fields);
+			return fields;
+		}
+		return [];
+	}
+
 	_genStructConstructor(fields) {
 		if (fields.length === 0) {
 			this.line("constructor() {}");
-		} else {
-			// A field named like a type used in a default (e.g. `Project Project`)
-			// would shadow that class inside the parameter scope, so alias it.
-			const binding = (f) => {
-				const re = new RegExp(`\\b${f.name}\\b`);
-				return fields.some((o) => re.test(o.zero)) ? `${f.name}$` : f.name;
-			};
-			const params = fields
-				.map((f) => {
-					const b = binding(f);
-					return b === f.name
-						? `${f.name} = ${f.zero}`
-						: `${f.name}: ${b} = ${f.zero}`;
-				})
-				.join(", ");
-			this.line(`constructor({ ${params} } = {}) {`);
-			this.indented(() => {
-				for (const f of fields) this.line(`this.${f.name} = ${binding(f)};`);
-			});
-			this.line("}");
+			return;
 		}
+		const binding = (f) => `${f.name}$`;
+		const params = fields.map((f) => `${binding(f)} = ${f.zero}`).join(", ");
+		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; }`,
+			);
+			for (const f of fields) {
+				this.line(`this.${f.name} = ${binding(f)};`);
+			}
+		});
+		this.line("}");
 	}
 
 	genStruct(name, structTypeAst, methodDecls) {
 		const fields = this._collectStructFields(name, structTypeAst);
+		this.structFields.set(name, fields);
 		this.line(`class ${name} {`);
 		this.indented(() => {
 			this._genStructConstructor(fields);
@@ -367,6 +382,9 @@ export class CodeGen {
 			this._genEmbeddedMethodStubs(name, methodDecls);
 		});
 		this.line("}");
+		this.line(
+			`Object.defineProperty(${name}.prototype, "value", { get() { return this; }, set(v) { Object.assign(this, v); }, configurable: true });`,
+		);
 	}
 
 	_genSingleEmbedStubs(embed, declared) {

package/src/codegen/runtime.js

@@ -7,14 +7,26 @@ export const HELPER_LEN = `var __len = __len || function(a) {
   return a?.length ?? 0;
 };`;
 
-export const HELPER_APPEND =
-	"var __append = __append || function(a, ...b) { return a ? [...a, ...b] : b; };";
+export const HELPER_APPEND = `var __append = __append || function(a, ...b) {
+  if (a && ArrayBuffer.isView(a)) {
+    const res = new a.constructor(a.length + b.length);
+    res.set(a);
+    res.set(b, a.length);
+    return res;
+  }
+  return a ? [...a, ...b] : b;
+};`;
 
 export const HELPER_S = "var __s = __s || function(a) { return a || []; };";
 
 export const HELPER_EQUAL = `var __equal = __equal || function __equal(a, b) {
   if (a === b) return true;
   if (a === null || b === null) return false;
+  if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+    if (a.byteLength !== b.byteLength || a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+    return true;
+  }
   if (Array.isArray(a) && Array.isArray(b)) {
     if (a.length !== b.length) return false;
     for (let i = 0; i < a.length; i++) if (!__equal(a[i], b[i])) return false;

package/src/codegen/statements.js

@@ -171,6 +171,17 @@ export const statementGenMethods = {
 		);
 	},
 
+	_isStructDerefAssign(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 === "*" &&
+			this._isStructPointerType(l.operand?._type)
+		);
+	},
+
 	_genAssignLhsExpr(e) {
 		if (e.kind === "Ident" && e.name !== "_" && this._boxedVars.has(e.name))
 			return `${e.name}.value`;
@@ -203,6 +214,10 @@ export const statementGenMethods = {
 			this._genCommaOkTypeAssert(stmt);
 			return;
 		}
+		if (this._isStructDerefAssign(stmt)) {
+			this._genStructDerefAssign(stmt);
+			return;
+		}
 		const rhs = stmt.rhs.map((e) => this.genExpr(e));
 		this._markIndexLvalues(stmt.lhs);
 		const lhs = stmt.lhs.map((e) => this._genAssignLhsExpr(e));
@@ -226,6 +241,12 @@ export const statementGenMethods = {
 		if (okName !== "_") this.line(`${okName} = ${tmp}[1];`);
 	},
 
+	_genStructDerefAssign(stmt) {
+		const target = this.genExpr(stmt.lhs[0].operand);
+		const source = this.genExpr(stmt.rhs[0]);
+		this.line(`Object.assign(${target}, ${source});`);
+	},
+
 	_genMultiAssignWithBlanks(stmt, lhs, rhs, rhsStr) {
 		const tmp = "__t";
 		this.line(`let ${tmp} = ${rhsStr};`);
@@ -345,13 +366,21 @@ export const statementGenMethods = {
 		}
 	},
 
+	_rangeExprLimit(iterType, iteree) {
+		if (this._isIntRangeType(iterType)) return iteree;
+		if (this._isMapRangeType(iterType)) return `Object.keys(${iteree}).length`;
+		return `(${iteree} ? ${iteree}.length : 0)`;
+	},
+
 	_genRangeExprFor(stmt) {
 		if (stmt.cond._isIterator) {
 			this.genIteratorForCond(stmt);
 			return;
 		}
+		const iterType = stmt.cond.expr._type;
 		const iteree = this.genExpr(stmt.cond.expr);
-		this.line(`for (let _$ = 0; _$ < ${iteree}; _$++) {`);
+		const limit = this._rangeExprLimit(iterType, iteree);
+		this.line(`for (let _$ = 0; _$ < ${limit}; _$++) {`);
 		this.indented(() => this.genBlock(stmt.body));
 		this.line("}");
 	},
@@ -418,6 +447,63 @@ export const statementGenMethods = {
 		);
 	},
 
+	_emitSliceLoopHeader(rawIdx, iteree, isAssign, 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}++) {`,
+			);
+		}
+	},
+
+	_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}];`);
+	},
+
+	_genSliceRangeFor(stmt, iteree, lhs, isAssign) {
+		this._loopDepth = this._loopDepth ?? 0;
+		const d = this._loopDepth;
+		this._loopDepth++;
+		this._emitSliceLoopHeader(lhs[0], iteree, isAssign, d);
+		this.indented(() => {
+			this._emitSliceValAssign(lhs[0], lhs[1], isAssign, d);
+			this.genBlock(stmt.body);
+		});
+		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("}");
+	},
+
+	_genIterFor(init, iterType, iteree, lhs, body) {
+		const iterExpr = this._genRangeIterExpr(iterType, iteree, lhs);
+		const binding =
+			lhs.length === 1
+				? lhs[0] === "_"
+					? "_$"
+					: lhs[0]
+				: `[${lhs.map((n) => (n === "_" ? "_$" : n)).join(", ")}]`;
+		const kw = init.kind === "AssignStmt" ? "" : "let ";
+		this.line(`for (${kw}${binding} of ${iterExpr}) {`);
+		this.indented(() => this.genBlock(body));
+		this.line("}");
+	},
+
 	genRangeFor(stmt) {
 		const init = stmt.init;
 		const range = init.rhs[0];
@@ -429,22 +515,16 @@ export const statementGenMethods = {
 			: this.genExpr(range.expr);
 
 		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("}");
+			this._genIntRangeFor(lhs[0], iteree, stmt.body);
 			return;
 		}
-		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("}");
+
+		if (!this._isMapRangeType(iterType) && !this._isStringRangeType(iterType)) {
+			this._genSliceRangeFor(stmt, iteree, lhs, init.kind === "AssignStmt");
+			return;
+		}
+
+		this._genIterFor(init, iterType, iteree, lhs, stmt.body);
 	},
 
 	_genRangeIterExpr(iterType, iteree, lhs) {

package/src/codegen/stdlib/builder.js

@@ -28,8 +28,8 @@ const BUILDER_COMMON = {
 export const builderMethods = {
 	_genBuilderCall(typeName, method, expr) {
 		const recv = expr.func.expr;
-		const isPtr = recv._type?.kind === "pointer";
-		const base = isPtr ? `${this.genExpr(recv)}.value` : this.genExpr(recv);
+		const recvJs = this.genExpr(recv);
+		const base = `(${recvJs}?.value ?? ${recvJs})`;
 		const args = expr.args.map((a) => this.genExpr(a));
 		const isStr = typeName === "strings.Builder";
 		const table = isStr ? BUILDER_STR : BUILDER_BYTES;

package/src/codegen/stdlib/bytes.js

@@ -27,7 +27,7 @@ const BYTES_DISPATCH = {
 	Split: (a) => `${__bs}(${a[0]}).split(${__bs}(${a[1]})).map(p => ${__sb}(p))`,
 	Join: (a) => `${__sb}(${a[0]}.map(p => ${__bs}(p)).join(${__bs}(${a[1]})))`,
 	ReplaceAll: (a) =>
-		`((b, o, n) => { const r = []; let i = 0; while (i <= b.length - o.length) { if (o.every((v, j) => b[i + j] === v)) { r.push(...n); i += o.length; } else r.push(b[i++]); } return r.concat(b.slice(i)); })(${a[0]}, ${a[1]}, ${a[2]})`,
+		`((b, o, n) => { const r = []; let i = 0; while (i <= b.length - o.length) { if (o.length > 0 && o.every((v, j) => b[i + j] === v)) { r.push(...n); i += o.length; } else { r.push(b[i++]); } } for (; i < b.length; i++) r.push(b[i]); return ArrayBuffer.isView(b) ? new Uint8Array(r) : r; })(${a[0]}, ${a[1]}, ${a[2]})`,
 	TrimPrefix: (a) =>
 		`((b, p) => p.every((v, i) => b[i] === v) ? b.slice(p.length) : b.slice())(${a[0]}, ${a[1]})`,
 	TrimSuffix: (a) =>

package/src/codegen/stdlib/fmt.js

@@ -80,13 +80,12 @@ export const fmtMethods = {
 		const sprintfCall = this._buildFprintSprintfCall(fn, rest.length, restJs);
 		if (targetTypeName === "strings.Builder") {
 			const w = this.genExpr(writerArg);
-			const buf =
-				writerType?.kind === "pointer" ? `${w}.value._buf` : `${w}._buf`;
-			return `(${buf} += ${sprintfCall})`;
+			const base = `(${w}?.value ?? ${w})`;
+			return `(${base}._buf += ${sprintfCall})`;
 		}
 		if (targetTypeName === "bytes.Buffer") {
 			const w = this.genExpr(writerArg);
-			const base = writerType?.kind === "pointer" ? `${w}.value` : w;
+			const base = `(${w}?.value ?? ${w})`;
 			return `((__b,__s)=>{ __b._buf.push(...new TextEncoder().encode(__s)); })(${base}, ${sprintfCall})`;
 		}
 		// Generic io.Writer fallback — call .WriteString if available