gofront 1.8.0 → 1.9.1

package/src/typechecker/resolve.js

@@ -3,14 +3,19 @@
 
 import { parseJsonTag } from "../parser/struct-tag.js";
 import { foldConstExpr } from "./const-fold.js";
+import { exprText, operandKind } from "./operand-text.js";
 import { EXCLUDED_STDLIB_MEMBERS } from "./stdlib/excluded.js";
 import {
 	ANY,
 	BASIC_TYPES,
 	COMPARABLE,
+	DECLARED_ANY,
 	defaultType,
 	displayTypeName,
+	isAmbiguousFieldSelector,
+	isAmbiguousPromotion,
 	isAny,
+	isMethodPromotedOverField,
 	isTypedArraySlice,
 	Scope,
 	TAINTED_ANY,
@@ -27,6 +32,11 @@ import {
 // instantiation is reported as a cycle.
 const MAX_INSTANTIATION_DEPTH = 32;
 
+// Type nodes in a constraint position, where a constraint interface may
+// appear. A property of the AST node, so it is shared by every checker: an
+// importing package resolves the constraints of the imported generics.
+const CONSTRAINT_POS = new WeakSet();
+
 // Two imported packages may both declare `Pt`, so the cache key of an
 // instance tells declarations apart by identity instead of by display name.
 const declIds = new WeakMap();
@@ -71,6 +81,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 +167,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,8 +222,10 @@ export const resolveMethods = {
 		if (!node) return ANY;
 		switch (node.kind) {
 			case "TypeName": {
-				if (BASIC_TYPES[node.name]) return BASIC_TYPES[node.name];
-				if (node.name === "comparable") return COMPARABLE;
+				if (BASIC_TYPES[node.name])
+					return node.name === "any" ? DECLARED_ANY : BASIC_TYPES[node.name];
+				if (node.name === "comparable")
+					return this._checkConstraintUse(COMPARABLE, node);
 				if (scope) {
 					const fromScope = scope.lookup(node.name);
 					if (fromScope?.kind === "typeParam") return fromScope;
@@ -176,11 +233,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;
+					return this._checkConstraintUse(named, node);
 				}
+				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)}`,
@@ -194,6 +251,7 @@ export const resolveMethods = {
 			case "IndexExpr":
 				return this._resolveGenericTypeName(node, scope);
 			case "TypeParam": {
+				this._markConstraintPos(node.constraint);
 				const constraint = node.constraint
 					? this.resolveTypeNode(node.constraint, scope)
 					: ANY;
@@ -217,7 +275,17 @@ export const resolveMethods = {
 			case "StructType":
 				return this._resolveStructType(node, scope);
 			case "InterfaceType":
-				return this._resolveInterfaceType(node, scope);
+				return this._checkConstraintUse(
+					this._resolveInterfaceType(node, scope),
+					node,
+				);
+			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 },
@@ -229,10 +297,9 @@ export const resolveMethods = {
 				if (node.expr?.kind === "Ident" && typeof node.field === "string") {
 					const qualified = `${node.expr.name}.${node.field}`;
 					if (this.types.has(qualified)) {
-						const resolved = this.resolveTypeNode(
-							{ kind: "TypeName", name: qualified },
-							scope,
-						);
+						const inner = { kind: "TypeName", name: qualified };
+						this._inheritConstraintPos(node, inner);
+						const resolved = this.resolveTypeNode(inner, scope);
 						this._useQualifiedTypeName(node, resolved);
 						return resolved;
 					}
@@ -252,23 +319,112 @@ export const resolveMethods = {
 		}
 	},
 
-	_checkWasmStdlibTypeMember(node) {
-		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`,
+	// ── Constraint interfaces outside constraints ───────────────────
+
+	// Records a type node that sits in a constraint position (a type
+	// parameter's constraint, an interface's embedded element or union term,
+	// the right-hand side of a type declaration), where a constraint
+	// interface is allowed.
+	_markConstraintPos(node) {
+		if (!node || typeof node !== "object") return;
+		if (node.kind === "UnionConstraint") {
+			for (const term of node.terms) this._markConstraintPos(term.type);
+			return;
+		}
+		CONSTRAINT_POS.add(node);
+	},
+
+	// `inner` stands for `node` (a rewritten qualified name).
+	_inheritConstraintPos(node, inner) {
+		if (CONSTRAINT_POS.has(node)) CONSTRAINT_POS.add(inner);
+	},
+
+	// An interface's embedded elements and union terms are constraint positions.
+	_markInterfaceElements(node) {
+		for (const embed of node.embeds ?? []) this._markConstraintPos(embed);
+		this._markConstraintPos(node.unionConstraint);
+	},
+
+	// Marks the constraint positions of top-level declarations before any
+	// type resolves (constraints resolve lazily from several places).
+	_markConstraintPositions(programs) {
+		for (const p of programs) {
+			for (const d of p.decls) {
+				if (d.kind === "TypeDecl") this._markConstraintPos(d.type);
+				for (const tp of d.typeParams ?? [])
+					this._markConstraintPos(tp.constraint);
+			}
+		}
+	},
+
+	// A constraint interface (one with a type set, or comparable) resolved
+	// outside a constraint position is an error. A type whose declaration has
+	// not resolved yet is judged once every package-level type has.
+	_checkConstraintUse(type, node) {
+		if (CONSTRAINT_POS.has(node)) return type;
+		if (type?.kind === "named" && type.underlying == null) {
+			this._pendingConstraintUses.push({
+				type,
+				node,
+				file: this._currentFile,
+				source: this._currentSource,
+			});
+			return type;
+		}
+		this._reportConstraintUse(type, node);
+		return type;
+	},
+
+	_reportConstraintUse(type, node) {
+		const u = this._deepUnderlying(type);
+		if (u === COMPARABLE || (u?.kind === "interface" && u._comparable)) {
+			this.err(
+				`cannot use type ${typeStr(type)} outside a type constraint: interface is (or embeds) comparable`,
+				node,
+			);
+		} else if (
+			u?.kind === "interface" &&
+			(u.unionConstraint || u._typeSetEmbeds)
+		) {
+			this.err(
+				`cannot use type ${typeStr(type)} outside a type constraint: interface contains type constraints`,
 				node,
-				"move this call to a JS package, or use a supported alternative",
 			);
 		}
-		return null;
+	},
+
+	_flushConstraintUses() {
+		const pending = this._pendingConstraintUses;
+		if (pending.length === 0) return;
+		this._pendingConstraintUses = [];
+		const file = this._currentFile;
+		const source = this._currentSource;
+		for (const u of pending) {
+			this._currentFile = u.file;
+			this._currentSource = u.source;
+			this._reportConstraintUse(u.type, u.node);
+		}
+		this._currentFile = file;
+		this._currentSource = source;
+	},
+
+	// `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 = 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
@@ -288,20 +444,81 @@ export const resolveMethods = {
 			const e = depth < 16 ? scope.lookupConstExpr(name) : null;
 			return e ? foldConstExpr(e, (n) => resolve(n, depth + 1)) : undefined;
 		};
+		let n = Number.NaN;
 		try {
 			const lit = foldConstExpr(size, resolve);
-			const n = lit ? Number(lit.value) : Number.NaN;
-			return Number.isInteger(n) && n >= 0 ? n : size;
+			n = lit ? Number(lit.value) : Number.NaN;
 		} catch {
+			// fall through to the checker's evaluator
+		}
+		// `[math.MaxInt8]T`: a package constant the AST folder cannot see.
+		if (!Number.isInteger(n))
+			n = this._constIntValue(size, scope) ?? Number.NaN;
+		if (!Number.isInteger(n)) {
+			this._reportNonConstantArrayLen(size, scope);
 			return size;
 		}
+		this._useQualifiedConsts(size);
+		if (n >= 0) return n;
+		this.err(
+			`invalid array length ${exprText(size)} (untyped int constant ${n})`,
+			size,
+		);
+		return 0;
+	},
+
+	// A length that is not a constant at all (`[len(s)]T` with a slice, `[n]T`
+	// with a variable) cannot size an array.  The operand's type is checked
+	// first, so it counts as used.
+	_reportNonConstantArrayLen(size, scope) {
+		if (size._type === undefined) this.checkExpr(size, scope);
+		this.err(
+			`invalid array length ${exprText(size)} (${operandKind(size, typeStr(size._type), false)}): must be constant`,
+			size,
+		);
+	},
+
+	// An array length must be an integer constant: `[1 == 1]T`, `["a"]T`,
+	// `[nil]T`, `[2.5]T`, `[2i]T` and a typed float constant are rejected.
+	_reportNonIntegerArrayLen(size, scope) {
+		const what = this._nonIntegerConst(size, scope);
+		if (!what) return false;
+		this.err(
+			`invalid array length ${exprText(size)} (${what}): must be integer`,
+			size,
+		);
+		return true;
+	},
+
+	// `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) {
+		if (
+			!node.inferLen &&
+			this._reportNonIntegerArrayLen(node._sizeExpr ?? node.size, scope)
+		)
+			return {
+				kind: "array",
+				size: 0,
+				elem: this.resolveTypeNode(node.elem, scope),
+			};
 		// Fold in place so backends that read the type node see a literal length.
-		if (!node.inferLen && node.size?.value === undefined) {
+		// The node may come from the parse cache: keep the original expression so
+		// a later compile of the same AST still counts `pkg.K` as using `pkg`
+		// and still reports an invalid length.
+		if (node._sizeExpr) this._foldArrayLen(node._sizeExpr, scope);
+		else if (!node.inferLen && node.size?.value === undefined) {
 			const n = this._foldArrayLen(node.size, scope);
-			if (typeof n === "number")
+			if (typeof n === "number") {
+				node._sizeExpr = node.size;
 				node.size = {
 					kind: "BasicLit",
 					litKind: "INT",
@@ -309,6 +526,7 @@ export const resolveMethods = {
 					_line: node.size._line,
 					_col: node.size._col,
 				};
+			}
 		}
 		return {
 			kind: "array",
@@ -337,8 +555,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));
@@ -417,6 +638,7 @@ export const resolveMethods = {
 	},
 
 	_resolveInterfaceType(node, scope) {
+		this._markInterfaceElements(node);
 		const methods = new Map();
 		for (const m of node.methods) {
 			const params = m.params.map((p) => this.resolveTypeNode(p.type, scope));
@@ -432,31 +654,41 @@ export const resolveMethods = {
 		// Embedded interfaces that carry a type set (`interface{ Integer }`):
 		// kept so type-parameter operator checks can follow them.
 		const typeSetEmbeds = [];
-		if (node.embeds) {
-			for (const embed of node.embeds) {
-				const resolved = this.resolveTypeNode(embed, scope);
-				const base =
-					resolved?.kind === "named" ? resolved.underlying : resolved;
-				if (base?.kind === "interface") {
-					for (const [mName, mType] of base.methods) {
-						if (!methods.has(mName)) methods.set(mName, mType);
-					}
-					if (base.unionConstraint || base._typeSetEmbeds)
-						typeSetEmbeds.push(base);
-				} else if (!isAny(resolved)) {
-					this.err(
-						`cannot embed non-interface type ${typeStr(resolved)}`,
-						embed,
-					);
-				}
-			}
+		// `interface{ comparable; ... }`: the type set is restricted to
+		// comparable types (directly or through an embedded constraint).
+		let comparable = false;
+		for (const embed of node.embeds ?? []) {
+			if (this._mergeInterfaceEmbed(embed, scope, methods, typeSetEmbeds))
+				comparable = true;
 		}
 		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;
+		if (comparable) result._comparable = true;
 		return result;
 	},
 
+	// Folds one embedded element of an interface into `methods` and
+	// `typeSetEmbeds`; returns true when it makes the interface comparable-only.
+	_mergeInterfaceEmbed(embed, scope, methods, typeSetEmbeds) {
+		const resolved = this.resolveTypeNode(embed, scope);
+		const base = resolved?.kind === "named" ? resolved.underlying : resolved;
+		if (base === COMPARABLE) return true;
+		if (base?.kind !== "interface") {
+			if (!isAny(resolved))
+				this.err(`cannot embed non-interface type ${typeStr(resolved)}`, embed);
+			return false;
+		}
+		for (const [mName, mType] of base.methods) {
+			if (!methods.has(mName)) methods.set(mName, mType);
+		}
+		if (base.unionConstraint || base._typeSetEmbeds) typeSetEmbeds.push(base);
+		return Boolean(base._comparable);
+	},
+
 	// ── Generics — substitution, instantiation, inference ────────────
 
 	substituteType(type, map) {
@@ -501,8 +733,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 +796,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 +837,76 @@ 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 (!tp.constraint) continue;
+				if (!arg) {
+					this._inferFromPointerCore(tp, typeParams, map, scope);
+					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;
+		}
+	},
+
+	// An unbound type parameter whose constraint has the single exact term
+	// `*T` (`P interface{ *T; M() }`) is the pointer type, once `T` is known.
+	_inferFromPointerCore(tp, typeParams, map, scope) {
+		const terms = this._constraintTerms(tp.constraint, new Set(), scope);
+		if (terms?.length !== 1 || terms[0]?.kind !== "pointer") return;
+		const free = new Set(
+			typeParams.filter((p) => !map.has(p.name)).map((p) => p.name),
+		);
+		const inferred = this.substituteType(terms[0], map);
+		const mentionsFree = (t) =>
+			t?.kind === "typeParam"
+				? free.has(t.name)
+				: t?.kind === "pointer"
+					? mentionsFree(t.base)
+					: false;
+		if (!mentionsFree(inferred) && inferred.kind === "pointer")
+			map.set(tp.name, inferred);
+	},
+
 	_inferFromFuncPair(paramType, argType, map) {
 		for (
 			let i = 0;
@@ -622,6 +925,10 @@ export const resolveMethods = {
 	_inferFromStructuredPair(paramType, argType, map) {
 		if (paramType.kind === "slice" && argType.kind === "slice")
 			this._inferFromPair(paramType.elem, argType.elem, map);
+		if (paramType.kind === "array" && argType.kind === "array")
+			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 +945,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);
@@ -662,15 +980,91 @@ 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);
-			if (typeStr(typeArg) === typeStr(termType)) return;
-		}
+		if (typeArg?._tainted || this._unionAccepts(typeArg, constraint, new Set()))
+			return;
 		this.err(`type ${typeStr(typeArg)} does not satisfy constraint`, node);
 	},
 
+	// Whether `typeArg` is in the type set of a union: some term holds it.
+	// `scope` resolves the names its terms mention.
+	_unionAccepts(typeArg, union, active, scope = this.globals) {
+		return union.terms.some((term) => {
+			// `~[]E` may mention a type parameter that is not in `scope`, so an
+			// approximation term is resolved (and compared) only when it names
+			// a type.
+			if (!term.resolved && term.approx && term.type?.kind !== "TypeName")
+				return true;
+			const t = term.resolved ?? this.resolveTypeNode(term.type, scope);
+			return this._termAccepts(typeArg, t, term.approx, active);
+		});
+	},
+
+	// One union term: a named interface contributes its own type set
+	// (`S | U` with `type S interface{ ~int }`), `~T` any type with the
+	// underlying type of `T`, and `T` exactly `T`.
+	_termAccepts(typeArg, t, approx, active) {
+		const base =
+			t?.kind === "named"
+				? (this.resolveType(t.underlying) ?? t.underlying)
+				: t;
+		if (base?.kind === "interface")
+			return this._interfaceAccepts(typeArg, base, active);
+		if (!approx) return typeStr(typeArg) === typeStr(t);
+		const want = this._deepUnderlying(t);
+		if (typeArg?.kind === "typeParam" || want?.kind !== "basic") return true;
+		return typeStr(this._deepUnderlying(typeArg)) === typeStr(want);
+	},
+
+	// An interface's type set is the intersection of its own union and the
+	// type sets of the interfaces it embeds; one with neither holds every type.
+	_interfaceAccepts(typeArg, iface, active) {
+		if (active.has(iface)) return true;
+		active.add(iface);
+		const ok =
+			(!iface.unionConstraint ||
+				this._unionAccepts(
+					typeArg,
+					iface.unionConstraint,
+					active,
+					iface._unionScope ?? this.globals,
+				)) &&
+			(iface._typeSetEmbeds ?? []).every((e) =>
+				this._interfaceAccepts(typeArg, e, active),
+			);
+		active.delete(iface);
+		return ok;
+	},
+
+	// Go's comparability: slices, maps and funcs are not comparable, nor are
+	// arrays and structs that contain them.
+	_isComparable(t, seen = new Set()) {
+		const base = t?.kind === "named" ? t.underlying : t;
+		if (!base || seen.has(base)) return true;
+		seen.add(base);
+		switch (base.kind) {
+			case "slice":
+			case "map":
+			case "func":
+				return false;
+			case "array":
+				return this._isComparable(base.elem, seen);
+			case "struct":
+				return [...(base.fields?.values() ?? [])].every((f) =>
+					this._isComparable(f, seen),
+				);
+			default:
+				return true;
+		}
+	},
+
 	_checkInterfaceConstraint(typeArg, base, constraint, node) {
+		if (base._comparable && !this._isComparable(typeArg)) {
+			this.err(
+				`type ${typeStr(typeArg)} does not satisfy constraint ${typeStr(constraint)}`,
+				node,
+			);
+			return;
+		}
 		if (base.methods.size === 0 && !base.unionConstraint) return;
 		if (base.unionConstraint) {
 			this.checkConstraint(typeArg, base.unionConstraint, node);
@@ -758,7 +1152,7 @@ export const resolveMethods = {
 		return (
 			baseType.kind === "pointer" &&
 			field !== "value" &&
-			baseType.base?.kind === "named"
+			(baseType.base?.kind === "named" || baseType.base?.kind === "struct")
 		);
 	},
 
@@ -788,7 +1182,11 @@ export const resolveMethods = {
 	},
 
 	_fieldTypeStruct(base, baseType, field, node) {
+		if (base.fields?.has(field) && isMethodPromotedOverField(base, field))
+			return base.methods.get(field);
 		if (base.fields?.has(field)) {
+			if (isAmbiguousFieldSelector(base, field))
+				return this._errAmbiguousSelector(baseType, field, node);
 			if (
 				field.startsWith("_") &&
 				(baseType?.name?.startsWith("strings.") ||
@@ -802,6 +1200,8 @@ export const resolveMethods = {
 			return base.fields.get(field);
 		}
 		if (base.methods?.has(field)) return base.methods.get(field);
+		if (isAmbiguousPromotion(base, field))
+			return this._errAmbiguousSelector(baseType, field, node);
 		const typeName = baseType?.name || base.name;
 		if (typeName) {
 			const dName = displayTypeName(typeName);
@@ -826,6 +1226,12 @@ export const resolveMethods = {
 		return this.err(`No field '${field}' on ${typeStr(baseType)}`, node);
 	},
 
+	_errAmbiguousSelector(baseType, field, node) {
+		const text = exprText(node?.expr);
+		const recv = text === "expression" ? typeStr(baseType) : text;
+		return this.err(`ambiguous selector ${recv}.${field}`, node);
+	},
+
 	_fieldTypeInterface(base, baseType, field, node) {
 		if (base.methods?.has(field)) return base.methods.get(field);
 		if (base.fields?.has(field)) return base.fields.get(field);
@@ -891,16 +1297,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) {