gofront 1.8.0 → 1.9.1

package/src/backend/js/index.js

@@ -20,67 +20,63 @@
 import {
 	computeEmbeddedStubs,
 	hasDirectRecover,
-	isReferenceType,
 	markInBoundsIndexes,
+	markRedundantNilChecks,
 	normalizeDefers,
 	scanAddressTaken,
+	splitForwardedTuples,
+	takesElementAddress,
 } from "../../lower/index.js";
 import { orderPackageInits } from "../../typechecker/init-order.js";
 import {
 	BROWSER_GLOBALS,
 	isComplex,
+	isMethodPromotedOverField,
 	isNumeric,
 } from "../../typechecker/types.js";
-import { comparesToNil, expressionGenMethods } from "./expressions.js";
+import { goTypeName } from "../shared/fmt-types.js";
+import {
+	unicodeIsJs,
+	unicodeToLowerJs,
+	unicodeToUpperJs,
+} from "../shared/host-unicode.js";
+import {
+	comparesToNil,
+	derefsReceiverFirst,
+	expressionGenMethods,
+} from "./expressions.js";
 import {
 	HELPER_APPEND,
-	HELPER_BASE64,
-	HELPER_BINARY,
 	HELPER_BOUNDS,
 	HELPER_CDIV,
 	HELPER_CMUL,
-	HELPER_CRYPTO_RAND,
-	HELPER_DURATION,
 	HELPER_EQUAL,
 	HELPER_ERROR,
-	HELPER_ERROR_AS,
-	HELPER_ERROR_IS,
-	HELPER_ERROR_JOIN,
 	HELPER_GENERICS,
 	HELPER_GEQ,
-	HELPER_HEX,
 	HELPER_IFACE_BOX,
-	HELPER_IFD,
 	HELPER_IFEQ,
 	HELPER_INJECT_STYLES,
-	HELPER_IO_EOF,
-	HELPER_JSON,
+	HELPER_JSONRT,
 	HELPER_LEN,
+	HELPER_MKLEN,
 	HELPER_NIL_CALL,
 	HELPER_NIL_MAP,
 	HELPER_NM,
-	HELPER_OS,
 	HELPER_PANIC,
-	HELPER_PATH_CLEAN,
-	HELPER_PATH_ERROR,
 	HELPER_PTREQ,
+	HELPER_PUSHS,
+	HELPER_RUNESTR,
 	HELPER_S,
 	HELPER_SCLONE,
-	HELPER_SHA256,
 	HELPER_SHIFT,
 	HELPER_SIMD,
 	HELPER_SLICE,
-	HELPER_SORT_SLICE,
-	HELPER_SPRINT,
-	HELPER_SPRINTF,
-	HELPER_STRCONV,
-	HELPER_STRCONV_ERROR,
 	HELPER_STRUCT_KEY,
 	HELPER_SV,
-	HELPER_SYNC,
-	HELPER_TESTING,
-	HELPER_TIME_FMT,
-	HELPER_TIME_PARSE,
+	HELPER_TO64,
+	HELPER_U8DEC,
+	HELPER_U8ENC,
 	HELPER_VA,
 	HELPER_VCLONE,
 } from "./runtime.js";
@@ -142,15 +138,19 @@ const jsBindingName = (n) =>
 // `this.useHelper(name)`; `_prependHelpers` emits every marked entry.
 const HELPER_MAP = [
 	["len", HELPER_LEN],
+	["u8enc", HELPER_U8ENC],
+	["u8dec", HELPER_U8DEC],
 	["sv", HELPER_SV],
 	["slice", HELPER_SLICE],
+	["mklen", HELPER_MKLEN],
+	["runestr", HELPER_RUNESTR],
 	["append", HELPER_APPEND],
 	["sliceGuard", HELPER_S],
+	["pushs", HELPER_PUSHS],
 	["sclone", HELPER_SCLONE],
 	["va", HELPER_VA],
 	["vclone", HELPER_VCLONE],
 	["ifaceBox", HELPER_IFACE_BOX],
-	["ifd", HELPER_IFD],
 	["equal", HELPER_EQUAL],
 	["geq", HELPER_GEQ],
 	["ptreq", HELPER_PTREQ],
@@ -159,42 +159,87 @@ const HELPER_MAP = [
 	["cdiv", HELPER_CDIV],
 	["panicRt", HELPER_PANIC],
 	["shift", HELPER_SHIFT],
+	["to64", HELPER_TO64],
 	["nilCall", HELPER_NIL_CALL],
 	["bounds", HELPER_BOUNDS],
 	["nilMap", HELPER_NIL_MAP],
 	["nm", HELPER_NM],
 	["structKey", HELPER_STRUCT_KEY],
 	["generics", HELPER_GENERICS],
-	["sprintf", HELPER_SPRINTF],
-	["sprint", HELPER_SPRINT],
 	["error", HELPER_ERROR],
-	["errorIs", HELPER_ERROR_IS],
-	["errorAs", HELPER_ERROR_AS],
-	["errorJoin", HELPER_ERROR_JOIN],
-	["strconvError", HELPER_STRCONV_ERROR],
-	["pathError", HELPER_PATH_ERROR],
-	["ioEOF", HELPER_IO_EOF],
-	["os", HELPER_OS],
-	["strconv", HELPER_STRCONV],
-	["pathClean", HELPER_PATH_CLEAN],
-	["sortSlice", HELPER_SORT_SLICE],
-	["timeFmt", HELPER_TIME_FMT],
-	["timeParse", HELPER_TIME_PARSE],
-	["duration", HELPER_DURATION],
-	["testing", HELPER_TESTING],
-	["sync", HELPER_SYNC],
-	["cryptoRand", HELPER_CRYPTO_RAND],
-	["sha256", HELPER_SHA256],
-	["binary", HELPER_BINARY],
-	["hex", HELPER_HEX],
-	["base64", HELPER_BASE64],
-	["json", HELPER_JSON],
+	["jsonrt", HELPER_JSONRT],
 	["simd", HELPER_SIMD],
 ];
 
 // JS bodies of `//gofront:intrinsic` functions (names: INTRINSICS in
 // typechecker/types.js).  The WASM backend keeps their empty body.
-const JS_INTRINSICS = {};
+const JS_INTRINSICS = {
+	rand_source: () => "return Math.random();",
+	time_now: () =>
+		'return BigInt(Math.floor(typeof globalThis.__GOFRONT_CLOCK === "function" ? globalThis.__GOFRONT_CLOCK() : Date.now())) * 1000000n;',
+	time_sleep: ([ns]) =>
+		`await new Promise((r) => setTimeout(r, Number(${ns}) / 1000000));`,
+	time_zone_offset: ([unix]) =>
+		`return (-new Date(Number(${unix}) * 1000).getTimezoneOffset() * 60) | 0;`,
+	// os: node writes straight to the stream; other hosts print whole lines
+	// (console.log adds the newline), buffering the partial line.
+	os_write: ([fd, s]) =>
+		`if (typeof process !== "undefined" && process?.stdout?.write) { (${fd} === 2 && process.stderr?.write ? process.stderr : process.stdout).write(${s}); return; } let b = (globalThis.__os_buf ?? "") + ${s}; const nl = b.lastIndexOf("\\n"); if (nl >= 0) { (${fd} === 2 && typeof console.error === "function" ? console.error : console.log)(b.slice(0, nl)); b = b.slice(nl + 1); } globalThis.__os_buf = b;`,
+	os_exit: ([code]) =>
+		`if (typeof process !== "undefined" && process?.exit) process.exit(${code}); throw new Error("os.Exit(" + ${code} + ")");`,
+	os_getenv: ([key]) =>
+		`return (typeof process !== "undefined" && process?.env ? process.env : (globalThis.__os_env ??= {}))[${key}] ?? "";`,
+	os_setenv: ([key, value]) =>
+		`(typeof process !== "undefined" && process?.env ? process.env : (globalThis.__os_env ??= {}))[${key}] = ${value};`,
+	unicode_is: ([r, class_]) => unicodeIsJs(r, class_),
+	unicode_to_upper: ([r]) => unicodeToUpperJs(r),
+	unicode_to_lower: ([r]) => unicodeToLowerJs(r),
+	crypto_rand_u32: () =>
+		'const c = typeof crypto !== "undefined" ? crypto : globalThis.crypto; if (c?.getRandomValues) return c.getRandomValues(new Uint32Array(1))[0]; return Math.floor(Math.random() * 4294967296);',
+	// A number per object for the whole run, from 1 (pointers print as 0x<id>).
+	testing_nanotime: () => "return BigInt(Math.round(performance.now() * 1e6));",
+	testing_match: ([pattern, s]) =>
+		`const c = (globalThis.__testRe ??= new Map()); let re = c.get(${pattern}); if (!re) { re = new RegExp(${pattern}); c.set(${pattern}, re); } return re.test(${s});`,
+	testing_call: ([f, t]) =>
+		`const r = ${f}(${t}); return r && typeof r.then === "function" ? r : null;`,
+	fmt_ptr_id: ([v]) =>
+		`if (${v} === null || ${v} === undefined || (typeof ${v} !== "object" && typeof ${v} !== "function")) return 0n; const t = (globalThis.__fmtptr ??= { m: new WeakMap(), n: 1 }); let id = t.m.get(${v}); if (!id) { id = t.n++; t.m.set(${v}, id); } return BigInt(id);`,
+	math_float64bits: ([f]) =>
+		`const $b = new ArrayBuffer(8); new Float64Array($b)[0] = ${f}; return new BigUint64Array($b)[0];`,
+	math_float64frombits: ([u]) =>
+		`const $b = new ArrayBuffer(8); new BigUint64Array($b)[0] = BigInt(${u}); return new Float64Array($b)[0];`,
+	math_float32bits: ([f]) =>
+		`const $b = new ArrayBuffer(4); new Float32Array($b)[0] = ${f}; return new Uint32Array($b)[0];`,
+	math_float32frombits: ([u]) =>
+		`const $b = new ArrayBuffer(4); new Uint32Array($b)[0] = ${u} >>> 0; return new Float32Array($b)[0];`,
+	math_mod: ([x, y]) => `return ${x} % ${y};`,
+	...Object.fromEntries(
+		[
+			"sin",
+			"cos",
+			"tan",
+			"asin",
+			"acos",
+			"atan",
+			"sinh",
+			"cosh",
+			"tanh",
+			"exp",
+			"expm1",
+			"log",
+			"log1p",
+			"log2",
+			"log10",
+			"cbrt",
+		].map((f) => [`math_${f}`, ([x]) => `return Math.${f}(${x});`]),
+	),
+	...Object.fromEntries(
+		["atan2", "pow", "hypot"].map((f) => [
+			`math_${f}`,
+			([x, y]) => `return Math.${f}(${x}, ${y});`,
+		]),
+	),
+};
 
 export class CodeGen {
 	// jsImports:       Map<importPath, string[]> — npm package imports to emit at top of file
@@ -209,6 +254,7 @@ export class CodeGen {
 		this.checker = checker;
 		this.target = options.target ?? "js";
 		this.strict = Boolean(options.strict || this.target === "both");
+		this.natives = options.natives !== false; // replace native calls with host code
 		this.out = [];
 		this.indent = 0;
 		this.structNames = new Set();
@@ -224,9 +270,9 @@ export class CodeGen {
 		this._srcMappings = []; // { genLine, srcLine, srcFileIdx } for source map
 		this._currentSrcFileIdx = 0; // updated as each top-level decl is generated
 		this._boxedVars = new Set(); // address-taken scalar variables that need boxing
-		this._jsonCodecs = new Map(); // memoized JSON encoders and decoders
-		this._localTypeNames = new Set(); // function-local type declarations
-		this._jsonAnyUsed = false; // program calls json.Marshal / Encoder.Encode
+		this._hoistedLocals = new Set(); // function-local classes the json codecs name
+		this._hasJsonCodecs = false;
+		this._jsonCodecFileIdx = -1;
 		// Runtime helper usage tracking — only emit helpers that are actually used
 		this._helpers = new Set();
 		// Per-function context for Go value semantics (see _withFnCtx)
@@ -328,10 +374,15 @@ export class CodeGen {
 		this._precisionWarned = new Set();
 		// Defer lowering (argument/receiver hoisting, recover-target marking) is
 		// idempotent and owned by the backends: the wasm path runs it via
-		// `lower()`, the JS path here.
+		// `lower()`, the JS path here.  So is splitting multi-value calls
+		// forwarded into interfaces into temps.
+		splitForwardedTuples(program);
 		normalizeDefers(program);
 		// Strict mode: index checks the loop shape proves unnecessary are elided.
-		if (this.strict) markInBoundsIndexes(program);
+		if (this.strict) {
+			markInBoundsIndexes(program);
+			markRedundantNilChecks(program, (d) => comparesToNil(d.body, d.recvName));
+		}
 		if (program._filename) this._srcFileNames = [program._filename];
 		// Ensure _pkgName is set on all decls (generateAll sets it for
 		// multi-file; for single-file compiles we derive it from the AST).
@@ -343,16 +394,22 @@ export class CodeGen {
 			}
 		}
 		this._renameReservedIdents(program.decls);
+		this._elemAddrTaken =
+			takesElementAddress(program.decls) ||
+			this.checker?.depElemAddrTaken === true;
 		this._boxedGlobals = this._collectBoxedGlobals(program);
 		this._boxedVars = new Set(this._boxedGlobals);
 		this._collectResliceNames(program);
-		this._jsonAnyUsed = this._usesJsonAnyMarshal(program.decls);
 		const methods = this._collectDecls(program);
 		this._emitJsImports();
 		this._emitTypeDecls(program, methods);
+		// Package variable initialisers may call functions that declare local
+		// structs, so the hoisted classes are declared before them.
+		const hoistedAt = this.out.length;
+		if (this._hasJsonCodecs) this.line("");
 		this._emitVarConstDecls(program);
 		const initNames = this._emitFuncDecls(program);
-		this._emitJsonCodecs();
+		this._emitHoistedLocals(hoistedAt);
 		this._callInitAndMain(initNames, program, isTest);
 		const prependedLines = this._prependHelpers(isTest);
 		return this._finalizeOutput(prependedLines);
@@ -467,6 +524,7 @@ export class CodeGen {
 		FuncLit: "_renameSignature",
 		TemplDecl: "_renameSignature",
 		TemplExpr: "_renameTemplExprNode",
+		TemplChildren: "_renameTemplExprNode",
 		TemplComponent: "_renameTemplExprNode",
 		TemplIf: "_renameTemplExprNode",
 		TemplSwitch: "_renameTemplExprNode",
@@ -535,13 +593,35 @@ export class CodeGen {
 				const name = d.recvType.name;
 				if (!methods.has(name)) methods.set(name, []);
 				methods.get(name).push(d);
-				if (d.recvPointer && comparesToNil(d.body, d.recvName))
-					this.nilSafeMethods.add(`${name}.${d.name}`);
 			}
 		}
+		this._markNilSafeMethods(methods);
 		return methods;
 	}
 
+	// Pointer-receiver methods that can run with a nil receiver: they compare
+	// it with nil, or do not read through it before anything could skip the
+	// read (a method that does panics on nil either way, so it keeps the
+	// faster direct call). Calls to these go through the prototype (see
+	// _nilSafeMethodClass).
+	_markNilSafeMethods(methods) {
+		for (const [name, decls] of methods) {
+			const safe = new Set();
+			const ptr = decls.filter((d) => d.recvPointer);
+			for (const d of ptr) safe.add(d.name);
+			for (let changed = true; changed; ) {
+				changed = false;
+				for (const d of ptr) {
+					if (!safe.has(d.name) || comparesToNil(d.body, d.recvName)) continue;
+					if (!derefsReceiverFirst(d.body?.stmts, d.recvName, safe)) continue;
+					safe.delete(d.name);
+					changed = true;
+				}
+			}
+			for (const m of safe) this.nilSafeMethods.add(`${name}.${m}`);
+		}
+	}
+
 	_collectNamedWrappers(program, methods) {
 		for (const d of program.decls) {
 			if (
@@ -567,37 +647,15 @@ export class CodeGen {
 		this._helpers.add(name);
 		if (name === "ifeq" || name === "geq") this._helpers.add("equal");
 		if (name === "geq") this._helpers.add("ifeq");
-		if (
-			name === "strconvError" ||
-			name === "pathError" ||
-			name === "ioEOF" ||
-			name === "base64" ||
-			name === "hex" ||
-			name === "json"
-		) {
-			this._helpers.add("error");
-		}
 		if (name === "json") {
-			this.useHelper("base64");
-		}
-		if (name === "os") {
-			this.useHelper("ioEOF");
 			this._helpers.add("error");
 		}
+		if (name === "panicRt") this._helpers.add("error");
 		if (name === "append") this.useHelper("slice");
-		if (name === "sprint") this._helpers.add("sprintf");
 		if (name === "slice") this._helpers.add("sv");
-		if (name === "binary") {
-			this.useHelper("ioEOF");
-			this._helpers.add("error");
-		}
 	}
 
-	_prependHelpers(isTest = false) {
-		if (isTest || this._helpers.has("testing")) {
-			this.useHelper("sprintf");
-			this.useHelper("testing");
-		}
+	_prependHelpers(_isTest = false) {
 		const helpers = [];
 		if (this.collectedCss.length > 0) helpers.push(HELPER_INJECT_STYLES);
 		for (const [name, src] of HELPER_MAP) {
@@ -616,6 +674,8 @@ export class CodeGen {
 	// Annotates each decl with its source file index before merging.
 	generateAll(programs, options = {}) {
 		this._srcFileNames = programs.map((p) => p._filename ?? null);
+		this._jsonCodecFileIdx = programs.findIndex((p) => p._generated);
+		this._hasJsonCodecs = this._jsonCodecFileIdx >= 0;
 		for (let i = 0; i < programs.length; i++) {
 			for (const decl of programs[i].decls) {
 				decl._srcFileIdx = i;
@@ -632,8 +692,13 @@ export class CodeGen {
 	// Records a non-fatal diagnostic at `node` ("main.go at line 3:5: msg").
 	_warn(msg, node) {
 		const file = this._srcFileNames[this._currentSrcFileIdx ?? 0];
-		const line = node?.line ?? node?._line;
-		const at = line ? `at line ${line}:${node.col ?? node._col ?? 1}` : "";
+		// Binary and unary expressions carry no position of their own: use the
+		// leftmost operand that does.
+		let pos = node;
+		while (pos && !(pos.line ?? pos._line))
+			pos = pos.left ?? pos.operand ?? pos.expr;
+		const line = pos?.line ?? pos?._line;
+		const at = line ? `at line ${line}:${pos.col ?? pos._col ?? 1}` : "";
 		const loc = [file, at].filter(Boolean).join(" ");
 		this.warnings.push(loc ? `${loc}: ${msg}` : msg);
 	}
@@ -646,14 +711,6 @@ export class CodeGen {
 		return this._srcMappings;
 	}
 
-	// Returns a source map JSON string for the last generate() call.
-	// sources: string[] of source filenames (relative to the output file).
-	// sourcesContent: string[] of original file contents (embedded for DevTools breakpoints).
-	getSourceMap(sources, sourcesContent) {
-		const srcArray = Array.isArray(sources) ? sources : [sources];
-		return buildSourceMap(srcArray, this._srcMappings, sourcesContent);
-	}
-
 	// ── Type declarations ────────────────────────────────────────
 
 	// `type S Base` with Base a struct declared in this package: the struct
@@ -665,15 +722,42 @@ export class CodeGen {
 		let t = decl.type;
 		for (let depth = 0; depth < 16 && t; depth++) {
 			if (t.kind === "StructType") return t;
+			// `type S Base[int]`: the fields come from the checked type.
+			if (t.kind === "GenericTypeName" || t.kind === "InstantiationExpr")
+				return { kind: "StructType", fields: [] };
 			if (t.kind !== "TypeName" && t.kind !== "Ident") return null;
 			const next = this._typeDeclsByName?.get(t.name);
-			if (!next || next.isAlias) return null;
+			if (!next) return null;
 			t = next.type;
 		}
 		return null;
 	}
 
 	genTypeDeclWithMethods(decl, methodDecls) {
+		this._genTypeDeclBody(decl, methodDecls);
+		this._genUnhashableMark(decl.name);
+	}
+
+	// Marks a defined type Go cannot hash so `__ik` can name it in the panic
+	// of an interface-keyed map insert: a struct class carries `__uh`, a
+	// defined slice or map type registers its interface tag.
+	_genUnhashableMark(name) {
+		const t = this.checker?.types.get(name);
+		if (t?.kind !== "named" || t.typeParams?.length || t.typeArgs?.length)
+			return;
+		if (!this._isUnhashableType(t)) return;
+		const goName = JSON.stringify(goTypeName(t));
+		if (this.structNames.has(name)) {
+			this.line(
+				`Object.defineProperty(${name}, "__uh", { value: ${goName} });`,
+			);
+		} else if (this._isNamedComposite(t)) {
+			this.useHelper("structKey");
+			this.line(`__uht.set(${JSON.stringify(name)}, ${goName});`);
+		}
+	}
+
+	_genTypeDeclBody(decl, methodDecls) {
 		const definedStruct =
 			decl.type.kind === "StructType" ? null : this._definedStructAst(decl);
 		if (decl.type.kind === "StructType") {
@@ -715,6 +799,7 @@ export class CodeGen {
 					);
 				}
 			}
+			this._tagMultiUnwrap(methodDecls);
 		});
 		this.line("}");
 		// Box for *T in an interface. It also proxies `.value` to the pointer, so
@@ -732,10 +817,20 @@ export class CodeGen {
 					`${m.name}(...__a) { return ${name}.$${m.name}(${recv}, ...__a); }`,
 				);
 			}
+			this._tagMultiUnwrap(methodDecls);
 		});
 		this.line("}");
 	}
 
+	// `Unwrap() []error` on a box class is told apart from `Unwrap() error`
+	// in type tests, as on struct classes.
+	_tagMultiUnwrap(methodDecls) {
+		const unwrap = methodDecls.find(
+			(m) => m.name === "Unwrap" && m.returnType?.kind === "SliceType",
+		);
+		if (unwrap) this.line("static { this.prototype.Unwrap.__multi = true; }");
+	}
+
 	_namedBoxField(underlying) {
 		if (underlying?.kind === "func") return "_fn";
 		if (underlying?.kind === "map") return "_map";
@@ -776,8 +871,11 @@ export class CodeGen {
 		if (this.checker) {
 			const resolved = this.checker.types.get(name)?.underlying;
 			if (resolved?.kind === "struct") {
-				for (const [fName, fType] of resolved.fields.entries())
+				for (const [fName, fType] of resolved.fields.entries()) {
+					// A method promoted shallower shadows the deeper field.
+					if (isMethodPromotedOverField(resolved, fName)) continue;
 					fields.push({ name: fName, zero: this.zeroValueForType(fType) });
+				}
 			}
 		} else {
 			for (const f of structTypeAst.fields) {
@@ -797,8 +895,10 @@ export class CodeGen {
 			const fields = [];
 			// Cached per type name, so never bound to the current generic body.
 			this._withTypeParamZeros(null, () => {
-				for (const [name, type] of resolved.fields.entries())
+				for (const [name, type] of resolved.fields.entries()) {
+					if (isMethodPromotedOverField(resolved, name)) continue;
 					fields.push({ name, zero: this.zeroValueForType(type) });
+				}
 			});
 			this.structFields.set(typeName, fields);
 			return fields;
@@ -948,46 +1048,102 @@ export class CodeGen {
 				`Object.defineProperty(${name}.prototype, "value", { get() { return this; }, set(v) { Object.assign(this, v); }, configurable: true });`,
 			);
 		}
-		this._genFmtClassMeta(name, methodDecls);
+		this._genValueMethodMeta(name, methodDecls);
 	}
 
-	_emitJsonCodecs() {
-		this._emitJsonAnyHooks();
-		if (!this._jsonCodecs || this._jsonCodecs.size === 0) return;
-		for (const [, code] of this._jsonCodecs) {
-			this.line(code);
-			this.blank();
-		}
+	// Names of the value-receiver methods: a typed nil pointer in an interface
+	// panics when one is called (see __mknil).
+	_genValueMethodMeta(name, methodDecls) {
+		const vm = methodDecls.filter((m) => !m.recvPointer).map((m) => m.name);
+		if (vm.length > 0)
+			this.line(
+				`Object.defineProperty(${name}, "__vm", { value: ${JSON.stringify(vm)} });`,
+			);
+		// Pointer-receiver methods are outside the method set of a struct value
+		// held in an interface (see _ifaceMethodCheck).
+		const pm = methodDecls.filter((m) => m.recvPointer).map((m) => m.name);
+		// ...and so are those promoted from an embedded struct value.
+		for (const stub of computeEmbeddedStubs(name, methodDecls, this.checker))
+			if (stub.ptrOnly) pm.push(stub.methodName);
+		if (pm.length > 0)
+			this.line(
+				`Object.defineProperty(${name}, "__pm", { value: ${JSON.stringify(pm)} });`,
+			);
+	}
+
+	// The generated json codecs live at package level and name function-local
+	// struct classes: those are declared once at module level and assigned
+	// where the Go source declares them.
+	_hoistLocalClass(stmt, start) {
+		if (!this._hasJsonCodecs || stmt.type.kind !== "StructType") return;
+		const open = this.out.findIndex(
+			(l, i) => i >= start && l.trimStart().startsWith(`class ${stmt.name} `),
+		);
+		if (open < 0) return;
+		const indent = this.out[open].match(/^\s*/)[0];
+		const close = this.out.findIndex((l, i) => i > open && l === `${indent}}`);
+		if (close < 0) return;
+		this.out[open] =
+			`${indent}${stmt.name} = ${stmt.name}.__ph ? ${this.out[open].trimStart()}`;
+		this.out[close] = `${indent}} : ${stmt.name};`;
+		this._hoistedLocals.add(stmt.name);
+	}
+
+	_emitHoistedLocals(at) {
+		if (this._hoistedLocals.size > 0 && this._hasJsonCodecs)
+			this.out[at] =
+				`var ${[...this._hoistedLocals].map((n) => `${n} = class { static __ph = true; }`).join(", ")};`;
 	}
 
 	// A promoted method runs on the embedded value (`this.In`), so it and the
 	// outer struct's promoted-field accesses see the same storage.  Embedded
 	// types that are not compiled Go structs keep the borrowed-`this` form.
-	_embedStub(method, embedName) {
-		const call = this.structNames.has(embedName)
-			? `this.${embedName}.${method}(...__a)`
-			: `${embedName}.prototype.${method}.call(this, ...__a)`;
+	_embedStub(
+		method,
+		embedName,
+		valueEmbed = false,
+		fieldName = null,
+		nilPtrRecv = false,
+		ifaceEmbed = false,
+	) {
+		// An embedded interface forwards to the interface value in its field.
+		if (ifaceEmbed)
+			return `${method}(...__a) { return this.${fieldName}.${method}(...__a); }`;
+		// The field is named after the type without its package suffix
+		// (`Mutex$$sync` is the field `Mutex`), or after the alias it embeds.
+		const field = fieldName || embedName.replace(/\$\$.*$/, "");
+		// A named non-struct type is boxed: its methods are static, taking
+		// the value as the receiver.
+		if (valueEmbed)
+			return `${method}(...__a) { return ${embedName}.$${method}(this.${field}, ...__a); }`;
+		const call = this._embedStubCall(method, embedName, field, nilPtrRecv);
 		return `${method}(...__a) { return ${call}; }`;
 	}
 
-	_genSingleEmbedStubs(embed, declared) {
-		const embedName = embed.kind === "named" ? embed.name : null;
-		if (!embedName) return;
-		const embedBase = embed.kind === "named" ? embed.underlying : embed;
-		if (embedBase?.kind !== "struct" || !embedBase.methods) return;
-		for (const [mName] of embedBase.methods.entries()) {
-			if (!declared.has(mName)) {
-				this.blank();
-				this.line(this._embedStub(mName, embedName));
-			}
-		}
+	_embedStubCall(method, embedName, field, nilPtrRecv) {
+		if (!this.structNames.has(embedName))
+			return `${embedName}.prototype.${method}.call(this, ...__a)`;
+		// A nil embedded pointer still reaches a pointer-receiver method, as in
+		// Go: call it through the prototype instead of reading it off null.
+		return nilPtrRecv
+			? `${embedName}.prototype.${method}.call(this.${field}, ...__a)`
+			: `this.${field}.${method}(...__a)`;
 	}
 
 	_genEmbeddedMethodStubs(name, methodDecls) {
 		const stubs = computeEmbeddedStubs(name, methodDecls, this.checker);
 		for (const stub of stubs) {
 			this.blank();
-			this.line(this._embedStub(stub.methodName, stub.embedName));
+			this.line(
+				this._embedStub(
+					stub.methodName,
+					stub.embedName,
+					stub.valueEmbed,
+					stub.fieldName,
+					stub.nilPtrRecv,
+					stub.ifaceEmbed,
+				),
+			);
 		}
 	}
 
@@ -1252,47 +1408,65 @@ export class CodeGen {
 		return Boolean(info?.methods.get(method)?._ptrRecv);
 	}
 
-	_isReferenceType(t) {
-		return isReferenceType(t);
-	}
-
 	// ── Variable / const declarations ────────────────────────────
 
 	genVarDecl(decl) {
 		for (const spec of decl.decls) {
-			if (spec.value) {
-				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" ||
-						spec.type?.name === "complex64"
-					) {
-						if (
-							!isComplex(v._type) &&
-							(isNumeric(v._type) || v._type?.kind === "untyped")
-						) {
-							return `{ re: ${js}, im: 0 }`;
-						}
-					}
-					return js;
-				});
-				this._emitVarBindings(spec.names, vals, paired);
-			} else {
-				const zero = spec.type ? this.zeroValueForTypeNode(spec.type) : "null";
-				for (const name of spec.names) {
-					if (name === "_") continue;
-					this._markOwnership(name, true);
-					const val = this._boxedVars.has(name) ? `{ value: ${zero} }` : zero;
-					this.line(`let ${name} = ${val};`);
+			if (spec._commaOk) this._genDefineStmt(this._varSpecAsDefine(spec));
+			else if (spec.value) this._genVarSpecValues(spec);
+			else this._genVarSpecZero(spec);
+		}
+	}
+
+	_genVarSpecValues(spec) {
+		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" || spec.type?.name === "complex64") {
+				if (
+					!isComplex(v._type) &&
+					!v._asComplex &&
+					(isNumeric(v._type) || v._type?.kind === "untyped")
+				) {
+					return `{ re: ${js}, im: 0 }`;
+				}
+			}
+			if (spec.type?.name === "int64" || spec.type?.name === "uint64") {
+				if (
+					v._type?.kind === "untyped" &&
+					!js.endsWith("n") &&
+					/^-?\d+$/.test(js)
+				) {
+					return `${js}n`;
 				}
 			}
+			return js;
+		});
+		this._emitVarBindings(spec.names, vals, paired);
+	}
+
+	_genVarSpecZero(spec) {
+		const zero = spec.type ? this.zeroValueForTypeNode(spec.type) : "null";
+		for (const name of spec.names) {
+			if (name === "_") continue;
+			this._markOwnership(name, true);
+			const val = this._boxedVars.has(name) ? `{ value: ${zero} }` : zero;
+			this.line(`let ${name} = ${val};`);
 		}
 	}
 
+	// `var v, ok = m[k]` generates like `v, ok := m[k]`.
+	_varSpecAsDefine(spec) {
+		return {
+			kind: "DefineStmt",
+			lhs: spec.names.map((name) => ({ kind: "Ident", name })),
+			rhs: spec.value,
+		};
+	}
+
 	// `var a = v` / `var a, b = v1, v2` / `var a, b = f()`, boxing address-taken names.
 	_emitVarBindings(names, vals, paired) {
 		if (names.length === 1 && names[0] === "_") {