gofront 1.9.0 → 1.9.1

package/src/backend/js/statements.js

@@ -13,6 +13,7 @@ import {
 import {
 	is64BitInt,
 	isComplex,
+	isComplex64,
 	isTypedArraySlice,
 } from "../../typechecker/types.js";
 
@@ -421,10 +422,25 @@ export const statementGenMethods = {
 					labels.push(body.label);
 					body = body.body;
 				}
-				if (body?.kind === "ForStmt") body.label = labels[labels.length - 1];
+				if (body?.kind === "ForStmt") {
+					body.label = labels[labels.length - 1];
+					body.labels = labels;
+				}
 				const hoisted = this._hoistForInit(body);
 				for (const label of labels) this.line(`${label}:`);
-				this.genStmt(body);
+				// Labels in scope of the JS function being emitted (see
+				// `_emitIterTargetDispatch`).
+				const prevLabels = this._jsLabels ?? [];
+				const loop = body?.kind === "ForStmt";
+				this._jsLabels = [
+					...prevLabels,
+					...labels.map((name) => ({ name, loop })),
+				];
+				try {
+					this.genStmt(body);
+				} finally {
+					this._jsLabels = prevLabels;
+				}
 				if (hoisted) this._closeHoistedForInit();
 				break;
 			}
@@ -767,6 +783,14 @@ export const statementGenMethods = {
 		if (syncs) for (const s of syncs) this.line(`${s};`);
 	},
 
+	// An untyped constant operand of a 64-bit compound assignment is a Number
+	// in the output; the operator needs it as a BigInt.
+	_untypedTo64(rhsVal, rhsNode) {
+		if (rhsNode?._type?.kind !== "untyped" || rhsVal.endsWith("n"))
+			return rhsVal;
+		return /^-?\d+$/.test(rhsVal) ? `${rhsVal}n` : `BigInt(${rhsVal})`;
+	},
+
 	_genAssignStmt(stmt) {
 		this._markIndexLvalues(stmt.lhs);
 		if (stmt.op !== "=") for (const l of stmt.lhs) this._markDerefOpTarget(l);
@@ -841,14 +865,7 @@ export const statementGenMethods = {
 				const binOp = stmt.op.slice(0, -1);
 				const is64Val = is64BitInt(stmt.lhs[0]._mapValueType);
 				let rhsVal = active[0].r;
-				if (
-					is64Val &&
-					stmt.rhs[0]?._type?.kind === "untyped" &&
-					!rhsVal.endsWith("n") &&
-					/^-?\d+$/.test(rhsVal)
-				) {
-					rhsVal = `${rhsVal}n`;
-				}
+				if (is64Val) rhsVal = this._untypedTo64(rhsVal, stmt.rhs[0]);
 				const rhsExpr = is64Val
 					? this._gen64BitBinary(
 							binOp,
@@ -881,14 +898,7 @@ export const statementGenMethods = {
 			}
 			const is64 = is64BitInt(stmt.lhs[0]._type);
 			let rhsVal = active[0].r;
-			if (
-				is64 &&
-				stmt.rhs[0]?._type?.kind === "untyped" &&
-				!rhsVal.endsWith("n") &&
-				/^-?\d+$/.test(rhsVal)
-			) {
-				rhsVal = `${rhsVal}n`;
-			}
+			if (is64) rhsVal = this._untypedTo64(rhsVal, stmt.rhs[0]);
 			if (
 				this._needsStrictCompoundStmt(stmt, is64) &&
 				this._genStrictCompound(
@@ -1134,27 +1144,16 @@ export const statementGenMethods = {
 		}
 		const rhsExpr = this._genComplexOperand(stmt.rhs[0]);
 		const baseOp = stmt.op.slice(0, -1); // "+=" → "+"
-		let result;
-		switch (baseOp) {
-			case "+":
-				result = `{ re: ${lhsRead}.re + ${rhsExpr}.re, im: ${lhsRead}.im + ${rhsExpr}.im }`;
-				break;
-			case "-":
-				result = `{ re: ${lhsRead}.re - ${rhsExpr}.re, im: ${lhsRead}.im - ${rhsExpr}.im }`;
-				break;
-			case "*":
-				this.useHelper("cmul");
-				result = `__cmul(${lhsRead}, ${rhsExpr})`;
-				break;
-			case "/":
-				this.useHelper("cdiv");
-				result = `__cdiv(${lhsRead}, ${rhsExpr})`;
-				break;
-			default:
-				throw new Error(
-					`unsupported complex compound assignment operator: ${stmt.op}`,
-				);
-		}
+		if (!["+", "-", "*", "/"].includes(baseOp))
+			throw new Error(
+				`unsupported complex compound assignment operator: ${stmt.op}`,
+			);
+		const result = this._genComplexArith(
+			baseOp,
+			lhsRead,
+			rhsExpr,
+			isComplex64(l._type),
+		);
 		this.line(`${lhsTarget} = ${result};`);
 	},
 
@@ -1163,10 +1162,21 @@ export const statementGenMethods = {
 			this.line(`${this._iterReturnFlag} = true; return false;`);
 			return;
 		}
-		const vals =
+		let vals =
 			stmt.values.length > 0
 				? stmt.values.map((v) => this._genReturnValue(v))
 				: (this.namedReturnVars ?? []);
+		const named = this.namedReturnVars ?? [];
+		if (stmt.values.length > 0 && named.length > 0) {
+			// Deferred calls read the named results after the loop returns.
+			const rhs =
+				vals.length === named.length && named.length > 1
+					? `[${vals.join(", ")}]`
+					: vals[0];
+			const lhs = named.length === 1 ? named[0] : `[${named.join(", ")}]`;
+			this.line(`${lhs} = ${rhs};`);
+			vals = named;
+		}
 		const stored = vals.length === 1 ? vals[0] : `[${vals.join(", ")}]`;
 		this.line(
 			`${this._iterReturnFlag} = true; ${this._iterReturnVar} = ${stored}; return false;`,
@@ -1235,11 +1245,10 @@ export const statementGenMethods = {
 				this.line(`${stmt.keyword} ${stmt.label};`);
 			return;
 		}
-		if (
-			stmt.keyword === "continue" &&
-			stmt.label === this._currentIterLoopLabel
-		) {
-			this.line("return true;");
+		if (this._currentIterLoopLabels?.includes(stmt.label)) {
+			if (stmt.keyword === "continue") this.line("return true;");
+			else if (stmt.keyword === "break")
+				this.line(`${this._iterBreakFlag} = true; return false;`);
 			return;
 		}
 		this.line(
@@ -1360,10 +1369,8 @@ export const statementGenMethods = {
 		const isInner = this._inIteratorBody;
 		if (isInner) {
 			this._iterLoopDepth = (this._iterLoopDepth ?? 0) + 1;
-			if (stmt.label) {
-				this._innerLoopLabels = this._innerLoopLabels ?? new Set();
-				this._innerLoopLabels.add(stmt.label);
-			}
+			this._innerLoopLabels = this._innerLoopLabels ?? new Set();
+			for (const l of this._loopLabels(stmt)) this._innerLoopLabels.add(l);
 		}
 		try {
 			if (this.isRangeFor(stmt)) {
@@ -1391,7 +1398,7 @@ export const statementGenMethods = {
 		} finally {
 			if (isInner) {
 				this._iterLoopDepth--;
-				if (stmt.label) this._innerLoopLabels.delete(stmt.label);
+				for (const l of this._loopLabels(stmt)) this._innerLoopLabels.delete(l);
 			}
 		}
 	},
@@ -1447,10 +1454,26 @@ export const statementGenMethods = {
 		return `${this._genAssignLhsExpr(e)} = `;
 	},
 
+	// The value a range assignment stores into an interface-typed variable,
+	// boxed as in any conversion to an interface.
+	_boxRangeAssigned(e, valueJs) {
+		const box = e._rangeBox;
+		if (!box) return valueJs;
+		if (this._isNamedBoxKind(box))
+			return this._genNamedIfaceBox(
+				valueJs,
+				box._ifaceNamedType,
+				box._ifaceBox === "named_ptr",
+			);
+		this.useHelper("ifaceBox");
+		return this._ifaceBoxWrap(valueJs, box._ifaceBox, box._ifacePtrFields);
+	},
+
 	_emitRangeVar(e, valueJs, isAssign) {
 		if (!e) return;
 		const target = this._rangeVarTarget(e, isAssign);
 		if (target === null) return;
+		if (isAssign) valueJs = this._boxRangeAssigned(e, valueJs);
 		if (typeof target === "string") {
 			this.line(`${target}${valueJs};`);
 			return;
@@ -1605,13 +1628,38 @@ export const statementGenMethods = {
 		this._loopDepth--;
 	},
 
-	_genIterFor(init, iterType, iteree, lhs, body) {
+	// `for _, v = range m` into an address-taken variable (or an element or
+	// field) cannot destructure into the target: bind temporaries and store
+	// through the variable's box after decoding.  Fills `stores` with the
+	// [target, temporary] pairs and returns the names to bind.
+	_rangeAssignTemps(init, names, stores) {
+		if (init.kind !== "AssignStmt") return names;
+		// `let [..]` declares every name, so once one target needs a temporary
+		// all the others go through temporaries too.
+		const needs = (n, i) => {
+			const e = init.lhs[i];
+			return (
+				n !== "_" &&
+				(e._rangeBox || !(e.kind === "Ident" && !this._boxedVars.has(e.name)))
+			);
+		};
+		const any = names.some(needs);
+		return names.map((n, i) => {
+			if (n === "_" || !any) return n;
+			stores.push([init.lhs[i], `__r${i}$`]);
+			return `__r${i}$`;
+		});
+	},
+
+	_genIterFor(init, iterType, iteree, lhsNames, body) {
+		const isAssign = init.kind === "AssignStmt";
+		const stores = [];
+		const lhs = this._rangeAssignTemps(init, lhsNames, stores);
 		const iterExpr = this._genRangeIterExpr(iterType, iteree, lhs);
 		const keyDecode = this._structKeyRange(iterType);
 		const paramKey = this._typeParamKeyRange(iterType);
 		const is64Key = this._is64BitMapRange(iterType);
 		const scalarKey = this._scalarKeyRange(iterType);
-		const isAssign = init.kind === "AssignStmt";
 		// `for _, v = range m` assigns existing variables, where a blank is a
 		// hole in the destructuring pattern; a lone blank still needs a binding.
 		const blank = isAssign && lhs.length > 1 ? "" : "_$";
@@ -1621,7 +1669,7 @@ export const statementGenMethods = {
 					? "_$"
 					: lhs[0]
 				: `[${lhs.map((n) => (n === "_" ? blank : n)).join(", ")}]`;
-		const kw = !isAssign || binding === "_$" ? "let " : "";
+		const kw = !isAssign || binding === "_$" || stores.length > 0 ? "let " : "";
 		this.line(`for (${kw}${binding} of ${iterExpr}) {`);
 		this.indented(() => {
 			if (paramKey && lhs[0] !== "_")
@@ -1637,6 +1685,7 @@ export const statementGenMethods = {
 						: `${lhs[0]} = Number(${lhs[0]});`,
 				);
 			this._cloneMapRangeValue(init, iterType, lhs[1]);
+			for (const [e, tmp] of stores) this._emitRangeVar(e, tmp, true);
 			this.genBlock(body);
 		});
 		this.line("}");
@@ -1775,17 +1824,40 @@ export const statementGenMethods = {
 		return `__s(${iteree}).entries()`;
 	},
 
-	_emitIterTargetDispatch(targetFlag) {
-		const labels = this._functionLabels ?? [];
+	// Every label of a loop: stacked labels (`a: b: for ...`) all name it.
+	_loopLabels(stmt) {
+		return stmt.labels ?? (stmt.label ? [stmt.label] : []);
+	},
+
+	_emitIterTargetDispatch(targetFlag, ownLabels = []) {
+		// The loop's own label is handled inside the callback (`break` and
+		// `continue` of the range-over-func loop), and a JS `continue` cannot
+		// name the labeled block that wraps it.  Only the labels of statements
+		// enclosing this loop in the same JS function are in scope (`_jsLabels`):
+		// inside another iterator's callback, the enclosing iterator loop's
+		// label is handled like a branch in its body, and any other label is
+		// passed on to the next dispatcher.
+		const inIter = this._inIteratorBody;
+		const labels = (this._jsLabels ?? []).filter(
+			(l) => !ownLabels.includes(l.name),
+		);
 		this.line(`if (${targetFlag}) {`);
 		this.indented(() => {
-			for (const lbl of labels) {
-				this.line(`if (${targetFlag} === "break$${lbl}") break ${lbl};`);
-				this.line(`if (${targetFlag} === "continue$${lbl}") continue ${lbl};`);
+			for (const { name, loop } of labels) {
+				this.line(`if (${targetFlag} === "break$${name}") break ${name};`);
+				if (loop)
+					this.line(
+						`if (${targetFlag} === "continue$${name}") continue ${name};`,
+					);
 			}
-			if (this._inIteratorBody) {
-				this.line(`${this._iterTargetFlag} = ${targetFlag}; return false;`);
+			if (!inIter) return;
+			for (const encl of this._currentIterLoopLabels ?? []) {
+				this.line(`if (${targetFlag} === "continue$${encl}") return true;`);
+				this.line(
+					`if (${targetFlag} === "break$${encl}") { ${this._iterBreakFlag} = true; return false; }`,
+				);
 			}
+			this.line(`${this._iterTargetFlag} = ${targetFlag}; return false;`);
 		});
 		this.line("}");
 	},
@@ -1795,7 +1867,7 @@ export const statementGenMethods = {
 		paramsStr,
 		body,
 		assignPreamble = null,
-		loopLabel = null,
+		loopLabels = [],
 	) {
 		let iteree = this.genExpr(itereeExpr);
 		if (itereeExpr.kind === "FuncLit") {
@@ -1834,16 +1906,21 @@ export const statementGenMethods = {
 					ret: this._iterReturnFlag,
 					retVar: this._iterReturnVar,
 					target: this._iterTargetFlag,
-					loopLabel: this._currentIterLoopLabel,
+					loopLabels: this._currentIterLoopLabels,
 					loopDepth: this._iterLoopDepth,
+					innerLabels: this._innerLoopLabels,
+					jsLabels: this._jsLabels,
 				};
 				this._inIteratorBody = true;
 				this._iterBreakFlag = breakFlag;
 				this._iterReturnFlag = retFlag;
 				this._iterReturnVar = retVar;
 				this._iterTargetFlag = targetFlag;
-				this._currentIterLoopLabel = loopLabel;
+				this._currentIterLoopLabels = loopLabels;
 				this._iterLoopDepth = 0;
+				// Loops of an enclosing callback are not JS labels in this one.
+				this._innerLoopLabels = new Set();
+				this._jsLabels = [];
 
 				if (assignPreamble) assignPreamble();
 				this.genBlock(body);
@@ -1853,14 +1930,16 @@ export const statementGenMethods = {
 				this._iterReturnFlag = prev.ret;
 				this._iterReturnVar = prev.retVar;
 				this._iterTargetFlag = prev.target;
-				this._currentIterLoopLabel = prev.loopLabel;
+				this._currentIterLoopLabels = prev.loopLabels;
 				this._iterLoopDepth = prev.loopDepth;
+				this._innerLoopLabels = prev.innerLabels;
+				this._jsLabels = prev.jsLabels;
 
 				this.line("return true;");
 			});
 			this.line("});");
 			this.line(`if (${retFlag}) return ${retVar};`);
-			this._emitIterTargetDispatch(targetFlag);
+			this._emitIterTargetDispatch(targetFlag, loopLabels);
 		});
 		this.line("}");
 		this._iterDepth--;
@@ -1869,7 +1948,8 @@ export const statementGenMethods = {
 	genIteratorFor(stmt) {
 		const range = stmt.init.rhs[0];
 		const isAssign = stmt.init.kind === "AssignStmt";
-		const lhs = stmt.init.lhs.map((e) => e.name ?? this.genExpr(e));
+		// A non-identifier target is stored through _emitRangeVar, not by name.
+		const lhs = stmt.init.lhs.map((e) => e.name ?? "_$target");
 		const yieldTypes = range._yieldParams ?? [];
 		if (isAssign) {
 			const cbParams = lhs.map((_, i) => `__p${i}`);
@@ -1881,12 +1961,9 @@ export const statementGenMethods = {
 						const isStruct =
 							this._isStructType(yType) ||
 							this._isStructType(stmt.init.lhs[i]?._type);
-						if (isStruct) {
-							this.useHelper("sclone");
-							this.line(`${lhs[i]} = __sclone(${cbParams[i]});`);
-						} else {
-							this.line(`${lhs[i]} = ${cbParams[i]};`);
-						}
+						if (isStruct) this.useHelper("sclone");
+						const value = isStruct ? `__sclone(${cbParams[i]})` : cbParams[i];
+						this._emitRangeVar(stmt.init.lhs[i], value, true);
 					}
 				}
 			};
@@ -1895,7 +1972,7 @@ export const statementGenMethods = {
 				params,
 				stmt.body,
 				assignPreamble,
-				stmt.label ?? null,
+				this._loopLabels(stmt),
 			);
 			return;
 		}
@@ -1920,7 +1997,7 @@ export const statementGenMethods = {
 			params,
 			stmt.body,
 			clonePreamble,
-			stmt.label ?? null,
+			this._loopLabels(stmt),
 		);
 	},
 
@@ -1931,7 +2008,7 @@ export const statementGenMethods = {
 			"",
 			stmt.body,
 			null,
-			stmt.label ?? null,
+			this._loopLabels(stmt),
 		);
 	},
 
@@ -2032,14 +2109,8 @@ export const statementGenMethods = {
 		if (stmt.lhs.length === 1) {
 			if (stmt.op !== "=" && is64BitInt(stmt.lhs[0]._type)) {
 				const binOp = stmt.op.slice(0, -1);
-				let r = rhs[0];
-				if (
-					stmt.rhs[0]?._type?.kind === "untyped" &&
-					!r.endsWith("n") &&
-					/^-?\d+$/.test(r)
-				) {
-					r = `${r}n`;
-				}
+				// Same operand coercion as the statement path (`_genAssignStmt`).
+				const r = this._untypedTo64(rhs[0], stmt.rhs[0]);
 				const l = this.genExpr(stmt.lhs[0]);
 				return `${l} = ${this._gen64BitBinary(binOp, l, r, stmt.lhs[0]._type)}`;
 			}
@@ -2059,6 +2130,11 @@ export const statementGenMethods = {
 		return `[${lhs.join(", ")}] = ${r}`;
 	},
 
+	_isMapTag(tag) {
+		const t = tag._type?.kind === "named" ? tag._type.underlying : tag._type;
+		return t?.kind === "map" || tag._coreType?.kind === "map";
+	},
+
 	// Interface-typed tags may hold boxed named values; cases compare with __ifeq.
 	_switchTagAndCases(stmt) {
 		const tag = stmt.tag ? this.genExpr(stmt.tag) : "true";
@@ -2073,6 +2149,37 @@ export const statementGenMethods = {
 				caseExpr: (e) => `__equal(${tmp}, ${this.genExpr(e)})`,
 			};
 		}
+		if (stmt.tag && isComplex(stmt.tag._type)) {
+			// A complex tag is an object: cases compare its parts.
+			this._swCounter = (this._swCounter ?? 0) + 1;
+			const tmp = `__sw${this._swCounter}`;
+			this.line(`const ${tmp} = ${tag};`);
+			return {
+				tag: "true",
+				caseExpr: (e) =>
+					this._genComplexEquality(
+						"===",
+						"&&",
+						tmp,
+						this._genComplexOperand(e),
+					),
+			};
+		}
+		if (stmt.tag && this._isMapTag(stmt.tag)) {
+			// A nil map is a sentinel object in JS, not `null`: `case nil`
+			// goes through `__isnm`, as `m == nil` does.
+			this.useHelper(this.strict ? "nilMap" : "nm");
+			this._swCounter = (this._swCounter ?? 0) + 1;
+			const tmp = `__sw${this._swCounter}`;
+			this.line(`const ${tmp} = ${tag};`);
+			return {
+				tag: "true",
+				caseExpr: (e) =>
+					this._isNilLiteral(e)
+						? `__isnm(${tmp})`
+						: `${tmp} === ${this.genExpr(e)}`,
+			};
+		}
 		if (!stmt.tag || !this._isIfaceType(stmt.tag._type))
 			return { tag, caseExpr: (e) => this.genExpr(e) };
 		this.useHelper("ifeq");
@@ -2125,7 +2232,9 @@ export const statementGenMethods = {
 		} else if (
 			stmt.tag &&
 			(this._isStructOrArrayType(stmt.tag._type) ||
-				this._isIfaceType(stmt.tag._type))
+				this._isIfaceType(stmt.tag._type) ||
+				isComplex(stmt.tag._type) ||
+				this._isMapTag(stmt.tag))
 		) {
 			// The tag temporary is a `const`, which cannot directly follow a label.
 			this.line("{");

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

@@ -13,7 +13,8 @@ import {
 	typedArrayConstructorForElem,
 	typeStr,
 } from "../../typechecker/types.js";
-import { mentionsTypeParam } from "./expressions.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) {
@@ -87,6 +88,8 @@ export const typeInfoGenMethods = {
 
 	_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) {
@@ -180,20 +183,33 @@ export const typeInfoGenMethods = {
 		const unbox = this._boxesInInterface(t) ? "true" : "false";
 		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 || t.kind === "named" || mentionsTypeParam(t)) return null;
+		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)}`;
@@ -227,7 +243,7 @@ export const typeInfoGenMethods = {
 		const tag = this._dynTypeTag(t);
 		if (!tag) return base;
 		this.useHelper("ifaceBox");
-		const ptr = t.kind === "pointer" ? ", true" : "";
+		const ptr = this._dynTagFlags(t);
 		return `(__v) => __ity(${base ? `(${base})(__v)` : "__v"}, ${JSON.stringify(tag)}${ptr})`;
 	},
 
@@ -239,6 +255,12 @@ export const typeInfoGenMethods = {
 			this.useHelper("ifaceBox");
 			return "(__v) => __ifp(__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(__v)";
@@ -247,6 +269,62 @@ export const typeInfoGenMethods = {
 		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
@@ -272,6 +350,27 @@ export const typeInfoGenMethods = {
 		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) {
@@ -302,6 +401,22 @@ export const typeInfoGenMethods = {
 				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