gofront 1.8.0 → 1.9.0

package/src/backend/wasm/prescan.js

@@ -2,28 +2,17 @@
 // Pre-scan helpers: walk the lowered AST to decide which imports, runtime helpers
 // and interface dispatchers a module needs before emission starts.
 
-import { BINARY_MATH_IMPORTS } from "./stdlib/core.js";
+import { prepareWasmNative } from "./natives.js";
 import {
 	anonIfaceName,
 	getInterfaceMethodList,
 	getReceiverTypeName,
-	isAnyType,
-	isBoolGoType,
 	isInterfaceType,
 	isNonEmptyInterface,
-	isTestingT,
+	printOperandKind,
 	toWasmType,
 } from "./types.js";
 
-export function importsAnyOf(programs, pkgs) {
-	const has = (p) => (pkgs instanceof Set ? pkgs.has(p) : pkgs.includes(p));
-	return (programs ?? []).some((p) =>
-		(p.imports ?? []).some((decl) =>
-			(decl.imports ?? [decl]).some((imp) => has(imp.path)),
-		),
-	);
-}
-
 export function hasErrorUsage(programs) {
 	return (programs ?? []).some((p) => {
 		let found = false;
@@ -64,28 +53,6 @@ export function _someNode(node, pred) {
 	return false;
 }
 
-export function _usesTestingRun(node) {
-	return _someNode(
-		node,
-		(n) =>
-			n.kind === "CallExpr" &&
-			n.func?.kind === "SelectorExpr" &&
-			n.func.field === "Run" &&
-			isTestingT(n.func.expr?._type),
-	);
-}
-
-export function _usesTestingCleanup(node) {
-	return _someNode(
-		node,
-		(n) =>
-			n.kind === "CallExpr" &&
-			n.func?.kind === "SelectorExpr" &&
-			n.func.field === "Cleanup" &&
-			isTestingT(n.func.expr?._type),
-	);
-}
-
 // `__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
@@ -110,68 +77,12 @@ export function _usesAnyEq(funcDecls, mod) {
 	);
 }
 
-// An `fmt` call with an `any`/interface operand or a `xs...` spread needs
-// `__any_fmt`.  `emitFmtCall` falls back to scalar-only dispatch without it.
-export function _usesFmtAny(funcDecls, mod) {
-	return funcDecls.some((fn) =>
-		_someNode(
-			fn.body,
-			(n) =>
-				n.kind === "CallExpr" &&
-				n.func?.kind === "SelectorExpr" &&
-				n.func.expr?.kind === "Ident" &&
-				n.func.expr.name === "fmt" &&
-				n.args?.some(
-					(a) =>
-						a._spread ||
-						isAnyType(a._type, mod.checker) ||
-						isInterfaceType(a._type, mod.checker),
-				),
-		),
-	);
-}
-
-// Whether a value of this static type may print a 64-bit unsigned integer
-// (directly, inside a container or struct, or behind `any`/an interface).
-export function typeMayHoldU64(t, mod, seen = new Set(), depth = 0) {
-	if (!t || typeof t !== "object" || seen.has(t) || depth > 8) return false;
-	seen.add(t);
-	if (isAnyType(t, mod.checker) || isInterfaceType(t, mod.checker)) return true;
-	const sub = (x) => typeMayHoldU64(x, mod, seen, depth + 1);
-	switch (t.kind) {
-		case "basic":
-			return t.name === "uint64" || t.name === "uint" || t.name === "uintptr";
-		case "TypeName":
-		case "Ident":
-			return sub(
-				mod.checker?.resolveType?.(t) ?? { kind: "basic", name: t.name },
-			);
-		case "named":
-			return sub(t.underlying);
-		case "tuple":
-			return (t.types ?? []).some(sub);
-		case "pointer":
-			return sub(t.base);
-		case "slice":
-		case "array":
-			return sub(t.elem);
-		case "map":
-			return sub(t.key) || sub(t.value);
-		case "struct":
-			return [...(t.fields?.values?.() ?? [])].some(sub);
-		default:
-			return false;
-	}
-}
-
 export function _scanImportsInBody(node, mod) {
 	if (!node || typeof node !== "object") return;
 
 	if (node.kind === "CallExpr") {
 		const { func, args } = node;
-		if ((args ?? []).some((a) => a._spread || typeMayHoldU64(a._type, mod))) {
-			mod.getFmtBoxU64Index();
-		}
+		prepareWasmNative(mod, node);
 		if (
 			func.kind === "Ident" &&
 			(func.name === "print" || func.name === "println")
@@ -181,69 +92,10 @@ export function _scanImportsInBody(node, mod) {
 				mod.getPrintlnEmptyIndex();
 			}
 			for (let i = 0; i < args.length; i++) {
-				const arg = args[i];
 				const isLast = i === args.length - 1 && isPrintln;
-				const isBool =
-					isBoolGoType(arg._type) ||
-					(arg.kind === "BasicLit" && arg.litKind === "BOOL");
-				const wType = toWasmType(arg._type, mod.checker);
+				const { wType, isBool } = printOperandKind(args[i], mod.checker);
 				mod.getLogImportIndex(wType, isLast, isBool);
-			}
-		} else if (
-			func.kind === "SelectorExpr" &&
-			func.expr?.name === "math" &&
-			func.field
-		) {
-			const jsMathMap = {
-				Sin: "sin",
-				Cos: "cos",
-				Tan: "tan",
-				Asin: "asin",
-				Acos: "acos",
-				Atan: "atan",
-				Atan2: "atan2",
-				Pow: "pow",
-				Mod: "mod",
-				Hypot: "hypot",
-				Cbrt: "cbrt",
-				Exp: "exp",
-				Log: "log",
-				Log1p: "log1p",
-				Log2: "log2",
-				Log10: "log10",
-				Expm1: "expm1",
-				Round: "round",
-				Sinh: "sinh",
-				Cosh: "cosh",
-				Tanh: "tanh",
-			};
-			if (jsMathMap[func.field]) {
-				const isBinary = BINARY_MATH_IMPORTS.has(jsMathMap[func.field]);
-				mod.getMathImportIndex(jsMathMap[func.field], isBinary);
-			}
-		} else if (
-			func.kind === "SelectorExpr" &&
-			isTestingT(func.expr?._type) &&
-			func.field
-		) {
-			mod.internString(func.field);
-			if (func.field === "Name") mod.getTestingNameImportIndex();
-			else if (func.field === "Failed" || func.field === "Skipped")
-				mod.getTestingFlagImportIndex();
-			else if (func.field === "Run") {
-				// closure type for func(*testing.T) must exist before bodies are emitted
-				mod.getTestingRunClosureType();
-			} else if (func.field === "Cleanup") {
-				mod.getTestingCleanupClosureType();
-			} else {
-				mod.getTestingCallImportIndex();
-				for (const arg of args) {
-					mod.getTestingArgImportIndex(
-						toWasmType(arg._type, mod.checker),
-						isBoolGoType(arg._type) ||
-							(arg.kind === "BasicLit" && arg.litKind === "BOOL"),
-					);
-				}
+				if (!isPrintln) mod.getPrintResetIndex();
 			}
 		}
 	}

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,38 +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";
 
-export {
-	BINARY_MATH_IMPORTS,
-	BytesEmitter,
-	ExtendedPackagesEmitter,
-	IoEmitter,
-	PurePackagesEmitter,
-	SimdEmitter,
-	StdlibCoreEmitter,
-	TimeEmitter,
-};
+export { SimdEmitter };
 
-export const stdlibEmitters = [
-	StdlibCoreEmitter,
-	BytesEmitter,
-	PurePackagesEmitter,
-	IoEmitter,
-	TimeEmitter,
-	ExtendedPackagesEmitter,
-	SimdEmitter,
-];
+export const stdlibEmitters = [SimdEmitter];

package/src/backend/wasm/types.js

@@ -9,25 +9,6 @@ export { isComplex, isComplex64 };
 // Name of the runtime's error struct (`errors.New`, `fmt.Errorf`, strconv).
 export const ERROR_STRUCT = "__errorString";
 
-// `*testing.T` is a JS-side object (the harness's __GoFront_T) passed through
-// the boundary as an opaque externref.
-export function isTestingT(goType) {
-	if (!goType) return false;
-	const base =
-		goType.kind === "pointer" || goType.kind === "PointerType"
-			? goType.base
-			: goType.kind === "StarExpr"
-				? (goType.expr ?? goType.operand)
-				: goType;
-	const name = base?.name ?? (typeof base === "string" ? base : null);
-	return (
-		name === "testing.T" ||
-		name === "testing.B" ||
-		name === "testing.M" ||
-		name === "testing.TB"
-	);
-}
-
 export function toWasmType(goType, checker = null, mod = null) {
 	if (!goType) return "i32";
 	if (typeof goType === "string") {
@@ -47,7 +28,6 @@ export function toWasmType(goType, checker = null, mod = null) {
 	if (typeof goType === "object" && goType.kind === "ref") {
 		return goType;
 	}
-	if (isTestingT(goType)) return "externref";
 
 	if (
 		goType.kind === "simd" ||
@@ -542,6 +522,47 @@ export function isSliceType(goType, checker = null) {
 	return goType.kind === "slice" || goType.kind === "SliceType";
 }
 
+// Element kinds whose slices share one WebAssembly representation (a slice of
+// i32), so `[]bool`, `[]byte` and `[]rune` cannot be told apart by `ref.test`.
+const TAGGED_SLICE_ELEMS = new Set([
+	"bool",
+	"int8",
+	"int16",
+	"int32",
+	"uint8",
+	"uint16",
+	"uint32",
+	"byte",
+	"rune",
+]);
+
+// True for a defined slice type or a slice of booleans or integers of at
+// most 32 bits.  In an
+// interface such a value carries a per-Go-type tag (see getTaggedSliceType).
+export function isTaggedSliceType(goType, checker = null) {
+	if (!isSliceType(goType, checker)) return false;
+	// A defined slice type (`type S []int`) is tagged whatever its element, so
+	// `case S` does not match an unnamed `[]int`.
+	const declared =
+		goType.kind === "TypeName" || goType.kind === "Ident"
+			? (checker?.types?.get(goType.name) ?? goType)
+			: goType;
+	if (declared?.kind === "named") return true;
+	let elem = getSliceElemType(goType, checker);
+	// A source-level element (`uint8` in a case list) is a TypeName node.
+	for (let i = 0; i < 16 && elem; i++) {
+		if (elem.kind === "named")
+			elem = elem.underlying ?? checker?.types?.get(elem.name);
+		else if (elem.kind === "TypeName" || elem.kind === "Ident")
+			elem = checker?.types?.get(elem.name) ?? {
+				kind: "basic",
+				name: elem.name,
+			};
+		else break;
+	}
+	return elem?.kind === "basic" && TAGGED_SLICE_ELEMS.has(elem.name);
+}
+
 export function getSliceElemType(t, checker = null) {
 	if (!t) return null;
 	if (t.elem) return t.elem;
@@ -765,6 +786,33 @@ export function isSigned(goType) {
 	return true;
 }
 
+// How a builtin `print`/`println` operand is handed to the host.  The host
+// prints an i32 or i64 as signed, so a uint32 widens to i64 and a uint64 uses
+// its own unsigned import (`wType` "u64").
+export function printOperandKind(arg, checker) {
+	const isBool =
+		isBoolGoType(arg._type) ||
+		_namedBasic(arg._type) === "bool" ||
+		(arg.kind === "BasicLit" && arg.litKind === "BOOL");
+	let wType = toWasmType(arg._type, checker);
+	let widen = false;
+	if (!isBool && (wType === "i32" || wType === "i64") && !isSigned(arg._type)) {
+		if (wType === "i64") wType = "u64";
+		else if (_namedBasic(arg._type) === "uint32") {
+			wType = "i64";
+			widen = true;
+		}
+	}
+	return { wType, isBool, widen };
+}
+
+function _namedBasic(t) {
+	while (t && (t.kind === "named" || t.kind === "TypeName") && t.underlying) {
+		t = t.underlying;
+	}
+	return t?.name;
+}
+
 export function isFloat(goType) {
 	if (!goType) return false;
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {

package/src/backend/wasm/variadic.js

@@ -13,9 +13,9 @@ function variadicFuncType(t) {
 	return fn?.kind === "func" && fn.variadic ? fn : null;
 }
 
-// `fmt.Sprintf(...)` or a method of an emitter-backed type (`t.Errorf(...)`
-// on `*testing.T`): those emitters take the arguments unpacked.  Emitter
-// types are the dotted names; GoFront and Go-source types are not.
+// A call of a package member or a method of an emitter-backed type: those
+// emitters take the arguments unpacked.  Emitter types are the dotted names;
+// GoFront and Go-source types are not.
 function isStdlibCall(call) {
 	const f = call.func;
 	if (f?.kind !== "SelectorExpr") return false;

package/src/cli/cli-core.js

@@ -45,11 +45,12 @@ export function runCompile(inputPath, isDir, options) {
 		dumpAst = false,
 		emitWat = false,
 		wasmOpt = false,
+		natives = true,
 		forceTarget = null,
 		targetOverrides = null,
 		rootDir = null,
 	} = options ?? {};
-	const targetOpts = {};
+	const targetOpts = { natives };
 	if (forceTarget) targetOpts.forceTarget = forceTarget;
 	if (targetOverrides) targetOpts.targetOverrides = targetOverrides;
 	if (rootDir) targetOpts.rootDir = rootDir;
@@ -632,6 +633,7 @@ export function parseBuildArgs(argv) {
 	const noWasmOpt = argv.includes("--no-wasm-opt");
 	const wasmOpt = !noWasmOpt && (argv.includes("--wasm-opt") || release);
 	const forceTarget = parseTargetFlag(argv);
+	const natives = !argv.includes("--no-natives");
 
 	for (let i = 0; i < argv.length; i++) {
 		const arg = argv[i];
@@ -656,6 +658,7 @@ export function parseBuildArgs(argv) {
 		mangle: !noMangle && !noMinify,
 		release,
 		wasmOpt,
+		natives,
 		forceTarget,
 	};
 }
@@ -858,6 +861,7 @@ export async function handleBuild(targetDir = ".", options = {}) {
 		sourceMap: options.sourceMap ?? false,
 		emitWat: options.emitWat ?? false,
 		wasmOpt: options.wasmOpt ?? false,
+		natives: options.natives ?? true,
 		forceTarget: options.forceTarget ?? null,
 		...projectTargetOptions(project, options),
 	});