gofront 1.7.0 → 1.9.0

package/src/backend/js/index.js

@@ -20,53 +20,64 @@
 import {
 	computeEmbeddedStubs,
 	hasDirectRecover,
-	isReferenceType,
+	markInBoundsIndexes,
+	markRedundantNilChecks,
 	normalizeDefers,
 	scanAddressTaken,
+	takesElementAddress,
 } from "../../lower/index.js";
-import { isComplex, isNumeric } from "../../typechecker/types.js";
-import { expressionGenMethods } from "./expressions.js";
+import { orderPackageInits } from "../../typechecker/init-order.js";
+import {
+	BROWSER_GLOBALS,
+	isComplex,
+	isNumeric,
+} from "../../typechecker/types.js";
+import {
+	unicodeIsJs,
+	unicodeToLowerJs,
+	unicodeToUpperJs,
+} from "../shared/host-unicode.js";
+import { comparesToNil, 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_HEX,
+	HELPER_GENERICS,
+	HELPER_GEQ,
 	HELPER_IFACE_BOX,
 	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_PANIC,
-	HELPER_PATH_CLEAN,
-	HELPER_PATH_ERROR,
+	HELPER_PTREQ,
+	HELPER_PUSHS,
+	HELPER_RUNESTR,
 	HELPER_S,
 	HELPER_SCLONE,
-	HELPER_SHA256,
+	HELPER_SHIFT,
 	HELPER_SIMD,
-	HELPER_SORT_SLICE,
-	HELPER_SPRINTF,
-	HELPER_STRCONV,
-	HELPER_STRCONV_ERROR,
-	HELPER_SYNC,
-	HELPER_TESTING,
-	HELPER_TIME_FMT,
-	HELPER_TIME_PARSE,
+	HELPER_SLICE,
+	HELPER_STRUCT_KEY,
+	HELPER_SV,
+	HELPER_TO64,
+	HELPER_U8DEC,
+	HELPER_U8ENC,
+	HELPER_VA,
+	HELPER_VCLONE,
 } from "./runtime.js";
 import { buildSourceMap, buildWasmSourceMap } from "./source-map.js";
 import { statementGenMethods } from "./statements.js";
 import { stdlibGenMethods } from "./stdlib/index.js";
 import { templGenMethods } from "./templ.js";
+import { typeInfoGenMethods } from "./type-info.js";
 
 export { buildSourceMap, buildWasmSourceMap };
 
@@ -110,45 +121,119 @@ const JS_RESERVED = new Set([
 const jsSafeName = (n) =>
 	typeof n === "string" && JS_RESERVED.has(n) ? `${n}$` : n;
 
+// Go declarations may shadow browser globals (Task 0.9).  The JS bundle is one
+// flat module scope, so such a binding gets a `$` suffix: generated code and
+// other packages keep reaching the real global (`Array.from`, `Object.keys`).
+const jsBindingName = (n) =>
+	typeof n === "string" && BROWSER_GLOBALS.has(n) ? `${n}$` : jsSafeName(n);
+
 // Runtime helpers by registry name, in output order.  Mark one as needed with
 // `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],
 	["equal", HELPER_EQUAL],
+	["geq", HELPER_GEQ],
+	["ptreq", HELPER_PTREQ],
 	["ifeq", HELPER_IFEQ],
 	["cmul", HELPER_CMUL],
 	["cdiv", HELPER_CDIV],
 	["panicRt", HELPER_PANIC],
+	["shift", HELPER_SHIFT],
+	["to64", HELPER_TO64],
 	["nilCall", HELPER_NIL_CALL],
-	["sprintf", HELPER_SPRINTF],
+	["bounds", HELPER_BOUNDS],
+	["nilMap", HELPER_NIL_MAP],
+	["nm", HELPER_NM],
+	["structKey", HELPER_STRUCT_KEY],
+	["generics", HELPER_GENERICS],
 	["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],
-	["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 = {
+	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
 	// bundledPackages: Set<string>               — GoFront package names bundled inline;
@@ -162,19 +247,25 @@ 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();
 		this.structFields = new Map();
 		this.namedWrapperNames = new Set();
 		this.collectedCss = [];
+		this.warnings = []; // non-fatal diagnostics; the compiler prints them
+		this._precisionWarned = new Set(); // nodes already given a precision warning
+		this._srcFileNames = []; // source file name per _srcFileIdx
 		this.jsImports = jsImports;
 		this.bundledPackages = bundledPackages;
 		this.namedReturnVars = null; // names of current function's named return vars
 		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._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)
@@ -221,6 +312,9 @@ export class CodeGen {
 	}
 
 	_emitTypeDecls(program, methods) {
+		this._typeDeclsByName = new Map();
+		for (const d of program.decls)
+			if (d.kind === "TypeDecl") this._typeDeclsByName.set(d.name, d);
 		for (const d of program.decls) {
 			if (d.kind === "TypeDecl") {
 				this._currentSrcFileIdx = d._srcFileIdx ?? 0;
@@ -231,20 +325,28 @@ export class CodeGen {
 	}
 
 	_emitVarConstDecls(program) {
-		for (const d of program.decls) {
-			if (d.kind === "ConstDecl") {
-				this._currentSrcFileIdx = d._srcFileIdx ?? 0;
-				this.genConstDecl(d);
-				this.blank();
+		const { consts, vars } = orderPackageInits([program]);
+		const emit = (decls, gen, ordered) => {
+			const natural = decls.flatMap((d) => d.decls ?? []);
+			const inOrder = ordered.every((e, i) => e.spec === natural[i]);
+			if (inOrder) {
+				for (const d of decls) {
+					this._currentSrcFileIdx = d._srcFileIdx ?? 0;
+					gen.call(this, d);
+					this.blank();
+				}
+				return;
 			}
-		}
-		for (const d of program.decls) {
-			if (d.kind === "VarDecl") {
-				this._currentSrcFileIdx = d._srcFileIdx ?? 0;
-				this.genVarDecl(d);
+			// Initialisers depend on declarations that come later (Go allows it).
+			for (const e of ordered) {
+				this._currentSrcFileIdx = e.decl._srcFileIdx ?? 0;
+				gen.call(this, { ...e.decl, decls: [e.spec] });
 				this.blank();
 			}
-		}
+		};
+		const declsOf = (kind) => program.decls.filter((d) => d.kind === kind);
+		emit(declsOf("ConstDecl"), this.genConstDecl, consts);
+		emit(declsOf("VarDecl"), this.genVarDecl, vars);
 	}
 
 	_callInitAndMain(initNames, program, isTest = false) {
@@ -262,25 +364,43 @@ export class CodeGen {
 
 	generate(program, options = {}) {
 		const isTest = options.isTest ?? false;
+		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.
 		normalizeDefers(program);
+		// Strict mode: index checks the loop shape proves unnecessary are elided.
+		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).
 		const pkgName = program.pkg?.name;
 		if (pkgName) {
+			this.pkgName = pkgName;
 			for (const d of program.decls) {
 				if (!d._pkgName) d._pkgName = pkgName;
 			}
 		}
 		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);
 		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);
@@ -331,12 +451,12 @@ export class CodeGen {
 	}
 
 	_renameParams(params) {
-		for (const p of params ?? []) p.name = jsSafeName(p.name);
+		for (const p of params ?? []) p.name = jsBindingName(p.name);
 	}
 
 	_renameNamedReturns(node) {
 		for (const r of node.returnType?._namedReturns ?? [])
-			r.name = jsSafeName(r.name);
+			r.name = jsBindingName(r.name);
 	}
 
 	_renameSignature(node) {
@@ -345,27 +465,37 @@ export class CodeGen {
 	}
 
 	_renameIdentNode(node) {
-		if (!node._isStructKey && node._type?.kind !== "builtin")
-			node.name = jsSafeName(node.name);
+		if (node._isStructKey || node._type?.kind === "builtin") return;
+		node.name = node._shadowsGlobal
+			? jsBindingName(node.name)
+			: jsSafeName(node.name);
 	}
 
 	_renameFuncDeclNode(node) {
-		node.name = jsSafeName(node.name);
+		node.name = jsBindingName(node.name);
 		this._renameSignature(node);
 	}
 
 	_renameMethodDeclNode(node) {
-		node.recvName = jsSafeName(node.recvName);
+		node.recvName = jsBindingName(node.recvName);
 		this._renameSignature(node);
 	}
 
 	_renameDeclSpecs(node) {
 		for (const spec of node.decls ?? [])
-			spec.names = spec.names.map(jsSafeName);
+			spec.names = spec.names.map(jsBindingName);
+	}
+
+	// `document := 1` declares a binding that shadows the browser global.  A
+	// `:=` redeclaration (`x, document := 2, 3`) always targets a local of the
+	// same scope, which carries the same suffix.
+	_renameDefineNode(node) {
+		for (const l of node.lhs ?? [])
+			if (l.kind === "Ident") l.name = jsBindingName(l.name);
 	}
 
 	_renameTypeSwitchNode(node) {
-		node.assign = jsSafeName(node.assign);
+		node.assign = jsBindingName(node.assign);
 	}
 
 	_markStructKeys(node) {
@@ -384,7 +514,16 @@ export class CodeGen {
 		MethodDecl: "_renameMethodDeclNode",
 		FuncLit: "_renameSignature",
 		TemplDecl: "_renameSignature",
+		TemplExpr: "_renameTemplExprNode",
+		TemplChildren: "_renameTemplExprNode",
+		TemplComponent: "_renameTemplExprNode",
+		TemplIf: "_renameTemplExprNode",
+		TemplSwitch: "_renameTemplExprNode",
+		TemplCase: "_renameTemplExprNode",
+		TemplFor: "_renameTemplForNode",
+		TemplElement: "_renameTemplElementNode",
 		CssDecl: "_renameSignature",
+		DefineStmt: "_renameDefineNode",
 		VarDecl: "_renameDeclSpecs",
 		ConstDecl: "_renameDeclSpecs",
 		TypeSwitchStmt: "_renameTypeSwitchNode",
@@ -410,6 +549,18 @@ export class CodeGen {
 	// Collects struct names, method map, and named wrapper names from program decls.
 	// Returns the method map (typeName → MethodDecl[]).
 	_collectStructNames(program) {
+		// Go-compiled variadic functions, methods and templ components: a
+		// `f(xs...)` call to one passes the slice itself (see `_genCallArgs`,
+		// `_emitParamCopies`).
+		this.variadicFns = new Set();
+		for (const d of program.decls) {
+			const last = d.params?.[d.params.length - 1];
+			if (!last?.variadic) continue;
+			if (d.kind === "FuncDecl" || d.kind === "TemplDecl")
+				this.variadicFns.add(d.name);
+			else if (d.kind === "MethodDecl")
+				this.variadicFns.add(`${d.recvType.name}.${d.name}`);
+		}
 		for (const d of program.decls) {
 			if (d.kind === "TypeDecl" && d.type.kind === "StructType")
 				this.structNames.add(d.name);
@@ -427,11 +578,14 @@ export class CodeGen {
 
 	_collectMethodMap(program) {
 		const methods = new Map();
+		this.nilSafeMethods = new Set();
 		for (const d of program.decls) {
 			if (d.kind === "MethodDecl") {
 				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}`);
 			}
 		}
 		return methods;
@@ -460,30 +614,17 @@ export class CodeGen {
 	/** Marks a runtime helper (key of HELPER_MAP) as needed by the output. */
 	useHelper(name) {
 		this._helpers.add(name);
-		if (
-			name === "strconvError" ||
-			name === "pathError" ||
-			name === "ioEOF" ||
-			name === "base64" ||
-			name === "hex" ||
-			name === "json"
-		) {
-			this._helpers.add("error");
-		}
+		if (name === "ifeq" || name === "geq") this._helpers.add("equal");
+		if (name === "geq") this._helpers.add("ifeq");
 		if (name === "json") {
-			this.useHelper("base64");
-		}
-		if (name === "binary") {
-			this.useHelper("ioEOF");
 			this._helpers.add("error");
 		}
+		if (name === "panicRt") this._helpers.add("error");
+		if (name === "append") this.useHelper("slice");
+		if (name === "slice") this._helpers.add("sv");
 	}
 
-	_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) {
@@ -501,16 +642,36 @@ export class CodeGen {
 	// Generate a single bundle from multiple programs (same-package multi-file).
 	// 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;
 				decl._pkgName = programs[i].pkg?.name;
 			}
 		}
-		const merged = { decls: programs.flatMap((p) => p.decls) };
+		const merged = {
+			pkg: programs[0]?.pkg,
+			decls: programs.flatMap((p) => p.decls),
+		};
 		return this.generate(merged, options);
 	}
 
+	// Records a non-fatal diagnostic at `node` ("main.go at line 3:5: msg").
+	_warn(msg, node) {
+		const file = this._srcFileNames[this._currentSrcFileIdx ?? 0];
+		// 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);
+	}
+
 	getCss() {
 		return [...new Set(this.collectedCss)].join("\n\n");
 	}
@@ -519,24 +680,45 @@ 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
+	// AST S inherits its fields from, or null.
+	_definedStructAst(decl) {
+		if (decl.isAlias || decl.typeParams) return null;
+		if (this.checker?.types.get(decl.name)?.underlying?.kind !== "struct")
+			return null;
+		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) return null;
+			t = next.type;
+		}
+		return null;
+	}
+
 	genTypeDeclWithMethods(decl, methodDecls) {
+		const definedStruct =
+			decl.type.kind === "StructType" ? null : this._definedStructAst(decl);
 		if (decl.type.kind === "StructType") {
 			this.genStruct(decl.name, decl.type, methodDecls);
+		} else if (definedStruct) {
+			this.genStruct(decl.name, definedStruct, methodDecls);
 		} else if (decl.type.kind === "InterfaceType") {
 			// Interfaces are compile-time only — no JS output needed.
 			this.line(`// interface ${decl.name} (compile-time only)`);
-		} else if (methodDecls.length > 0) {
+		} else if (
+			methodDecls.length > 0 ||
+			this._isPlainNamedBox(this.checker?.types.get(decl.name))
+		) {
 			// Named non-struct type with methods — emit an ES6 wrapper class.
+			if (methodDecls.length === 0)
+				this.line(`// type ${decl.name} = ${this.typeComment(decl.type)}`);
 			this.genNamedTypeClass(decl.name, methodDecls);
 		} else {
 			this.line(`// type ${decl.name} = ${this.typeComment(decl.type)}`);
@@ -562,6 +744,7 @@ export class CodeGen {
 					);
 				}
 			}
+			this._tagMultiUnwrap(methodDecls);
 		});
 		this.line("}");
 		// Box for *T in an interface. It also proxies `.value` to the pointer, so
@@ -579,22 +762,48 @@ 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";
 		return "_items";
 	}
 
+	// A user-declared named basic type without methods: still boxed in an
+	// interface so `any(L("x")).(string)` fails like Go.
+	_isPlainNamedBox(type) {
+		if (type?.kind !== "named" || type._generic) return false;
+		if (type._target === undefined || type._target === "wasm") return false;
+		if (type.underlying?.kind !== "basic" || type.methods?.size > 0)
+			return false;
+		return type.methods instanceof Map;
+	}
+
 	// Box/dispatch info for a named non-struct type with methods, or null.
 	_namedBoxInfo(type) {
 		if (type?.kind !== "named") return null;
 		const u = type.underlying;
 		if (!u || u.kind === "struct" || u.kind === "interface") return null;
 		const methods = type.methods ?? type._generic?.methods;
+		if (this._isPlainNamedBox(type))
+			return {
+				cls: this._dequalify(type.name),
+				field: this._namedBoxField(u),
+				methods: new Map(),
+			};
 		if (!methods || methods.size === 0) return null;
 		if (![...methods.values()].some((m) => Object.hasOwn(m ?? {}, "_ptrRecv")))
 			return null;
@@ -626,9 +835,11 @@ export class CodeGen {
 		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) });
-			}
+			// Cached per type name, so never bound to the current generic body.
+			this._withTypeParamZeros(null, () => {
+				for (const [name, type] of resolved.fields.entries())
+					fields.push({ name, zero: this.zeroValueForType(type) });
+			});
 			this.structFields.set(typeName, fields);
 			return fields;
 		}
@@ -661,17 +872,69 @@ export class CodeGen {
 		this.line("}");
 	}
 
+	// A generic struct's constructor takes the instance's zero-value factories
+	// after the fields (see HELPER_GENERICS). A field whose zero value depends
+	// on a type parameter starts at it when its argument is undefined.
+	_genTypeParamBindings(tpNames, tz) {
+		tpNames.forEach((n, i) => {
+			this.line(`const $z_${n} = ${tz}?.[${i}] ?? __zn;`);
+		});
+	}
+
+	_genGenericStructConstructor(fields, tpNames) {
+		const usesTz = (f) => f.zero.includes("$z_");
+		const params = fields.map((f) =>
+			usesTz(f) ? `${f.name}$` : `${f.name}$ = ${f.zero}`,
+		);
+		this.line(`constructor(${[...params, "$tz"].join(", ")}) {`);
+		this.indented(() => {
+			this.line("this[__tz] = $tz;");
+			if (fields.some(usesTz)) this._genTypeParamBindings(tpNames, "$tz");
+			for (const f of fields) {
+				const v = usesTz(f)
+					? `${f.name}$ === undefined ? ${f.zero} : ${f.name}$`
+					: `${f.name}$`;
+				this.line(`this.${f.name} = ${v};`);
+			}
+		});
+		this.line("}");
+	}
+
+	// JS object keys are strings: a struct used as a map key becomes an
+	// injective encoding of its fields (see HELPER_STRUCT_KEY), so equal values
+	// share a key and distinct values never collide.
+	_genStructKeyString(_name, fields) {
+		if (fields.some((f) => f.name === "toString")) return;
+		if (fields.length === 0) {
+			this.line('toString() { return "{}"; }');
+			return;
+		}
+		this.useHelper("structKey");
+		this.line("toString() { return __sk(this); }");
+	}
+
 	_genStructClone(name, structTypeAst, fields) {
 		const resolved = this.checker?.types.get(name)?.underlying;
 		const astTypes = new Map();
 		for (const f of structTypeAst?.fields ?? [])
 			for (const n of f.names ?? []) astTypes.set(n, f.type);
-		const args = fields.map((f) => {
-			const t =
-				resolved?.fields?.get(f.name) ??
-				this._typeFromNode(astTypes.get(f.name));
-			return this._cloneJs(t, `this.${f.name}`);
-		});
+		const tpNames = this._genericTypeParamNames(name);
+		const prevZeros = this._typeParamZeros;
+		this._typeParamZeros = tpNames
+			? new Map(tpNames.map((n, i) => [n, `this[__tz]?.[${i}]`]))
+			: null;
+		let args;
+		try {
+			args = fields.map((f) => {
+				const t =
+					resolved?.fields?.get(f.name) ??
+					this._typeFromNode(astTypes.get(f.name));
+				return this._cloneJs(t, `this.${f.name}`);
+			});
+		} finally {
+			this._typeParamZeros = prevZeros;
+		}
+		if (tpNames) args.push("this[__tz]");
 		this.blank();
 		this.line(`__clone() { return new ${name}(${args.join(", ")}); }`);
 	}
@@ -685,18 +948,38 @@ export class CodeGen {
 		);
 	}
 
+	// Type parameter names of generic type `name`, or null.
+	_genericTypeParamNames(name) {
+		const generic = this.checker?.types.get(name)?._generic;
+		if (!generic?.typeParams?.length || generic.isAlias) return null;
+		return generic.typeParams.map((tp) => tp.name);
+	}
+
 	genStruct(name, structTypeAst, methodDecls) {
-		const fields = this._collectStructFields(name, structTypeAst);
-		this.structFields.set(name, fields);
+		const tpNames = this._genericTypeParamNames(name);
+		if (tpNames) this.useHelper("generics");
+		const fields = this._withTypeParamZeros(tpNames, () =>
+			this._collectStructFields(name, structTypeAst),
+		);
+		this.structFields.set(
+			name,
+			tpNames
+				? this._withTypeParamZeros(null, () =>
+						this._collectStructFields(name, structTypeAst),
+					)
+				: fields,
+		);
 		this.line(`class ${name} {`);
 		this.indented(() => {
-			this._genStructConstructor(fields);
+			if (tpNames) this._genGenericStructConstructor(fields, tpNames);
+			else this._genStructConstructor(fields);
 			for (const m of methodDecls) {
 				this.blank();
 				this.genMethod(m);
 			}
 			this._genEmbeddedMethodStubs(name, methodDecls);
 			this._genStructClone(name, structTypeAst, fields);
+			this._genStructKeyString(name, fields);
 		});
 		this.line("}");
 		// Lets generic `p.value` dereferences resolve to the struct itself.
@@ -705,29 +988,68 @@ export class CodeGen {
 				`Object.defineProperty(${name}.prototype, "value", { get() { return this; }, set(v) { Object.assign(this, v); }, configurable: true });`,
 			);
 		}
+		this._genValueMethodMeta(name, methodDecls);
 	}
 
-	_emitJsonCodecs() {
-		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)} });`,
+			);
 	}
 
-	_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(
-					`${mName}(...__a) { return ${embedName}.prototype.${mName}.call(this, ...__a); }`,
-				);
-			}
-		}
+	// 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, valueEmbed = false, fieldName = null) {
+		// 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.structNames.has(embedName)
+			? `this.${field}.${method}(...__a)`
+			: `${embedName}.prototype.${method}.call(this, ...__a)`;
+		return `${method}(...__a) { return ${call}; }`;
 	}
 
 	_genEmbeddedMethodStubs(name, methodDecls) {
@@ -735,7 +1057,12 @@ export class CodeGen {
 		for (const stub of stubs) {
 			this.blank();
 			this.line(
-				`${stub.methodName}(...__a) { return ${stub.embedName}.prototype.${stub.methodName}.call(this, ...__a); }`,
+				this._embedStub(
+					stub.methodName,
+					stub.embedName,
+					stub.valueEmbed,
+					stub.fieldName,
+				),
 			);
 		}
 	}
@@ -751,12 +1078,35 @@ export class CodeGen {
 			decl._line ?? null,
 		);
 		const prevBoxed = this._boxedVars;
-		this._boxedVars = new Set();
+		this._boxedVars = new Set(this._boxedGlobals);
 		this._scanAddressTaken(decl.body);
+		// Methods of a generic struct read its type arguments from the
+		// instance; named non-struct types have no instance to carry them.
+		const tpNames = staticNamed
+			? null
+			: this._genericTypeParamNames(decl.recvType?.name);
+		this._withTypeParamZeros(tpNames, () =>
+			this._genMethodBody(decl, staticNamed, recvParam, tpNames),
+		);
+		this._boxedVars = prevBoxed;
+		this.line("}");
+		// `Unwrap() []error` is told apart from `Unwrap() error` in type tests.
+		if (
+			!staticNamed &&
+			decl.name === "Unwrap" &&
+			decl.returnType?.kind === "SliceType"
+		)
+			this.line("static { this.prototype.Unwrap.__multi = true; }");
+		this._currentSrcFileIdx = prevFileIdx;
+	}
+
+	_genMethodBody(decl, staticNamed, recvParam, tpNames) {
 		this._withFnCtx(decl.body, () =>
 			this.indented(() => {
+				if (tpNames) this._genTypeParamBindings(tpNames, "this?.[__tz]");
+				if (decl.recvName) this._fnCtx.params.add(decl.recvName);
 				if (!staticNamed && decl.recvName && decl.recvName !== "_") {
-					this.line(`const ${decl.recvName} = ${this._receiverValue(decl)};`);
+					this.line(`let ${decl.recvName} = ${this._receiverValue(decl)};`);
 				}
 				if (staticNamed && this._boxedVars.has(recvParam)) {
 					this.line(`${recvParam} = { value: ${recvParam} };`);
@@ -765,14 +1115,18 @@ export class CodeGen {
 				this._withNamedReturns(decl, () => this._genBody(decl.body, decl));
 			}),
 		);
-		this._boxedVars = prevBoxed;
-		this.line("}");
-		this._currentSrcFileIdx = prevFileIdx;
+	}
+
+	// JS parameter names; a variadic Go parameter is a rest parameter.
+	_paramNames(params) {
+		return params.map((p, i) =>
+			p.variadic && i === params.length - 1 ? `...${p.name}` : p.name,
+		);
 	}
 
 	// Static methods of named non-struct types take the receiver as first parameter.
 	_methodSignature(decl, staticNamed, recvParam) {
-		const params = decl.params.map((p) => p.name);
+		const params = this._paramNames(decl.params);
 		const asyncPrefix = decl.async ? "async " : "";
 		if (!staticNamed)
 			return `${asyncPrefix}${decl.name}(${params.join(", ")}) {`;
@@ -803,17 +1157,33 @@ export class CodeGen {
 	// ── Function declarations ────────────────────────────────────
 
 	genFuncDecl(decl, nameOverride) {
+		const tpNames = decl.typeParams?.length
+			? decl.typeParams.map((tp) => tp.name)
+			: null;
+		this._withTypeParamZeros(tpNames, () =>
+			this._genFuncDecl(decl, nameOverride, tpNames),
+		);
+	}
+
+	// A generic function takes one zero-value factory per type parameter
+	// before its parameters (see HELPER_GENERICS).
+	_genFuncDecl(decl, nameOverride, tpNames) {
 		const name = nameOverride ?? decl.name;
-		const params = decl.params
-			.map((p, i) =>
-				p.variadic && i === decl.params.length - 1 ? `...${p.name}` : p.name,
-			)
-			.join(", ");
+		const params = [
+			...(tpNames ?? []).map((n) => `$z_${n}`),
+			...this._paramNames(decl.params),
+		].join(", ");
 		const asyncPrefix = decl.async ? "async " : "";
 		const srcLine = decl._line ?? null;
 		this.line(`${asyncPrefix}function ${name}(${params}) {`, srcLine);
+		if (decl.intrinsic) {
+			const args = decl.params.map((p) => p.name);
+			this.indented(() => this.line(JS_INTRINSICS[decl.intrinsic](args)));
+			this.line("}");
+			return;
+		}
 		const prevBoxed = this._boxedVars;
-		this._boxedVars = new Set();
+		this._boxedVars = new Set(this._boxedGlobals);
 		this._scanAddressTaken(decl.body);
 		this._withFnCtx(decl.body, () =>
 			this.indented(() => {
@@ -836,6 +1206,7 @@ export class CodeGen {
 				const { name, type } = named[i];
 				const varName = !name || name === "_" ? `__ret_blank$${i}` : name;
 				this._markOwnership(varName, true);
+				this._fnCtx?.params.add(varName);
 				this.line(`let ${varName} = ${this.zeroValueForTypeNode(type)};`);
 			}
 			this.namedReturnVars = named.map((r, i) =>
@@ -910,11 +1281,25 @@ export class CodeGen {
 		this._recoverOkInScope = prevRecoverOk;
 	}
 
+	// Package-level variables whose address is taken anywhere (`&g`, `g.Inc()`
+	// on a pointer-receiver method) are boxed like address-taken locals.
+	_collectBoxedGlobals(program) {
+		const names = new Set();
+		for (const d of program.decls)
+			if (d.kind === "VarDecl")
+				for (const spec of d.decls) for (const n of spec.names) names.add(n);
+		const boxed = new Set();
+		if (names.size === 0) return boxed;
+		for (const n of this._scanAddressTaken(program.decls, new Set()))
+			if (names.has(n)) boxed.add(n);
+		return boxed;
+	}
+
 	// Scan AST node for _addressTaken idents on scalars and populate _boxedVars.
 	// A pointer-receiver method call on a named non-struct local (`l.Set(5)`)
 	// takes the variable's address too, so the variable must be boxed.
-	_scanAddressTaken(node) {
-		scanAddressTaken(node, this._boxedVars);
+	_scanAddressTaken(node, into = this._boxedVars) {
+		scanAddressTaken(node, into);
 		const visit = (n) => {
 			if (!n || typeof n !== "object") return;
 			if (Array.isArray(n)) {
@@ -927,7 +1312,7 @@ export class CodeGen {
 					recv?.kind === "Ident" &&
 					this._namedPtrMethodOn(recv._type, n.func.field)
 				)
-					this._boxedVars.add(recv.name);
+					into.add(recv.name);
 			}
 			for (const key of Object.keys(n)) {
 				if (key.startsWith("_") || key === "kind") continue;
@@ -935,6 +1320,7 @@ export class CodeGen {
 			}
 		};
 		visit(node);
+		return into;
 	}
 
 	_namedPtrMethodOn(type, method) {
@@ -942,48 +1328,72 @@ 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) {
-					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] === "_") {
+			// A blank binding only runs its initialiser (`var _ = f()` may repeat).
+			this.line(`void (${vals[0]});`);
+			return;
+		}
 		if (names.length === 1) {
 			const val = this._boxedVars.has(names[0])
 				? `{ value: ${vals[0]} }`
@@ -992,7 +1402,8 @@ export class CodeGen {
 			return;
 		}
 		const rhs = paired ? `[${vals.join(", ")}]` : vals[0];
-		this.line(`let [${names.join(", ")}] = ${rhs};`);
+		const targets = names.map((n) => (n === "_" ? "" : n));
+		this.line(`let [${targets.join(", ")}] = ${rhs};`);
 		this._boxDeclaredNames(names);
 	}
 
@@ -1012,5 +1423,6 @@ export class CodeGen {
 
 Object.assign(CodeGen.prototype, statementGenMethods);
 Object.assign(CodeGen.prototype, expressionGenMethods);
+Object.assign(CodeGen.prototype, typeInfoGenMethods);
 Object.assign(CodeGen.prototype, stdlibGenMethods);
 Object.assign(CodeGen.prototype, templGenMethods);