gofront 1.8.0 → 1.9.0

package/src/backend/wasm/index.js

@@ -23,18 +23,17 @@ import {
 import { desugarMethodExprs } from "./method-expr.js";
 import { ModuleEmitter } from "./module-emitter.js";
 import { hasGenerics, monomorphise } from "./monomorph.js";
+import { emitWasmIntrinsic, prepareWasmIntrinsic } from "./natives.js";
 import { hasNativeWasmOpt, optimizeWasm } from "./optimize.js";
 import {
 	_scanFuncSigInterfaces,
 	_scanImportsInBody,
 	_scanInterfaceCallNodes,
 	_scanInterfaceTypeDecls,
+	_someNode,
 	_usesAnyEq,
-	_usesFmtAny,
-	_usesTestingCleanup,
-	_usesTestingRun,
-	importsAnyOf,
 } from "./prescan.js";
+import { pruneUnusedFuncs } from "./prune-funcs.js";
 import {
 	ERROR_STRUCT,
 	getMapKeyValTypes,
@@ -84,8 +83,7 @@ function emitIndexPanicBody(mod, emitter) {
 	concat();
 	emitter.pushInstruction("end");
 	concat();
-	emitter.pushInstruction("any.convert_extern");
-	emitter.emitPanicThrow();
+	emitter.emitRuntimePanicThrow();
 }
 
 function peepholeOptimize(instructions) {
@@ -176,6 +174,7 @@ export function compileWasmModule(
 
 	const mod = new ModuleEmitter(resolvedChecker, resolvedLowerResult, progs, {
 		bundledPackages: options.bundledPackages,
+		natives: options.natives,
 	});
 
 	// 1. Collect all functions, methods, and package-level globals
@@ -591,18 +590,6 @@ export function compileWasmModule(
 			_mapInfo: mapInfo,
 			_rootFuncDecl: null,
 		});
-		// clone
-		funcDecls.push({
-			kind: "FuncDecl",
-			name: mapInfo.cloneFuncName,
-			params: [{ name: "m", type: mapInfo.wType }],
-			returnType: mapInfo.wType,
-			body: { kind: "Block", stmts: [], list: [] },
-			_isMapHelper: true,
-			_mapHelperKind: "clone",
-			_mapInfo: mapInfo,
-			_rootFuncDecl: null,
-		});
 	}
 
 	// 1e2. `gofront/shared` linear-memory helpers (only when imported).
@@ -650,9 +637,7 @@ export function compileWasmModule(
 		});
 	}
 
-	// 1e3. Runtime helpers: error values, interface equality, t.Run callback.
-	mod.usesTestingRun = funcDecls.some((fn) => _usesTestingRun(fn.body));
-	mod.usesTestingCleanup = funcDecls.some((fn) => _usesTestingCleanup(fn.body));
+	// 1e3. Runtime helpers: error values and interface equality.
 	mod.usesAnyEq = _usesAnyEq(funcDecls, mod);
 	const ANY_T = { kind: "basic", name: "any" };
 	const STR_T = { kind: "basic", name: "string" };
@@ -680,6 +665,25 @@ export function compileWasmModule(
 			),
 		);
 	}
+	// `x.(T)` outside comma-ok form panics with the dynamic type's name.
+	mod.usesTypeAssertFail = funcDecls.some((fn) =>
+		_someNode(fn.body, (n) => n.kind === "TypeAssertExpr" && !n._commaOk),
+	);
+	if (mod.usesTypeAssertFail) {
+		funcDecls.push(
+			helper(
+				"__ta_fail",
+				[
+					{ name: "v", type: ANY_T },
+					{ name: "src", type: STR_T },
+					{ name: "target", type: STR_T },
+					{ name: "iface", type: BOOL_T },
+				],
+				null,
+				"ta_fail",
+			),
+		);
+	}
 	mod.usesAnyHash = false;
 	for (const info of mod.mapTypes.values()) {
 		if (isInterfaceType(info.keyGoType, checker)) {
@@ -714,88 +718,8 @@ export function compileWasmModule(
 					_methodName: "Error",
 				},
 			),
-			helper(
-				`${ERROR_STRUCT}.Unwrap`,
-				[{ name: "e", type: errPtr }],
-				ANY_T,
-				"error_cause",
-				{
-					_isMethod: true,
-					_recvTypeName: ERROR_STRUCT,
-					_methodName: "Unwrap",
-				},
-			),
-			helper(
-				"__mk_error",
-				[
-					{ name: "msg", type: STR_T },
-					{ name: "cause", type: ANY_T },
-				],
-				ANY_T,
-				"mk_error",
-			),
+			helper("__mk_error", [{ name: "msg", type: STR_T }], ANY_T, "mk_error"),
 			helper("__error_str", [{ name: "e", type: ANY_T }], STR_T, "error_str"),
-			{
-				kind: "FuncDecl",
-				name: "__errors_unwrap",
-				params: [{ name: "__recv", type: ANY_T }],
-				returnType: ANY_T,
-				body: { kind: "Block", stmts: [], list: [] },
-				_isInterfaceDispatcher: true,
-				_softDispatch: true,
-				_ifaceName: "error",
-				_ifaceType: null,
-				_methodName: "Unwrap",
-				_rootFuncDecl: null,
-			},
-			helper(
-				"__errors_is",
-				[
-					{ name: "err", type: ANY_T },
-					{ name: "target", type: ANY_T },
-				],
-				BOOL_T,
-				"errors_is",
-			),
-		);
-	}
-	if (mod.usesTestingRun) {
-		funcDecls.push(
-			helper(
-				"__testing_run_cb",
-				[
-					{ name: "fn", type: ANY_T },
-					{
-						name: "t",
-						type: {
-							kind: "pointer",
-							base: { kind: "named", name: "testing.T" },
-						},
-					},
-				],
-				null,
-				"testing_run_cb",
-				{ _forceExport: true },
-			),
-		);
-	}
-	if (mod.usesTestingCleanup) {
-		funcDecls.push(
-			helper(
-				"__testing_cleanup_cb",
-				[{ name: "fn", type: ANY_T }],
-				null,
-				"testing_cleanup_cb",
-				{ _forceExport: true },
-			),
-		);
-	}
-	_registerIoSyntheticMethods(funcDecls, mod, STR_T, progs);
-	// `__any_fmt` turns an `any` operand of fmt into the host value; its body
-	// is emitted last-but-one so every type registered by user code is seen.
-	if (_usesFmtAny(funcDecls, mod)) {
-		funcDecls.push(
-			helper("__any_fmt", [{ name: "a", type: ANY_T }], STR_T, "any_fmt"),
 		);
 	}
 
@@ -806,6 +730,7 @@ export function compileWasmModule(
 
 	// 2. Pre-scan for needed imports so import func indices are fixed
 	for (const fn of funcDecls) {
+		if (fn.intrinsic) prepareWasmIntrinsic(mod, fn);
 		_scanImportsInBody(fn.body, mod);
 	}
 	if (boundaryMeta) scanBoundaryImports(mod, boundaryMeta);
@@ -859,8 +784,11 @@ export function compileWasmModule(
 			fn._forceExport ||
 			(!fn._isGlobalInit &&
 				!fn._isRuntimeHelper &&
-				!fn._isIoHelper &&
-				!fn._isPhase7Helper &&
+				!fn._isMapHelper &&
+				!fn._isInterfaceDispatcher &&
+				!fn._isSharedHelper &&
+				!fn._isRuntimePanic &&
+				!fn._isIndexPanic &&
 				(options.exportAll ||
 					fn.name === "main" ||
 					(fn.name[0] >= "A" && fn.name[0] <= "Z") ||
@@ -899,8 +827,7 @@ export function compileWasmModule(
 			const funcIdx = mod.getStringImportIndex();
 			emitter.pushInstruction({ op: "i32.const", value: strIdx });
 			emitter.pushInstruction({ op: "call", funcIndex: funcIdx });
-			emitter.pushInstruction("any.convert_extern");
-			emitter.emitPanicThrow();
+			emitter.emitRuntimePanicThrow();
 		} else if (fn._isPushPanic) {
 			const panicNodeTypeIndex = mod.getPanicNodeTypeIndex();
 			const panicGlobal = mod.getPanicGlobalIndex();
@@ -922,8 +849,8 @@ export function compileWasmModule(
 			emitter.emitSharedHelper(fn);
 		} else if (fn._isRuntimeHelper) {
 			emitter.emitRuntimeHelper(fn);
-		} else if (fn._isIoHelper || fn._isPhase7Helper) {
-			emitter.emitIoHelper(fn);
+		} else if (fn.intrinsic) {
+			emitWasmIntrinsic(emitter, fn);
 		} else if (fn.body) {
 			emitter.emitFunctionBody(fn.body);
 		}
@@ -961,7 +888,6 @@ export function compileWasmModule(
 		facade = generateFacade(boundaryMeta, {
 			stringTable: mod.stringTable,
 			callMain: Boolean(options.callMain) && mod.funcMap.has("main"),
-			stdlibEnv: mod.usesStdlibEnv,
 		});
 	}
 
@@ -978,6 +904,7 @@ export function compileWasmModule(
 		sourceMappingURL: options.sourceMappingURL ?? null,
 	};
 
+	pruneUnusedFuncs(moduleIR);
 	const wasmBytes = encodeModule(moduleIR);
 	const watText = options.emitWat ? emitWat(moduleIR) : null;
 
@@ -1037,428 +964,7 @@ function _collectInterfaceDispatchers(progs, funcDecls, mod, checker) {
 		});
 	}
 
-	const hasIo = importsAnyOf(progs, [
-		"io",
-		"fmt",
-		"strings",
-		"bytes",
-		"crypto/sha256",
-		"sha256",
-		"encoding/binary",
-		"binary",
-		"encoding/hex",
-		"hex",
-		"encoding/base64",
-		"base64",
-	]);
-	if (hasIo) {
-		const byteSliceType = {
-			kind: "slice",
-			elem: { kind: "basic", name: "byte" },
-		};
-		const intErrReturns = [
-			{ kind: "basic", name: "int" },
-			{ kind: "interface", name: "error" },
-		];
-		if (!interfaceCalls.has("io.Reader.Read")) {
-			interfaceCalls.set("io.Reader.Read", {
-				ifaceName: "io.Reader",
-				ifaceType: checker?.types?.get("io.Reader"),
-				methodName: "Read",
-				methodSig: {
-					kind: "func",
-					params: [byteSliceType],
-					returns: intErrReturns,
-				},
-			});
-		}
-		if (!interfaceCalls.has("io.Writer.Write")) {
-			interfaceCalls.set("io.Writer.Write", {
-				ifaceName: "io.Writer",
-				ifaceType: checker?.types?.get("io.Writer"),
-				methodName: "Write",
-				methodSig: {
-					kind: "func",
-					params: [byteSliceType],
-					returns: intErrReturns,
-				},
-			});
-		}
-	}
-
 	for (const info of interfaceCalls.values()) {
 		funcDecls.push(_makeInterfaceDispatcher(info, checker));
 	}
 }
-
-function _registerIoSyntheticMethods(funcDecls, mod, strType, programs) {
-	const progs = Array.isArray(programs) ? programs : [programs];
-	const hasStrings = importsAnyOf(progs, ["strings"]);
-	const hasBytes = importsAnyOf(progs, ["bytes"]);
-	const hasIo = importsAnyOf(progs, ["io"]);
-
-	const BYTE_SLICE_T = {
-		kind: "slice",
-		elem: { kind: "basic", name: "byte" },
-	};
-	const INT_T = { kind: "basic", name: "int" };
-	const ERR_T = { kind: "interface", name: "error" };
-	const INT_ERR_RET = { kind: "tuple", types: [INT_T, ERR_T] };
-	const ioHelper = (name, params, returnType, kind, extra = {}) => ({
-		kind: "FuncDecl",
-		name,
-		params,
-		returnType,
-		body: { kind: "Block", stmts: [], list: [] },
-		_isIoHelper: kind,
-		_rootFuncDecl: null,
-		...extra,
-	});
-
-	if (hasStrings && mod.structTypes.has("strings.Builder")) {
-		const bPtr = {
-			kind: "pointer",
-			base: { kind: "named", name: "strings.Builder" },
-		};
-		funcDecls.push(
-			ioHelper(
-				"strings.Builder.Write",
-				[
-					{ name: "b", type: bPtr },
-					{ name: "p", type: BYTE_SLICE_T },
-				],
-				INT_ERR_RET,
-				"builder_write",
-				{
-					_isMethod: true,
-					_recvTypeName: "strings.Builder",
-					_methodName: "Write",
-				},
-			),
-			ioHelper(
-				"strings.Builder.WriteString",
-				[
-					{ name: "b", type: bPtr },
-					{ name: "s", type: strType },
-				],
-				INT_ERR_RET,
-				"builder_write_string",
-				{
-					_isMethod: true,
-					_recvTypeName: "strings.Builder",
-					_methodName: "WriteString",
-				},
-			),
-		);
-	}
-	if (hasBytes && mod.structTypes.has("bytes.Buffer")) {
-		const bPtr = {
-			kind: "pointer",
-			base: { kind: "named", name: "bytes.Buffer" },
-		};
-		funcDecls.push(
-			ioHelper(
-				"bytes.Buffer.Write",
-				[
-					{ name: "b", type: bPtr },
-					{ name: "p", type: BYTE_SLICE_T },
-				],
-				INT_ERR_RET,
-				"buffer_write",
-				{
-					_isMethod: true,
-					_recvTypeName: "bytes.Buffer",
-					_methodName: "Write",
-				},
-			),
-			ioHelper(
-				"bytes.Buffer.WriteString",
-				[
-					{ name: "b", type: bPtr },
-					{ name: "s", type: strType },
-				],
-				INT_ERR_RET,
-				"buffer_write_string",
-				{
-					_isMethod: true,
-					_recvTypeName: "bytes.Buffer",
-					_methodName: "WriteString",
-				},
-			),
-			ioHelper(
-				"bytes.Buffer.Read",
-				[
-					{ name: "b", type: bPtr },
-					{ name: "p", type: BYTE_SLICE_T },
-				],
-				INT_ERR_RET,
-				"buffer_read",
-				{
-					_isMethod: true,
-					_recvTypeName: "bytes.Buffer",
-					_methodName: "Read",
-				},
-			),
-		);
-	}
-	if (hasStrings && mod.structTypes.has("strings.Reader")) {
-		const rPtr = {
-			kind: "pointer",
-			base: { kind: "named", name: "strings.Reader" },
-		};
-		funcDecls.push(
-			ioHelper(
-				"strings.Reader.Read",
-				[
-					{ name: "r", type: rPtr },
-					{ name: "p", type: BYTE_SLICE_T },
-				],
-				INT_ERR_RET,
-				"strings_reader_read",
-				{
-					_isMethod: true,
-					_recvTypeName: "strings.Reader",
-					_methodName: "Read",
-				},
-			),
-			ioHelper(
-				"strings.Reader.Len",
-				[{ name: "r", type: rPtr }],
-				INT_T,
-				"strings_reader_len",
-				{
-					_isMethod: true,
-					_recvTypeName: "strings.Reader",
-					_methodName: "Len",
-				},
-			),
-			ioHelper(
-				"strings.Reader.Reset",
-				[
-					{ name: "r", type: rPtr },
-					{ name: "s", type: strType },
-				],
-				null,
-				"strings_reader_reset",
-				{
-					_isMethod: true,
-					_recvTypeName: "strings.Reader",
-					_methodName: "Reset",
-				},
-			),
-		);
-	}
-	if (hasBytes && mod.structTypes.has("bytes.Reader")) {
-		const rPtr = {
-			kind: "pointer",
-			base: { kind: "named", name: "bytes.Reader" },
-		};
-		funcDecls.push(
-			ioHelper(
-				"bytes.Reader.Read",
-				[
-					{ name: "r", type: rPtr },
-					{ name: "p", type: BYTE_SLICE_T },
-				],
-				INT_ERR_RET,
-				"bytes_reader_read",
-				{ _isMethod: true, _recvTypeName: "bytes.Reader", _methodName: "Read" },
-			),
-			ioHelper(
-				"bytes.Reader.Len",
-				[{ name: "r", type: rPtr }],
-				INT_T,
-				"bytes_reader_len",
-				{ _isMethod: true, _recvTypeName: "bytes.Reader", _methodName: "Len" },
-			),
-			ioHelper(
-				"bytes.Reader.Reset",
-				[
-					{ name: "r", type: rPtr },
-					{ name: "b", type: BYTE_SLICE_T },
-				],
-				null,
-				"bytes_reader_reset",
-				{
-					_isMethod: true,
-					_recvTypeName: "bytes.Reader",
-					_methodName: "Reset",
-				},
-			),
-		);
-	}
-	if (hasIo && mod.structTypes.has("io.discard")) {
-		const dPtr = {
-			kind: "pointer",
-			base: { kind: "named", name: "io.discard" },
-		};
-		funcDecls.push(
-			ioHelper(
-				"io.discard.Write",
-				[
-					{ name: "d", type: dPtr },
-					{ name: "p", type: BYTE_SLICE_T },
-				],
-				INT_ERR_RET,
-				"discard_write",
-				{ _isMethod: true, _recvTypeName: "io.discard", _methodName: "Write" },
-			),
-			ioHelper(
-				"io.discard.WriteString",
-				[
-					{ name: "d", type: dPtr },
-					{ name: "s", type: strType },
-				],
-				INT_ERR_RET,
-				"discard_write_string",
-				{
-					_isMethod: true,
-					_recvTypeName: "io.discard",
-					_methodName: "WriteString",
-				},
-			),
-		);
-	}
-	if (hasIo && mod.structTypes.has("io.LimitedReader")) {
-		const lrPtr = {
-			kind: "pointer",
-			base: { kind: "named", name: "io.LimitedReader" },
-		};
-		funcDecls.push(
-			ioHelper(
-				"io.LimitedReader.Read",
-				[
-					{ name: "l", type: lrPtr },
-					{ name: "p", type: BYTE_SLICE_T },
-				],
-				INT_ERR_RET,
-				"limited_reader_read",
-				{
-					_isMethod: true,
-					_recvTypeName: "io.LimitedReader",
-					_methodName: "Read",
-				},
-			),
-		);
-	}
-	const hasOs = importsAnyOf(progs, ["os"]);
-	if (hasOs && mod.structTypes.has("os.File")) {
-		const fPtr = {
-			kind: "pointer",
-			base: { kind: "named", name: "os.File" },
-		};
-		funcDecls.push(
-			ioHelper(
-				"os.File.Write",
-				[
-					{ name: "f", type: fPtr },
-					{ name: "p", type: BYTE_SLICE_T },
-				],
-				INT_ERR_RET,
-				"os_file_write",
-				{ _isMethod: true, _recvTypeName: "os.File", _methodName: "Write" },
-			),
-			ioHelper(
-				"os.File.WriteString",
-				[
-					{ name: "f", type: fPtr },
-					{ name: "s", type: strType },
-				],
-				INT_ERR_RET,
-				"os_file_write_string",
-				{
-					_isMethod: true,
-					_recvTypeName: "os.File",
-					_methodName: "WriteString",
-				},
-			),
-			ioHelper(
-				"os.File.Read",
-				[
-					{ name: "f", type: fPtr },
-					{ name: "p", type: BYTE_SLICE_T },
-				],
-				INT_ERR_RET,
-				"os_file_read",
-				{ _isMethod: true, _recvTypeName: "os.File", _methodName: "Read" },
-			),
-			ioHelper(
-				"os.File.Close",
-				[{ name: "f", type: fPtr }],
-				ERR_T,
-				"os_file_close",
-				{ _isMethod: true, _recvTypeName: "os.File", _methodName: "Close" },
-			),
-		);
-	}
-	const hasSha256 = importsAnyOf(progs, ["crypto/sha256", "sha256"]);
-	if (
-		hasSha256 &&
-		(mod.structTypes.has("sha256.digest") ||
-			mod.structTypes.has("crypto/sha256.digest"))
-	) {
-		const dPtr = {
-			kind: "pointer",
-			base: { kind: "named", name: "sha256.digest" },
-		};
-		funcDecls.push(
-			ioHelper(
-				"sha256.digest.Write",
-				[
-					{ name: "d", type: dPtr },
-					{ name: "p", type: BYTE_SLICE_T },
-				],
-				INT_ERR_RET,
-				"sha256_write",
-				{
-					_isMethod: true,
-					_recvTypeName: "sha256.digest",
-					_methodName: "Write",
-				},
-			),
-			ioHelper(
-				"sha256.digest.Sum",
-				[
-					{ name: "d", type: dPtr },
-					{ name: "b", type: BYTE_SLICE_T },
-				],
-				BYTE_SLICE_T,
-				"sha256_sum",
-				{ _isMethod: true, _recvTypeName: "sha256.digest", _methodName: "Sum" },
-			),
-			ioHelper(
-				"sha256.digest.Reset",
-				[{ name: "d", type: dPtr }],
-				null,
-				"sha256_reset",
-				{
-					_isMethod: true,
-					_recvTypeName: "sha256.digest",
-					_methodName: "Reset",
-				},
-			),
-			ioHelper(
-				"sha256.digest.Size",
-				[{ name: "d", type: dPtr }],
-				INT_T,
-				"sha256_size",
-				{
-					_isMethod: true,
-					_recvTypeName: "sha256.digest",
-					_methodName: "Size",
-				},
-			),
-			ioHelper(
-				"sha256.digest.BlockSize",
-				[{ name: "d", type: dPtr }],
-				INT_T,
-				"sha256_block_size",
-				{
-					_isMethod: true,
-					_recvTypeName: "sha256.digest",
-					_methodName: "BlockSize",
-				},
-			),
-		);
-	}
-}

package/src/backend/wasm/method-expr.js

@@ -96,6 +96,10 @@ function forwardingFuncLit(sel, recvName = "recv$") {
 	};
 }
 
+function isInterfaceRecv(t) {
+	return (t?.underlying ?? t)?.kind === "interface";
+}
+
 function methodValueLit(sel) {
 	const fnType = sel._type;
 	let recvType = sel.expr._type;
@@ -143,7 +147,14 @@ function methodValueLit(sel) {
 			returnType: typeToTypeNode(fnType),
 			body: {
 				kind: "Block",
-				stmts: [{ kind: "ReturnStmt", values: [inner] }],
+				stmts: [
+					// A method value on a nil interface panics when it is
+					// evaluated, not when it is called.
+					...(isInterfaceRecv(recvType)
+						? [{ kind: "NilCheckStmt", expr: ident(recvName, recvType, sel) }]
+						: []),
+					{ kind: "ReturnStmt", values: [inner] },
+				],
 			},
 			_type: outerType,
 			_line: sel._line,