gofront 1.8.0 → 1.9.1

package/src/backend/wasm/module-emitter.js

@@ -2,8 +2,7 @@
 // ModuleEmitter: Module IR builder that registers types, imports, globals and functions.
 
 import { wTypeKey } from "./boundary.js";
-import { hasErrorUsage, importsAnyOf } from "./prescan.js";
-import { BINARY_MATH_IMPORTS } from "./stdlib/index.js";
+import { hasErrorUsage } from "./prescan.js";
 import {
 	ERROR_STRUCT,
 	getFuncSignature,
@@ -14,215 +13,6 @@ import {
 	toWasmType,
 } from "./types.js";
 
-const ERROR_PRODUCING_PKGS = new Set([
-	"errors",
-	"fmt",
-	"strconv",
-	"path",
-	"path/filepath",
-	"io",
-	"os",
-	"strings",
-	"bytes",
-	"time",
-	"sync",
-	"crypto/rand",
-	"rand",
-	"crypto/sha256",
-	"sha256",
-	"encoding/binary",
-	"binary",
-	"encoding/hex",
-	"hex",
-	"encoding/base64",
-	"base64",
-	"math/bits",
-	"bits",
-]);
-// Packages whose calls lower to the `env.*` imports in STDLIB_IMPORTS (the
-// matching JS lives in WASM_STDLIB_JS).  Only modules importing one of them
-// declare the imports and ship that JS block.
-const STDLIB_ENV_PKGS = new Set([
-	"strings",
-	"strconv",
-	"unicode/utf8",
-	"fmt",
-	"testing",
-	"unicode",
-	"math/rand",
-	"path",
-	"path/filepath",
-	"html",
-	"bytes",
-	"io",
-	"os",
-	"time",
-	"sync",
-	"crypto/rand",
-	"rand",
-	"crypto/sha256",
-	"sha256",
-	"encoding/binary",
-	"binary",
-	"encoding/hex",
-	"hex",
-	"encoding/base64",
-	"base64",
-	"math/bits",
-	"bits",
-]);
-
-// [name, params, results] for `env.*` imports backing stdlib calls; the JS
-// side lives in WASM_STDLIB_JS (boundary.js).  All are registered eagerly
-// (when any STDLIB_ENV_PKGS package is imported) because the import table is
-// locked before function bodies are emitted.
-const S = "externref";
-const STDLIB_IMPORTS = [
-	// strings
-	["str_trim", [S, S], [S]],
-	["str_trim_left", [S, S], [S]],
-	["str_trim_right", [S, S], [S]],
-	["str_trim_prefix", [S, S], [S]],
-	["str_trim_suffix", [S, S], [S]],
-	["str_cut", [S, S], ["i32"]],
-	["str_cut_before", [], [S]],
-	["str_cut_after", [], [S]],
-	["str_cut_prefix", [S, S], ["i32"]],
-	["str_cut_suffix", [S, S], ["i32"]],
-	["str_replace", [S, S, S, "i32"], [S]],
-	["str_contains_rune", [S, "i32"], ["i32"]],
-	["str_contains_any", [S, S], ["i32"]],
-	["str_index_byte", [S, "i32"], ["i32"]],
-	["str_index_rune", [S, "i32"], ["i32"]],
-	["str_index_any", [S, S], ["i32"]],
-	["str_last_index_byte", [S, "i32"], ["i32"]],
-	["str_last_index_any", [S, S], ["i32"]],
-	["str_title", [S], [S]],
-	["str_split", [S, S], ["i32"]],
-	["str_split_n", [S, S, "i32"], ["i32"]],
-	["str_split_after", [S, S], ["i32"]],
-	["str_split_after_n", [S, S, "i32"], ["i32"]],
-	["str_fields", [S], ["i32"]],
-	["str_part", ["i32"], [S]],
-	["str_replacer_init", [S], []],
-	["str_replacer_add", [S, S], []],
-	["str_replacer_run", [], [S]],
-	// strconv
-	["strconv_atoi", [S], ["i64"]],
-	["strconv_parse_int", [S, "i32", "i32"], ["i64"]],
-	["strconv_parse_float", [S], ["f64"]],
-	["strconv_parse_bool", [S], ["i32"]],
-	["strconv_err", [], [S]],
-	["strconv_err_kind", [], ["i32"]],
-	["strconv_format_float", ["f64", "i32", "i32", "i32"], [S]],
-	["strconv_format_int", ["i64", "i32"], [S]],
-	["strconv_format_uint", ["i64", "i32"], [S]],
-	["strconv_parse_uint", [S, "i32", "i32"], ["i64"]],
-	["strconv_quote", [S], [S]],
-	["strconv_unquote", [S], [S]],
-	// unicode/utf8
-	["utf8_rune_count", [S], ["i32"]],
-	["utf8_rune_len", ["i32"], ["i32"]],
-	["utf8_valid_string", [S], ["i32"]],
-	["utf8_decode_rune", [S, "i32"], ["i32"]],
-	["utf8_decode_size", [], ["i32"]],
-	["utf8_full_rune", [S], ["i32"]],
-	// fmt (arguments travel through the testing_arg_* buffer)
-	["fmt_sprintf", [S], [S]],
-	["fmt_printf", [S], []],
-	["fmt_sprint", ["i32"], [S]],
-	["fmt_print", ["i32"], []],
-	["fmt_print_raw", [S], []],
-	["fmt_format_v", [S], [S]],
-	["fmt_sscan_init", [S, "i32"], ["i32"]],
-	["fmt_sscanf_init", [S, S], ["i32"]],
-	["fmt_sscan_has_err", [], ["i32"]],
-	["fmt_sscan_err_msg", [], [S]],
-	["fmt_sscan_token_str", ["i32"], [S]],
-	["fmt_sscan_token_i64", ["i32"], ["i64"]],
-	["fmt_sscan_token_f64", ["i32"], ["f64"]],
-	["fmt_sscan_token_bool", ["i32"], ["i32"]],
-	// testing.T.Run: the harness calls back into the exported __testing_run_cb
-	["testing_run", [S, S, "anyref"], ["i32"]],
-	["testing_cleanup", [S, "anyref"], []],
-	["testing_n", [S], ["i64"]],
-	["testing_elapsed", [S], ["i64"]],
-	["testing_context", [S], [S]],
-	["testing_output", [S], [S]],
-	// unicode
-	["unicode_is_letter", ["i32"], ["i32"]],
-	["unicode_is_digit", ["i32"], ["i32"]],
-	["unicode_is_space", ["i32"], ["i32"]],
-	["unicode_is_upper", ["i32"], ["i32"]],
-	["unicode_is_lower", ["i32"], ["i32"]],
-	["unicode_is_punct", ["i32"], ["i32"]],
-	["unicode_is_control", ["i32"], ["i32"]],
-	["unicode_is_print", ["i32"], ["i32"]],
-	["unicode_is_graphic", ["i32"], ["i32"]],
-	["unicode_to_upper", ["i32"], ["i32"]],
-	["unicode_to_lower", ["i32"], ["i32"]],
-	// html
-	["html_escape", [S], [S]],
-	["html_unescape", [S], [S]],
-	// path
-	["path_base", [S], [S]],
-	["path_dir", [S], [S]],
-	["path_ext", [S], [S]],
-	["path_is_abs", [S], ["i32"]],
-	["path_clean", [S], [S]],
-	["path_split", [S], []],
-	["path_split_dir", [], [S]],
-	["path_split_file", [], [S]],
-	["path_join_init", [], []],
-	["path_join_push", [S], []],
-	["path_join_run", [], [S]],
-	["path_match", [S, S], ["i32"]],
-	["path_match_has_err", [], ["i32"]],
-	["bytes_trim", [S, S, "i32", "i32"], []],
-	["bytes_trim_start", [], ["i32"]],
-	["bytes_trim_end", [], ["i32"]],
-	// time
-	["time_now_ms", [], ["f64"]],
-	["time_timezone_offset", ["f64"], ["i32"]],
-	["time_parse", [S, S], ["f64"]],
-	["time_parse_err", [], [S]],
-	["time_parse_offset", [], ["i32"]],
-	["time_parse_sub_ns", [], ["i32"]],
-	[
-		"time_format",
-		["i32", "i32", "i32", "i32", "i32", "i32", "i32", "i32", "i32", S],
-		[S],
-	],
-	["time_duration_string", ["i64"], [S]],
-	["time_parse_duration", [S], ["i64"]],
-	["time_parse_duration_err", [], [S]],
-	["time_month_string", ["i32"], [S]],
-	["time_weekday_string", ["i32"], [S]],
-	// raw binary buffer for crypto/rand, crypto/sha256, hex, base64
-	["raw_bytes_init", ["i32"], []],
-	["raw_bytes_push", ["i32"], []],
-	["raw_bytes_len", [], ["i32"]],
-	["raw_bytes_get", ["i32"], ["i32"]],
-	// crypto/rand
-	["crypto_rand_fill", ["i32"], ["i32"]],
-	// crypto/sha256
-	["crypto_sha256_sum", [], ["i32"]],
-	// encoding/hex
-	["hex_encode_to_string", [], [S]],
-	["hex_decode_string", [S], ["i32"]],
-	["hex_get_err", [], [S]],
-	// encoding/base64
-	["base64_encode_to_string", ["i32"], [S]],
-	["base64_decode_string", ["i32", S], ["i32"]],
-	["base64_get_err", [], [S]],
-	["bits_div32", ["i32", "i32", "i32"], ["i32"]],
-	["bits_div32_rem", [], ["i32"]],
-	["bits_rem32", ["i32", "i32", "i32"], ["i32"]],
-	["bits_div64", ["i64", "i64", "i64"], ["i64"]],
-	["bits_div64_rem", [], ["i64"]],
-	["bits_rem64", ["i64", "i64", "i64"], ["i64"]],
-];
-
 export class ModuleEmitter {
 	constructor(checker, lowerResult = null, programs = [], options = {}) {
 		this.checker = checker;
@@ -230,6 +20,7 @@ export class ModuleEmitter {
 		// Local package names whose code is linked into this module; selectors
 		// like `mathx.NewVec3` are de-qualified to `NewVec3` by the emitter.
 		this.bundledPackages = options.bundledPackages ?? new Set();
+		this.natives = options.natives !== false; // replace native calls with host code
 		this.constCache = new Map(); // name -> BasicLit (package-level literal consts)
 		this.nonLiteralConsts = new Set(); // package-level consts the backend cannot evaluate yet
 
@@ -246,6 +37,7 @@ export class ModuleEmitter {
 		this.arrayTypes = new Map(); // wType key -> array info
 		this.sliceTypes = new Map(); // wType key -> slice info
 		this.sliceTypesByIndex = new Map(); // typeIndex -> slice info
+		this.taggedSliceTypes = new Map(); // Go slice type key -> tagged info
 		this.mapTypes = new Map(); // wType key -> map info
 		this.mapTypesByIndex = new Map(); // typeIndex -> map info
 		this.mapBucketsType = null; // shared (array (mut i32))
@@ -275,10 +67,7 @@ export class ModuleEmitter {
 		// `errors.New` / `fmt.Errorf` / strconv parse failures allocate the
 		// runtime's own error struct; it joins the struct rec group so the
 		// `error.Error` dispatcher can `ref.test` it like any user type.
-		this.hasErrorType =
-			importsAnyOf(programs, ERROR_PRODUCING_PKGS) || hasErrorUsage(programs);
-		this.usesStdlibEnv = importsAnyOf(programs, STDLIB_ENV_PKGS);
-		this.importsTesting = importsAnyOf(programs, ["testing"]);
+		this.hasErrorType = hasErrorUsage(programs);
 
 		if (programs && programs.length > 0) {
 			this.initTypes(programs);
@@ -288,6 +77,26 @@ export class ModuleEmitter {
 		this._initRuntimeImports();
 	}
 
+	// The runtime error struct is not declared in Go source: give the checker a
+	// named type with its method set (`Error() string`) so type assertions to
+	// `interface{ Error() string }` find it as a candidate.
+	_registerRuntimeErrorType() {
+		const types = this.checker?.types;
+		if (!types || types.has(ERROR_STRUCT)) return;
+		const STRING = { kind: "basic", name: "string" };
+		types.set(ERROR_STRUCT, {
+			kind: "named",
+			name: ERROR_STRUCT,
+			underlying: {
+				kind: "struct",
+				fields: new Map(),
+				methods: new Map([
+					["Error", { kind: "func", params: [], returns: [STRING] }],
+				]),
+			},
+		});
+	}
+
 	initTypes(programs) {
 		const progs = Array.isArray(programs) ? programs : [programs];
 		const rawStructs = [];
@@ -295,15 +104,13 @@ export class ModuleEmitter {
 		const aliases = []; // qualified key (pkg.T) -> unqualified struct name
 
 		if (this.hasErrorType) {
+			this._registerRuntimeErrorType();
 			seen.add(ERROR_STRUCT);
 			rawStructs.push({
 				name: ERROR_STRUCT,
 				structType: {
 					kind: "struct",
-					fields: new Map([
-						["msg", { kind: "basic", name: "string" }],
-						["cause", { kind: "basic", name: "any" }],
-					]),
+					fields: new Map([["msg", { kind: "basic", name: "string" }]]),
 				},
 			});
 		}
@@ -332,11 +139,6 @@ export class ModuleEmitter {
 			for (const [key, t] of this.checker.types.entries()) {
 				if (t.kind === "named" && t.underlying?.kind === "struct") {
 					const name = t.name ?? key;
-					if (
-						name.startsWith("testing.") &&
-						(!this.importsTesting || name !== "testing.BenchmarkResult")
-					)
-						continue;
 					if (!seen.has(name)) {
 						seen.add(name);
 						rawStructs.push({ name, structType: t.underlying });
@@ -416,8 +218,16 @@ export class ModuleEmitter {
 						});
 						fieldIndexMap.set(n, fIdx);
 						if (f.embedded) {
+							// The embedded type, when it differs from the field
+							// name (`Mutex$$sync` for the field `Mutex`).
+							const ref =
+								f.type?.kind === "PointerType"
+									? f.type.base?.name
+									: f.type?.name;
+							const typeName = this.checker?.types?.get(ref)?.name;
 							embeds.push({
 								name: n,
+								...(typeName && typeName !== n && { typeName }),
 								fieldIndex: fIdx,
 							});
 						}
@@ -524,9 +334,11 @@ export class ModuleEmitter {
 		const typeEntry = {
 			form: "struct",
 			name: typeName,
+			// Mutable so the facade's per-field setters for an exported struct
+			// that holds a complex value validate.
 			fields: [
-				{ type: elemWType, mutable: false },
-				{ type: elemWType, mutable: false },
+				{ type: elemWType, mutable: true },
+				{ type: elemWType, mutable: true },
 			],
 		};
 		this._pushType(typeEntry);
@@ -704,6 +516,10 @@ export class ModuleEmitter {
 		const typeIndex = this._getTotalTypeCount();
 		const typeEntry = {
 			form: "struct",
+			// Slice types are open: each defined slice type, and each Go type among
+			// the 32-bit-or-smaller elements, gets a tagged subtype when it
+			// reaches an interface.
+			sub: true,
 			fields: [
 				{
 					type: {
@@ -750,6 +566,61 @@ export class ModuleEmitter {
 		return sliceInfo;
 	}
 
+	// The subtype of the slice struct a value of Go slice type `sliceGoType`
+	// takes inside an interface.  Slices of booleans and small integers share
+	// one WebAssembly type, so the extra tag field (a nullable ref to a struct
+	// with one immutable i32 field per tag index) is what tells `[]byte` from
+	// `[]bool` and `json.RawMessage` from `[]byte` in a type test.
+	getTaggedSliceType(sliceGoType, elemGoType) {
+		const key = goTypeKey(sliceGoType);
+		const known = this.taggedSliceTypes.get(key);
+		if (known) return known;
+		const base = this.getSliceType(elemGoType);
+		const root = this.getTaggedSliceRoot(base);
+		const tagIndex = this.taggedSliceTypes.size + 1;
+		const tagTypeIndex = this._getTotalTypeCount();
+		this._pushType({
+			form: "struct",
+			fields: Array.from({ length: tagIndex }, () => ({
+				type: "i32",
+				mutable: false,
+			})),
+		});
+		const typeIndex = this._getTotalTypeCount();
+		this._pushType({
+			form: "struct",
+			sub: true,
+			superTypeIndex: root.typeIndex,
+			fields: [
+				...base.typeEntry.fields,
+				{
+					type: { kind: "ref", nullable: true, typeIndex: tagTypeIndex },
+					mutable: false,
+				},
+			],
+		});
+		const info = { key, typeIndex, tagTypeIndex, base, goType: sliceGoType };
+		this.taggedSliceTypes.set(key, info);
+		return info;
+	}
+
+	// The common supertype of every tagged subtype of the slice type `base`.  An
+	// unnamed `[]int` in an interface is the bare slice type, which every
+	// tagged subtype (`type S []int`) also passes `ref.test` for; testing
+	// "base and not root" is what keeps `any(S{}).([]int)` from matching.
+	getTaggedSliceRoot(base) {
+		if (base.tagRoot) return base.tagRoot;
+		const typeIndex = this._getTotalTypeCount();
+		this._pushType({
+			form: "struct",
+			sub: true,
+			superTypeIndex: base.typeIndex,
+			fields: [...base.typeEntry.fields],
+		});
+		base.tagRoot = { typeIndex };
+		return base.tagRoot;
+	}
+
 	getSliceTypeByIndex(typeIndex) {
 		return this.sliceTypesByIndex?.get(typeIndex) ?? null;
 	}
@@ -848,17 +719,12 @@ export class ModuleEmitter {
 			clearFuncName: `__map_clear_${suffix}`,
 			keysFuncName: `__map_keys_${suffix}`,
 			valuesFuncName: `__map_values_${suffix}`,
-			cloneFuncName: `__map_clone_${suffix}`,
 		};
 		this.mapTypes.set(key, mapInfo);
 		this.mapTypesByIndex.set(mapTypeIndex, mapInfo);
 		return mapInfo;
 	}
 
-	getMapTypeByIndex(typeIndex) {
-		return this.mapTypesByIndex?.get(typeIndex) ?? null;
-	}
-
 	getClosureType(goType) {
 		const sig = getFuncSignature(goType, this.checker);
 		const paramWTypes = sig.params
@@ -971,19 +837,6 @@ export class ModuleEmitter {
 		this.getStringFromCodePointImportIndex(); // env.str_from_code_point
 		this.getStringCodePointAtImportIndex(); // env.str_code_point_at
 		this.getStringHashImportIndex(); // env.str_hash
-		this.getStringToUpperImportIndex();
-		this.getStringToLowerImportIndex();
-		this.getStringTrimSpaceImportIndex();
-		this.getStringContainsImportIndex();
-		this.getStringHasPrefixImportIndex();
-		this.getStringHasSuffixImportIndex();
-		this.getStringIndexImportIndex();
-		this.getStringLastIndexImportIndex();
-		this.getStringRepeatImportIndex();
-		this.getStringReplaceAllImportIndex();
-		this.getStringEqualFoldImportIndex();
-		this.getStringCountImportIndex();
-		this.getStringToValidUTF8ImportIndex();
 		this.getStrFromI64ImportIndex();
 		this.getStrFromI32ImportIndex();
 		this.getStrFromF64ImportIndex();
@@ -993,35 +846,6 @@ export class ModuleEmitter {
 		this.getBytesToStrInitImportIndex();
 		this.getBytesToStrPushImportIndex();
 		this.getBytesToStrFinishImportIndex();
-		this.getTestingCallImportIndex();
-		this.getTestingNameImportIndex();
-		this.getTestingFlagImportIndex();
-		for (const t of ["i32", "i64", "f32", "f64", "externref", "anyref"]) {
-			this.getTestingArgImportIndex(t, false);
-		}
-		this.getTestingArgImportIndex("i32", true);
-		this.getTestingArgErrImportIndex();
-		this.getTestingArgSpreadImportIndex();
-		this.getTestingArgU64ImportIndex();
-		this.getFmtArgTypeImportIndex();
-		this.getFmtStructTypeImportIndex();
-		this.getFmtNewArrayIndex();
-		this.getFmtArrayPushIndex();
-		this.getFmtNewMapIndex();
-		this.getFmtMapSetIndex();
-		this.getFmtNewStructIndex();
-		this.getFmtStructSetIndex();
-		this.getFmtBoxI32Index();
-		this.getFmtBoxI64Index();
-		this.getFmtBoxF64Index();
-		this.getFmtBoxBoolIndex();
-		this.getFmtNewBoxIndex();
-		this.getFmtNewStringerIndex();
-		if (this.usesStdlibEnv) {
-			for (const [name, params, results] of STDLIB_IMPORTS) {
-				this.getOrAddFuncImport("env", name, params, results);
-			}
-		}
 
 		// Logging built-ins
 		this.getPrintlnEmptyIndex(); // env.println_empty
@@ -1032,30 +856,6 @@ export class ModuleEmitter {
 		}
 		this.getLogImportIndex("i32", false, true); // env.print_bool
 		this.getLogImportIndex("i32", true, true); // env.println_bool
-
-		// Math built-ins
-		const unaryMath = [
-			"sin",
-			"cos",
-			"tan",
-			"asin",
-			"acos",
-			"atan",
-			"exp",
-			"log",
-			"log2",
-			"log10",
-			"round",
-			"cbrt",
-			"log1p",
-			"expm1",
-		];
-		for (const m of unaryMath) {
-			this.getMathImportIndex(m, false);
-		}
-		for (const m of BINARY_MATH_IMPORTS) {
-			this.getMathImportIndex(m, true);
-		}
 	}
 
 	_initPanicTag() {
@@ -1137,93 +937,6 @@ export class ModuleEmitter {
 		return gIdx;
 	}
 
-	getRandStateGlobalIndex() {
-		if (this.randStateGlobalIndex !== undefined) {
-			return this.randStateGlobalIndex;
-		}
-		const gIdx = this.globals.length;
-		this.globals.push({
-			type: "i64",
-			mutable: true,
-			init: [{ op: "i64.const", value: 1n }],
-		});
-		this.randStateGlobalIndex = gIdx;
-		return gIdx;
-	}
-
-	getStrconvErrGlobalIndex(field) {
-		if (!this.strconvErrGlobals) this.strconvErrGlobals = new Map();
-		if (this.strconvErrGlobals.has(field)) {
-			return this.strconvErrGlobals.get(field);
-		}
-		const gIdx = this.globals.length;
-		this.globals.push({
-			type: "anyref",
-			mutable: true,
-			init: [{ op: "ref.null", heapType: "any" }],
-		});
-		this.strconvErrGlobals.set(field, gIdx);
-		return gIdx;
-	}
-
-	getPathErrGlobalIndex(field) {
-		if (!this.pathErrGlobals) this.pathErrGlobals = new Map();
-		if (this.pathErrGlobals.has(field)) {
-			return this.pathErrGlobals.get(field);
-		}
-		const gIdx = this.globals.length;
-		this.globals.push({
-			type: "anyref",
-			mutable: true,
-			init: [{ op: "ref.null", heapType: "any" }],
-		});
-		this.pathErrGlobals.set(field, gIdx);
-		return gIdx;
-	}
-
-	getIoErrGlobalIndex(field) {
-		if (!this.ioErrGlobals) this.ioErrGlobals = new Map();
-		if (this.ioErrGlobals.has(field)) {
-			return this.ioErrGlobals.get(field);
-		}
-		const gIdx = this.globals.length;
-		this.globals.push({
-			type: "anyref",
-			mutable: true,
-			init: [{ op: "ref.null", heapType: "any" }],
-		});
-		this.ioErrGlobals.set(field, gIdx);
-		return gIdx;
-	}
-
-	getIoDiscardGlobalIndex() {
-		if (this.ioDiscardGlobalIndex !== undefined) {
-			return this.ioDiscardGlobalIndex;
-		}
-		this.getStructType("io.discard");
-		const gIdx = this.globals.length;
-		this.globals.push({
-			type: "anyref",
-			mutable: true,
-			init: [{ op: "ref.null", heapType: "any" }],
-		});
-		this.ioDiscardGlobalIndex = gIdx;
-		return gIdx;
-	}
-
-	getOsGlobalIndex(field) {
-		this.osGlobals ??= new Map();
-		if (this.osGlobals.has(field)) return this.osGlobals.get(field);
-		const gIdx = this.globals.length;
-		this.globals.push({
-			type: "anyref",
-			mutable: true,
-			init: [{ op: "ref.null", heapType: "any" }],
-		});
-		this.osGlobals.set(field, gIdx);
-		return gIdx;
-	}
-
 	getDeferNodeTypeIndex() {
 		if (this.deferNodeTypeIndex !== undefined) {
 			return this.deferNodeTypeIndex;
@@ -1361,190 +1074,8 @@ export class ModuleEmitter {
 		return this.getOrAddFuncImport("env", "println_empty", [], []);
 	}
 
-	getFmtNewArrayIndex() {
-		return this.getOrAddFuncImport("env", "fmt_new_array", [], ["externref"]);
-	}
-
-	getFmtArrayPushIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"fmt_array_push",
-			["externref", "externref"],
-			[],
-		);
-	}
-
-	getFmtNewMapIndex() {
-		return this.getOrAddFuncImport("env", "fmt_new_map", [], ["externref"]);
-	}
-
-	getFmtMapSetIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"fmt_map_set",
-			["externref", "externref", "externref"],
-			[],
-		);
-	}
-
-	getFmtNewStringerIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"fmt_new_stringer",
-			["externref", "externref", "i32"],
-			["externref"],
-		);
-	}
-
-	getFmtNewStructIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"fmt_new_struct",
-			["anyref", "i32"],
-			["externref"],
-		);
-	}
-
-	// Names the Go type of a struct built for fmt (`%T`, `%#v` of an any).
-	getFmtStructTypeImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"fmt_struct_type",
-			["externref", "i32"],
-			[],
-		);
-	}
-
-	getFmtStructSetIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"fmt_struct_set",
-			["externref", "i32", "externref"],
-			[],
-		);
-	}
-
-	getFmtBoxI32Index() {
-		return this.getOrAddFuncImport(
-			"env",
-			"fmt_box_i32",
-			["i32"],
-			["externref"],
-		);
-	}
-
-	getFmtBoxI64Index() {
-		return this.getOrAddFuncImport(
-			"env",
-			"fmt_box_i64",
-			["i64"],
-			["externref"],
-		);
-	}
-
-	// Registered only for programs whose fmt operands may hold a uint64
-	// (see scanFmtU64), so other modules keep their import table.
-	getFmtBoxU64Index() {
-		return this.getOrAddFuncImport(
-			"env",
-			"fmt_box_u64",
-			["i64"],
-			["externref"],
-		);
-	}
-
-	getFmtBoxF64Index() {
-		return this.getOrAddFuncImport(
-			"env",
-			"fmt_box_f64",
-			["f64"],
-			["externref"],
-		);
-	}
-
-	getFmtBoxBoolIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"fmt_box_bool",
-			["i32"],
-			["externref"],
-		);
-	}
-
-	getFmtNewBoxIndex() {
-		return this.getOrAddFuncImport("env", "fmt_new_box", [], ["externref"]);
-	}
-
-	// `*testing.T` method calls: args are pushed one by one to a JS-side
-	// buffer, then `testing_call(t, methodNameStrIdx)` invokes the method.
-	getTestingArgImportIndex(wType, isBool = false) {
-		if (isBool)
-			return this.getOrAddFuncImport("env", "testing_arg_bool", ["i32"], []);
-		const suffix =
-			wType === "externref" ? "str" : wType === "anyref" ? "any" : wType;
-		if (!["i32", "i64", "f32", "f64", "str", "any"].includes(suffix)) {
-			throw new Error(
-				"only primitive, string, error and any arguments are supported for fmt and testing.T calls in wasm packages (format slices/structs field by field)",
-			);
-		}
-		return this.getOrAddFuncImport(
-			"env",
-			`testing_arg_${suffix}`,
-			[suffix === "str" ? "externref" : suffix === "any" ? "anyref" : wType],
-			[],
-		);
-	}
-
-	// Error operands of fmt.Sprint/Print/Append: a non-string for the host.
-	getTestingArgSpreadImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"testing_arg_spread",
-			["externref"],
-			[],
-		);
-	}
-
-	// An unsigned 64-bit operand: the host reinterprets the i64 as unsigned.
-	getTestingArgU64ImportIndex() {
-		return this.getOrAddFuncImport("env", "testing_arg_u64", ["i64"], []);
-	}
-
-	// Tags the last operand in the argument buffer with the static type
-	// descriptor (JSON) held in string table entry `i32`, for `%T` and `%#v`.
-	getFmtArgTypeImportIndex() {
-		return this.getOrAddFuncImport("env", "fmt_arg_type", ["i32"], []);
-	}
-
-	getTestingArgErrImportIndex() {
-		return this.getOrAddFuncImport("env", "testing_arg_err", ["externref"], []);
-	}
-
-	getTestingCallImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"testing_call",
-			["externref", "i32"],
-			[],
-		);
-	}
-
-	getTestingNameImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"testing_name",
-			["externref"],
-			["externref"],
-		);
-	}
-
-	getTestingFlagImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"testing_flag",
-			["externref", "i32"],
-			["i32"],
-		);
+	getPrintResetIndex() {
+		return this.getOrAddFuncImport("env", "print_reset", [], []);
 	}
 
 	getLogImportIndex(wType, isLast = false, isBool = false) {
@@ -1557,6 +1088,8 @@ export class ModuleEmitter {
 				return this.getOrAddFuncImport("env", `${prefix}_i32`, ["i32"], []);
 			case "i64":
 				return this.getOrAddFuncImport("env", `${prefix}_i64`, ["i64"], []);
+			case "u64":
+				return this.getOrAddFuncImport("env", `${prefix}_u64`, ["i64"], []);
 			case "f32":
 				return this.getOrAddFuncImport("env", `${prefix}_f32`, ["f32"], []);
 			case "f64":
@@ -1656,123 +1189,6 @@ export class ModuleEmitter {
 		return this.getOrAddFuncImport("env", "str_hash", ["externref"], ["i32"]);
 	}
 
-	getStringToUpperImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"str_to_upper",
-			["externref"],
-			["externref"],
-		);
-	}
-
-	getStringToLowerImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"str_to_lower",
-			["externref"],
-			["externref"],
-		);
-	}
-
-	getStringTrimSpaceImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"str_trim_space",
-			["externref"],
-			["externref"],
-		);
-	}
-
-	getStringContainsImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"str_contains",
-			["externref", "externref"],
-			["i32"],
-		);
-	}
-
-	getStringHasPrefixImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"str_has_prefix",
-			["externref", "externref"],
-			["i32"],
-		);
-	}
-
-	getStringHasSuffixImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"str_has_suffix",
-			["externref", "externref"],
-			["i32"],
-		);
-	}
-
-	getStringIndexImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"str_index",
-			["externref", "externref"],
-			["i32"],
-		);
-	}
-
-	getStringLastIndexImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"str_last_index",
-			["externref", "externref"],
-			["i32"],
-		);
-	}
-
-	getStringRepeatImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"str_repeat",
-			["externref", "i32"],
-			["externref"],
-		);
-	}
-
-	getStringReplaceAllImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"str_replace_all",
-			["externref", "externref", "externref"],
-			["externref"],
-		);
-	}
-
-	getStringEqualFoldImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"str_equal_fold",
-			["externref", "externref"],
-			["i32"],
-		);
-	}
-
-	getStringCountImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"str_count",
-			["externref", "externref"],
-			["i32"],
-		);
-	}
-
-	getStringToValidUTF8ImportIndex() {
-		return this.getOrAddFuncImport(
-			"env",
-			"str_to_valid_utf8",
-			["externref", "externref"],
-			["externref"],
-		);
-	}
-
 	getStrFromI64ImportIndex() {
 		return this.getOrAddFuncImport(
 			"env",
@@ -1839,35 +1255,6 @@ export class ModuleEmitter {
 		return this.getOrAddFuncImport("Math", "random", [], ["f64"]);
 	}
 
-	// Imports from the STDLIB_IMPORTS table (strings/strconv/utf8/fmt/testing.Run).
-	getStdlibImportIndex(name) {
-		const idx = this.importCache.get(`env.${name}`);
-		if (idx === undefined) throw new Error(`Unknown runtime import: ${name}`);
-		return idx;
-	}
-
-	getTimezoneOffsetImportIndex() {
-		return this.getStdlibImportIndex("time_timezone_offset");
-	}
-
-	// Closure type of `func(*testing.T)` (the t.Run body).
-	getTestingRunClosureType() {
-		return this.getClosureType({
-			kind: "func",
-			params: [{ kind: "pointer", base: { kind: "named", name: "testing.T" } }],
-			returns: [],
-		});
-	}
-
-	// Closure type of `func()` (the t.Cleanup body).
-	getTestingCleanupClosureType() {
-		return this.getClosureType({
-			kind: "func",
-			params: [],
-			returns: [],
-		});
-	}
-
 	resolveFuncIndex(name) {
 		return this.funcMap.get(name) ?? null;
 	}
@@ -1961,60 +1348,60 @@ export class ModuleEmitter {
 			}
 
 			// Promoted methods on sName
-			if (sInfo.embeds && sInfo.embeds.length > 0) {
-				for (const embed of sInfo.embeds) {
-					const embedMethodName = `${embed.name}.${methodName}`;
-					if (this.funcMap.has(embedMethodName)) {
-						const fIdx = this.resolveFuncIndex(embedMethodName);
-						const paramGoTypes = this.getFuncParamGoTypes(embedMethodName);
-						const paramWTypes = this.getFuncParamTypes(embedMethodName);
-						const isPtrRecv = paramGoTypes[0]?.kind === "pointer";
-						const embedSInfo = this.getStructType(embed.name);
-
-						const ptrKey = `ptr:${sName}`;
-						if (!seenKeys.has(ptrKey)) {
-							seenKeys.add(ptrKey);
-							candidates.push({
-								recvTypeName: sName,
-								testTypeIndex: sInfo.typeIndex,
-								isBoxedValue: false,
-								needsValueDeref: !isPtrRecv,
-								embedPath: [
-									{
-										parentTypeIndex: sInfo.typeIndex,
-										fieldIndex: embed.fieldIndex,
-									},
-								],
-								funcIndex: fIdx,
-								targetParamTypes: paramWTypes,
-								targetRecvWType: paramWTypes[0],
-								structInfo: embedSInfo,
-							});
-						}
+			const promoted = this._findPromotedMethod(sInfo, methodName);
+			if (promoted?.iface) {
+				this._addIfaceEmbedCandidates(
+					candidates,
+					seenKeys,
+					sName,
+					sInfo,
+					promoted.embedPath,
+				);
+			} else if (promoted) {
+				const { embedType, embedPath, viaPointer } = promoted;
+				const embedMethodName = `${embedType}.${methodName}`;
+				const fIdx = this.resolveFuncIndex(embedMethodName);
+				const paramGoTypes = this.getFuncParamGoTypes(embedMethodName);
+				const paramWTypes = this.getFuncParamTypes(embedMethodName);
+				const isPtrRecv = paramGoTypes[0]?.kind === "pointer";
+				const embedSInfo = this.getStructType(embedType);
+
+				const ptrKey = `ptr:${sName}`;
+				if (!seenKeys.has(ptrKey)) {
+					seenKeys.add(ptrKey);
+					candidates.push({
+						recvTypeName: sName,
+						testTypeIndex: sInfo.typeIndex,
+						isBoxedValue: false,
+						needsValueDeref: !isPtrRecv,
+						embedPath,
+						nilCheckLast: !isPtrRecv,
+						funcIndex: fIdx,
+						targetParamTypes: paramWTypes,
+						targetRecvWType: paramWTypes[0],
+						structInfo: embedSInfo,
+					});
+				}
 
-						if (!isPtrRecv) {
-							const box = this.getIfaceBoxType({ kind: "named", name: sName });
-							const valKey = `val:${sName}`;
-							if (box && !seenKeys.has(valKey)) {
-								seenKeys.add(valKey);
-								candidates.push({
-									recvTypeName: sName,
-									testTypeIndex: box.typeIndex,
-									isBoxedValue: true,
-									needsValueDeref: false,
-									embedPath: [
-										{
-											parentTypeIndex: sInfo.typeIndex,
-											fieldIndex: embed.fieldIndex,
-										},
-									],
-									funcIndex: fIdx,
-									targetParamTypes: paramWTypes,
-									targetRecvWType: paramWTypes[0],
-									structInfo: embedSInfo,
-								});
-							}
-						}
+				// A pointer-receiver method is in the value's method set only
+				// when it is reached through an embedded pointer.
+				if (!isPtrRecv || viaPointer) {
+					const box = this.getIfaceBoxType({ kind: "named", name: sName });
+					const valKey = `val:${sName}`;
+					if (box && !seenKeys.has(valKey)) {
+						seenKeys.add(valKey);
+						candidates.push({
+							recvTypeName: sName,
+							testTypeIndex: box.typeIndex,
+							isBoxedValue: true,
+							needsValueDeref: false,
+							embedPath,
+							nilCheckLast: !isPtrRecv,
+							funcIndex: fIdx,
+							targetParamTypes: paramWTypes,
+							targetRecvWType: paramWTypes[0],
+							structInfo: embedSInfo,
+						});
 					}
 				}
 			}
@@ -2125,6 +1512,116 @@ export class ModuleEmitter {
 		return candidates;
 	}
 
+	// Whether `goType`, the type of an embedded field, is an interface whose
+	// method set has `methodName`.
+	embeddedInterfaceHas(goType, methodName) {
+		let t = goType;
+		for (let i = 0; i < 8 && t; i++) {
+			if (t.kind === "TypeName" || t.kind === "Ident") {
+				const named = this.checker?.types?.get(t.name);
+				if (!named) return t.name === "error" && methodName === "Error";
+				t = named;
+			} else if (t.kind === "named") {
+				t = t.underlying ?? this.checker?.types?.get(t.name)?.underlying;
+			} else if (t.kind === "interface") {
+				return t.methods?.has?.(methodName) ?? false;
+			} else if (t.kind === "InterfaceType") {
+				return (t.methods ?? []).some((m) => (m.name ?? m) === methodName);
+			} else {
+				return false;
+			}
+		}
+		return false;
+	}
+
+	// Dispatch candidates for a method `sName` promotes from an embedded
+	// interface: the embedded value is loaded and dispatched again through the
+	// same dispatcher (`selfDispatch`).
+	_addIfaceEmbedCandidates(candidates, seenKeys, sName, sInfo, embedPath) {
+		const base = {
+			recvTypeName: sName,
+			needsValueDeref: false,
+			embedPath,
+			selfDispatch: true,
+			structInfo: sInfo,
+		};
+		const ptrKey = `ptr:${sName}`;
+		if (!seenKeys.has(ptrKey)) {
+			seenKeys.add(ptrKey);
+			candidates.push({
+				...base,
+				testTypeIndex: sInfo.typeIndex,
+				isBoxedValue: false,
+			});
+		}
+		const box = this.getIfaceBoxType({ kind: "named", name: sName });
+		const valKey = `val:${sName}`;
+		if (box && !seenKeys.has(valKey)) {
+			seenKeys.add(valKey);
+			candidates.push({
+				...base,
+				testTypeIndex: box.typeIndex,
+				isBoxedValue: true,
+			});
+		}
+	}
+
+	// The shallowest embedded type of `sInfo` (any depth) that declares
+	// `methodName`: its name, the field path to reach it from an `sInfo`
+	// struct, and whether that path goes through an embedded pointer. Null
+	// when two embeds at that depth declare it (ambiguous, as in Go).
+	_findPromotedMethod(sInfo, methodName) {
+		let level = [{ info: sInfo, path: [], viaPointer: false }];
+		const seen = new Set([sInfo]);
+		while (level.length > 0) {
+			const next = [];
+			const hits = [];
+			for (const { info, path, viaPointer } of level) {
+				for (const embed of info.embeds ?? []) {
+					const embedType = embed.typeName ?? embed.name;
+					const goType = info.fields?.[embed.fieldIndex]?.goType;
+					const isPtr =
+						goType?.kind === "PointerType" || goType?.kind === "pointer";
+					const step = {
+						path: [
+							...path,
+							{
+								parentTypeIndex: info.typeIndex,
+								fieldIndex: embed.fieldIndex,
+								// An embedded pointer may be nil: reading through it
+								// is a recoverable nil dereference.
+								...(isPtr && {
+									ptrWType: info.fields[embed.fieldIndex].wType,
+								}),
+							},
+						],
+						viaPointer: viaPointer || isPtr,
+					};
+					if (this.embeddedInterfaceHas(goType, methodName)) {
+						hits.push({ iface: true, embedPath: step.path, viaPointer: false });
+						continue;
+					}
+					if (this.funcMap.has(`${embedType}.${methodName}`)) {
+						hits.push({
+							embedType,
+							embedPath: step.path,
+							viaPointer: step.viaPointer,
+						});
+						continue;
+					}
+					// A type reached twice at one depth stays twice in the next
+					// level, so a diamond's method is ambiguous there too.
+					const inner = this.structTypes.get(embedType);
+					if (inner && !seen.has(inner)) next.push({ info: inner, ...step });
+				}
+			}
+			if (hits.length > 0) return hits.length === 1 ? hits[0] : null;
+			for (const n of next) seen.add(n.info);
+			level = next;
+		}
+		return null;
+	}
+
 	// A value-receiver method of a named scalar is also in the method set of
 	// the pointer: `var g Getter = &x` holds a pointer box whose target is read
 	// before the call.
@@ -2180,12 +1677,17 @@ export class ModuleEmitter {
 			if (this.checker?.implements?.(ptrType, ifaceResolved)) {
 				if (!seen.has(sInfo.typeIndex)) {
 					seen.add(sInfo.typeIndex);
-					candidates.push({ name: `*${sName}`, typeIndex: sInfo.typeIndex });
+					// A typed nil `*S` is a marker object, which also satisfies it.
+					candidates.push({
+						name: `*${sName}`,
+						typeIndex: sInfo.typeIndex,
+						nilTypeIndex: this.getNilBoxType(ptrType).typeIndex,
+					});
 				}
 			}
 
 			// Check struct value (boxed)
-			if (this.checker?.implements?.(namedType, ifaceResolved)) {
+			if (this._valueImplements(namedType, ifaceResolved)) {
 				const box = this.getIfaceBoxType(namedType);
 				if (box && !seen.has(box.typeIndex)) {
 					seen.add(box.typeIndex);
@@ -2203,7 +1705,7 @@ export class ModuleEmitter {
 					tVal.underlying?.kind !== "interface"
 				) {
 					if (this.checker?.implements?.(tVal, ifaceResolved)) {
-						const box = this.getIfaceBoxType(tVal);
+						const box = this._namedValueBox(tVal);
 						if (box && !seen.has(box.typeIndex)) {
 							seen.add(box.typeIndex);
 							candidates.push({ name: tName, typeIndex: box.typeIndex });
@@ -2223,6 +1725,33 @@ export class ModuleEmitter {
 		return candidates;
 	}
 
+	// The WebAssembly type a value of the named non-struct type `tVal` takes
+	// inside an interface: a defined slice type is a tagged slice (see
+	// getTaggedSliceType), anything else an interface box.
+	_namedValueBox(tVal) {
+		if (!isSliceType(tVal, this.checker)) return this.getIfaceBoxType(tVal);
+		const elem = getSliceElemType(tVal, this.checker);
+		return elem ? this.getTaggedSliceType(tVal, elem) : null;
+	}
+
+	// Whether the struct value `namedType` implements `iface`, including when its
+	// pointer-receiver methods are promoted through an embedded pointer, which
+	// puts them in the value's method set (`struct{ *Inner }`).
+	_valueImplements(namedType, iface) {
+		const checker = this.checker;
+		if (checker?.implements?.(namedType, iface)) return true;
+		const ptr = { kind: "pointer", base: namedType };
+		if (!checker?.implements?.(ptr, iface)) return false;
+		const st = checker.resolveType(namedType.underlying);
+		const methods = st?.methods?.size ? st.methods : namedType.methods;
+		const names = [...(iface.methods?.keys() ?? [])];
+		return names.every(
+			(n) =>
+				!methods?.get(n)?._ptrRecv ||
+				checker._promotedThroughPointer(namedType, n),
+		);
+	}
+
 	// `*T` of a named scalar or slice is boxed apart from `T`.
 	_addPtrNamedImplementor(tVal, tName, ifaceResolved, seen, candidates) {
 		const ptrType = { kind: "pointer", base: tVal };