gofront 1.8.0 → 1.9.1

package/src/backend/js/stdlib/index.js

@@ -1,74 +1,56 @@
 // CodeGen stdlib call generation — installed as a mixin on CodeGen.prototype.
-// One file per Go package under ./stdlib/. This index merges them.
+// Dispatches `gofront/shared` and `gofront/simd` calls to inline JS.
 
-import { base64Methods } from "./base64.js";
-import { binaryMethods } from "./binary.js";
-import { bitsMethods } from "./bits.js";
-import { builderMethods } from "./builder.js";
-import { bytesMethods } from "./bytes.js";
-import { errorsMethods } from "./errors.js";
-import { fmtMethods } from "./fmt.js";
-import { gomMethods } from "./gom.js";
-import { hexMethods } from "./hex.js";
-import { htmlMethods } from "./html.js";
-import { ioMethods } from "./io.js";
-import { jsonMethods } from "./json.js";
-import { mapsMethods } from "./maps.js";
-import { mathMethods } from "./math.js";
-import { osMethods } from "./os.js";
-import { pathMethods } from "./path.js";
-import { randMethods } from "./rand.js";
-import { regexpMethods } from "./regexp.js";
-import { sha256Methods } from "./sha256.js";
-import { sharedMethods } from "./shared.js";
-import { simdMethods } from "./simd.js";
-import { slicesMethods } from "./slices.js";
-import { sortMethods } from "./sort.js";
-import { strconvMethods } from "./strconv.js";
-import { stringsMethods } from "./strings.js";
-import { syncMethods } from "./sync.js";
-import { testingMethods } from "./testing.js";
-import { timeMethods } from "./time.js";
-import { unicodeMethods } from "./unicode.js";
-import { utf8Methods } from "./utf8.js";
+import { SHARED_KINDS } from "../../../typechecker/stdlib/shared.js";
 
 /** @typedef {import('../index.js').CodeGen} CodeGen */
 
 // Stdlib namespace → handler method name. Used by _genStdlibCall to dispatch
 // dynamically without creating static call edges.
 const STDLIB_METHOD_MAP = {
-	fmt: "_genFmt",
-	strings: "_genStrings",
-	bytes: "_genBytes",
-	strconv: "_genStrconv",
-	sort: "_genSort",
-	math: "_genMath",
-	bits: "_genBits",
-	unicode: "_genUnicode",
-	os: "_genOs",
-	errors: "_genErrors",
-	time: "_genTime",
-	regexp: "_genRegexp",
-	slices: "_genSlices",
-	maps: "_genMaps",
-	html: "_genHtml",
-	io: "_genIo",
-	rand: "_genRand",
-	utf8: "_genUtf8",
-	path: "_genPath",
-	filepath: "_genPath",
-	testing: "_genTesting",
 	shared: "_genShared",
-	sync: "_genSync",
-	sha256: "_genSha256",
-	binary: "_genBinary",
-	hex: "_genHex",
-	base64: "_genBase64",
-	json: "_genJson",
 	simd: "_genSimd",
 };
 
 const dispatchMethods = {
+	// `gofront/shared`: in js packages a shared buffer is just a TypedArray (no
+	// linear memory is involved); in wasm packages the facade hands out
+	// zero-copy views onto the module memory.
+	_genShared(fn, a) {
+		if (!fn.startsWith("New")) return undefined;
+		const info = SHARED_KINDS[fn.slice(3)];
+		if (!info) return undefined;
+		return `new ${info.ctor}(${a()[0]})`;
+	},
+
+	// `gofront/simd` in JS packages.
+	_genSimd(fn, a) {
+		this.useHelper("simd");
+		const args = a();
+		switch (fn) {
+			case "Splat":
+				return `__simd_splat(${args[0]})`;
+			case "NewF32x4":
+				return `__simd_f32x4(${args[0]}, ${args[1]}, ${args[2]}, ${args[3]})`;
+			case "Select":
+				return `__simd_select(${args[0]}, ${args[1]}, ${args[2]})`;
+			case "Shuffle":
+				return `__simd_shuffle(${args.join(", ")})`;
+			case "LoadF32x4":
+				return `__simd_load(${args[0]}, ${args[1]})`;
+			case "StoreF32x4":
+				return `__simd_store(${args[0]}, ${args[1]}, ${args[2]})`;
+			case "LoadF32x4Slice":
+				return `__simd_load_slice(${args[0]}, ${args[1]})`;
+			case "StoreF32x4Slice":
+				return `__simd_store_slice(${args[0]}, ${args[1]}, ${args[2]})`;
+			case "Pad4":
+				return `(Math.floor((${args[0]} + 3) / 4) * 4)`;
+			default:
+				return undefined;
+		}
+	},
+
 	typeComment(typeNode) {
 		if (!typeNode) return "unknown";
 		switch (typeNode.kind) {
@@ -86,18 +68,18 @@ const dispatchMethods = {
 	// Dispatch table for stdlib namespace calls (pkg.Func → inline JS).
 	// Returns the generated JS string, or undefined if not handled.
 	_genStdlibCall(ns, fn, expr) {
-		if (ns === "gom") return this._genGom(fn, expr);
 		const method = STDLIB_METHOD_MAP[ns];
 		if (!method) return undefined;
-		// Stdlib shims take raw values; only fmt and errors use the interface box
-		// of a named value (Error() dispatch, error comparisons).
+		// A member written in Go is an ordinary call of its mangled name.
+		if (expr.func?._stdName) return undefined;
+		// Stdlib shims take raw values, not the interface box of a named value.
 		const isNamespace = expr.func?.expr?._type?.kind === "namespace";
-		if (isNamespace && ns !== "fmt" && ns !== "errors") {
+		if (isNamespace) {
 			for (const e of expr.args) if (e) e._noNamedBox = true;
 		}
 		const a = () => expr.args.map((e) => this.genExpr(e));
 		const res = this[method](fn, a, expr);
-		if (res === undefined && isNamespace && ns !== "fmt" && ns !== "errors") {
+		if (res === undefined && isNamespace) {
 			for (const e of expr.args) if (e) delete e._noNamedBox;
 		}
 		return res;
@@ -106,35 +88,5 @@ const dispatchMethods = {
 
 /** @type {ThisType<CodeGen>} */
 export const stdlibGenMethods = {
-	...bitsMethods,
-	...builderMethods,
-	...bytesMethods,
-	...errorsMethods,
-	...fmtMethods,
-	...gomMethods,
-	...htmlMethods,
-	...ioMethods,
-	...mapsMethods,
-	...mathMethods,
-	...osMethods,
-	...pathMethods,
-	...randMethods,
-	...regexpMethods,
-	...sharedMethods,
-	...simdMethods,
-	...slicesMethods,
-	...sortMethods,
-	...strconvMethods,
-	...stringsMethods,
-	...timeMethods,
-	...unicodeMethods,
-	...utf8Methods,
-	...testingMethods,
-	...syncMethods,
-	...sha256Methods,
-	...binaryMethods,
-	...hexMethods,
-	...base64Methods,
-	...jsonMethods,
 	...dispatchMethods,
 };

package/src/backend/js/templ.js

@@ -13,6 +13,8 @@ export const templGenMethods = {
 			)
 			.join(", ");
 		this.line(`function ${decl.name}(${params}) {`);
+		const prevBoxed = this._boxedVars;
+		this._boxedVars = new Set(this._boxedGlobals);
 		this.indented(() => {
 			// `@W(xs...)` passes `{ __sp: xs }` like any Go variadic call.
 			const last = decl.params[decl.params.length - 1];
@@ -26,6 +28,7 @@ export const templGenMethods = {
 			});
 			this.line(`}};`);
 		});
+		this._boxedVars = prevBoxed;
 		this.line("}");
 	},
 
@@ -86,11 +89,17 @@ export const templGenMethods = {
 				);
 			case "TemplComponent":
 				return this._genTemplComponentMount(node, p);
-			case "TemplChildren":
-				// children is a variadic gom.Node param — mount each child
+			case "TemplChildren": {
+				// `{ name... }`: mount each node of a variadic gom.Node parameter
+				// (nil mounts nothing). `children` may also be absent altogether.
+				const slot =
+					node.name === "children"
+						? `(typeof children!=="undefined"?children:null)`
+						: this._genTemplExpr(node, "null");
 				return this.line(
-					`if(typeof children!=="undefined")(Array.isArray(children)?children:[...children]).forEach(___c=>___c?.Mount?.(${p}));`,
+					`for (const ___c of ${slot} ?? []) ___c?.Mount?.(${p});`,
 				);
+			}
 			case "TemplIf":
 				return this._genTemplIf(node, p);
 			case "TemplFor":
@@ -200,15 +209,18 @@ export const templGenMethods = {
 	_genTemplSwitch(node, p) {
 		const { cases } = node;
 		if (cases.length === 0) return;
-		const exprJs = this._genTemplExpr(node, '""');
+		// `switch { case cond: }` compares each condition with `true`.
+		const exprJs = this._genTemplExpr(node, "true");
 		this.line(`switch (${exprJs}) {`);
 		this.indented(() => {
 			for (const c of cases) {
-				const label =
-					c.caseTokens === null
-						? "default"
-						: `case ${this._genTemplExpr(c, '""')}`;
-				this.line(`${label}: {`);
+				if (c.caseTokens === null) this.line("default: {");
+				else {
+					// One JS label per value of `case a, b:`.
+					if (c.exprError) throw c.exprError;
+					const labels = (c.exprs ?? []).map((e) => `case ${this.genExpr(e)}:`);
+					this.line(`${labels.join(" ") || 'case "":'} {`);
+				}
 				this.indented(() => this._genTemplNodes(c.body, p));
 				this.line(`break; }`);
 			}
@@ -216,48 +228,23 @@ export const templGenMethods = {
 		this.line(`}`);
 	},
 
+	// The header is a parsed Go `for` statement, so it goes through the regular
+	// loop generator; its body is a statement that mounts the templ nodes.
 	_genTemplFor(node, p) {
 		if (node.forError) throw node.forError;
 		if (!node.forStmt)
 			throw new Error("templ for header was not parsed by TemplParser");
-		this._genTemplRangeFor(node.forStmt, node.body, p);
-	},
-
-	_genTemplRangeFor(forStmt, templBody, mountParent) {
-		const init = forStmt.init;
-		if (init?.rhs?.[0]?.kind !== "RangeExpr") {
-			// Plain for loop (cond-only or three-clause)
-			const condJs = forStmt.cond ? this.genExpr(forStmt.cond) : "true";
-			this.line(`while (${condJs}) {`);
-			this.indented(() => this._genTemplNodes(templBody, mountParent));
-			this.line("}");
-			return;
-		}
-		// Range for: for key, val := range iter
-		const range = init.rhs[0];
-		const iterJs = this.genExpr(range.expr);
-		const lhs = init.lhs.map((e) => e.name ?? "_");
-		const keyName = lhs[0] ?? "_";
-		const valName = lhs[1] ?? null;
-
-		const loopHeader = this._genTemplRangeHeader(keyName, valName, iterJs);
-		this.line(loopHeader);
-		this.indented(() => this._genTemplNodes(templBody, mountParent));
-		this.line("}");
+		const mount = { kind: "TemplMount", parent: p };
+		// Hidden from the generic AST walkers: they know no templ node kinds.
+		Object.defineProperty(mount, "nodes", { value: node.body });
+		this.genFor({
+			...node.forStmt,
+			body: { kind: "Block", stmts: [mount] },
+		});
 	},
 
-	_genTemplRangeHeader(keyName, valName, iterJs) {
-		if (valName === null || valName === undefined) {
-			return `for (const ${keyName === "_" ? "_$" : keyName} of ${iterJs}) {`;
-		}
-		if (keyName === "_" && valName === "_")
-			return `for (const _$ of ${iterJs}) {`;
-		if (keyName === "_") return `for (const ${valName} of ${iterJs}) {`;
-		if (valName === "_")
-			return `for (const [${keyName}] of Object.entries(${iterJs})) {`;
-		// Default to .entries() for arrays, Object.entries for objects
-		this.useHelper("sliceGuard");
-		return `for (const [${keyName}, ${valName}] of __s(${iterJs}).entries()) {`;
+	_genTemplMountStmt(stmt) {
+		this._genTemplNodes(stmt.nodes, stmt.parent);
 	},
 
 	// Emit JS for the Go expression TemplParser parsed onto `node`. `emptyJs` is

package/src/backend/js/type-info.js

@@ -7,8 +7,14 @@
 // type's kind, identity and a type test (see `__ti` in HELPER_GENERICS).
 
 import { forEachChild } from "../../lower/index.js";
-import { isAny, typeStr } from "../../typechecker/types.js";
-import { mentionsTypeParam } from "./expressions.js";
+import {
+	isAny,
+	isTypedArraySlice,
+	typedArrayConstructorForElem,
+	typeStr,
+} from "../../typechecker/types.js";
+import { goTypeName } from "../shared/fmt-types.js";
+import { isGenericComposite, mentionsTypeParam } from "./expressions.js";
 
 // True when type node `node` names one of the type parameters `names`.
 function typeNodeMentions(node, names) {
@@ -68,8 +74,24 @@ export const typeInfoGenMethods = {
 		return found;
 	},
 
+	// `x.M(...)` where x has a type parameter type: a raw value of a named
+	// non-struct type argument must be boxed to reach its methods.
+	_isTypeParamMethodCall(call, names) {
+		const t = call.func?.expr?._type;
+		return (
+			call.func?.kind === "SelectorExpr" &&
+			!call.func._isMethodExpr &&
+			t?.kind === "typeParam" &&
+			(!names || names.has(t.name))
+		);
+	},
+
 	_nodeUsesTypeInfo(node, names) {
 		if (node._ifaceKeyDyn && names.has(node._ifaceKeyParam)) return true;
+		// A map or slice entering an interface is tagged by its instantiated type.
+		if (isGenericComposite(node._ifaceSrc)) return true;
+		if (node._ifaceSrc?.kind === "typeParam" && names.has(node._ifaceSrc.name))
+			return true;
 		switch (node.kind) {
 			case "TypeAssertExpr":
 				return typeNodeMentions(node.type, names);
@@ -79,11 +101,23 @@ export const typeInfoGenMethods = {
 				return typeNodeMentions(node.targetType, names);
 			case "BinaryExpr":
 				return (
-					(node.op === "==" || node.op === "!=") &&
-					node.left._type?.kind === "typeParam"
+					((node.op === "==" || node.op === "!=") &&
+						node.left._type?.kind === "typeParam") ||
+					(node._type?.kind === "typeParam" && names.has(node._type.name))
+				);
+			case "AssignStmt":
+				return (
+					node.op !== "=" &&
+					node.lhs?.[0]?._type?.kind === "typeParam" &&
+					names.has(node.lhs[0]._type.name)
+				);
+			case "IncDecStmt":
+				return (
+					node.expr?._type?.kind === "typeParam" &&
+					names.has(node.expr._type.name)
 				);
 			case "CallExpr":
-				return this._callUsesTypeInfo(node);
+				return this._callUsesTypeInfo(node, names);
 			case "CompositeLit":
 			case "GenericTypeName":
 				return typeArgsMention(node);
@@ -92,7 +126,8 @@ export const typeInfoGenMethods = {
 		}
 	},
 
-	_callUsesTypeInfo(call) {
+	_callUsesTypeInfo(call, names) {
+		if (this._isTypeParamMethodCall(call, names)) return true;
 		if (call._isTypeConversion)
 			return call._conversionTargetType?.kind === "typeParam";
 		// A fmt operand of a type parameter type is formatted by its instantiated
@@ -146,16 +181,45 @@ export const typeInfoGenMethods = {
 		const check = this._typeCheckForType(t, "__v");
 		const is = check ? `(__v) => ${check}` : "null";
 		const unbox = this._boxesInInterface(t) ? "true" : "false";
-		const box = this._ifaceKeyBox(t);
+		const box = this._ifaceKeyBox(t) ?? this._ptrMethodBox(t);
 		const fmtBox = this._fmtBoxFor(t);
-		const tail = fmtBox
-			? `, ${box ?? "null"}, ${fmtBox}`
-			: box
-				? `, ${box}`
-				: "";
+		const tail = this._typeInfoTail(t, box, fmtBox);
 		return `__ti(${base}, ${JSON.stringify(k)}, ${JSON.stringify(typeStr(t))}, ${is}, ${unbox}${tail})`;
 	},
 
+	// The optional trailing arguments of `__ti` (`b`, `fb`, `nm`).  `typeStr`
+	// drops the `...` of a variadic func type, so a func type also carries its
+	// spelled name (see `__tnm`).
+	_typeInfoTail(t, box, fmtBox) {
+		if (t.kind === "func")
+			return `, ${box ?? "null"}, ${fmtBox ?? "null"}, ${JSON.stringify(this._dynTypeName(t))}`;
+		if (fmtBox) return `, ${box ?? "null"}, ${fmtBox}`;
+		return box ? `, ${box}` : "";
+	},
+
+	// How `__ik` tells the dynamic type of an interface map key apart where
+	// the JS value cannot: the numeric type name for types sharing a JS
+	// representation with `int`/`float64`/`int64`, `*` for pointers (keyed by
+	// identity) and `!type` for types Go cannot hash.
+	_ifaceKeyTag(t) {
+		if (!t || mentionsTypeParam(t)) return null;
+		if (t.kind === "named") {
+			// A defined slice, map or func type: a literal of it carries no tag.
+			const u = this._underlyingOf(t)?.kind;
+			return u === "slice" || u === "map" || u === "func"
+				? `!${goTypeName(t)}`
+				: null;
+		}
+		if (t.kind === "pointer") return "*";
+		if (t.kind === "slice" || t.kind === "map" || t.kind === "func")
+			return `!${this._dynTypeName(t)}`;
+		if (t.kind !== "basic") return null;
+		const name = this._dynTypeName(t);
+		if (["int", "float64", "int64", "string", "bool"].includes(name))
+			return null;
+		return /^(u?int\d*|uintptr|float32)$/.test(name) ? name : null;
+	},
+
 	// A function boxing a plain value of named basic type `t`, as converting
 	// it to an interface does; null when `t` is not boxed.
 	_ifaceKeyBox(t) {
@@ -163,9 +227,27 @@ export const typeInfoGenMethods = {
 		return `(__v) => ${this._genNamedIfaceBox("__v", t, false)}`;
 	},
 
+	// A function boxing a pointer to a named non-struct type with methods, as
+	// converting it to an interface does; null for any other type.
+	_ptrMethodBox(t) {
+		if (t?.kind !== "pointer" || !this._boxesInInterface(t)) return null;
+		return `(__v) => ${this._genNamedIfaceBox("__v", t.base, true)}`;
+	},
+
 	// A function giving a plain value of type `t` the type information fmt
-	// needs once it is an `any` operand (see _fmtDesc); null when it needs none.
+	// needs once it is an `any` operand; null when it needs none.
 	_fmtBoxFor(t) {
+		const base = this._fmtBoxBase(t);
+		// An unnamed slice, map or pointer also carries its type tag, as
+		// converting it to an `any` gives it, so a type switch tells it apart.
+		const tag = this._dynTypeTag(t);
+		if (!tag) return base;
+		this.useHelper("ifaceBox");
+		const ptr = this._dynTagFlags(t);
+		return `(__v) => __ity(${base ? `(${base})(__v)` : "__v"}, ${JSON.stringify(tag)}${ptr})`;
+	},
+
+	_fmtBoxBase(t) {
 		if (!t || t.kind === "typeParam" || mentionsTypeParam(t)) return null;
 		if (this._ifaceKeyBox(t)) return null; // boxed by the key box already
 		const u = this._underlyingOf(t);
@@ -173,15 +255,212 @@ export const typeInfoGenMethods = {
 			this.useHelper("ifaceBox");
 			return "(__v) => __ifp(__v)";
 		}
-		const desc = this._fmtDesc(t);
-		if (desc) this.useHelper("ifd");
-		const tagged = (v) => (desc ? `__ifd(${v}, ${desc})` : v);
+		// A struct value is marked as a value, so a pointer boxed earlier by the
+		// same generic code does not make it read as `*T`.
+		if (u?.kind === "struct" && t.kind !== "pointer") {
+			this.useHelper("ifaceBox");
+			return "(__v) => __ifv(__v)";
+		}
 		if (u?.kind === "map") {
 			this.useHelper("ifaceBox");
-			return `(__v) => __ifm(${tagged("__v")})`;
+			return "(__v) => __ifm(__v)";
+		}
+		if (u?.kind === "slice") return "(__v) => (__v ?? [])";
+		return null;
+	},
+
+	// Extra `__ity` arguments: `, true` marks a pointer and `, false, true` a
+	// defined slice type, whose nil value keeps its type as a tagged sentinel.
+	_dynTagFlags(t) {
+		if (t?.kind === "pointer") return ", true";
+		if (this._isNamedComposite(t) && this._underlyingOf(t)?.kind === "slice")
+			return ", false, true";
+		return "";
+	},
+
+	// JS expression for the run-time type tag of a map, slice or array type `t`
+	// that mentions type parameters, built from their type information (see
+	// `__ti`); null when some part cannot be spelled.
+	_genericMapTag(t) {
+		const part = (x) => {
+			if (!mentionsTypeParam(x)) return JSON.stringify(this._dynTypeName(x));
+			switch (x.kind) {
+				case "typeParam": {
+					const f = this._typeParamZeroFactory(x.name);
+					return f ? `__tnm(${f})` : null;
+				}
+				case "slice": {
+					const e = part(x.elem);
+					return e && `"[]" + ${e}`;
+				}
+				case "array": {
+					const e = part(x.elem);
+					return e && `"[${x.size}]" + ${e}`;
+				}
+				case "pointer": {
+					const e = part(x.base);
+					return e && `"*" + ${e}`;
+				}
+				case "map": {
+					const k = part(x.key);
+					const v = part(x.value);
+					return k && v && `"map[" + ${k} + "]" + ${v}`;
+				}
+				default:
+					return null;
+			}
+		};
+		return part(t);
+	},
+
+	// A defined func type whose values carry their name as a run-time tag
+	// (one with methods is boxed as a class instead).
+	_isTaggedFuncType(t) {
+		return (
+			t?.kind === "named" &&
+			!mentionsTypeParam(t) &&
+			!t.typeArgs?.length &&
+			this._underlyingOf(t)?.kind === "func" &&
+			!this._namedBoxInfo(t)
+		);
+	},
+
+	// The run-time type tag of an unnamed slice, map or non-struct pointer
+	// entering an interface, or null when the value needs none.  The tag lets
+	// assertions and type switches tell `[]int32` from `[]uint8`, `*int` from
+	// `*string`, and a nil `*int` from the nil interface.
+	_dynTypeTag(t) {
+		if (!t || mentionsTypeParam(t)) return null;
+		if (
+			t.kind === "slice" ||
+			t.kind === "map" ||
+			t.kind === "array" ||
+			t.kind === "struct" ||
+			t.kind === "func"
+		)
+			return this._dynTypeName(t);
+		if (this._isNamedComposite(t)) return t.name;
+		if (t.kind === "pointer") {
+			const base = t.base;
+			if (base?.kind === "struct" && !base.name) return this._dynTypeName(t);
+			if (this._underlyingOf(base)?.kind === "struct") return null;
+			if (this._boxesInInterface(t)) return null;
+			return this._dynTypeName(t);
+		}
+		return null;
+	},
+
+	// Whether Go cannot hash a value of type `t` (it contains a slice, map or
+	// func), so using it as an interface map key panics.
+	_isUnhashableType(t, depth = 0) {
+		if (!t || depth > 8 || mentionsTypeParam(t)) return false;
+		const u = this._underlyingOf(t) ?? t;
+		switch (u.kind) {
+			case "slice":
+			case "map":
+			case "func":
+				return true;
+			case "array":
+				return this._isUnhashableType(u.elem, depth + 1);
+			case "struct":
+				return [...(u.fields?.values() ?? [])].some((f) =>
+					this._isUnhashableType(f, depth + 1),
+				);
+			default:
+				return false;
+		}
+	},
+
+	// A named slice, array or map type: its values are plain JS arrays and
+	// objects, told apart in an interface by a tag carrying the type's name.
+	_isNamedComposite(t) {
+		if (t?.kind !== "named" || this._namedBoxInfo(t)) return false;
+		const kind = this._underlyingOf(t)?.kind;
+		return kind === "slice" || kind === "array" || kind === "map";
+	},
+
+	// `typeStr` with the spellings of identical types unified.
+	_dynTypeName(t) {
+		return this._dynTypeStr(t)
+			.replace(/\bbyte\b/g, "uint8")
+			.replace(/\brune\b/g, "int32")
+			.replace(/\bany\b/g, "interface {}")
+			.replace(/interface\{\.\.\.\}/g, "interface {}");
+	},
+
+	// `typeStr`, but an unnamed struct lists its fields, so two anonymous
+	// structs do not share a tag.
+	_dynTypeStr(t) {
+		const s = (x) => this._dynTypeStr(x);
+		switch (t?.kind) {
+			case "slice":
+				return `[]${s(t.elem)}`;
+			case "array":
+				return `[${t.size?.value ?? t.size ?? "..."}]${s(t.elem)}`;
+			case "map":
+				return `map[${s(t.key)}]${s(t.value)}`;
+			case "pointer":
+				return `*${s(t.base)}`;
+			case "func": {
+				// Go's spelling: no result is `func()`, not `func() void`.
+				const rs = (t.returns ?? []).filter(
+					(r) => !(r?.kind === "basic" && r.name === "void"),
+				);
+				const ps = (t.params ?? []).map((p, i) =>
+					t.variadic && i === t.params.length - 1 ? `...${s(p)}` : s(p),
+				);
+				const res =
+					rs.length === 0
+						? ""
+						: rs.length === 1
+							? ` ${s(rs[0])}`
+							: ` (${rs.map(s).join(", ")})`;
+				return `func(${ps.join(", ")})${res}`;
+			}
+			case "struct":
+				if (t.name || !t._structFields) return typeStr(t);
+				return `struct{${t._structFields
+					.map(
+						(f) =>
+							`${(f.names ?? []).join(",")} ${s(f.type)}${f.tag ? ` ${JSON.stringify(f.tag)}` : ""}${f.embedded ? " embedded" : ""}`,
+					)
+					.join("; ")}}`;
+			default:
+				return typeStr(t);
+		}
+	},
+
+	// Run-time test that `val` holds a value of the unnamed composite type
+	// (or named func type) of assertion target `typeNode`; null when the
+	// checker recorded no type for it.
+	_dynTypeCheck(typeNode, val) {
+		const t = typeNode?._assertType;
+		if (!t) return null;
+		const u = this._underlyingOf(t);
+		const shape = mentionsTypeParam(t);
+		const tag = JSON.stringify(shape ? "" : this._dynTypeName(t));
+		this.useHelper("ifaceBox");
+		const args = (kind, ctor = "null", n = "0") =>
+			`__isty(${val}, ${tag}, "${kind}", ${ctor}, ${n})`;
+		if (u?.kind === "func") return args("func");
+		if (t.kind === "named") return null;
+		if (u?.kind === "map") return args("map");
+		if (u?.kind === "struct") return args("struct");
+		if (u?.kind === "array")
+			return args("array", "null", String(u.size?.value ?? u.size ?? 0));
+		if (u?.kind === "slice") {
+			const ctor = isTypedArraySlice(u)
+				? typedArrayConstructorForElem(u.elem)
+				: null;
+			return args("slice", ctor ?? "null");
+		}
+		if (u?.kind === "pointer") {
+			if (u.base?.kind === "struct" && !u.base.name) return args("struct");
+			if (this._underlyingOf(u.base)?.kind === "struct") return null;
+			if (this._boxesInInterface(u)) return null;
+			return args("ptr");
 		}
-		if (u?.kind === "slice") return `(__v) => ${tagged("(__v ?? [])")}`;
-		return desc ? `(__v) => ${tagged("__v")}` : null;
+		return null;
 	},
 
 	_underlyingOf(t) {