gofront 1.8.0 → 1.9.0

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,43 @@ 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 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: base.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;
+	}
+
 	getSliceTypeByIndex(typeIndex) {
 		return this.sliceTypesByIndex?.get(typeIndex) ?? null;
 	}
@@ -848,17 +701,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 +819,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 +828,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 +838,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 +919,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 +1056,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 +1070,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 +1171,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 +1237,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;
 	}
@@ -1963,13 +1332,14 @@ 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}`;
+					const embedType = embed.typeName ?? embed.name;
+					const embedMethodName = `${embedType}.${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 embedSInfo = this.getStructType(embedType);
 
 						const ptrKey = `ptr:${sName}`;
 						if (!seenKeys.has(ptrKey)) {
@@ -2180,7 +1550,12 @@ 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,
+					});
 				}
 			}