gofront 1.9.0 → 1.9.2

package/src/typechecker/resolve.js

@@ -3,6 +3,7 @@
 
 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,
@@ -11,7 +12,10 @@ import {
 	DECLARED_ANY,
 	defaultType,
 	displayTypeName,
+	isAmbiguousFieldSelector,
+	isAmbiguousPromotion,
 	isAny,
+	isMethodPromotedOverField,
 	isTypedArraySlice,
 	Scope,
 	TAINTED_ANY,
@@ -28,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();
@@ -215,7 +224,8 @@ export const resolveMethods = {
 			case "TypeName": {
 				if (BASIC_TYPES[node.name])
 					return node.name === "any" ? DECLARED_ANY : BASIC_TYPES[node.name];
-				if (node.name === "comparable") return COMPARABLE;
+				if (node.name === "comparable")
+					return this._checkConstraintUse(COMPARABLE, node);
 				if (scope) {
 					const fromScope = scope.lookup(node.name);
 					if (fromScope?.kind === "typeParam") return fromScope;
@@ -224,7 +234,7 @@ export const resolveMethods = {
 				const named = this.types.get(node.name);
 				if (named) {
 					this._useQualifiedTypeName(node, named);
-					return named;
+					return this._checkConstraintUse(named, node);
 				}
 				const jsOnly = this._jsOnlyMember(node.name);
 				if (jsOnly) return this._errJsOnly(jsOnly, node);
@@ -241,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;
@@ -264,7 +275,10 @@ 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;
@@ -283,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;
 					}
@@ -306,6 +319,95 @@ export const resolveMethods = {
 		}
 	},
 
+	// ── 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,
+			);
+		}
+	},
+
+	_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) {
@@ -342,18 +444,50 @@ 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;
-			if (Number.isInteger(n) && n >= 0) return n;
+			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.
-		const q = this._constIntValue(size, scope);
-		if (q === null || !Number.isInteger(q) || q < 0) return size;
+		if (!Number.isInteger(n))
+			n = this._constIntValue(size, scope) ?? Number.NaN;
+		if (!Number.isInteger(n)) {
+			this._reportNonConstantArrayLen(size, scope);
+			return size;
+		}
 		this._useQualifiedConsts(size);
-		return q;
+		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.
@@ -367,10 +501,24 @@ export const resolveMethods = {
 	},
 
 	_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",
@@ -378,6 +526,7 @@ export const resolveMethods = {
 					_line: node.size._line,
 					_col: node.size._col,
 				};
+			}
 		}
 		return {
 			kind: "array",
@@ -489,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));
@@ -504,24 +654,12 @@ 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) {
@@ -529,9 +667,28 @@ export const resolveMethods = {
 			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) {
@@ -715,7 +872,11 @@ export const resolveMethods = {
 			const before = map.size;
 			for (const tp of typeParams) {
 				const arg = map.get(tp.name);
-				if (!arg || !tp.constraint) continue;
+				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 =
@@ -727,6 +888,25 @@ export const resolveMethods = {
 		}
 	},
 
+	// 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;
@@ -745,6 +925,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 === "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") {
@@ -798,16 +980,91 @@ export const resolveMethods = {
 	},
 
 	_checkUnionConstraint(typeArg, constraint, node) {
-		for (const term of constraint.terms) {
-			if (term.approx) return;
-			const termType =
-				term.resolved ?? 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);
@@ -925,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.") ||
@@ -939,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);
@@ -963,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);