gofront 1.9.0 → 1.9.1

package/README.md

@@ -461,7 +461,7 @@ For detailed command flags, project configuration (`gofront.json`), multi-file p
 ## Tests
 
 ```sh
-npm test                  # unit, zero-alloc perf, and example tests (~3,800 tests, no browser required)
+npm test                  # unit, zero-alloc perf, and example tests (~4,700 tests, no browser required)
 npm run test:e2e          # E2E browser tests (Playwright, headless Chromium)
 npm run bench             # Raycast, JSON, and SIMD particle benchmarks (pure JS vs hybrid WASM)
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "gofront",
-	"version": "1.9.0",
+	"version": "1.9.1",
 	"author": "Luuk van Venrooij",
 	"license": "MIT",
 	"repository": {
@@ -47,7 +47,7 @@
 		"prepare": "lefthook install"
 	},
 	"devDependencies": {
-		"@biomejs/biome": "^2.5.15",
+		"@biomejs/biome": "^2.6.6",
 		"@playwright/test": "^1.64.1",
 		"c8": "^12.0.0",
 		"esbuild": "^0.28.2",

package/src/backend/js/expressions.js

@@ -16,6 +16,7 @@ import {
 	is64BitUnsigned,
 	isAny,
 	isComplex,
+	isComplex64,
 	isTypedArraySlice,
 	typedArrayConstructorForElem,
 	typeStr,
@@ -42,8 +43,92 @@ export function comparesToNil(node, name) {
 	return someChild(node, (c) => comparesToNil(c, name));
 }
 
+// True when evaluating `node` reads through the receiver `name` (`r.f`,
+// `r[i]`, `*r`), which panics on a nil receiver anyway. Calling a method of
+// `safe` on it is not a read: that method accepts a nil receiver. A func
+// literal's body is not evaluated where it appears, so it is not searched.
+export function derefsReceiver(node, name, safe) {
+	if (Array.isArray(node))
+		return node.some((n) => derefsReceiver(n, name, safe));
+	if (!node || typeof node !== "object" || node.kind === "FuncLit")
+		return false;
+	const isRecv = (e) => e?.kind === "Ident" && e.name === name;
+	if (node.kind === "SelectorExpr" && isRecv(node.expr))
+		return !safe.has(node.field);
+	if (
+		(node.kind === "IndexExpr" || node.kind === "SliceExpr") &&
+		isRecv(node.expr)
+	)
+		return true;
+	if (node.kind === "UnaryExpr" && node.op === "*" && isRecv(node.operand))
+		return true;
+	return someChild(node, (c) => derefsReceiver(c, name, safe));
+}
+
+// True when `stmts` (a method body) reads through the receiver `name` before
+// anything could skip the read: only the statements that always run first
+// count, up to the first branch, loop, return or rebinding of `name`. A
+// method that does so panics on a nil receiver either way.
+export function derefsReceiverFirst(stmts, name, safe) {
+	return receiverPrefix(stmts, name, safe) === "deref";
+}
+
+// What one statement of a method body's unconditional prefix does with the
+// receiver: "deref" reads through it, "stop" may skip the rest (a branch,
+// loop, return, panic or rebinding of the name), "next" runs on.
+const binds = (lhs, name) =>
+	lhs.some((e) => e?.kind === "Ident" && e.name === name);
+const branches = (reads, ...parts) => (parts.some(reads) ? "deref" : "stop");
+const RECEIVER_STEP = {
+	Block: (s, _reads, name, safe) => receiverPrefix(s.stmts, name, safe),
+	IfStmt: (s, reads) => branches(reads, s.init, s.cond),
+	ForStmt: (s, reads) => branches(reads, s.init, s.cond),
+	SwitchStmt: (s, reads) => branches(reads, s.init, s.tag),
+	TypeSwitchStmt: (s, reads) => branches(reads, s.expr),
+	ReturnStmt: (s, reads) => branches(reads, s.values),
+	ExprStmt: (s, reads) => {
+		if (reads(s.expr)) return "deref";
+		const panics = s.expr?.kind === "CallExpr" && s.expr.func?.name === "panic";
+		return panics ? "stop" : "next";
+	},
+	DefineStmt: (s, reads, name) => {
+		if (reads(s.rhs) || reads(s.lhs.filter((e) => e?.kind !== "Ident")))
+			return "deref";
+		return binds(s.lhs, name) ? "stop" : "next";
+	},
+	IncDecStmt: (s, reads) => (reads(s.expr) ? "deref" : "next"),
+	VarDecl: (s, reads, name) => {
+		if (s.decls.some((d) => reads(d.value))) return "deref";
+		const named = (d) => d.names.some((n) => (n?.name ?? n) === name);
+		return s.decls.some(named) ? "stop" : "next";
+	},
+};
+RECEIVER_STEP.AssignStmt = RECEIVER_STEP.DefineStmt;
+
+// "deref" when the unconditional prefix of `stmts` reads through the
+// receiver, "stop" when something may skip the rest, else "next".
+function receiverPrefix(stmts, name, safe) {
+	const reads = (n) => derefsReceiver(n, name, safe);
+	for (const s of stmts ?? []) {
+		const step = RECEIVER_STEP[s?.kind];
+		const r = step ? step(s, reads, name, safe) : "stop";
+		if (r !== "next") return r;
+	}
+	return "next";
+}
+
 /** @typedef {import('./index.js').CodeGen} CodeGen */
 
+// True for a map, slice or array type that mentions a type parameter: one
+// that generic code boxes into an interface is tagged by its instantiated
+// type.
+export function isGenericComposite(t) {
+	return (
+		(t?.kind === "map" || t?.kind === "slice" || t?.kind === "array") &&
+		mentionsTypeParam(t)
+	);
+}
+
 // True when type `t` mentions a type parameter anywhere.
 export function mentionsTypeParam(t, depth = 0) {
 	if (!t || depth > 16) return false;
@@ -130,21 +215,6 @@ const STRICT_OPS = new Set([
 	">>",
 ]);
 
-function collectFunctionLabels(node, labels = new Set()) {
-	if (!node || typeof node !== "object") return labels;
-	if (Array.isArray(node)) {
-		for (const item of node) collectFunctionLabels(item, labels);
-		return labels;
-	}
-	if (node.kind === "LabeledStmt" && node.label) labels.add(node.label);
-	if (node.kind === "ForStmt" && node.label) labels.add(node.label);
-	for (const k of Object.keys(node)) {
-		if (k.startsWith("_")) continue;
-		collectFunctionLabels(node[k], labels);
-	}
-	return labels;
-}
-
 const NAMED_ZERO_TABLE = {
 	"simd.F32x4": [null, "Object.freeze([0, 0, 0, 0])"],
 	F32x4: [null, "Object.freeze([0, 0, 0, 0])"],
@@ -522,6 +592,41 @@ function hasTypeParamType(t) {
 	).includes('"typeParam"');
 }
 
+// Complex constant arithmetic on [re, im] pairs.
+const COMPLEX_CONST_OPS = {
+	"+": (a, b) => [a[0] + b[0], a[1] + b[1]],
+	"-": (a, b) => [a[0] - b[0], a[1] - b[1]],
+	"*": (a, b) => [a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0]],
+	"/": (a, b) => {
+		const d = b[0] * b[0] + b[1] * b[1];
+		if (d === 0) return null;
+		return [(a[0] * b[0] + a[1] * b[1]) / d, (a[1] * b[0] - a[0] * b[1]) / d];
+	},
+};
+
+// The [re, im] value of an untyped complex constant expression built from
+// literals and named constants, or null.
+function complexConstParts(e, depth = 0) {
+	if (!e || typeof e !== "object" || depth > 32) return null;
+	if (e.kind === "ParenExpr") return complexConstParts(e.expr, depth + 1);
+	// A named complex constant has no folded value: fold its initializer.
+	if (e._complexInit) return complexConstParts(e._complexInit, depth + 1);
+	if (e.kind === "ImagLit") return [0, Number(e.value)];
+	const val = e._const;
+	if (val && (val.k === "FLOAT" || val.k === "INT")) return [Number(val.v), 0];
+	if (e.kind === "UnaryExpr") return complexConstNeg(e, depth);
+	const op = e.kind === "BinaryExpr" ? COMPLEX_CONST_OPS[e.op] : null;
+	const a = op && complexConstParts(e.left, depth + 1);
+	const b = a && complexConstParts(e.right, depth + 1);
+	return b ? op(a, b) : null;
+}
+
+function complexConstNeg(e, depth) {
+	if (e.op !== "-" && e.op !== "+") return null;
+	const c = complexConstParts(e.operand, depth + 1);
+	return c && e.op === "-" ? [-c[0], -c[1]] : c;
+}
+
 export const expressionGenMethods = {
 	genExpr(expr) {
 		if (expr._asComplex && !expr._complexWrapping) {
@@ -605,14 +710,44 @@ export const expressionGenMethods = {
 			}
 		}
 		if (this._isNamedIfaceBox(expr)) return this._genNamedIfaceBoxExpr(expr);
-		if (expr._ifaceSrc && !expr._ityTagging && !this._isNamedBoxKind(expr)) {
-			const tag = this._dynTypeTag(expr._ifaceSrc);
+		if (
+			expr._ifaceSrc &&
+			!expr._tfnTagging &&
+			this._isTaggedFuncType(expr._ifaceSrc)
+		) {
+			// A value of a defined func type keeps that type in an interface.
+			expr._tfnTagging = true;
+			try {
+				this.useHelper("ifaceBox");
+				return `__tfn(${this.genExpr(expr)}, ${JSON.stringify(expr._ifaceSrc.name)})`;
+			} finally {
+				expr._tfnTagging = false;
+			}
+		}
+		if (isGenericComposite(expr._ifaceSrc) && !expr._gmapTagging) {
+			const tag = this._genericMapTag(expr._ifaceSrc);
+			if (tag) {
+				this.useHelper("ifaceBox");
+				expr._gmapTagging = true;
+				try {
+					// An array is copied before it is tagged: a copy made after
+					// `__ity` (`.map`) would drop the tag.
+					return `__ity(${this.genValueExpr(expr)}, ${tag})`;
+				} finally {
+					expr._gmapTagging = false;
+				}
+			}
+		}
+		{
+			const tag = this._ityTag(expr);
 			if (tag) {
 				this.useHelper("ifaceBox");
 				expr._ityTagging = true;
 				try {
-					const ptr = expr._ifaceSrc.kind === "pointer" ? ", true" : "";
-					return `__ity(${this.genExpr(expr)}, ${JSON.stringify(tag)}${ptr})`;
+					const ptr = this._dynTagFlags(expr._ifaceSrc);
+					// An array is copied before it is tagged: the copy is the value
+					// the interface holds, and it must keep the tag.
+					return `__ity(${this.genValueExpr(expr)}, ${JSON.stringify(tag)}${ptr})`;
 				} finally {
 					expr._ityTagging = false;
 				}
@@ -633,6 +768,10 @@ export const expressionGenMethods = {
 				expr._ifaceBoxing = false;
 			}
 		}
+		const f32 = this._genFloat32Const(expr);
+		if (f32 !== null) return f32;
+		const c64 = this._genComplex64Const(expr);
+		if (c64 !== null) return c64;
 		const folded = this._genFoldedConst(expr);
 		if (folded !== null) return folded;
 		switch (expr.kind) {
@@ -687,6 +826,31 @@ export const expressionGenMethods = {
 		return null;
 	},
 
+	// An untyped constant converted to float32 (`var c float32 = 0.01`) is
+	// emitted as its float32 value, or null when that changes nothing.
+	_genFloat32Const(expr) {
+		const val = expr._const;
+		if (!expr._f32Const || !val || (val.k !== "FLOAT" && val.k !== "INT"))
+			return null;
+		const n = Number(val.v);
+		if (!Number.isFinite(n)) return null;
+		const r = Math.fround(n);
+		if (r === n) return null;
+		return CONST_LITS.FLOAT(r);
+	},
+
+	// An untyped complex constant that takes type complex64
+	// (`var c complex64 = 1 + 0.01i`) is emitted as its folded value with
+	// float32 components, or null when it cannot be folded here.
+	_genComplex64Const(expr) {
+		if (!expr._c64Const) return null;
+		const c = complexConstParts(expr);
+		if (!c) return null;
+		const re = CONST_LITS.FLOAT(Math.fround(c[0]));
+		const im = CONST_LITS.FLOAT(Math.fround(c[1]));
+		return re === null || im === null ? null : `{ re: ${re}, im: ${im} }`;
+	},
+
 	// The literal for a folded constant expression (`1 << 40` →
 	// `1099511627776`), or null.  Integers outside ±2⁵³ emit the nearest
 	// Number and a precision warning.
@@ -906,10 +1070,22 @@ export const expressionGenMethods = {
 		}
 	},
 
+	// The type tag `expr` takes on entering an interface, or null.
+	_ityTag(expr) {
+		if (!expr._ifaceSrc || expr._ityTagging || this._isNamedBoxKind(expr))
+			return null;
+		return this._dynTypeTag(expr._ifaceSrc);
+	},
+
 	// Emits `expr` as a Go value: struct/array operands that alias existing storage are copied.
 	genValueExpr(expr) {
+		const tagged =
+			Boolean(this._ityTag(expr)) ||
+			(isGenericComposite(expr._ifaceSrc) &&
+				!expr._gmapTagging &&
+				Boolean(this._genericMapTag(expr._ifaceSrc)));
 		const js = this.genExpr(expr);
-		if (expr._ifaceBox) return js;
+		if (expr._ifaceBox || tagged) return js;
 		if (
 			!(
 				this._aggregateBase(expr._type) || this._typeParamClone(expr._type, js)
@@ -935,12 +1111,10 @@ export const expressionGenMethods = {
 
 	_withFnCtx(body, fn) {
 		const prev = this._fnCtx;
-		const prevLabels = this._functionLabels;
-		const labels = collectFunctionLabels(
-			body,
-			new Set(this._functionLabels ?? []),
-		);
-		this._functionLabels = Array.from(labels);
+		// A function starts with no JS labels in scope (see
+		// `_emitIterTargetDispatch`).
+		const prevLabels = this._jsLabels;
+		this._jsLabels = [];
 		this._fnCtx = {
 			body,
 			mut: new Map(),
@@ -954,7 +1128,7 @@ export const expressionGenMethods = {
 			fn();
 		} finally {
 			this._fnCtx = prev;
-			this._functionLabels = prevLabels;
+			this._jsLabels = prevLabels;
 		}
 	},
 
@@ -1121,9 +1295,24 @@ export const expressionGenMethods = {
 			const namedExpr = this._namedMethodExprInfo(expr);
 			if (namedExpr) return `${namedExpr.cls}.$${expr.field}`;
 			const rt = expr._methodExprRecv;
+			// `(*MyInt).M` for a pointer-receiver method of a named non-struct
+			// type: the static method takes the pointer, nil included.
+			if (rt?.kind === "pointer") {
+				const info = this._namedBoxInfo(rt.base);
+				const decl = rt.base?.methods?.get(expr.field)?._methodDecl;
+				if (info?.methods.has(expr.field) && decl?.recvPointer)
+					return `${info.cls}.$${expr.field}`;
+			}
 			const protoCls = this._ptrMethodProtoClass(rt, expr.field);
-			if (protoCls)
-				return `((recv, ...args) => ${protoCls}.prototype.${expr.field}.call(recv, ...args))`;
+			if (protoCls) {
+				// A value-receiver method reads `*recv`, which panics on nil.
+				let recv = "recv";
+				if (rt.base.methods.get(expr.field)?._ptrRecv === false) {
+					this.useHelper("nilCall");
+					recv = "__nilcall(recv)";
+				}
+				return `((recv, ...args) => ${protoCls}.prototype.${expr.field}.call(${recv}, ...args))`;
+			}
 			return `((recv, ...args) => recv.${expr.field}(...args))`;
 		}
 		const namedValue = this._genNamedMethodValue(expr);
@@ -1466,7 +1655,7 @@ export const expressionGenMethods = {
 			if (!expr._lvalue) return this._genMapIndexExpr(expr, base, idx);
 			return `${this._genMapWriteBase(base)}[${idx}]`;
 		}
-		if (this._is64BitInt(expr.index?._type)) idx = `Number(${idx})`;
+		idx = this._asIndexNumber(idx, expr.index?._type);
 		const checked = this._genStrictIndex(expr, base, idx);
 		if (checked) return checked;
 		if (this._isStringExprType(exprType) && !expr._lvalue)
@@ -1523,14 +1712,10 @@ export const expressionGenMethods = {
 	_genSliceExpr(expr) {
 		const base = this.genExpr(expr.expr);
 		const lo = expr.low
-			? this._is64BitInt(expr.low._type)
-				? `Number(${this.genExpr(expr.low)})`
-				: this.genExpr(expr.low)
+			? this._asIndexNumber(this.genExpr(expr.low), expr.low._type)
 			: "0";
 		const hi = expr.high
-			? this._is64BitInt(expr.high._type)
-				? `Number(${this.genExpr(expr.high)})`
-				: this.genExpr(expr.high)
+			? this._asIndexNumber(this.genExpr(expr.high), expr.high._type)
 			: "undefined";
 		if (this._isStringExprType(expr.expr._type))
 			return expr.high ? `${base}.slice(${lo}, ${hi})` : `${base}.slice(${lo})`;
@@ -1545,7 +1730,7 @@ export const expressionGenMethods = {
 		if (expr._selfReslice && !isTypedArraySlice(expr.expr._type))
 			return `__reslice(${base}, ${lo}, ${hi})`;
 		const max = expr.max
-			? `, ${this._is64BitInt(expr.max._type) ? `Number(${this.genExpr(expr.max)})` : this.genExpr(expr.max)}`
+			? `, ${this._asIndexNumber(this.genExpr(expr.max), expr.max._type)}`
 			: "";
 		return `__slice(${base}, ${lo}, ${hi}${max})`;
 	},
@@ -1667,6 +1852,10 @@ export const expressionGenMethods = {
 				[...named.underlying.methods.keys()],
 				this._unwrapIsMulti(named.underlying.methods.get("Unwrap")),
 			);
+		if (this._isTaggedFuncType(named)) {
+			this.useHelper("ifaceBox");
+			return `__isty(${val}, ${JSON.stringify(name)}, "namedfunc")`;
+		}
 		if (this._isNamedComposite(named)) {
 			this.useHelper("ifaceBox");
 			return `__isty(${val}, ${JSON.stringify(name)}, "named")`;
@@ -1727,7 +1916,10 @@ export const expressionGenMethods = {
 			this.useHelper("ifaceBox");
 			return `__unnil(${val})`;
 		}
-		if (typeNode?._assertType?.kind === "slice") {
+		if (
+			typeNode?._assertType?.kind === "slice" ||
+			this._isNamedSliceTypeNode(typeNode)
+		) {
 			// A nil slice in an interface is a tagged empty array.
 			this.useHelper("ifaceBox");
 			return `__unnil(${val})`;
@@ -1739,6 +1931,16 @@ export const expressionGenMethods = {
 		return factory ? `(${factory}?.u ? ${val}.__gfUnbox() : ${val})` : val;
 	},
 
+	// A type name that denotes a defined slice type (`type S []int`).
+	_isNamedSliceTypeNode(typeNode) {
+		if (typeNode?.kind !== "TypeName") return false;
+		const named = this.checker?.types.get(typeNode.name);
+		return (
+			this._isNamedComposite(named) &&
+			this._underlyingOf(named)?.kind === "slice"
+		);
+	},
+
 	_isStructPtrTypeNode(typeNode) {
 		const base = typeNode?.kind === "PointerType" ? typeNode.base : null;
 		const name =
@@ -1793,6 +1995,10 @@ export const expressionGenMethods = {
 			targetType?.kind === "named" ? targetType.underlying : targetType;
 		if (base?.kind === "map" && this._isNilLiteral(expr.args[0]))
 			return this._nilMapZero();
+		if (this._isTaggedFuncType(targetType)) {
+			this.useHelper("ifaceBox");
+			return `__tfn(${arg}, ${JSON.stringify(targetType.name)})`;
+		}
 		if (
 			targetType?.kind === "named" &&
 			base?.kind === "basic" &&
@@ -1856,7 +2062,13 @@ export const expressionGenMethods = {
 			// prototype so a nil `this` reaches it instead of a TypeError.
 			const recv = this.genExpr(expr.func.expr);
 			const rest = this._genCallArgs(expr);
-			return `${nilSafe}.prototype.${expr.func.field}.call(${rest ? `${recv}, ${rest}` : recv})`;
+			const m = expr.func.field;
+			const viaProto = (r) =>
+				`${nilSafe}.prototype.${m}.call(${rest ? `${r}, ${rest}` : r})`;
+			// A non-nil variable keeps the direct (faster) call.
+			if (/^[\w$]+$/.test(recv))
+				return `(${recv} != null ? ${recv}.${m}(${rest}) : ${viaProto(recv)})`;
+			return viaProto(recv);
 		}
 
 		expr.func._callee = true;
@@ -1875,11 +2087,27 @@ export const expressionGenMethods = {
 		const factory = this._typeParamZeroFactory(expr.func.expr._type.name);
 		if (!factory) return null;
 		this.useHelper("generics");
-		const recv = `__tbox(${factory}, ${this.genExpr(expr.func.expr)})`;
+		let recv = `__tbox(${factory}, ${this.genExpr(expr.func.expr)})`;
+		// `P(&v).M()` with `P interface{ *T; M() }`: a pointer to a boxed
+		// type-parameter variable is the box, so reach the value it holds.
+		if (this._hasPointerTypeSet(expr.func.expr._type))
+			recv = `((__r) => typeof __r?.${expr.func.field} === "function" ? __r : __r?.value)(${recv})`;
 		const args = this._genCallArgs(expr);
 		return `${recv}.${expr.func.field}(${args})`;
 	},
 
+	// Whether type parameter `tp` is constrained to a single `*T` type-set term.
+	_hasPointerTypeSet(tp) {
+		const c = tp.constraint;
+		const iface = c?.kind === "named" ? c.underlying : c;
+		const terms = iface?.unionConstraint?.terms;
+		return (
+			terms?.length === 1 &&
+			(terms[0].resolved?.kind === "pointer" ||
+				terms[0].type?.kind === "PointerType")
+		);
+	},
+
 	// `(*S)(p).M()` where `p` points at another struct type: the JS object keeps
 	// its own class, so call S's prototype method on it.
 	_convertedPointerMethodCall(expr) {
@@ -1918,9 +2146,17 @@ export const expressionGenMethods = {
 		if (func?.kind !== "SelectorExpr" || func._isMethodExpr) return null;
 		const t = func.expr?._type;
 		if (t?.kind !== "pointer" || t.base?.kind !== "named") return null;
-		const cls = t.base.name;
-		if (t.base.typeArgs?.length) return null;
-		if (this.nilSafeMethods?.has(`${cls}.${func.field}`)) return cls;
+		// An instance of a generic struct (`Gen[int]`) shares its class.
+		const cls = t.base.typeArgs?.length
+			? this._structClassName(t.base)
+			: t.base.name;
+		if (!cls) return null;
+		if (
+			t.base.underlying?.kind === "struct" &&
+			!this._promotedPath(func) &&
+			this.nilSafeMethods?.has(`${cls}.${func.field}`)
+		)
+			return cls;
 		// A Go-source stdlib type (`Buffer$$bytes`) is declared outside this
 		// package: its method decl tells whether it tests the receiver for nil.
 		const decl = cls.includes("$$")
@@ -2066,9 +2302,7 @@ export const expressionGenMethods = {
 			// TypeError with a different message.
 			this.useHelper("nilCall");
 			const recv = this.genExpr(expr.func.expr);
-			const args = expr.args
-				.map((a) => (a._spread ? `...${this.genExpr(a)}` : this.genExpr(a)))
-				.join(", ");
+			const args = this._genCallArgs(expr);
 			return `__nilcall(${recv}).${expr.func.field}(${args})`;
 		}
 		return undefined;
@@ -2223,8 +2457,7 @@ export const expressionGenMethods = {
 		const resolvedKind = madeType?.kind;
 		if (typeNode.kind === "SliceType" || resolvedKind === "slice") {
 			let n = expr.args[1] ? this.genExpr(expr.args[1]) : "0";
-			if (expr.args[1] && this._is64BitInt(expr.args[1]._type))
-				n = `Number(${n})`;
+			if (expr.args[1]) n = this._asIndexNumber(n, expr.args[1]._type);
 			// A negative length or capacity panics with Go's message.
 			n = this._guardMakeSize(n, "__mkn");
 			const elemNode = typeNode.kind === "SliceType" ? typeNode.elem : null;
@@ -2240,8 +2473,8 @@ export const expressionGenMethods = {
 			// make([]T, n, cap) allocates cap elements and returns a view of
 			// the first n (`__mkslice`), so append within cap shares them.
 			let capArg = expr.args[2] ? this.genExpr(expr.args[2]) : null;
-			if (capArg && expr.args[2] && this._is64BitInt(expr.args[2]._type))
-				capArg = `Number(${capArg})`;
+			if (capArg && expr.args[2])
+				capArg = this._asIndexNumber(capArg, expr.args[2]._type);
 			if (capArg) {
 				this.useHelper("slice");
 				capArg = this._guardMakeSize(capArg, "__mkc");
@@ -3025,22 +3258,47 @@ export const expressionGenMethods = {
 		const r = this._genComplexOperand(expr.right);
 		switch (expr.op) {
 			case "+":
-				return `{ re: ${l}.re + ${r}.re, im: ${l}.im + ${r}.im }`;
 			case "-":
-				return `{ re: ${l}.re - ${r}.re, im: ${l}.im - ${r}.im }`;
 			case "*":
-				this.useHelper("cmul");
-				return `__cmul(${l}, ${r})`;
 			case "/":
-				this.useHelper("cdiv");
-				return `__cdiv(${l}, ${r})`;
+				return this._genComplexArith(expr.op, l, r, isComplex64(expr._type));
 			case "==":
-				return `(${l}.re === ${r}.re && ${l}.im === ${r}.im)`;
+				return this._genComplexEquality("===", "&&", l, r);
 			case "!=":
-				return `(${l}.re !== ${r}.re || ${l}.im !== ${r}.im)`;
+				return this._genComplexEquality("!==", "||", l, r);
 		}
 	},
 
+	// `l == r` / `l != r` on complex operands: each component reads both
+	// operands, so an operand that calls a function is bound once first.
+	_genComplexEquality(cmp, join, l, r) {
+		const pure = (js) => !js.includes("(");
+		if (pure(l) && pure(r))
+			return `(${l}.re ${cmp} ${r}.re ${join} ${l}.im ${cmp} ${r}.im)`;
+		return `((__a, __b) => __a.re ${cmp} __b.re ${join} __a.im ${cmp} __b.im)(${l}, ${r})`;
+	},
+
+	// `l op r` for complex operands.  A complex64 result has float32
+	// components, as in Go (where the arithmetic runs in float64 and the
+	// result is narrowed).
+	_genComplexArith(op, l, r, is64) {
+		let re;
+		let im;
+		let call = null;
+		if (op === "+" || op === "-") {
+			re = `${l}.re ${op} ${r}.re`;
+			im = `${l}.im ${op} ${r}.im`;
+		} else {
+			const helper = op === "*" ? "cmul" : "cdiv";
+			this.useHelper(helper);
+			call = `__${helper}(${l}, ${r})`;
+		}
+		if (!is64) return call ?? `{ re: ${re}, im: ${im} }`;
+		if (call)
+			return `((__z) => ({ re: Math.fround(__z.re), im: Math.fround(__z.im) }))(${call})`;
+		return `{ re: Math.fround(${re}), im: Math.fround(${im}) }`;
+	},
+
 	_genBinaryExpr(expr) {
 		if (
 			isComplex(expr._type) ||
@@ -3507,6 +3765,19 @@ export const expressionGenMethods = {
 		return is64BitInt(t);
 	},
 
+	// Whether a value of type `t` can be a BigInt at run time: a 64-bit
+	// integer, or a type parameter whose type set holds one (`~int | ~int64`).
+	_mayBeBigInt(t) {
+		if (t?.kind !== "typeParam") return is64BitInt(t);
+		const terms = this.checker?._constraintTerms(t.constraint, new Set());
+		return terms?.some(is64BitInt) === true;
+	},
+
+	// `code` as a JS number for an index, slice bound or `make` size.
+	_asIndexNumber(code, t) {
+		return this._mayBeBigInt(t) ? `Number(${code})` : code;
+	},
+
 	// float32 arithmetic rounds through Math.fround and arithmetic on a type
 	// parameter wraps for the instantiated type (`__tar`) in every package kind.
 	_isFloat32(t) {