gofront 1.8.0 → 1.9.0

package/src/typechecker/operand-text.js

@@ -0,0 +1,40 @@
+// Source-like text of an expression for diagnostics ("cannot use y (variable
+// of type float64) as int value"). Only the common shapes are printed in full;
+// anything else falls back to "expression".
+
+function litText(node) {
+	switch (node.litKind) {
+		case "STRING":
+			return JSON.stringify(node.value);
+		case "NIL":
+			return "nil";
+		default:
+			return String(node.value);
+	}
+}
+
+const PRINTERS = {
+	Ident: (n) => n.name,
+	BasicLit: litText,
+	ParenExpr: (n) => `(${exprText(n.expr)})`,
+	SelectorExpr: (n) => `${exprText(n.expr)}.${n.field}`,
+	UnaryExpr: (n) => `${n.op}${exprText(n.operand)}`,
+	BinaryExpr: (n) => `${exprText(n.left)} ${n.op} ${exprText(n.right)}`,
+	CallExpr: (n) =>
+		`${exprText(n.func)}(${(n.args ?? []).map(exprText).join(", ")})`,
+	IndexExpr: (n) => `${exprText(n.expr)}[${exprText(n.index)}]`,
+};
+
+export function exprText(node) {
+	const print = node && PRINTERS[node.kind];
+	return print ? print(node) : "expression";
+}
+
+// "variable of type float64", "untyped int constant", "value of type float64".
+export function operandKind(node, typeName, isUntypedConst) {
+	if (isUntypedConst)
+		return `untyped ${typeName === "float64" ? "float" : typeName} constant`;
+	return node?.kind === "Ident"
+		? `variable of type ${typeName}`
+		: `value of type ${typeName}`;
+}

package/src/typechecker/resolve.js

@@ -8,6 +8,7 @@ import {
 	ANY,
 	BASIC_TYPES,
 	COMPARABLE,
+	DECLARED_ANY,
 	defaultType,
 	displayTypeName,
 	isAny,
@@ -71,6 +72,30 @@ function typeSize(t) {
 	}
 }
 
+// Whether `t` mentions one of the type parameters `params` below its root.
+function nestsTypeParam(t, params) {
+	const mentions = (u) => {
+		switch (u?.kind) {
+			case "typeParam":
+				return params.includes(u);
+			case "pointer":
+				return mentions(u.base);
+			case "slice":
+			case "array":
+				return mentions(u.elem);
+			case "map":
+				return mentions(u.key) || mentions(u.value);
+			case "func":
+				return [...(u.params ?? []), ...(u.returns ?? [])].some(mentions);
+			case "named":
+				return (u.typeArgs ?? []).some(mentions);
+			default:
+				return false;
+		}
+	};
+	return t?.kind !== "typeParam" && mentions(t);
+}
+
 function instanceKey(t) {
 	switch (t?.kind) {
 		case "named":
@@ -133,13 +158,34 @@ const SUBSTITUTE_DISPATCH = {
 			fields,
 			methods,
 			_embeds: type._embeds,
-			_structFields: type._structFields,
+			// The JSON codecs read the field types from here.
+			_structFields: type._structFields?.map((f) => ({
+				...f,
+				type: s.substituteType(f.type, map),
+			})),
 		};
 	},
 	interface: (s, type, map) => {
 		const methods = new Map();
 		for (const [k, v] of type.methods) methods.set(k, s.substituteType(v, map));
-		return { kind: "interface", name: type.name, methods };
+		const out = { kind: "interface", name: type.name, methods };
+		// The type set follows the substitution (`interface{ ~[]E }` with E=int).
+		if (type.unionConstraint)
+			out.unionConstraint = {
+				...type.unionConstraint,
+				terms: type.unionConstraint.terms.map((term) => ({
+					...term,
+					resolved: s.substituteType(
+						term.resolved ?? s.resolveTypeNode(term.type, type._unionScope),
+						map,
+					),
+				})),
+			};
+		if (type._typeSetEmbeds)
+			out._typeSetEmbeds = type._typeSetEmbeds.map((e) =>
+				s.substituteType(e, map),
+			);
+		return out;
 	},
 	named: (s, type, map) => {
 		// An instance of a generic type: re-instantiate with the substituted
@@ -167,7 +213,8 @@ export const resolveMethods = {
 		if (!node) return ANY;
 		switch (node.kind) {
 			case "TypeName": {
-				if (BASIC_TYPES[node.name]) return BASIC_TYPES[node.name];
+				if (BASIC_TYPES[node.name])
+					return node.name === "any" ? DECLARED_ANY : BASIC_TYPES[node.name];
 				if (node.name === "comparable") return COMPARABLE;
 				if (scope) {
 					const fromScope = scope.lookup(node.name);
@@ -176,11 +223,11 @@ export const resolveMethods = {
 				}
 				const named = this.types.get(node.name);
 				if (named) {
-					const wasmErr = this._checkWasmStdlibTypeMember(node);
-					if (wasmErr) return wasmErr;
 					this._useQualifiedTypeName(node, named);
 					return named;
 				}
+				const jsOnly = this._jsOnlyMember(node.name);
+				if (jsOnly) return this._errJsOnly(jsOnly, node);
 				if (EXCLUDED_STDLIB_MEMBERS.has(node.name)) {
 					return this.err(
 						`${node.name} is not available: ${EXCLUDED_STDLIB_MEMBERS.get(node.name)}`,
@@ -218,6 +265,13 @@ export const resolveMethods = {
 				return this._resolveStructType(node, scope);
 			case "InterfaceType":
 				return this._resolveInterfaceType(node, scope);
+			case "UnaryExpr":
+				// `new(*T)`: the parser reads the pointer type as a dereference.
+				if (node.op !== "*") return ANY;
+				return {
+					kind: "pointer",
+					base: this.resolveTypeNode(node.operand, scope),
+				};
 			case "Ident":
 				return this.resolveTypeNode(
 					{ kind: "TypeName", name: node.name },
@@ -252,23 +306,23 @@ export const resolveMethods = {
 		}
 	},
 
-	_checkWasmStdlibTypeMember(node) {
+	// `pkg.Name` when `pkg` is a Go-source package whose `js` files declare
+	// Name and this package is wasm or both (those files are not loaded).
+	_jsOnlyMember(qualified) {
 		if (this.target !== "wasm" && this.target !== "both") return null;
-		const dot = node.name.indexOf(".");
-		if (dot === -1) return null;
-		const pkg = node.name.slice(0, dot);
-		if (pkg !== "time") return null;
-		const field = node.name.slice(dot + 1);
-		const allowed = WASM_STDLIB_MEMBERS.get(pkg);
-		if (allowed && !allowed.has(field)) {
-			this.recordBlocker("unsupported stdlib member", node.name);
-			return this.err(
-				`'${node.name}' is not yet available in wasm packages`,
-				node,
-				"move this call to a JS package, or use a supported alternative",
-			);
-		}
-		return null;
+		const dot = qualified.indexOf(".");
+		if (dot < 0) return null;
+		const ns = this.globals.lookup(qualified.slice(0, dot));
+		return ns?._jsOnly?.has(qualified.slice(dot + 1)) ? qualified : null;
+	},
+
+	_errJsOnly(qualified, node) {
+		this.recordBlocker("unsupported stdlib member", qualified);
+		return this.err(
+			`'${qualified}' is only available in js packages`,
+			node,
+			"move this call to a JS package",
+		);
 	},
 
 	// `pkg.T` in a type position counts as using the import; a Go-source
@@ -291,10 +345,25 @@ export const resolveMethods = {
 		try {
 			const lit = foldConstExpr(size, resolve);
 			const n = lit ? Number(lit.value) : Number.NaN;
-			return Number.isInteger(n) && n >= 0 ? n : size;
+			if (Number.isInteger(n) && n >= 0) return n;
 		} catch {
-			return size;
+			// fall through to the checker's evaluator
 		}
+		// `[math.MaxInt8]T`: a package constant the AST folder cannot see.
+		const q = this._constIntValue(size, scope);
+		if (q === null || !Number.isInteger(q) || q < 0) return size;
+		this._useQualifiedConsts(size);
+		return q;
+	},
+
+	// `pkg.K` inside a folded array length counts as using the import.
+	_useQualifiedConsts(node) {
+		if (!node || typeof node !== "object") return;
+		if (node.kind === "SelectorExpr" && node.expr?.kind === "Ident")
+			this.globals.lookup(node.expr.name);
+		for (const key of ["expr", "left", "right", "operand"])
+			this._useQualifiedConsts(node[key]);
+		for (const arg of node.args ?? []) this._useQualifiedConsts(arg);
 	},
 
 	_resolveArrayTypeNode(node, scope) {
@@ -337,8 +406,11 @@ export const resolveMethods = {
 				? this.resolveTypeNode(node.expr, scope)
 				: null;
 		if (!base) return this.err(`Unknown type '${name ?? "?"}'`, node);
-		if (qualified) this.globals.lookup(sel.expr.name);
-		else if (name)
+		if (qualified) {
+			this.globals.lookup(sel.expr.name);
+			// `iter.Seq[int](f)`: the selector names the mangled stdlib type.
+			this._useQualifiedTypeName(sel, base);
+		} else if (name)
 			this._useQualifiedTypeName(node.name ? node : node.expr, base);
 		if (base.kind === "named" && base._generic?.isAlias) {
 			const aliasArgs = typeArgs.map((n) => this.resolveTypeNode(n, scope));
@@ -452,7 +524,10 @@ export const resolveMethods = {
 			}
 		}
 		const result = { kind: "interface", methods };
-		if (node.unionConstraint) result.unionConstraint = node.unionConstraint;
+		if (node.unionConstraint) {
+			result.unionConstraint = node.unionConstraint;
+			result._unionScope = scope;
+		}
 		if (typeSetEmbeds.length > 0) result._typeSetEmbeds = typeSetEmbeds;
 		return result;
 	},
@@ -501,8 +576,15 @@ export const resolveMethods = {
 		// settles (`T[X]` containing `T[[]X]`), and doubling forms such as
 		// `T[Pair[X, X]]` blow up long before a depth limit is reached.
 		const top = generic._buildSizes[generic._buildSizes.length - 1];
+		// Inside a method of `G[T]`, `G[[]T]` makes every instance ask for a
+		// larger one, even if the method is never called.
+		const growsReceiver =
+			this._recvGeneric === generic &&
+			typeArgs.some((a) => nestsTypeParam(a, generic.typeParams));
 		if (
+			growsReceiver ||
 			building.length >= MAX_INSTANTIATION_DEPTH ||
+			(generic._syncDepth ?? 0) >= MAX_INSTANTIATION_DEPTH ||
 			(top !== undefined && size > top)
 		) {
 			if (!generic._cycleReported) {
@@ -557,13 +639,20 @@ export const resolveMethods = {
 		const methods = named.methods;
 		if (!methods || !named._instMap || named._syncing) return;
 		// A method signature that names the instance reaches this again.
+		// `func (s Stack[T]) Wrap() Stack[[]T]` makes every instance's methods
+		// ask for a larger instance: count the nesting to diagnose it.
 		named._syncing = true;
-		for (const [mName, mType] of generic.methods ?? [])
-			if (!methods.has(mName))
-				methods.set(mName, this.substituteType(mType, named._instMap));
-		// Methods promoted from embedded structs (`Outer[T]` embedding `Base`).
-		this._promoteEmbeddedInto(named.underlying);
-		named._syncing = false;
+		generic._syncDepth = (generic._syncDepth ?? 0) + 1;
+		try {
+			for (const [mName, mType] of generic.methods ?? [])
+				if (!methods.has(mName))
+					methods.set(mName, this.substituteType(mType, named._instMap));
+			// Methods promoted from embedded structs (`Outer[T]` embedding `Base`).
+			this._promoteEmbeddedInto(named.underlying);
+		} finally {
+			generic._syncDepth--;
+			named._syncing = false;
+		}
 	},
 
 	// A[X] for `type A[P any] = T`: resolve T with each P bound to the
@@ -591,19 +680,53 @@ export const resolveMethods = {
 
 	// `explicit` seeds the leading type arguments of a partial instantiation
 	// (`F[int](x)`); the rest are inferred from the call arguments.
-	inferTypeArgs(genericType, argTypes, explicit = []) {
+	// `scope` resolves the type parameters of the calling function, so an
+	// argument of type `S ~[]E` unifies through its core type.
+	inferTypeArgs(genericType, argTypes, explicit = [], scope = null) {
 		const map = new Map();
+		const saved = this._inferScope;
+		this._inferScope = scope;
+		try {
+			return this._inferTypeArgs(genericType, argTypes, explicit, map);
+		} finally {
+			this._inferScope = saved;
+		}
+	},
+
+	_inferTypeArgs(genericType, argTypes, explicit, map) {
 		for (let i = 0; i < explicit.length; i++)
 			map.set(genericType.typeParams[i].name, explicit[i]);
 		const params = genericType.underlying.params;
 		for (let i = 0; i < params.length && i < argTypes.length; i++)
 			this._inferFromPair(params[i], argTypes[i], map);
+		this._inferFromCoreTypes(genericType.typeParams, map);
 		for (const tp of genericType.typeParams) {
 			if (!map.has(tp.name)) return null;
 		}
 		return genericType.typeParams.map((tp) => defaultType(map.get(tp.name)));
 	},
 
+	// Constraint type inference: a type parameter `S` constrained by `~[]E`
+	// whose argument is known unifies `E` with that argument's element type.
+	_inferFromCoreTypes(typeParams, map) {
+		const scope = new Scope(this.globals);
+		for (const tp of typeParams) scope.define(tp.name, tp);
+		for (let round = 0; round < typeParams.length; round++) {
+			const before = map.size;
+			for (const tp of typeParams) {
+				const arg = map.get(tp.name);
+				if (!arg || !tp.constraint) continue;
+				const terms = this._constraintTerms(tp.constraint, new Set(), scope);
+				if (terms?.length !== 1) continue;
+				const argUnder =
+					this._coreOfTypeParam(arg) ??
+					this._deepUnderlying(this.resolveType(arg));
+				if (argUnder) this._inferFromPair(terms[0], argUnder, map);
+			}
+			if (map.size === before) break;
+		}
+	},
+
 	_inferFromFuncPair(paramType, argType, map) {
 		for (
 			let i = 0;
@@ -622,6 +745,8 @@ export const resolveMethods = {
 	_inferFromStructuredPair(paramType, argType, map) {
 		if (paramType.kind === "slice" && argType.kind === "slice")
 			this._inferFromPair(paramType.elem, argType.elem, map);
+		if (paramType.kind === "pointer" && argType.kind === "pointer")
+			this._inferFromPair(paramType.base, argType.base, map);
 		if (paramType.kind === "map" && argType.kind === "map") {
 			this._inferFromPair(paramType.key, argType.key, map);
 			this._inferFromPair(paramType.value, argType.value, map);
@@ -638,8 +763,19 @@ export const resolveMethods = {
 		}
 	},
 
+	// An argument whose type is a type parameter of the calling function
+	// (`S ~[]E`) unifies through its core type: that type, or null.
+	// `paramType` (optional) is the parameter it is matched against; a bare
+	// type parameter takes the argument as it is.
+	_coreOfTypeParam(argType, paramType = null) {
+		if (argType.kind !== "typeParam" || !this._inferScope) return null;
+		if (paramType?.kind === "typeParam") return null;
+		return this._coreType(argType, this._inferScope);
+	},
+
 	_inferFromPair(paramType, argType, map) {
 		if (!paramType || !argType) return;
+		argType = this._coreOfTypeParam(argType, paramType) ?? argType;
 		if (paramType.kind === "typeParam") {
 			const prev = map.get(paramType.name);
 			if (!prev || untypedWins(prev, argType)) map.set(paramType.name, argType);
@@ -664,7 +800,8 @@ export const resolveMethods = {
 	_checkUnionConstraint(typeArg, constraint, node) {
 		for (const term of constraint.terms) {
 			if (term.approx) return;
-			const termType = this.resolveTypeNode(term.type, this.globals);
+			const termType =
+				term.resolved ?? this.resolveTypeNode(term.type, this.globals);
 			if (typeStr(typeArg) === typeStr(termType)) return;
 		}
 		this.err(`type ${typeStr(typeArg)} does not satisfy constraint`, node);
@@ -758,7 +895,7 @@ export const resolveMethods = {
 		return (
 			baseType.kind === "pointer" &&
 			field !== "value" &&
-			baseType.base?.kind === "named"
+			(baseType.base?.kind === "named" || baseType.base?.kind === "struct")
 		);
 	},
 
@@ -891,16 +1028,35 @@ export const resolveMethods = {
 		return ANY;
 	},
 
-	_fieldTypeNamespace(base, field, node) {
+	// An error for `field` when the namespace cannot offer it to this package:
+	// an unexported name, or a member of a `js` file in a wasm or both package.
+	_namespaceMemberError(base, field, node) {
 		if (base._gofront && field.length > 0 && field[0] >= "a" && field[0] <= "z")
 			return this.err(
 				`cannot refer to unexported name ${base.name}.${field}`,
 				node,
 			);
+		const wasm = this.target === "wasm" || this.target === "both";
+		return wasm && base._jsOnly?.has(field)
+			? this._errJsOnly(`${base.name}.${field}`, node)
+			: null;
+	},
+
+	_fieldTypeNamespace(base, field, node) {
+		const bad = this._namespaceMemberError(base, field, node);
+		if (bad) return bad;
 		// Go-source stdlib member: backends emit the mangled top-level name.
 		const mangled = base._mangle?.get(field);
 		if (mangled) {
 			node._stdName = mangled;
+			// Lazy stdlib bodies: referencing a member checks what it reaches.
+			const failure = base._reach?.(mangled);
+			if (failure)
+				this.err(
+					`internal stdlib error in ${base._path}; please report`,
+					node,
+					failure,
+				);
 			return base.members[field];
 		}
 		if (field in base.members) {

package/src/typechecker/statements.js

@@ -15,15 +15,20 @@ const CHECK_STMT_DELEGATE = {
 	BranchStmt: "_checkBranchStmt",
 };
 
+import { exprText, operandKind } from "./operand-text.js";
 import {
 	ANY,
 	BOOL,
 	defaultType,
+	is64BitInt,
 	isAny,
 	isBool,
+	isNil,
+	isUntyped,
 	isVoid,
 	iteratorYieldParams,
 	Scope,
+	typeStr,
 } from "./types.js";
 
 /** @typedef {import('./index.js').TypeChecker} TypeChecker */
@@ -67,9 +72,9 @@ export const statementCheckMethods = {
 
 	_checkDefineCommaOkAssert(stmt, rhs, scope) {
 		if (!stmt.rhs[0]?._commaOk) return false;
-		const lhsNames = stmt.lhs.map((e) => e.name ?? e);
-		if (lhsNames[0] !== "_") scope.defineLocal(lhsNames[0], rhs[0]);
-		if (lhsNames[1] !== "_") scope.defineLocal(lhsNames[1], BOOL);
+		this._declareDefineVars(stmt, [rhs[0], BOOL], scope);
+		if (stmt.lhs.every((e) => e._redecl || (e.name ?? e) === "_"))
+			this.err("no new variables on left side of :=", stmt.lhs[0]);
 		stmt._rhsTypes = [rhs[0], BOOL];
 		return true;
 	},
@@ -97,10 +102,10 @@ export const statementCheckMethods = {
 		)
 			return false;
 		const mapBaseType = this.checkExpr(stmt.rhs[0].expr, scope);
-		const resolvedBase =
-			mapBaseType?.kind === "named" ? mapBaseType.underlying : mapBaseType;
+		const resolvedBase = this._underlyingOrCore(mapBaseType, scope);
 		if (resolvedBase?.kind !== "map") return false;
 		const keyType = this.checkExpr(stmt.rhs[0].index, scope);
+		this.assertAssignable(resolvedBase.key, keyType, stmt.rhs[0].index);
 		this._markIfaceKey(resolvedBase, stmt.rhs[0].index, keyType);
 		stmt._commaOkMap = true;
 		stmt.rhs[0]._mapValueType = resolvedBase.value;
@@ -129,7 +134,8 @@ export const statementCheckMethods = {
 		if (this._checkDefineCommaOkAssert(stmt, rhs, scope)) return;
 		if (
 			stmt.rhs[0]?.kind !== "RangeExpr" &&
-			stmt.lhs.length !== rhsFlat.length
+			stmt.lhs.length !== rhsFlat.length &&
+			!rhsFlat.some((t) => t?._tainted)
 		) {
 			const vars =
 				stmt.lhs.length === 1 ? "1 variable" : `${stmt.lhs.length} variables`;
@@ -156,10 +162,10 @@ export const statementCheckMethods = {
 		)
 			return null;
 		const mapBaseType = this.checkExpr(stmt.rhs[0].expr, scope);
-		const resolvedBase =
-			mapBaseType?.kind === "named" ? mapBaseType.underlying : mapBaseType;
+		const resolvedBase = this._underlyingOrCore(mapBaseType, scope);
 		if (resolvedBase?.kind !== "map") return null;
 		const keyType = this.checkExpr(stmt.rhs[0].index, scope);
+		this.assertAssignable(resolvedBase.key, keyType, stmt.rhs[0].index);
 		this._markIfaceKey(resolvedBase, stmt.rhs[0].index, keyType);
 		stmt._commaOkMap = true;
 		stmt.rhs[0]._mapValueType = resolvedBase.value;
@@ -211,7 +217,13 @@ export const statementCheckMethods = {
 				continue;
 			if (!isAny(lhsTypes[i]) && !isAny(r)) {
 				this._skipIfaceMark = true;
-				this.assertAssignable(lhsTypes[i], r, stmt.lhs[i]);
+				this.assertAssignable(
+					lhsTypes[i],
+					r,
+					stmt.lhs[i],
+					"assignment",
+					stmt.rhs.length === lhsTypes.length ? stmt.rhs[i] : undefined,
+				);
 				this._skipIfaceMark = false;
 			}
 		}
@@ -231,7 +243,8 @@ export const statementCheckMethods = {
 			if (
 				!stmt.rhs[0]?._commaOk &&
 				stmt.rhs[0]?.kind !== "RangeExpr" &&
-				stmt.lhs.length !== rhsFlat.length
+				stmt.lhs.length !== rhsFlat.length &&
+				!rhsFlat.some((t) => t?._tainted)
 			) {
 				const vars =
 					stmt.lhs.length === 1 ? "1 variable" : `${stmt.lhs.length} variables`;
@@ -321,6 +334,8 @@ export const statementCheckMethods = {
 				this.err("For condition must be bool", stmt);
 		} else {
 			const ct = this.checkExpr(stmt.cond.expr, inner);
+			const core = ct?.kind === "typeParam" ? this._coreType(ct, inner) : null;
+			if (core) stmt.cond.expr._coreType = core;
 			const info = iteratorYieldParams(ct);
 			if (info) {
 				stmt.cond._isIterator = true;
@@ -359,10 +374,17 @@ export const statementCheckMethods = {
 		const inner = new Scope(scope);
 		if (stmt.init) this.checkStmt(stmt.init, inner, returnType);
 		if (stmt.tag) this.checkExpr(stmt.tag, inner);
+		const tagIs64 = stmt.tag && is64BitInt(stmt.tag._type);
 		this._switchDepth++;
 		for (const c of stmt.cases) {
 			const caseScope = new Scope(inner);
-			if (c.list) for (const e of c.list) this.checkExpr(e, caseScope);
+			if (c.list) {
+				for (const e of c.list) {
+					this.checkExpr(e, caseScope);
+					this._checkCaseValue(stmt.tag, e);
+					if (tagIs64 && e._type?.kind === "untyped") e._is64Bit = true;
+				}
+			}
 			for (const s of c.stmts) this.checkStmt(s, caseScope, returnType);
 			this._reportUnused(caseScope, stmt);
 		}
@@ -370,6 +392,76 @@ export const statementCheckMethods = {
 		this._reportUnused(inner, stmt);
 	},
 
+	// `case e:` compares `tag == e`, so `e` must convert to the tag's type
+	// (or the other way round for typed values).
+	_checkCaseValue(tag, e) {
+		const caseType = this.resolveType(e._type);
+		if (!tag) {
+			this._checkTaglessCase(e, caseType);
+			return;
+		}
+		let tagType = this.resolveType(tag._type);
+		// `switch "foo" {` compares as the constant's default type.
+		if (isUntyped(tagType) && !isNil(tagType) && tagType.base !== "bool")
+			tagType = defaultType(tagType);
+		if (this._caseValueUnchecked(tagType, caseType)) return;
+		if (isUntyped(caseType)) {
+			if (this._isUntypedAssignable(tagType, caseType)) return;
+			this.err(
+				`cannot convert ${exprText(e)} (${operandKind(e, caseType.base, true)}) to type ${typeStr(tagType)}`,
+				e,
+			);
+			return;
+		}
+		if (
+			this._assignableQuietly(tagType, caseType) ||
+			this._assignableQuietly(caseType, tagType)
+		)
+			return;
+		this.err(
+			`invalid case ${exprText(e)} in switch on ${exprText(tag)} (mismatched types ${typeStr(caseType)} and ${typeStr(tagType)})`,
+			e,
+		);
+	},
+
+	// A tagless `switch` is `switch true`, so every case must be boolean.
+	_checkTaglessCase(e, caseType) {
+		if (!caseType || caseType._tainted || caseType.kind === "typeParam") return;
+		if (isAny(caseType) || isNil(caseType) || isBool(caseType)) return;
+		if (isUntyped(caseType) && caseType.base === "bool") return;
+		const under = this.resolveType(caseType.underlying ?? caseType);
+		if (isBool(under)) return;
+		this.err(
+			`invalid case ${exprText(e)} in switch (mismatched types ${typeStr(caseType)} and bool)`,
+			e,
+		);
+	},
+
+	// Operands whose comparison the checker cannot (or need not) judge: unknown
+	// or recovered types, `any`/interface tags, nil cases, type parameters.
+	_caseValueUnchecked(tagType, caseType) {
+		if (!tagType || !caseType || tagType._tainted || caseType._tainted)
+			return true;
+		if (isAny(tagType) || isAny(caseType) || isNil(caseType)) return true;
+		if (isUntyped(tagType) || tagType.kind === "typeParam") return true;
+		return (
+			this.resolveType(tagType.underlying ?? tagType)?.kind === "interface"
+		);
+	},
+
+	// Whether assertAssignable(target, source) reports nothing.
+	_assignableQuietly(target, source) {
+		const saved = this.errors;
+		const savedSkip = this._skipIfaceMark;
+		this.errors = [];
+		this._skipIfaceMark = true;
+		this.assertAssignable(target, source, null);
+		const ok = this.errors.length === 0;
+		this.errors = saved;
+		this._skipIfaceMark = savedSkip;
+		return ok;
+	},
+
 	// A case naming an interface (literal or declared) records the resolved
 	// type so backends test its method set.
 	_markInterfaceCaseType(t, scope) {
@@ -383,6 +475,23 @@ export const statementCheckMethods = {
 		if (u?.kind === "interface") t._type = resolved;
 	},
 
+	// Records the resolved type of a composite type node used as an assertion
+	// or type-switch target (`[]int`, `map[string]any`, `*int`, `iter.Seq[int]`)
+	// so the backend can match it against the dynamic type of an interface value.
+	_markDynamicType(node, resolved) {
+		const kind = node?.kind;
+		if (
+			kind === "SliceType" ||
+			kind === "ArrayType" ||
+			kind === "MapType" ||
+			kind === "PointerType" ||
+			kind === "FuncType" ||
+			kind === "StructType" ||
+			kind === "GenericTypeName"
+		)
+			node._assertType = resolved;
+	},
+
 	_checkTypeSwitchStmt(stmt, scope, returnType) {
 		const inner = new Scope(scope);
 		this.checkExpr(stmt.expr, inner);
@@ -396,6 +505,8 @@ export const statementCheckMethods = {
 				const base = t?.kind === "PointerType" ? t.base : t;
 				if (base?.kind === "GenericTypeName") this.resolveTypeNode(t, inner);
 				this._markInterfaceCaseType(t, inner);
+				if (t && t.kind !== "TypeName" && t.kind !== "InterfaceType")
+					this._markDynamicType(t, this.resolveTypeNode(t, inner));
 			}
 			if (stmt.assign) {
 				// Bind the variable to the single case type, or any for multi/default.