gofront 1.5.1 → 1.6.1

package/src/backend/js/index.js

@@ -19,36 +19,53 @@
 
 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,
+	HELPER_BASE64,
+	HELPER_BINARY,
 	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_IFACE_BOX,
 	HELPER_INJECT_STYLES,
+	HELPER_IO_EOF,
 	HELPER_LEN,
+	HELPER_NIL_CALL,
+	HELPER_PANIC,
 	HELPER_PATH_CLEAN,
+	HELPER_PATH_ERROR,
 	HELPER_S,
 	HELPER_SCLONE,
+	HELPER_SHA256,
 	HELPER_SORT_SLICE,
 	HELPER_SPRINTF,
+	HELPER_STRCONV,
+	HELPER_STRCONV_ERROR,
+	HELPER_SYNC,
 	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 };
+export { buildSourceMap, buildWasmSourceMap };
 
 // Valid Go identifiers that cannot be used as JS bindings; emitted with a `$` suffix.
 const JS_RESERVED = new Set([
@@ -90,6 +107,42 @@ 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],
+	["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],
+];
+
 export class CodeGen {
 	// jsImports:       Map<importPath, string[]> — npm package imports to emit at top of file
 	// bundledPackages: Set<string>               — GoFront package names bundled inline;
@@ -116,22 +169,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
@@ -217,6 +255,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;
@@ -407,28 +449,34 @@ export class CodeGen {
 		return methods;
 	}
 
+	/** 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"
+		) {
+			this._helpers.add("error");
+		}
+		if (name === "binary") {
+			this.useHelper("ioEOF");
+			this._helpers.add("error");
+		}
+	}
+
 	_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("");
@@ -559,7 +607,7 @@ export class CodeGen {
 					.map((f) => `${f.name}: ${binding(f)} = ${f.zero}`)
 					.join(", ");
 				this.line(
-					`if (typeof ${first} === "object" && ${first} !== null && ${first}.constructor === Object) ({ ${pattern} } = ${first});`,
+					`if (arguments.length === 1 && typeof ${first} === "object" && ${first} !== null && ${first}.constructor === Object) ({ ${pattern} } = ${first});`,
 				);
 			}
 			for (const f of fields) {
@@ -661,7 +709,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;
@@ -718,7 +766,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;
@@ -726,45 +774,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;
@@ -773,7 +850,12 @@ 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.