gofront 1.4.0 → 1.6.0

package/src/{codegen → backend/js}/index.js

@@ -1,6 +1,6 @@
 // Code generator: walks the typed AST and emits clean JavaScript.
 //
-// Split into sub-modules under codegen/:
+// Split into sub-modules under backend/js/:
 //   source-map.js    — VLQ encoder and source map builder
 //   statements.js    — genBlock, genStmt, genFor, genSwitch, etc.
 //   expressions.js   — genExpr, genCall, genCompositeLit, helpers
@@ -17,7 +17,14 @@
 //   - make(map[K]V)    → {}
 //   - for range        → for...of with .entries()
 
-import { isComplex, isNumeric } from "../typechecker/types.js";
+import {
+	computeEmbeddedStubs,
+	hasDirectRecover,
+	isReferenceType,
+	normalizeDefers,
+	scanAddressTaken,
+} from "../../lower/index.js";
+import { isComplex, isNumeric } from "../../typechecker/types.js";
 import { expressionGenMethods } from "./expressions.js";
 import {
 	HELPER_APPEND,
@@ -29,20 +36,25 @@ import {
 	HELPER_IFACE_BOX,
 	HELPER_INJECT_STYLES,
 	HELPER_LEN,
+	HELPER_NIL_CALL,
+	HELPER_PANIC,
 	HELPER_PATH_CLEAN,
 	HELPER_S,
 	HELPER_SCLONE,
 	HELPER_SORT_SLICE,
 	HELPER_SPRINTF,
+	HELPER_STRCONV,
 	HELPER_TESTING,
 	HELPER_TIME_FMT,
 	HELPER_TIME_PARSE,
 } from "./runtime.js";
-import { buildSourceMap } from "./source-map.js";
+import { buildSourceMap, buildWasmSourceMap } from "./source-map.js";
 import { statementGenMethods } from "./statements.js";
 import { stdlibGenMethods } from "./stdlib/index.js";
 import { templGenMethods } from "./templ.js";
 
+export { buildSourceMap, buildWasmSourceMap };
+
 // Valid Go identifiers that cannot be used as JS bindings; emitted with a `$` suffix.
 const JS_RESERVED = new Set([
 	"arguments",
@@ -83,6 +95,30 @@ const JS_RESERVED = new Set([
 const jsSafeName = (n) =>
 	typeof n === "string" && JS_RESERVED.has(n) ? `${n}$` : 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],
+	["append", HELPER_APPEND],
+	["sliceGuard", HELPER_S],
+	["sclone", HELPER_SCLONE],
+	["ifaceBox", HELPER_IFACE_BOX],
+	["equal", HELPER_EQUAL],
+	["cmul", HELPER_CMUL],
+	["cdiv", HELPER_CDIV],
+	["panicRt", HELPER_PANIC],
+	["nilCall", HELPER_NIL_CALL],
+	["sprintf", HELPER_SPRINTF],
+	["error", HELPER_ERROR],
+	["errorIs", HELPER_ERROR_IS],
+	["strconv", HELPER_STRCONV],
+	["pathClean", HELPER_PATH_CLEAN],
+	["sortSlice", HELPER_SORT_SLICE],
+	["timeFmt", HELPER_TIME_FMT],
+	["timeParse", HELPER_TIME_PARSE],
+	["testing", HELPER_TESTING],
+];
+
 export class CodeGen {
 	// jsImports:       Map<importPath, string[]> — npm package imports to emit at top of file
 	// bundledPackages: Set<string>               — GoFront package names bundled inline;
@@ -91,8 +127,11 @@ export class CodeGen {
 		checker = null,
 		jsImports = new Map(),
 		bundledPackages = new Set(),
+		options = {},
 	) {
 		this.checker = checker;
+		this.target = options.target ?? "js";
+		this.strict = Boolean(options.strict || this.target === "both");
 		this.out = [];
 		this.indent = 0;
 		this.structNames = new Set();
@@ -106,22 +145,7 @@ export class CodeGen {
 		this._currentSrcFileIdx = 0; // updated as each top-level decl is generated
 		this._boxedVars = new Set(); // address-taken scalar variables that need boxing
 		// Runtime helper usage tracking — only emit helpers that are actually used
-		this._usesLen = false;
-		this._usesAppend = false;
-		this._usesSliceGuard = false;
-		this._usesSprintf = false;
-		this._usesEqual = false;
-		this._usesCmul = false;
-		this._usesCdiv = false;
-		this._usesError = false;
-		this._usesErrorIs = false;
-		this._usesPathClean = false;
-		this._usesSortSlice = false;
-		this._usesTimeFmt = false;
-		this._usesTimeParse = false;
-		this._usesTesting = false;
-		this._usesSClone = false;
-		this._usesIfaceBox = false;
+		this._helpers = new Set();
 		// Per-function context for Go value semantics (see _withFnCtx)
 		this._fnCtx = null;
 		// Iterator (range-over-func) context
@@ -207,6 +231,10 @@ export class CodeGen {
 
 	generate(program, options = {}) {
 		const isTest = options.isTest ?? false;
+		// 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);
 		// 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;
@@ -397,28 +425,21 @@ export class CodeGen {
 		return methods;
 	}
 
+	/** Marks a runtime helper (key of HELPER_MAP) as needed by the output. */
+	useHelper(name) {
+		this._helpers.add(name);
+	}
+
 	_prependHelpers(isTest = false) {
-		const needsTesting = isTest || this._usesTesting;
-		const HELPER_MAP = [
-			[this.collectedCss.length > 0, HELPER_INJECT_STYLES],
-			[this._usesLen, HELPER_LEN],
-			[this._usesAppend, HELPER_APPEND],
-			[this._usesSliceGuard, HELPER_S],
-			[this._usesSClone, HELPER_SCLONE],
-			[this._usesIfaceBox, HELPER_IFACE_BOX],
-			[this._usesEqual, HELPER_EQUAL],
-			[this._usesCmul, HELPER_CMUL],
-			[this._usesCdiv, HELPER_CDIV],
-			[this._usesSprintf || needsTesting, HELPER_SPRINTF],
-			[this._usesError, HELPER_ERROR],
-			[this._usesErrorIs, HELPER_ERROR_IS],
-			[this._usesPathClean, HELPER_PATH_CLEAN],
-			[this._usesSortSlice, HELPER_SORT_SLICE],
-			[this._usesTimeFmt, HELPER_TIME_FMT],
-			[this._usesTimeParse, HELPER_TIME_PARSE],
-			[needsTesting, HELPER_TESTING],
-		];
-		const helpers = HELPER_MAP.filter(([flag]) => flag).map(([, h]) => h);
+		if (isTest || this._helpers.has("testing")) {
+			this.useHelper("sprintf");
+			this.useHelper("testing");
+		}
+		const helpers = [];
+		if (this.collectedCss.length > 0) helpers.push(HELPER_INJECT_STYLES);
+		for (const [name, src] of HELPER_MAP) {
+			if (this._helpers.has(name)) helpers.push(src);
+		}
 		if (helpers.length > 0) {
 			const helperLines = helpers.flatMap((h) => h.split("\n"));
 			helperLines.push("");
@@ -621,12 +642,13 @@ export class CodeGen {
 	}
 
 	_genEmbeddedMethodStubs(name, methodDecls) {
-		if (!this.checker) return;
-		const resolvedType = this.checker.types.get(name)?.underlying;
-		if (resolvedType?.kind !== "struct" || !resolvedType._embeds) return;
-		const declared = new Set(methodDecls.map((m) => m.name));
-		for (const embed of resolvedType._embeds)
-			this._genSingleEmbedStubs(embed, declared);
+		const stubs = computeEmbeddedStubs(name, methodDecls, this.checker);
+		for (const stub of stubs) {
+			this.blank();
+			this.line(
+				`${stub.methodName}(...__a) { return ${stub.embedName}.prototype.${stub.methodName}.call(this, ...__a); }`,
+			);
+		}
 	}
 
 	genMethod(decl, recvField = null) {
@@ -650,7 +672,7 @@ export class CodeGen {
 					}
 				}
 				this._emitParamCopies(decl.params);
-				this._withNamedReturns(decl, () => this._genBody(decl.body));
+				this._withNamedReturns(decl, () => this._genBody(decl.body, decl));
 			}),
 		);
 		this._unwrappedRecv = prevUnwrapped;
@@ -707,7 +729,7 @@ export class CodeGen {
 		this._withFnCtx(decl.body, () =>
 			this.indented(() => {
 				this._emitParamCopies(decl.params);
-				this._withNamedReturns(decl, () => this._genBody(decl.body));
+				this._withNamedReturns(decl, () => this._genBody(decl.body, decl));
 			}),
 		);
 		this._boxedVars = prevBoxed;
@@ -715,45 +737,74 @@ export class CodeGen {
 	}
 
 	_withNamedReturns(decl, fn) {
+		const prevDecl = this._currentDecl;
+		this._currentDecl = decl;
 		const named = decl.returnType?._namedReturns;
 		const prev = this.namedReturnVars;
 		if (named) {
 			// Emit zero-value declarations for named return vars
-			for (const { name, type } of named) {
-				if (name) {
-					this._markOwnership(name, true);
-					this.line(`let ${name} = ${this.zeroValueForTypeNode(type)};`);
-				}
+			for (let i = 0; i < named.length; i++) {
+				const { name, type } = named[i];
+				const varName = !name || name === "_" ? `__ret_blank$${i}` : name;
+				this._markOwnership(varName, true);
+				this.line(`let ${varName} = ${this.zeroValueForTypeNode(type)};`);
 			}
-			this.namedReturnVars = named.map((r) => r.name).filter(Boolean);
+			this.namedReturnVars = named.map((r, i) =>
+				!r.name || r.name === "_" ? `__ret_blank$${i}` : r.name,
+			);
 		} else {
 			this.namedReturnVars = null;
 		}
 		fn();
 		this.namedReturnVars = prev;
+		this._currentDecl = prevDecl;
 	}
 
 	// Emit a function body, wrapping in try/catch/finally for defer if needed.
-	_genBody(body) {
+	// `fnNode` is the enclosing FuncDecl/MethodDecl/FuncLit; it decides whether
+	// the recover-arming prologue is needed (see HELPER_PANIC).
+	_genBody(body, fnNode = null) {
+		const prevRecoverOk = this._recoverOkInScope;
+		this._recoverOkInScope = false;
+		const isTarget = Boolean(fnNode?._isDeferTarget);
+		const forwards = isTarget && Boolean(fnNode._deferForward);
+		if (!forwards && (isTarget || hasDirectRecover(body))) {
+			this.useHelper("panicRt");
+			this.line(
+				"const __recoverOk = __gopanic.armed; __gopanic.armed = false;",
+			);
+			this._recoverOkInScope = true;
+		}
 		if (!body._hasDefer) {
 			this.genBlock(body);
+			this._recoverOkInScope = prevRecoverOk;
 			return;
 		}
+		this.useHelper("panicRt");
 		this.line("const __defers = [];");
-		this.line("let __panic = null;");
+		this.line("const __frame = { pn: null };");
 		this.line("try {");
 		this.indented(() => this.genBlock(body));
 		this.line("} catch (__err) {");
-		this.indented(() => this.line("__panic = __err;"));
+		this.indented(() => {
+			this.line("__frame.pn = { err: __err, recovered: false };");
+			this.line("__gopanic.stack.push(__frame.pn);");
+		});
 		this.line("} finally {");
 		this.indented(() => {
-			this.line(
-				"for (let __i = __defers.length - 1; __i >= 0; __i--) __defers[__i]();",
-			);
-			this.line("if (__panic !== null) throw __panic;");
+			// Runs defers LIFO and rethrows an unrecovered panic.
+			this.line("__runDefers(__defers, __frame);");
+			if (this.namedReturnVars?.length > 0) {
+				const vars = this.namedReturnVars;
+				this.line(
+					vars.length === 1
+						? `return ${vars[0]};`
+						: `return [${vars.join(", ")}];`,
+				);
+			}
 		});
 		this.line("}");
-		// If a recover() cleared __panic, execution reaches here.
+		// If a recover() cleared the panic, execution reaches here.
 		// Return named return vars so deferred mutations are visible to the caller.
 		if (this.namedReturnVars?.length > 0) {
 			const vars = this.namedReturnVars;
@@ -762,41 +813,21 @@ export class CodeGen {
 					? `return ${vars[0]};`
 					: `return [${vars.join(", ")}];`,
 			);
+		} else if (this._currentDecl?.returnType) {
+			this.line(
+				`return ${this.zeroValueForTypeNode(this._currentDecl.returnType)};`,
+			);
 		}
+		this._recoverOkInScope = prevRecoverOk;
 	}
 
 	// Scan AST node for _addressTaken idents on scalars and populate _boxedVars.
 	_scanAddressTaken(node) {
-		if (!node || typeof node !== "object") return;
-		if (Array.isArray(node)) {
-			for (const child of node) this._scanAddressTaken(child);
-			return;
-		}
-		// &x — the operand ident will have _addressTaken set by typechecker
-		if (node.kind === "Ident" && node._addressTaken) {
-			// Check if the type is a scalar (needs boxing) vs reference type (no boxing)
-			const t = node._type;
-			if (t && !this._isReferenceType(t)) {
-				this._boxedVars.add(node.name);
-			}
-		}
-		// Recurse into FuncLit too — closures may take address of outer vars
-		for (const key of Object.keys(node)) {
-			if (key.startsWith("_")) continue;
-			this._scanAddressTaken(node[key]);
-		}
+		scanAddressTaken(node, this._boxedVars);
 	}
 
 	_isReferenceType(t) {
-		if (!t) return false;
-		const base = t.kind === "named" ? t.underlying : t;
-		return (
-			base?.kind === "struct" ||
-			base?.kind === "slice" ||
-			base?.kind === "map" ||
-			base?.kind === "func" ||
-			base?.kind === "interface"
-		);
+		return isReferenceType(t);
 	}
 
 	// ── Variable / const declarations ────────────────────────────

package/src/{codegen → backend/js}/runtime.js

@@ -55,6 +55,13 @@ var __ifp = __ifp || function(x) {
   return x;
 };`;
 
+// Nil-interface method call guard (strict mode only): matches Go's panic
+// message instead of a JS TypeError.
+export const HELPER_NIL_CALL = `var __nilcall = __nilcall || function(x) {
+  if (x == null) throw new Error("runtime error: invalid memory address or nil pointer dereference");
+  return x;
+};`;
+
 export const HELPER_EQUAL = `var __equal = __equal || function __equal(a, b) {
   if (a === b) return true;
   if (a === null || b === null) return false;
@@ -86,6 +93,35 @@ export const HELPER_CDIV = `var __cdiv = __cdiv || function(a, b) {
   return { re: (a.re * b.re + a.im * b.im) / d, im: (a.im * b.re - a.re * b.im) / d };
 };`;
 
+// Panic/defer runtime.  \`stack\` holds the in-flight panic of every frame
+// currently running its defers; \`armed\` is set right before a deferred
+// function is invoked and consumed by that function's prologue, so recover()
+// only takes effect when called directly by the deferred function (Go spec).
+export const HELPER_PANIC = `var __gopanic = __gopanic || { stack: [], armed: false };
+var __runDefers = __runDefers || function(defers, frame) {
+  for (let i = defers.length - 1; i >= 0; i--) {
+    __gopanic.armed = true;
+    try { defers[i](); }
+    catch (e) {
+      if (frame.pn !== null) __gopanic.stack.pop();
+      frame.pn = { err: e, recovered: false };
+      __gopanic.stack.push(frame.pn);
+    } finally { __gopanic.armed = false; }
+  }
+  if (frame.pn !== null) {
+    __gopanic.stack.pop();
+    if (!frame.pn.recovered) throw frame.pn.err;
+  }
+};
+var __recover = __recover || function(ok) {
+  if (!ok) return null;
+  const s = __gopanic.stack;
+  const top = s.length > 0 ? s[s.length - 1] : null;
+  if (top === null || top.recovered) return null;
+  top.recovered = true;
+  return top.err?.message ?? String(top.err);
+};`;
+
 export const HELPER_SPRINTF = `var __sprintf = __sprintf || function(f, ...a) {
   let i = 0;
   return f.replace(/%([#+\\- 0]*)([0-9]*)\\.?([0-9]*)[sdvftxXqobeEgGw%]/g, (m) => {
@@ -150,6 +186,72 @@ export const HELPER_ERROR_IS = `var __errorIs = __errorIs || function(err, targe
   return false;
 };`;
 
+// Go-semantics strconv parsers shared by the JS backend and the wasm runtime
+// imports (boundary.js), so both targets agree.  Each parser returns
+// [value, errorMessage | null]; integer values are BigInt (the wasm side
+// needs i64, the JS side converts with Number()).
+export const HELPER_STRCONV = `var __strconv_atoi = __strconv_atoi || function(s) {
+  if (!/^[+-]?[0-9]+$/.test(s)) return [0n, 'strconv.Atoi: parsing "' + s + '": invalid syntax'];
+  const v = BigInt(s);
+  if (v > 9223372036854775807n || v < -9223372036854775808n) {
+    return [v > 0n ? 9223372036854775807n : -9223372036854775808n, 'strconv.Atoi: parsing "' + s + '": value out of range'];
+  }
+  return [v, null];
+};
+var __strconv_parse_int = __strconv_parse_int || function(s, base, bits) {
+  let str = s, neg = false;
+  if (str[0] === "-" || str[0] === "+") { neg = str[0] === "-"; str = str.slice(1); }
+  if (base === 0) {
+    if (/^0[xX]/.test(str)) { base = 16; str = str.slice(2); }
+    else if (/^0[bB]/.test(str)) { base = 2; str = str.slice(2); }
+    else if (/^0[oO]/.test(str)) { base = 8; str = str.slice(2); }
+    else if (/^0[0-9]/.test(str)) { base = 8; str = str.slice(1); }
+    else base = 10;
+    str = str.replaceAll("_", "");
+  }
+  if (base < 2 || base > 36) return [0n, 'strconv.ParseInt: parsing "' + s + '": invalid base ' + base];
+  const digits = "0123456789abcdefghijklmnopqrstuvwxyz".slice(0, base);
+  if (str === "" || [...str.toLowerCase()].some((c) => !digits.includes(c))) {
+    return [0n, 'strconv.ParseInt: parsing "' + s + '": invalid syntax'];
+  }
+  let v = 0n; const B = BigInt(base);
+  for (const c of str.toLowerCase()) v = v * B + BigInt(digits.indexOf(c));
+  if (neg) v = -v;
+  const w = bits === 0 ? 64 : bits;
+  const max = (1n << BigInt(w - 1)) - 1n, min = -(1n << BigInt(w - 1));
+  if (v > max || v < min) return [v > max ? max : min, 'strconv.ParseInt: parsing "' + s + '": value out of range'];
+  return [v, null];
+};
+var __strconv_parse_float = __strconv_parse_float || function(s) {
+  const str = s.replaceAll("_", "");
+  if (/^[+-]?(inf|infinity)$/i.test(str)) return [str[0] === "-" ? -Infinity : Infinity, null];
+  if (/^[+-]?nan$/i.test(str)) return [NaN, null];
+  if (str === "" || !/^[+-]?(\\d+\\.?\\d*|\\.\\d+)([eE][+-]?\\d+)?$|^[+-]?0[xX][0-9a-fA-F]+$/.test(str)) {
+    return [0, 'strconv.ParseFloat: parsing "' + s + '": invalid syntax'];
+  }
+  return [Number(str), null];
+};
+var __strconv_parse_bool = __strconv_parse_bool || function(s) {
+  if (["1", "t", "T", "TRUE", "true", "True"].includes(s)) return [true, null];
+  if (["0", "f", "F", "FALSE", "false", "False"].includes(s)) return [false, null];
+  return [false, 'strconv.ParseBool: parsing "' + s + '": invalid syntax'];
+};
+var __strconv_format_float = __strconv_format_float || function(f, fmtc, prec) {
+  const c = String.fromCharCode(fmtc);
+  if (!Number.isFinite(f)) return f !== f ? "NaN" : (f > 0 ? "+Inf" : "-Inf");
+  if (c === "f") return prec < 0 ? String(f) : f.toFixed(prec);
+  if (c === "e" || c === "E") {
+    const r = prec < 0 ? f.toExponential() : f.toExponential(prec);
+    const o = r.replace(/e([+-])(\\d)$/, "e$10$2");
+    return c === "E" ? o.toUpperCase() : o;
+  }
+  if (c === "g" || c === "G") {
+    const r = prec < 0 ? String(f) : f.toPrecision(prec);
+    return c === "G" ? r.toUpperCase() : r;
+  }
+  return String(f);
+};`;
+
 export const HELPER_PATH_CLEAN = `var __pathClean = __pathClean || function(p) {
   if (!p) return ".";
   const abs = p.startsWith("/");

package/src/{codegen → backend/js}/source-map.js

@@ -57,3 +57,35 @@ export function buildSourceMap(sources, mappings, sourcesContent) {
 	if (sourcesContent) map.sourcesContent = sourcesContent;
 	return JSON.stringify(map);
 }
+
+// WASM source maps use the convention "generated line 0, generated column =
+// byte offset into the module".  `mappings` is Array<{ offset, srcFileIdx,
+// srcLine }> (0-based line), one segment per function body (function-level
+// granularity); DevTools shows the Go file/line for each wasm function.
+export function buildWasmSourceMap(sources, mappings, sourcesContent) {
+	const sorted = [...mappings].sort((a, b) => a.offset - b.offset);
+	const segments = [];
+	let prevOffset = 0;
+	let prevSrcFile = 0;
+	let prevSrcLine = 0;
+	for (const m of sorted) {
+		const fileIdx = m.srcFileIdx ?? 0;
+		segments.push(
+			vlqEncode(m.offset - prevOffset) +
+				vlqEncode(fileIdx - prevSrcFile) +
+				vlqEncode(m.srcLine - prevSrcLine) +
+				vlqEncode(0),
+		);
+		prevOffset = m.offset;
+		prevSrcFile = fileIdx;
+		prevSrcLine = m.srcLine;
+	}
+	const map = {
+		version: 3,
+		sources: sources.map((s) => s.replace(/\\/g, "/")),
+		names: [],
+		mappings: segments.join(","),
+	};
+	if (sourcesContent) map.sourcesContent = sourcesContent;
+	return JSON.stringify(map);
+}