gofront 1.5.1 → 1.6.0

package/src/backend/wasm/optimize.js

@@ -0,0 +1,227 @@
+// src/backend/wasm/optimize.js
+// Binaryen optimization pipeline for GoFront WebAssembly modules.
+//
+// Supports:
+// - Bundled Binaryen optimizer (binaryen npm package)
+// - Native wasm-opt binary auto-detection with graceful fallback
+// - WasmGC feature flag configuration (GC, ReferenceTypes, BulkMemory, Multivalue, ExceptionHandling, etc.)
+// - Optimization levels (-O3 by default) + GUFA (Grand Unified Flow Analysis)
+// - Post-optimization module validation (WebAssembly.validate)
+// - WASM source map passthrough (`-ism` the encoder's function-level map,
+//   `-osm` the remapped one) and GoFront custom section preservation
+
+import { execFileSync, spawnSync } from "node:child_process";
+import {
+	existsSync,
+	mkdtempSync,
+	readFileSync,
+	rmSync,
+	writeFileSync,
+} from "node:fs";
+import { createRequire } from "node:module";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { GOFRONT_SECTION_BYTES, isGoFrontWasm } from "./encode.js";
+
+// Binaryen feature bitmask: GC (1024) | ReferenceTypes (256) | BulkMemory (16) | Multivalue (512) |
+// ExceptionHandling (64) | MutableGlobals (2) | NontrappingFPToInt (4) | TailCall (128) = 2006
+export const DEFAULT_WASM_FEATURES = 2006;
+
+let _nativeWasmOptAvailable = null;
+let _npmWasmOptPath = null;
+
+const _require = createRequire(import.meta.url);
+
+function getNpmWasmOptPath() {
+	if (_npmWasmOptPath === null) {
+		try {
+			_npmWasmOptPath = _require.resolve("binaryen/bin/wasm-opt");
+		} catch {
+			_npmWasmOptPath = "";
+		}
+	}
+	return _npmWasmOptPath;
+}
+
+export function hasNativeWasmOpt() {
+	if (_nativeWasmOptAvailable === null) {
+		try {
+			const res = spawnSync("wasm-opt", ["--version"], { stdio: "ignore" });
+			_nativeWasmOptAvailable = res.status === 0;
+		} catch {
+			_nativeWasmOptAvailable = false;
+		}
+	}
+	return _nativeWasmOptAvailable;
+}
+
+// Injects GoFront custom section right after the 8-byte WASM header so that
+// isGoFrontWasm recognises the module for clean artifact cleanup.
+export function injectGoFrontSection(bytes) {
+	if (isGoFrontWasm(bytes)) return bytes;
+	if (!bytes || bytes.length < 8) return bytes;
+	const header = bytes.subarray(0, 8);
+	const rest = bytes.subarray(8);
+	const tagged = new Uint8Array(
+		header.length + GOFRONT_SECTION_BYTES.length + rest.length,
+	);
+	tagged.set(header, 0);
+	tagged.set(GOFRONT_SECTION_BYTES, header.length);
+	tagged.set(rest, header.length + GOFRONT_SECTION_BYTES.length);
+	return tagged;
+}
+
+function runWasmOpt(
+	command,
+	cmdArgs,
+	wasmBytes,
+	options = {},
+	engine = "native",
+) {
+	const dir = mkdtempSync(join(tmpdir(), "gofront-wasmopt-"));
+	const input = join(dir, "in.wasm");
+	const output = join(dir, "out.wasm");
+	const mapOutput = join(dir, "out.wasm.map");
+	const watOutput = join(dir, "out.wat");
+	try {
+		writeFileSync(input, wasmBytes);
+		const level = options.level ?? 3;
+		const shrinkLevel = options.shrinkLevel ?? 0;
+		const args = [
+			`-O${level}`,
+			`--shrink-level=${shrinkLevel}`,
+			"--enable-gc",
+			"--enable-reference-types",
+			"--enable-exception-handling",
+			"--enable-multivalue",
+			"--enable-bulk-memory",
+			"--enable-mutable-globals",
+			"--enable-nontrapping-float-to-int",
+			"--enable-tail-call",
+		];
+		if (options.gufa !== false) {
+			args.push("--gufa");
+		}
+		if (options.sourceMap) {
+			if (options.inputSourceMap) {
+				const mapInput = join(dir, "in.wasm.map");
+				writeFileSync(mapInput, options.inputSourceMap);
+				args.push("-ism", mapInput);
+			}
+			args.push("-osm", mapOutput);
+			if (options.sourceMapUrl) {
+				args.push("-osu", options.sourceMapUrl);
+			}
+		}
+		args.push(input, "-o", output);
+		execFileSync(command, [...cmdArgs, ...args], { stdio: "pipe" });
+		const optimizedBytes = new Uint8Array(readFileSync(output));
+		let sourceMap = null;
+		if (options.sourceMap && existsSync(mapOutput)) {
+			sourceMap = readFileSync(mapOutput, "utf8");
+		}
+		let wat = null;
+		if (options.emitWat) {
+			try {
+				const watArgs = [
+					`-O${level}`,
+					`--shrink-level=${shrinkLevel}`,
+					"--enable-gc",
+					"--enable-reference-types",
+					"--enable-exception-handling",
+					"--enable-multivalue",
+					"--enable-bulk-memory",
+					"--enable-mutable-globals",
+					"--enable-nontrapping-float-to-int",
+					"--enable-tail-call",
+				];
+				if (options.gufa !== false) watArgs.push("--gufa");
+				watArgs.push(input, "-S", "-o", watOutput);
+				execFileSync(command, [...cmdArgs, ...watArgs], { stdio: "pipe" });
+				if (existsSync(watOutput)) {
+					wat = readFileSync(watOutput, "utf8");
+				}
+			} catch {
+				// Continue if WAT generation fails
+			}
+		}
+		const tagged = injectGoFrontSection(optimizedBytes);
+		if (typeof WebAssembly !== "undefined" && !WebAssembly.validate(tagged)) {
+			throw new Error("WASM module validation failed after optimization");
+		}
+		return {
+			wasm: tagged,
+			wat,
+			sourceMap,
+			engine,
+		};
+	} catch (e) {
+		const stderr = e.stderr ? e.stderr.toString() : e.message;
+		throw new Error(`WASM optimization failed: ${stderr}`);
+	} finally {
+		rmSync(dir, { recursive: true, force: true });
+	}
+}
+
+function optimizeWithNative(wasmBytes, options = {}) {
+	return runWasmOpt("wasm-opt", [], wasmBytes, options, "native");
+}
+
+export function optimizeWithBinaryen(wasmBytes, options = {}) {
+	const npmPath = getNpmWasmOptPath();
+	if (!npmPath) {
+		throw new Error("Binaryen npm package wasm-opt binary not found");
+	}
+	return runWasmOpt(
+		process.execPath,
+		[npmPath],
+		wasmBytes,
+		options,
+		"binaryen",
+	);
+}
+
+export function optimizeWasm(wasmBytes, options = {}) {
+	if (!wasmBytes || wasmBytes.length === 0) {
+		return {
+			wasm: wasmBytes,
+			wat: null,
+			sourceMap: null,
+			originalSize: 0,
+			optimizedSize: 0,
+			savedBytes: 0,
+			percentSaved: 0,
+			engine: "none",
+		};
+	}
+
+	const originalSize = wasmBytes.length;
+	let res;
+	if (options.preferNative !== false && hasNativeWasmOpt()) {
+		try {
+			res = optimizeWithNative(wasmBytes, options);
+		} catch {
+			res = optimizeWithBinaryen(wasmBytes, options);
+		}
+	} else {
+		res = optimizeWithBinaryen(wasmBytes, options);
+	}
+
+	const optimizedSize = res.wasm.length;
+	const savedBytes = originalSize - optimizedSize;
+	const percentSaved =
+		originalSize > 0
+			? Number(((savedBytes / originalSize) * 100).toFixed(1))
+			: 0;
+
+	return {
+		wasm: res.wasm,
+		wat: res.wat ?? null,
+		sourceMap: res.sourceMap ?? null,
+		originalSize,
+		optimizedSize,
+		savedBytes,
+		percentSaved,
+		engine: res.engine,
+	};
+}

package/src/backend/wasm/types.js

@@ -1,6 +1,11 @@
 // src/backend/wasm/types.js
 // Maps GoFront types to WasmGC types and manages type registry.
 
+import { SHARED_KINDS } from "../../typechecker/stdlib/shared.js";
+
+// 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) {
@@ -16,6 +21,22 @@ export function isTestingT(goType) {
 
 export function toWasmType(goType, checker = null, mod = null) {
 	if (!goType) return "i32";
+	if (typeof goType === "string") {
+		if (
+			goType === "i32" ||
+			goType === "i64" ||
+			goType === "f32" ||
+			goType === "f64" ||
+			goType === "anyref" ||
+			goType === "externref" ||
+			goType === "funcref"
+		) {
+			return goType;
+		}
+	}
+	if (typeof goType === "object" && goType.kind === "ref") {
+		return goType;
+	}
 	if (isTestingT(goType)) return "externref";
 
 	// Pointer AST nodes
@@ -30,13 +51,20 @@ export function toWasmType(goType, checker = null, mod = null) {
 		);
 	}
 
-	// Slice and Array AST nodes
+	// Slice, Array, and Map AST nodes
 	if (goType.kind === "SliceType") {
 		return toWasmType({ kind: "slice", elem: goType.elem }, checker, mod);
 	}
 	if (goType.kind === "ArrayType") {
 		return toWasmType({ kind: "array", elem: goType.elem }, checker, mod);
 	}
+	if (goType.kind === "MapType") {
+		return toWasmType(
+			{ kind: "map", key: goType.key, value: goType.value ?? goType.elem },
+			checker,
+			mod,
+		);
+	}
 
 	// TypeName AST node
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {
@@ -144,6 +172,16 @@ export function toWasmType(goType, checker = null, mod = null) {
 		return { kind: "ref", nullable: true, heapType: "any" };
 	}
 
+	if (goType.kind === "shared") {
+		if (mod?.getSharedType)
+			return {
+				kind: "ref",
+				nullable: true,
+				typeIndex: mod.getSharedType().typeIndex,
+			};
+		return { kind: "ref", nullable: true, heapType: "struct" };
+	}
+
 	if (goType.kind === "slice") {
 		if (mod?.getSliceType && goType.elem) {
 			const sliceInfo = mod.getSliceType(goType.elem);
@@ -168,6 +206,20 @@ export function toWasmType(goType, checker = null, mod = null) {
 		return { kind: "ref", nullable: true, heapType: "array" };
 	}
 
+	if (goType.kind === "map") {
+		const key = goType.key;
+		const val = goType.value ?? goType.elem;
+		if (mod?.getMapType && key && val) {
+			const mapInfo = mod.getMapType(key, val);
+			return {
+				kind: "ref",
+				nullable: true,
+				typeIndex: mapInfo.typeIndex,
+			};
+		}
+		return { kind: "ref", nullable: true, heapType: "struct" };
+	}
+
 	if (goType.kind === "struct") {
 		if (goType.name && mod?.getStructType(goType.name)) {
 			return {
@@ -235,6 +287,20 @@ export function isSliceType(goType, checker = null) {
 	return goType.kind === "slice" || goType.kind === "SliceType";
 }
 
+// `gofront/shared` linear-memory buffer: returns the SHARED_KINDS entry
+// (elem, ctor, bytes, key) or null.
+export function getSharedInfo(goType, checker = null) {
+	if (!goType) return null;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const resolved = checker?.types?.get(goType.name);
+		return resolved ? getSharedInfo(resolved, checker) : null;
+	}
+	if (goType.kind === "named" && goType.underlying)
+		return getSharedInfo(goType.underlying, checker);
+	if (goType.kind !== "shared") return null;
+	return { name: goType.shared, ...SHARED_KINDS[goType.shared] };
+}
+
 export function isArrayType(goType, checker = null) {
 	if (!goType) return false;
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {
@@ -247,6 +313,37 @@ export function isArrayType(goType, checker = null) {
 	return goType.kind === "array" || goType.kind === "ArrayType";
 }
 
+export function isMapType(goType, checker = null) {
+	if (!goType) return false;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isMapType(resolved, checker);
+	}
+	if (goType.kind === "named" && goType.underlying) {
+		return isMapType(goType.underlying, checker);
+	}
+	return goType.kind === "map" || goType.kind === "MapType";
+}
+
+// Returns `{ keyType, valType }` (Go types) for a map type, or nulls.
+export function getMapKeyValTypes(goType, checker = null) {
+	if (!goType) return { keyType: null, valType: null };
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return getMapKeyValTypes(resolved, checker);
+	}
+	if (goType.kind === "named" && goType.underlying) {
+		return getMapKeyValTypes(goType.underlying, checker);
+	}
+	if (goType.kind === "map" || goType.kind === "MapType") {
+		const key = goType.key ?? goType.keyType;
+		const val =
+			goType.value ?? goType.elem ?? goType.valueType ?? goType.valType;
+		return { keyType: key, valType: val };
+	}
+	return { keyType: null, valType: null };
+}
+
 export function isStringType(goType, checker = null) {
 	if (!goType) return false;
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {
@@ -279,27 +376,75 @@ export function isAnyType(goType, checker = null) {
 	return false;
 }
 
-export function isNarrowInt(goType) {
+export function isInterfaceType(goType, checker = null) {
 	if (!goType) return false;
+	if (goType.kind === "interface" || goType.kind === "InterfaceType")
+		return true;
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {
-		return isNarrowInt({ kind: "basic", name: goType.name });
+		if (goType.name === "any" || goType.name === "interface{}") return true;
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isInterfaceType(resolved, checker);
 	}
-	if (goType.kind === "named" && goType.underlying) {
-		return isNarrowInt(goType.underlying);
+	if (goType.kind === "named") {
+		if (goType.name === "any" || goType.name === "interface{}") return true;
+		if (goType.underlying) return isInterfaceType(goType.underlying, checker);
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isInterfaceType(resolved, checker);
 	}
-	if (goType.kind === "basic") {
-		switch (goType.name) {
-			case "int8":
-			case "int16":
-			case "uint8":
-			case "uint16":
-			case "byte":
-				return true;
-		}
+	return false;
+}
+
+// The built-in `error` interface (checker ERROR type or its name).
+export function isErrorType(goType) {
+	if (!goType) return false;
+	if (goType.kind === "interface") return goType.name === "error";
+	if (
+		(goType.kind === "named" ||
+			goType.kind === "TypeName" ||
+			goType.kind === "Ident") &&
+		goType.name === "error"
+	) {
+		return true;
+	}
+	if (goType.kind === "named" && goType.underlying)
+		return isErrorType(goType.underlying);
+	return false;
+}
+
+export function isNonEmptyInterface(goType, checker = null) {
+	if (!goType) return false;
+	if (goType.name === "any" || goType.name === "interface{}") return false;
+	if (goType.kind === "TypeName" || goType.kind === "Ident") {
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isNonEmptyInterface(resolved, checker);
+	}
+	if (goType.kind === "named") {
+		if (goType.name === "any" || goType.name === "interface{}") return false;
+		if (goType.underlying)
+			return isNonEmptyInterface(goType.underlying, checker);
+		const resolved = checker?.types?.get(goType.name);
+		if (resolved) return isNonEmptyInterface(resolved, checker);
+	}
+	if (goType.kind === "interface" || goType.kind === "InterfaceType") {
+		if (goType.methods instanceof Map) return goType.methods.size > 0;
+		if (Array.isArray(goType.methods)) return goType.methods.length > 0;
+		if (goType.methods instanceof Set) return goType.methods.size > 0;
+		return false;
 	}
 	return false;
 }
 
+export function getReceiverTypeName(recvType, _node = null) {
+	if (recvType) {
+		let t = recvType;
+		while (t.kind === "pointer") t = t.base;
+		if (t.name) return t.name;
+		if (t.kind === "named") return t.name;
+		if (t.kind === "TypeName" || t.kind === "Ident") return t.name;
+	}
+	return null;
+}
+
 export function isSigned(goType) {
 	if (!goType) return true;
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {
@@ -329,27 +474,6 @@ export function isFloat(goType) {
 	);
 }
 
-export function isInt(goType) {
-	if (!goType) return false;
-	if (goType.kind === "TypeName" || goType.kind === "Ident") {
-		return isInt({ kind: "basic", name: goType.name });
-	}
-	if (goType.kind === "named" && goType.underlying) {
-		return isInt(goType.underlying);
-	}
-	if (goType.kind === "untyped") return goType.base === "int";
-	if (goType.kind === "basic") {
-		return (
-			goType.name.startsWith("int") ||
-			goType.name.startsWith("uint") ||
-			goType.name === "byte" ||
-			goType.name === "rune" ||
-			goType.name === "uintptr"
-		);
-	}
-	return false;
-}
-
 export function isFuncType(goType, checker = null) {
 	if (!goType) return false;
 	if (goType.kind === "TypeName" || goType.kind === "Ident") {

package/src/backend/wasm/wat.js

@@ -83,6 +83,21 @@ function formatInstruction(inst) {
 		case "global.get":
 		case "global.set":
 			return `${op} ${inst.globalIndex ?? inst.index ?? 0}`;
+		case "i32.load":
+		case "i64.load":
+		case "f32.load":
+		case "f64.load":
+		case "i32.load8_s":
+		case "i32.load8_u":
+		case "i32.load16_s":
+		case "i32.load16_u":
+		case "i32.store":
+		case "i64.store":
+		case "f32.store":
+		case "f64.store":
+		case "i32.store8":
+		case "i32.store16":
+			return inst.offset ? `${op} offset=${inst.offset}` : op;
 		case "i32.const":
 		case "i64.const":
 			return `${op} ${inst.value ?? 0}`;
@@ -96,6 +111,26 @@ function formatInstruction(inst) {
 		}
 		case "throw":
 			return `${op} ${inst.tagIndex ?? inst.index ?? 0}`;
+		case "throw_ref":
+			return "throw_ref";
+		case "try_table": {
+			const bt = inst.blockType ?? inst.resultType;
+			const res = bt && bt !== "void" ? ` (result ${formatValType(bt)})` : "";
+			const catches = (inst.catches ?? [])
+				.map((c) => {
+					const k = c.kind ?? c.op;
+					if (k === "catch")
+						return `(catch ${c.tagIndex ?? 0} ${c.label ?? 0})`;
+					if (k === "catch_ref")
+						return `(catch_ref ${c.tagIndex ?? 0} ${c.label ?? 0})`;
+					if (k === "catch_all") return `(catch_all ${c.label ?? 0})`;
+					if (k === "catch_all_ref") return `(catch_all_ref ${c.label ?? 0})`;
+					return "";
+				})
+				.filter(Boolean)
+				.join(" ");
+			return `${op}${res}${catches ? ` ${catches}` : ""}`;
+		}
 		case "struct.new":
 			return `struct.new ${inst.typeIndex !== undefined ? `$t${inst.typeIndex}` : 0}`;
 		case "struct.get":
@@ -119,8 +154,15 @@ function formatInstruction(inst) {
 		case "ref.test":
 		case "ref.test_null":
 		case "ref.cast":
-		case "ref.cast_null":
-			return `${op} ${inst.typeIndex !== undefined ? `$t${inst.typeIndex}` : 0}`;
+		case "ref.cast_null": {
+			const ht =
+				inst.typeIndex !== undefined
+					? `$t${inst.typeIndex}`
+					: inst.heapType !== undefined
+						? String(inst.heapType)
+						: 0;
+			return `${op} ${ht}`;
+		}
 		case "any.convert_extern":
 		case "extern.convert_any":
 			return op;
@@ -166,6 +208,11 @@ export function emitWat(mod) {
 		}
 	}
 
+	if (mod.memory) {
+		const max = mod.memory.max != null ? ` ${mod.memory.max}` : "";
+		lines.push(`  (memory $mem ${mod.memory.min}${max})`);
+	}
+
 	// 4. Globals
 	if (mod.globals && mod.globals.length > 0) {
 		for (let i = 0; i < mod.globals.length; i++) {