gofront 1.7.0 → 1.9.0

package/src/typechecker/resolve.js

@@ -2,11 +2,15 @@
 // Installed as a mixin on TypeChecker.prototype.
 
 import { parseJsonTag } from "../parser/struct-tag.js";
+import { foldConstExpr } from "./const-fold.js";
+import { EXCLUDED_STDLIB_MEMBERS } from "./stdlib/excluded.js";
 import {
 	ANY,
 	BASIC_TYPES,
 	COMPARABLE,
+	DECLARED_ANY,
 	defaultType,
+	displayTypeName,
 	isAny,
 	isTypedArraySlice,
 	Scope,
@@ -20,6 +24,97 @@ import {
 /** @typedef {import('./index.js').TypeChecker} TypeChecker */
 
 // Dispatch table for substituteType — keyed by type.kind.
+// Nesting depth of in-progress instances of one generic type before the
+// instantiation is reported as a cycle.
+const MAX_INSTANTIATION_DEPTH = 32;
+
+// 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();
+let nextDeclId = 0;
+function declId(t) {
+	if (!declIds.has(t)) declIds.set(t, ++nextDeclId);
+	return declIds.get(t);
+}
+
+// Go infers T from the "largest" untyped constant kind (int < rune < float <
+// complex), and a typed argument beats any untyped one.
+const UNTYPED_RANK = { int: 0, int32: 1, float64: 2, complex128: 3 };
+function untypedWins(prev, next) {
+	if (prev.kind !== "untyped") return false;
+	if (next.kind !== "untyped") return true;
+	return (UNTYPED_RANK[next.base] ?? 0) > (UNTYPED_RANK[prev.base] ?? 0);
+}
+
+// Node count of a type, so a request that keeps growing can be told from one
+// that merely repeats.
+function typeSize(t) {
+	switch (t?.kind) {
+		case "named":
+			return 1 + (t.typeArgs ?? []).reduce((n, a) => n + typeSize(a), 0);
+		case "pointer":
+			return 1 + typeSize(t.base);
+		case "slice":
+		case "array":
+			return 1 + typeSize(t.elem);
+		case "map":
+			return 1 + typeSize(t.key) + typeSize(t.value);
+		case "func":
+			return (
+				1 +
+				[...(t.params ?? []), ...(t.returns ?? [])].reduce(
+					(n, a) => n + typeSize(a),
+					0,
+				)
+			);
+		default:
+			return 1;
+	}
+}
+
+// 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":
+			return t.typeArgs?.length
+				? `${typeStr(t)}`
+				: `${typeStr(t)}#${declId(t)}`;
+		case "pointer":
+			return `*${instanceKey(t.base)}`;
+		case "slice":
+			return `[]${instanceKey(t.elem)}`;
+		case "array":
+			return `[${t.size ?? "..."}]${instanceKey(t.elem)}`;
+		case "map":
+			return `map[${instanceKey(t.key)}]${instanceKey(t.value)}`;
+		default:
+			return typeStr(t);
+	}
+}
+
 const SUBSTITUTE_DISPATCH = {
 	basic: (_s, type) => type,
 	untyped: (_s, type) => type,
@@ -63,18 +158,53 @@ const SUBSTITUTE_DISPATCH = {
 			fields,
 			methods,
 			_embeds: type._embeds,
+			// 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
+		// arguments (through the instance cache) rather than copying its
+		// possibly cyclic underlying type.
+		if (type._genericOf)
+			return s.instantiateGenericWithArgs(
+				type._genericOf,
+				type.typeArgs.map((t) => s.substituteType(t, map)),
+			);
+		return {
+			kind: "named",
+			name: type.name,
+			...(type.typeArgs && {
+				typeArgs: type.typeArgs.map((t) => s.substituteType(t, map)),
+			}),
+			underlying: s.substituteType(type.underlying, map),
+		};
 	},
-	named: (s, type, map) => ({
-		kind: "named",
-		name: type.name,
-		underlying: s.substituteType(type.underlying, map),
-	}),
 };
 
 /** @type {ThisType<TypeChecker>} */
@@ -83,45 +213,33 @@ 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);
 					if (fromScope?.kind === "typeParam") return fromScope;
+					if (fromScope?.kind === "aliasArg") return fromScope.type;
 				}
 				const named = this.types.get(node.name);
 				if (named) {
-					// `pkg.T` in a type position counts as using the import.
-					const dot = node.name.indexOf(".");
-					if (dot > 0) this.globals.lookup(node.name.slice(0, dot));
+					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)}`,
+						node,
+					);
+				}
 				return this.err(`Unknown type '${node.name}'`, node);
 			}
 			case "GenericTypeName":
 			case "InstantiationExpr":
-			case "IndexExpr": {
-				const name =
-					node.name ?? (node.expr?.kind === "Ident" ? node.expr.name : null);
-				const typeArgs = node.typeArgs ?? (node.index ? [node.index] : []);
-				const base = name
-					? this.types.get(name)
-					: node.expr
-						? this.resolveTypeNode(node.expr, scope)
-						: null;
-				if (!base) return this.err(`Unknown type '${name ?? "?"}'`, node);
-				if (base.kind === "named" && base._generic) {
-					const res = this.instantiateGenericType(
-						base._generic,
-						typeArgs,
-						scope,
-					);
-					node._typeArgs = res.typeArgs;
-					node._genericType = base;
-					return res;
-				}
-				return this.err(`Type '${name ?? "?"}' is not generic`, node);
-			}
+			case "IndexExpr":
+				return this._resolveGenericTypeName(node, scope);
 			case "TypeParam": {
 				const constraint = node.constraint
 					? this.resolveTypeNode(node.constraint, scope)
@@ -147,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 },
@@ -157,11 +282,14 @@ export const resolveMethods = {
 				// SelectorExpr; resolve it like a qualified TypeName.
 				if (node.expr?.kind === "Ident" && typeof node.field === "string") {
 					const qualified = `${node.expr.name}.${node.field}`;
-					if (this.types.has(qualified))
-						return this.resolveTypeNode(
+					if (this.types.has(qualified)) {
+						const resolved = this.resolveTypeNode(
 							{ kind: "TypeName", name: qualified },
 							scope,
 						);
+						this._useQualifiedTypeName(node, resolved);
+						return resolved;
+					}
 				}
 				return ANY;
 			case "ArrayType":
@@ -178,24 +306,134 @@ export const resolveMethods = {
 		}
 	},
 
+	// `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
+	// stdlib type is emitted under its mangled name.
+	_useQualifiedTypeName(node, named) {
+		const name =
+			node.name ?? (node.expr ? `${node.expr.name}.${node.field}` : "");
+		const dot = name.indexOf(".");
+		if (dot <= 0) return;
+		this.globals.lookup(name.slice(0, dot));
+		if (named.name?.includes("$$")) node._stdName = named.name;
+	},
+
+	// `[N]T` with a named constant (or constant expression) length folds to a number.
+	_foldArrayLen(size, scope) {
+		const resolve = (name, depth = 0) => {
+			const e = depth < 16 ? scope.lookupConstExpr(name) : null;
+			return e ? foldConstExpr(e, (n) => resolve(n, depth + 1)) : undefined;
+		};
+		try {
+			const lit = foldConstExpr(size, resolve);
+			const n = lit ? Number(lit.value) : Number.NaN;
+			if (Number.isInteger(n) && n >= 0) return n;
+		} catch {
+			// 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) {
+		// Fold in place so backends that read the type node see a literal length.
+		if (!node.inferLen && node.size?.value === undefined) {
+			const n = this._foldArrayLen(node.size, scope);
+			if (typeof n === "number")
+				node.size = {
+					kind: "BasicLit",
+					litKind: "INT",
+					value: String(n),
+					_line: node.size._line,
+					_col: node.size._col,
+				};
+		}
 		return {
 			kind: "array",
 			size: node.inferLen
 				? null
 				: node.size?.value !== undefined
 					? Number(node.size.value)
-					: node.size,
+					: this._foldArrayLen(node.size, scope),
 			elem: this.resolveTypeNode(node.elem, scope),
 		};
 	},
 
+	// `G[X]`: instantiate a generic named type, or expand a generic alias.
+	_resolveGenericTypeName(node, scope) {
+		const sel = node.expr?.kind === "SelectorExpr" ? node.expr : null;
+		const qualified =
+			sel?.expr?.kind === "Ident" ? `${sel.expr.name}.${sel.field}` : null;
+		const name =
+			node.name ??
+			(node.expr?.kind === "Ident" ? node.expr.name : null) ??
+			qualified;
+		const typeArgs = node.typeArgs ?? (node.index ? [node.index] : []);
+		const base = name
+			? this.types.get(name)
+			: node.expr
+				? this.resolveTypeNode(node.expr, scope)
+				: null;
+		if (!base) return this.err(`Unknown type '${name ?? "?"}'`, node);
+		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));
+			node._typeArgs = aliasArgs;
+			return this._instantiateGenericAlias(base._generic, aliasArgs);
+		}
+		if (base.kind === "named" && base._generic) {
+			const res = this.instantiateGenericType(base._generic, typeArgs, scope);
+			node._typeArgs = res.typeArgs;
+			node._genericType = base;
+			return res;
+		}
+		return this.err(`Type '${name ?? "?"}' is not generic`, node);
+	},
+
 	_resolveFuncTypeNode(node, scope) {
 		const params = node.params.map((p) => this.resolveTypeNode(p.type, scope));
 		const returns = node.returnType
 			? [this.resolveTypeNode(node.returnType, scope)]
 			: [VOID];
-		return { kind: "func", params, returns };
+		const fn = { kind: "func", params, returns };
+		if (node.params.at(-1)?.variadic) fn.variadic = true;
+		return fn;
 	},
 
 	resolveTypeNodeName(node, scope) {
@@ -223,6 +461,7 @@ export const resolveMethods = {
 			if (f.embedded) {
 				const inner = ft.kind === "pointer" ? ft.base : ft;
 				const embedName = (
+					f.embeddedName ??
 					f.astType?.name ??
 					f.type?.name ??
 					f.type?.base?.name ??
@@ -262,6 +501,9 @@ export const resolveMethods = {
 			if (isVariadic) mType.variadic = true;
 			methods.set(m.name, mType);
 		}
+		// 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);
@@ -271,6 +513,8 @@ export const resolveMethods = {
 					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)}`,
@@ -280,7 +524,11 @@ 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;
 	},
 
@@ -301,45 +549,184 @@ export const resolveMethods = {
 	},
 
 	instantiateGenericType(generic, typeArgNodes, scope) {
-		const map = new Map();
 		const typeArgs = typeArgNodes.map((n) => this.resolveTypeNode(n, scope));
+		return this.instantiateGenericWithArgs(generic, typeArgs);
+	},
+
+	// One instance per type-argument list.  The instance is cached before its
+	// fields are resolved, so a field that names the instance again (`Next
+	// *List[T]`, `Children []Tree[T]`, or a cycle through another generic type)
+	// reaches the same object instead of recursing forever.
+	instantiateGenericWithArgs(generic, typeArgs) {
+		const key = typeArgs.map(instanceKey).join(",");
+		generic._instances ??= new Map();
+		const cached = generic._instances.get(key);
+		if (cached) {
+			this._syncInstanceMethods(generic, cached);
+			return cached;
+		}
+		// `type T[X any] struct{ n *T[[]X] }` asks for T[[]X], then T[[][]X], and
+		// so on: an instance still being built that keeps asking for a larger
+		// one never settles.
+		generic._building ??= [];
+		generic._buildSizes ??= [];
+		const building = generic._building;
+		const size = typeArgs.reduce((n, a) => n + typeSize(a), 0);
+		// A request for a larger instance while one is being built never
+		// 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) {
+				generic._cycleReported = true;
+				this.err(
+					`instantiation cycle: ${generic.declNode.name} instantiates itself with ever larger type arguments`,
+					generic.declNode,
+				);
+			}
+			return ANY;
+		}
+		const map = new Map();
 		for (let i = 0; i < generic.typeParams.length; i++)
 			map.set(generic.typeParams[i].name, typeArgs[i] ?? ANY);
+		const named = {
+			kind: "named",
+			name: generic.declNode.name,
+			typeArgs,
+			underlying: null,
+			_genericOf: generic,
+		};
+		generic._instances.set(key, named);
 		// Resolve the declaration with its type params in scope (as typeParams,
 		// never as value symbols), then substitute the concrete arguments.
 		const typeScope = new Scope(this.globals);
 		for (const tp of generic.typeParams) typeScope.define(tp.name, tp);
-		const underlying = this.resolveTypeNode(generic.declNode.type, typeScope);
-		const instantiated = this.substituteType(underlying, map);
+		building.push(key);
+		generic._buildSizes.push(size);
+		let instantiated;
+		try {
+			const underlying = this.resolveTypeNode(generic.declNode.type, typeScope);
+			instantiated = this.substituteType(underlying, map);
+		} finally {
+			building.pop();
+			generic._buildSizes.pop();
+		}
 		if (instantiated.kind === "struct") {
 			instantiated.name = generic.declNode.name;
 			instantiated.typeArgs = typeArgs;
 			if (!instantiated.methods) instantiated.methods = new Map();
-			if (generic.methods) {
-				for (const [mName, mType] of generic.methods)
-					instantiated.methods.set(mName, this.substituteType(mType, map));
+		}
+		named.underlying = instantiated;
+		named.methods = instantiated.methods;
+		named._instMap = map;
+		this._syncInstanceMethods(generic, named);
+		return named;
+	},
+
+	// Methods are collected after types, so an instance created earlier picks
+	// up the methods declared since.
+	_syncInstanceMethods(generic, named) {
+		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;
+		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
+	// concrete X, so A[int] is exactly T[int] (generic named types inside T
+	// are instantiated normally and keep their identity).
+	_instantiateGenericAlias(generic, typeArgs) {
+		const { typeParams, declNode } = generic;
+		if (typeArgs.length !== typeParams.length) {
+			return this.err(
+				`got ${typeArgs.length} type arguments but ${declNode.name} has ${typeParams.length} type parameters`,
+				declNode,
+			);
+		}
+		const aliasScope = new Scope(this.globals);
+		for (let i = 0; i < typeParams.length; i++) {
+			const tp = typeParams[i];
+			if (tp.constraint) {
+				const constraint = this.resolveTypeNode(tp.constraint, this.globals);
+				this.checkConstraint(typeArgs[i], constraint, declNode);
 			}
+			aliasScope.define(tp.name, { kind: "aliasArg", type: typeArgs[i] });
 		}
-		return {
-			kind: "named",
-			name: generic.declNode.name,
-			typeArgs,
-			underlying: instantiated,
-			methods: instantiated.methods,
-		};
+		return this.resolveTypeNode(declNode.type, aliasScope);
 	},
 
-	inferTypeArgs(genericType, argTypes) {
+	// `explicit` seeds the leading type arguments of a partial instantiation
+	// (`F[int](x)`); the rest are inferred from the call arguments.
+	// `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;
@@ -358,27 +745,63 @@ 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);
 		}
 		if (paramType.kind === "func" && argType.kind === "func")
 			this._inferFromFuncPair(paramType, argType, map);
+		if (paramType.kind === "tuple" && argType.kind === "tuple") {
+			for (
+				let i = 0;
+				i < paramType.types.length && i < argType.types.length;
+				i++
+			)
+				this._inferFromPair(paramType.types[i], argType.types[i], map);
+		}
+	},
+
+	// 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") {
-			if (!map.has(paramType.name)) map.set(paramType.name, argType);
+			const prev = map.get(paramType.name);
+			if (!prev || untypedWins(prev, argType)) map.set(paramType.name, argType);
 			return;
 		}
+		if (paramType.kind === "named" && paramType.typeArgs) {
+			// `iter.Seq[E]` against `iter.Seq[int]`: unify the type arguments;
+			// against any other type, its underlying type.
+			if (argType.kind === "named" && argType.name === paramType.name) {
+				const args = argType.typeArgs ?? [];
+				for (let i = 0; i < paramType.typeArgs.length; i++)
+					this._inferFromPair(paramType.typeArgs[i], args[i], map);
+				return;
+			}
+			paramType = paramType.underlying;
+		}
+		if (argType.kind === "named" && argType.underlying)
+			argType = argType.underlying;
 		this._inferFromStructuredPair(paramType, argType, map);
 	},
 
 	_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);
@@ -422,11 +845,37 @@ export const resolveMethods = {
 			(!t.underlying || !t.methods)
 		) {
 			const found = this.types.get(t.name);
-			if (found) return found;
+			// Two imported packages can both declare `Pt`; the bare name only
+			// reaches the last one registered, so a declaration that came from
+			// an import's own type table stays itself.
+			if (found && !(t.underlying && this._ambiguousImported?.has(t)))
+				return found;
 		}
+		if (t.kind === "named" && t.typeArgs?.length)
+			return this._withGenericMethods(t);
 		return t;
 	},
 
+	// A substituted generic instance (e.g. Stack[int] from an inferred call)
+	// drops the methods map; re-derive it from the generic declaration.
+	_withGenericMethods(t) {
+		const decl = this.types.get(t.name);
+		const generic = decl?._generic;
+		// Struct generics only: codegen has no receiver support for generic
+		// slice/map/func named types, so those keep the baseline diagnostics.
+		if (this.resolveType(decl?.underlying)?.kind !== "struct") return t;
+		if (!generic?.methods || generic.methods.size === 0) return t;
+		if (t.methods && generic.methods.size <= t.methods.size) return t;
+		const map = new Map();
+		for (let i = 0; i < generic.typeParams.length; i++)
+			map.set(generic.typeParams[i].name, t.typeArgs[i] ?? ANY);
+		const methods = new Map(t.methods);
+		for (const [name, mType] of generic.methods)
+			if (!methods.has(name))
+				methods.set(name, this.substituteType(mType, map));
+		return { ...t, methods };
+	},
+
 	// ── Field type lookup ─────────────────────────────────────────────
 
 	fieldType(baseType, field, node) {
@@ -446,7 +895,7 @@ export const resolveMethods = {
 		return (
 			baseType.kind === "pointer" &&
 			field !== "value" &&
-			baseType.base?.kind === "named"
+			(baseType.base?.kind === "named" || baseType.base?.kind === "struct")
 		);
 	},
 
@@ -490,12 +939,54 @@ export const resolveMethods = {
 			return base.fields.get(field);
 		}
 		if (base.methods?.has(field)) return base.methods.get(field);
+		const typeName = baseType?.name || base.name;
+		if (typeName) {
+			const dName = displayTypeName(typeName);
+			const shortName = typeName.includes("$$")
+				? typeName.split("$$")[0]
+				: typeName.includes(".")
+					? typeName.split(".").pop()
+					: typeName;
+			for (const key of [
+				`${dName}.${field}`,
+				`${typeName}.${field}`,
+				`${shortName}.${field}`,
+			]) {
+				if (EXCLUDED_STDLIB_MEMBERS.has(key)) {
+					return this.err(
+						`${dName}.${field} is not available: ${EXCLUDED_STDLIB_MEMBERS.get(key)}`,
+						node,
+					);
+				}
+			}
+		}
 		return this.err(`No field '${field}' on ${typeStr(baseType)}`, 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);
+		const typeName = baseType?.name || base.name;
+		if (typeName) {
+			const dName = displayTypeName(typeName);
+			const shortName = typeName.includes("$$")
+				? typeName.split("$$")[0]
+				: typeName.includes(".")
+					? typeName.split(".").pop()
+					: typeName;
+			for (const key of [
+				`${dName}.${field}`,
+				`${typeName}.${field}`,
+				`${shortName}.${field}`,
+			]) {
+				if (EXCLUDED_STDLIB_MEMBERS.has(key)) {
+					return this.err(
+						`${dName}.${field} is not available: ${EXCLUDED_STDLIB_MEMBERS.get(key)}`,
+						node,
+					);
+				}
+			}
+		}
 		if (base._excluded?.has(field))
 			return this.err(`No member '${field}' on ${typeStr(baseType)}`, node);
 		if (base._isOpen) return ANY;
@@ -537,12 +1028,37 @@ 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) {
 			if (
 				(this.target === "wasm" || this.target === "both") &&
@@ -561,6 +1077,12 @@ export const resolveMethods = {
 			}
 			return base.members[field];
 		}
+		const excluded = EXCLUDED_STDLIB_MEMBERS.get(`${base.name}.${field}`);
+		if (excluded)
+			return this.err(
+				`${base.name}.${field} is not available: ${excluded}`,
+				node,
+			);
 		return this.err(`No member '${field}' in namespace ${base.name}`, node);
 	},
 
@@ -575,7 +1097,16 @@ function isExported(name) {
 	return code >= 65 && code <= 90;
 }
 
-function _processJsonField(f, depth, path, visited, queue, candidates) {
+function _processJsonField(
+	f,
+	depth,
+	path,
+	visited,
+	queue,
+	candidates,
+	index,
+	pos,
+) {
 	const tagInfo = parseJsonTag(f.tag);
 	if (tagInfo.ignored) return;
 
@@ -602,6 +1133,7 @@ function _processJsonField(f, depth, path, visited, queue, candidates) {
 					depth,
 					tagged: true,
 					isEmbedded: true,
+					index: [...index, pos],
 					path: [...path, { name: embedName, isPtr, typeName: embedName }],
 				});
 			}
@@ -612,6 +1144,7 @@ function _processJsonField(f, depth, path, visited, queue, candidates) {
 				queue.push({
 					struct: embedStruct,
 					depth: depth + 1,
+					index: [...index, pos],
 					path: [...path, { name: embedName, isPtr, typeName: embedName }],
 					visited: nextVisited,
 				});
@@ -620,9 +1153,10 @@ function _processJsonField(f, depth, path, visited, queue, candidates) {
 		return;
 	}
 
-	for (const name of f.names) {
+	for (const [i, name] of f.names.entries()) {
 		if (!isExported(name)) continue;
 		candidates.push({
+			index: [...index, pos + i],
 			jsonKey: tagInfo.name !== null ? tagInfo.name : name,
 			goName: name,
 			type: f.type,
@@ -658,10 +1192,18 @@ function _resolveCandidateCollisions(candidates) {
 		}
 	}
 
-	winningFields.sort((a, b) => candidates.indexOf(a) - candidates.indexOf(b));
+	// Go orders the fields of a struct by their index sequence, so a promoted
+	// field sits where its embedded struct is declared.
+	winningFields.sort((a, b) => compareIndex(a.index, b.index));
 	return winningFields;
 }
 
+function compareIndex(a, b) {
+	for (let i = 0; i < a.length && i < b.length; i++)
+		if (a[i] !== b[i]) return a[i] - b[i];
+	return a.length - b.length;
+}
+
 export function resolveJsonFields(structType) {
 	if (!structType) return [];
 	const underlying =
@@ -670,16 +1212,25 @@ export function resolveJsonFields(structType) {
 	if (underlying._jsonFields) return underlying._jsonFields;
 
 	const queue = [
-		{ struct: underlying, depth: 0, path: [], visited: new Set([underlying]) },
+		{
+			struct: underlying,
+			depth: 0,
+			path: [],
+			index: [],
+			visited: new Set([underlying]),
+		},
 	];
 	const candidates = [];
 
 	while (queue.length > 0) {
-		const { struct: curr, depth, path, visited } = queue.shift();
+		const { struct: curr, depth, path, index, visited } = queue.shift();
 		if (curr?.kind !== "struct") continue;
 
+		// Each name of a `A, B int` field is its own field, as in Go.
+		let pos = 0;
 		for (const f of curr._structFields || []) {
-			_processJsonField(f, depth, path, visited, queue, candidates);
+			_processJsonField(f, depth, path, visited, queue, candidates, index, pos);
+			pos += f.embedded ? 1 : (f.names?.length ?? 1);
 		}
 	}