gofront 1.7.0 → 1.9.0

package/src/backend/wasm/prescan.js

@@ -0,0 +1,249 @@
+// src/backend/wasm/prescan.js
+// Pre-scan helpers: walk the lowered AST to decide which imports, runtime helpers
+// and interface dispatchers a module needs before emission starts.
+
+import { prepareWasmNative } from "./natives.js";
+import {
+	anonIfaceName,
+	getInterfaceMethodList,
+	getReceiverTypeName,
+	isInterfaceType,
+	isNonEmptyInterface,
+	printOperandKind,
+	toWasmType,
+} from "./types.js";
+
+export function hasErrorUsage(programs) {
+	return (programs ?? []).some((p) => {
+		let found = false;
+		const scan = (n) => {
+			if (!n || found || typeof n !== "object") return;
+			if (Array.isArray(n)) {
+				for (const x of n) scan(x);
+				return;
+			}
+			if (
+				(n.kind === "Ident" ||
+					n.kind === "TypeName" ||
+					n.kind === "basic" ||
+					n.kind === "interface") &&
+				n.name === "error"
+			) {
+				found = true;
+				return;
+			}
+			for (const k of Object.keys(n)) {
+				if (!k.startsWith("_")) scan(n[k]);
+			}
+		};
+		scan(p);
+		return found;
+	});
+}
+
+// Depth-first search over AST nodes (skipping `_`-prefixed annotations).
+export function _someNode(node, pred) {
+	if (!node || typeof node !== "object") return false;
+	if (Array.isArray(node)) return node.some((n) => _someNode(n, pred));
+	if (pred(node)) return true;
+	for (const key of Object.keys(node)) {
+		if (key.startsWith("_")) continue;
+		if (_someNode(node[key], pred)) return true;
+	}
+	return false;
+}
+
+// `__any_eq` is only needed when some `==`/`!=` (or switch case) compares
+// anyref operands, a struct with an anyref field is compared, or the error
+// runtime (`errors.Is`) is present.  `_emitAnyEq` throws if this misses a
+// site, so a gap surfaces as a compile error rather than a bad module.
+export function _usesAnyEq(funcDecls, mod) {
+	if (mod.hasErrorType) return true;
+	for (const info of mod.mapTypes.values()) {
+		if (isInterfaceType(info.keyGoType, mod.checker)) return true;
+	}
+	for (const info of mod.structTypes.values()) {
+		if (info.fields?.some((f) => f.wType === "anyref")) return true;
+	}
+	const isAnyRef = (n) =>
+		Boolean(n?._type) && toWasmType(n._type, mod.checker, mod) === "anyref";
+	return funcDecls.some((fn) =>
+		_someNode(fn.body, (n) => {
+			if (n.kind === "BinaryExpr" && (n.op === "==" || n.op === "!="))
+				return isAnyRef(n.left) || isAnyRef(n.right);
+			if (n.kind === "SwitchStmt" && n.tag) return isAnyRef(n.tag);
+			return false;
+		}),
+	);
+}
+
+export function _scanImportsInBody(node, mod) {
+	if (!node || typeof node !== "object") return;
+
+	if (node.kind === "CallExpr") {
+		const { func, args } = node;
+		prepareWasmNative(mod, node);
+		if (
+			func.kind === "Ident" &&
+			(func.name === "print" || func.name === "println")
+		) {
+			const isPrintln = func.name === "println";
+			if (args.length === 0 && isPrintln) {
+				mod.getPrintlnEmptyIndex();
+			}
+			for (let i = 0; i < args.length; i++) {
+				const isLast = i === args.length - 1 && isPrintln;
+				const { wType, isBool } = printOperandKind(args[i], mod.checker);
+				mod.getLogImportIndex(wType, isLast, isBool);
+				if (!isPrintln) mod.getPrintResetIndex();
+			}
+		}
+	}
+
+	if (node.kind === "BasicLit" && node.litKind === "STRING") {
+		mod.getStringImportIndex();
+		const strVal = String(node.value ?? "");
+		mod.internString(strVal);
+	}
+
+	// Recurse child properties
+	for (const key of Object.keys(node)) {
+		if (key.startsWith("_")) continue;
+		const child = node[key];
+		if (Array.isArray(child)) {
+			for (const item of child) _scanImportsInBody(item, mod);
+		} else if (child && typeof child === "object") {
+			_scanImportsInBody(child, mod);
+		}
+	}
+}
+
+export function _scanInterfaceCallNodes(node, interfaceCalls, checker) {
+	if (!node || typeof node !== "object") return;
+	if (Array.isArray(node)) {
+		for (const item of node)
+			_scanInterfaceCallNodes(item, interfaceCalls, checker);
+		return;
+	}
+	if (node.kind === "CallExpr" && node.func?.kind === "SelectorExpr") {
+		const recvType = node.func.expr?._type;
+		if (isNonEmptyInterface(recvType, checker)) {
+			const ifaceName =
+				getReceiverTypeName(recvType, node.func.expr) ||
+				anonIfaceName(recvType);
+			const methodName = node.func.field;
+			const key = `${ifaceName}.${methodName}`;
+			if (!interfaceCalls.has(key)) {
+				interfaceCalls.set(key, {
+					ifaceName,
+					ifaceType: recvType,
+					methodName,
+					callNode: node,
+				});
+			}
+		}
+	}
+	for (const key of Object.keys(node)) {
+		if (!key.startsWith("_"))
+			_scanInterfaceCallNodes(node[key], interfaceCalls, checker);
+	}
+}
+
+export function _scanInterfaceTypeDecls(progs, interfaceCalls, checker) {
+	for (const p of progs) {
+		for (const d of p.decls ?? []) {
+			if (d.kind !== "TypeDecl") continue;
+			const resolved = checker?.types?.get(d.name) ?? d.type;
+			const underlying =
+				resolved?.kind === "named"
+					? resolved.underlying
+					: d.type?.kind === "InterfaceType"
+						? d.type
+						: resolved;
+			if (!isNonEmptyInterface(underlying, checker)) continue;
+			const methods =
+				underlying.methods instanceof Map
+					? Array.from(underlying.methods.entries())
+					: Array.isArray(underlying.methods)
+						? underlying.methods.map((m) => [m.name ?? m, m])
+						: [];
+			for (const [mName, mSig] of methods) {
+				const key = `${d.name}.${mName}`;
+				if (!interfaceCalls.has(key)) {
+					interfaceCalls.set(key, {
+						ifaceName: d.name,
+						ifaceType: resolved,
+						methodName: mName,
+						methodSig: mSig,
+					});
+				}
+			}
+		}
+	}
+}
+
+// A qualified interface (`fmt.Stringer`) in a signature is a boundary type
+// when the function is exported, so its dispatchers must exist.  Returns true
+// when `t` names such a type.
+function _registerQualifiedIface(t, interfaceCalls, checker) {
+	if (t.kind !== "TypeName" || !t.name?.includes(".")) return false;
+	const resolved = checker?.types?.get(t.name);
+	const iface = resolved?.underlying ?? resolved;
+	if (!resolved || !isNonEmptyInterface(iface, checker)) return true;
+	for (const m of getInterfaceMethodList(iface)) {
+		const key = `${t.name}.${m.name}`;
+		if (interfaceCalls.has(key)) continue;
+		interfaceCalls.set(key, {
+			ifaceName: t.name,
+			ifaceType: resolved,
+			methodName: m.name,
+			methodSig: { kind: "func", params: m.params, returns: m.returns },
+		});
+	}
+	return true;
+}
+
+export function _scanFuncSigInterfaces(
+	progs,
+	funcDecls,
+	interfaceCalls,
+	checker,
+	mod,
+) {
+	const scanType = (t) => {
+		if (!t) return;
+		if (_registerQualifiedIface(t, interfaceCalls, checker)) return;
+		if (t.kind === "InterfaceType" || (t.kind === "interface" && !t.name)) {
+			const mList = getInterfaceMethodList(t);
+			if (mList.length === 0) return;
+			const ifaceName = anonIfaceName(t, checker, mod);
+			for (const m of mList) {
+				const key = `${ifaceName}.${m.name}`;
+				if (!interfaceCalls.has(key)) {
+					interfaceCalls.set(key, {
+						ifaceName,
+						ifaceType: t,
+						methodName: m.name,
+						methodSig: {
+							kind: "func",
+							params: m.params,
+							returns: m.returns,
+						},
+					});
+				}
+			}
+		}
+	};
+	for (const fn of funcDecls) {
+		for (const p of fn.params ?? []) scanType(p.type);
+		scanType(fn.returnType);
+	}
+	for (const p of progs) {
+		for (const d of p.decls ?? []) {
+			if (d.kind === "FuncDecl") {
+				for (const param of d.params ?? []) scanType(param.type);
+				scanType(d.returnType);
+			}
+		}
+	}
+}

package/src/backend/wasm/prune-funcs.js

@@ -0,0 +1,89 @@
+// src/backend/was./prune-funcs.js
+// Drops function imports and defined functions that no export, element
+// segment, global initialiser or start function reaches, and renumbers the function index space to match. Imports
+// are registered eagerly because the table is locked before bodies are
+// emitted, so most modules declare far more than they call.
+
+const FUNC_REF_OPS = new Set(["call", "return_call", "ref.func"]);
+
+const funcRef = (inst) => inst.funcIndex ?? inst.index ?? 0;
+
+function funcRefsOf(insts, visit) {
+	for (const inst of insts ?? []) {
+		if (FUNC_REF_OPS.has(inst.op)) visit(funcRef(inst));
+	}
+}
+
+// Calls `visit` for every function the module reaches without a body: exports,
+// element segments, global initialisers and the start function.
+function forEachRoot(moduleIR, visit) {
+	for (const g of moduleIR.globals ?? []) funcRefsOf(g.init, visit);
+	for (const idx of moduleIR.elements ?? []) visit(idx);
+	for (const exp of moduleIR.exports ?? []) {
+		if (exp.kind === "func") visit(exp.index);
+	}
+	if (typeof moduleIR.start === "number") visit(moduleIR.start);
+}
+
+function remapInst(inst, remap) {
+	if (!FUNC_REF_OPS.has(inst.op)) return inst;
+	const next = remap[funcRef(inst)];
+	return "funcIndex" in inst
+		? { ...inst, funcIndex: next }
+		: { ...inst, index: next };
+}
+
+// Marks every function index reachable from the roots through call bodies.
+function reachableFuncs(moduleIR, count, total) {
+	const used = new Array(total).fill(false);
+	const work = [];
+	const mark = (idx) => {
+		if (idx < total && !used[idx]) {
+			used[idx] = true;
+			work.push(idx);
+		}
+	};
+	forEachRoot(moduleIR, mark);
+	while (work.length > 0) {
+		const idx = work.pop();
+		if (idx >= count) funcRefsOf(moduleIR.funcs[idx - count].body, mark);
+	}
+	return used;
+}
+
+function applyRemap(moduleIR, remap) {
+	for (const fn of moduleIR.funcs) {
+		fn.body = fn.body.map((inst) => remapInst(inst, remap));
+	}
+	for (const g of moduleIR.globals ?? []) {
+		if (g.init) g.init = g.init.map((inst) => remapInst(inst, remap));
+	}
+	if (moduleIR.elements) {
+		moduleIR.elements = moduleIR.elements.map((idx) => remap[idx]);
+	}
+	for (const exp of moduleIR.exports ?? []) {
+		if (exp.kind === "func") exp.index = remap[exp.index];
+	}
+	if (typeof moduleIR.start === "number") {
+		moduleIR.start = remap[moduleIR.start];
+	}
+}
+
+export function pruneUnusedFuncs(moduleIR) {
+	const imports = moduleIR.imports ?? [];
+	const funcImports = imports.filter((imp) => imp.kind === "func");
+	const count = funcImports.length;
+	const total = count + moduleIR.funcs.length;
+
+	const used = reachableFuncs(moduleIR, count, total);
+	if (used.every(Boolean)) return;
+
+	const remap = new Array(total);
+	let next = 0;
+	for (let i = 0; i < total; i++) if (used[i]) remap[i] = next++;
+
+	const dropped = new Set(funcImports.filter((_, i) => !used[i]));
+	moduleIR.imports = imports.filter((imp) => !dropped.has(imp));
+	moduleIR.funcs = moduleIR.funcs.filter((_, i) => used[count + i]);
+	applyRemap(moduleIR, remap);
+}

package/src/backend/wasm/stdlib/index.js

@@ -1,43 +1,8 @@
 // src/backend/wasm/stdlib/index.js
 // Standard library emitters for the WebAssembly backend.
-//
-// Organized by domain:
-// - core.js:   math, math/bits, maps, slices, strings, strconv, fmt, errors, sort, unicode/utf8, testing
-// - bytes.js:  bytes package functions and bytes.Buffer methods
-// - pure.js:   stateless utilities (unicode, math/rand, html, path/filepath)
-// - io.js:     io constants/functions, readers/writers, fmt Fprint/Sscan, synthetic IO methods
-// - time.js:   time package (Duration, Time struct, components, Format/Parse, clock)
 
-import { BytesEmitter } from "./bytes.js";
-import { BINARY_MATH_IMPORTS, StdlibCoreEmitter } from "./core.js";
-import { IoEmitter } from "./io.js";
-import { ExtendedPackagesEmitter } from "./packages.js";
-import { PurePackagesEmitter } from "./pure.js";
 import { SimdEmitter } from "./simd.js";
-import { TimeEmitter } from "./time.js";
 
-// Aliases for backwards compatibility
-export {
-	BINARY_MATH_IMPORTS,
-	BytesEmitter,
-	ExtendedPackagesEmitter,
-	IoEmitter,
-	IoEmitter as Phase7Emitter,
-	PurePackagesEmitter,
-	PurePackagesEmitter as Phase6Emitter,
-	SimdEmitter,
-	StdlibCoreEmitter,
-	StdlibCoreEmitter as StdlibEmitter,
-	TimeEmitter,
-	TimeEmitter as Phase8Emitter,
-};
+export { SimdEmitter };
 
-export const stdlibEmitters = [
-	StdlibCoreEmitter,
-	BytesEmitter,
-	PurePackagesEmitter,
-	IoEmitter,
-	TimeEmitter,
-	ExtendedPackagesEmitter,
-	SimdEmitter,
-];
+export const stdlibEmitters = [SimdEmitter];