@lzehrung/codegraph 2.4.0 → 3.0.1

package/dist/indexer/navigation-goto.js

@@ -4,15 +4,14 @@ import { isPythonReceiverAttributeAssignmentName } from "../languages/definition
 import { sliceText } from "../util/ast.js";
 import { foldPhpIdentifierCase } from "../util/identifiers.js";
 import { fileIdentityKey } from "../util/paths.js";
-import { collectMemberAccessChain, getMemberAccessParts, getNavigationExpressionProperty, isMemberAccessNode, isReceiverNameNode, memberAccessTraversalTypes, receiverKeywordText, } from "../util/member-access.js";
-import { keywordReceiverKind, MEMBER_ACCESS_ROWS, supportsReceiverMemberNavigation, } from "../util/member-access-tables.js";
-import { cppCallableShapeForNode } from "./cpp-callables.js";
-import { typescriptCallableContainerKey, typescriptMergedNamespaceContainers, typescriptSelectOverloadCandidate, } from "./ts-callables.js";
+import { collectMemberAccessChain, getMemberAccessParts, getNavigationExpressionProperty, isMemberAccessNode, isReceiverNameNode, memberAccessTraversalTypes, } from "../util/member-access.js";
+import { MEMBER_ACCESS_ROWS, supportsReceiverMemberNavigation } from "../util/member-access-tables.js";
+import { typescriptCallableContainerKey, typescriptMergedNamespaceContainers } from "./ts-callables.js";
 import { effectiveExplicitBinding, isExpandedStarBinding, resolveStarImportedName, resolveStarImportedNamespace, starImportPrecedence, } from "./star-import-precedence.js";
-import { classifyReceiver, cppOutOfLineOwnerPath, cppQualifiedNameSegments, declarationIsStaticEquivalent, declarationNodeIsStatic, declaresMembers, hasStaticMemberDistinction, memberContainerDef, nearestMemberContainer, keywordReceiverCrossesDynamicBoundary, isUnprovenHeritageExpression, keywordReceiverMemberScope, kotlinExtensionReceiverTypeNode, csharpDottedNameRoot, nodeInStaticMemberContext, importTypeQuerySpecifier, receiverConstructorExpression, rustImplSelfTypeNode, supportsStaticMemberScope, TRANSPARENT_MEMBER_CONTAINER_TYPES, unwrapNamedType, } from "../graphs/symbol-graph-detailed/receiver-calls.js";
-import { CALLABLE_DECLARATION_NODE_TYPES, getCallableArity, getCallArgumentCount, memberLookupBinding, } from "../languages/callable-arity.js";
-import { getCompilationUnitPeers } from "./compilation-units.js";
-import { isExportedDeclaration, isPrivateDeclaration, isGoExportedMemberName, isSwiftCrossFileHiddenSharedOwnerMember, } from "./declaration-visibility.js";
+import { classifyReceiver, cppOutOfLineOwnerPath, cppQualifiedNameSegments, declarationIsStaticEquivalent, declarationNodeIsStatic, declaredTypeNameNode, declaresMembers, hasStaticMemberDistinction, memberContainerDef, nearestMemberContainer, isUnprovenHeritageExpression, kotlinExtensionReceiverTypeNode, csharpDottedNameRoot, nodeInStaticMemberContext, importTypeQuerySpecifier, rustImplSelfTypeNode, supportsStaticMemberScope, TRANSPARENT_MEMBER_CONTAINER_TYPES, unwrapNamedType, } from "../graphs/symbol-graph-detailed/receiver-calls.js";
+import { getCallArgumentCount, memberLookupBinding } from "../languages/callable-arity.js";
+import { getCompilationUnitPeers, getPackageDeclarationName } from "./compilation-units.js";
+import { isExportedDeclaration, isJvmPackageSymbolVisible, isPrivateDeclaration, isGoExportedMemberName, isSwiftCrossFileHiddenSharedOwnerMember, } from "./declaration-visibility.js";
 import { ensureParsedContext } from "./parse-context.js";
 import { csharpLookupName, csharpQualifiedNameNode, findClosestScopeBinding, getOrBuildScopeIndex, resolveNamedDefinition, } from "./navigation-local.js";
 import { resolveCppQualifiedMemberContainer, cppFunctionHasImplicitThis } from "./navigation-cpp.js";
@@ -21,7 +20,81 @@ import { comparePhpReferenceNames, findPhpImportAlias } from "./navigation-php.j
 import { resolveIndexedPhpClassReference, resolvePhpNamespaceSymbol } from "./php-namespace-symbols.js";
 import { cjsRequireValueBinding, memberContainerForDefinition, resolveCsharpQualifiedName, resolveExport, resolveImported, resolvePhpExportByImportType, resolveImportTypeMember, } from "./navigation-resolve.js";
 import { CSHARP_PARTIAL_CONTAINER_TYPES, getSharedOwnerIdentity, isSwiftExtensionContainer, sharedOwnerCanUseMembers, } from "./shared-owner-identity.js";
+import { hasSeparateMemberScopes, inheritsMemberOverloads, selectMember, } from "./member-selection.js";
 import { SymbolKind, } from "./types.js";
+const DECLARED_FIELD_CHAIN_LANGUAGES = {
+    ts: true,
+    tsx: true,
+    java: true,
+    csharp: true,
+    kotlin: true,
+};
+/** Type-syntax nodes that wrap a declared type name together with its qualifier. */
+const QUALIFIED_TYPE_NODE_TYPES = {
+    qualified_name: true,
+    scoped_type_identifier: true,
+    nested_type_identifier: true,
+    user_type: true,
+    generic_name: true,
+    generic_type: true,
+};
+/**
+ * The full spelling of a declared type, e.g. `B.Repo` for `B.Repo<T>`: the last segment alone
+ * would resolve to a same-named type of another namespace.
+ */
+function qualifiedDeclaredTypeText(typeName, source) {
+    let top = typeName;
+    for (let parent = typeName.parent; parent && QUALIFIED_TYPE_NODE_TYPES[parent.type]; parent = parent.parent) {
+        top = parent;
+    }
+    let text = sliceText(top, source).replace(/\s+/g, "");
+    for (let previous = ""; previous !== text;) {
+        previous = text;
+        text = text.replace(/<[^<>]*>/g, "");
+    }
+    return text;
+}
+/** Type-parameter list nodes across the TypeScript, Java, C#, and Kotlin grammars. */
+const TYPE_PARAMETER_LIST_TYPES = {
+    type_parameters: true,
+    type_parameter_list: true,
+};
+/** Names of the generic type parameters declared by `node` and its enclosing declarations. */
+function typeParameterNamesInScope(node, source) {
+    const names = new Set();
+    for (let current = node; current; current = current.parent) {
+        for (const list of current.namedChildren) {
+            if (!TYPE_PARAMETER_LIST_TYPES[list.type])
+                continue;
+            for (const parameter of list.namedChildren) {
+                const name = parameter.childForFieldName("name") ??
+                    parameter.namedChildren.find((child) => child.type === "identifier" || child.type === "type_identifier");
+                if (name)
+                    names.add(sliceText(name, source));
+            }
+        }
+    }
+    return names;
+}
+export function supportsDeclaredFieldChains(languageId) {
+    return !!DECLARED_FIELD_CHAIN_LANGUAGES[languageId];
+}
+function noLexicalBinding() {
+    return false;
+}
+/** A Rust named `use crate::mod` binding names the indexed module, not a class export. */
+export function resolveRustModuleNamespace(index, binding) {
+    if (binding.kind !== "named" || typeof binding.resolved !== "string")
+        return null;
+    const owner = index.byFile.get(fileIdentityKey(binding.resolved));
+    if (!owner)
+        return null;
+    const modules = owner.imports.filter((candidate) => candidate.kind === "namespace" && candidate.localNS === binding.imported);
+    if (modules.length !== 1)
+        return null;
+    const resolved = modules[0]?.resolved;
+    return typeof resolved === "string" ? resolved : null;
+}
 /**
  * One bound for every receiver-hierarchy walk in this module: keyword `super`/`parent` lookup,
  * Go struct embedding, and Python base classes. Each walk keeps its own visited set, so this is a
@@ -393,6 +466,45 @@ function resolveRubyQualifiedConstantDefinition(index, mod, node, source) {
         confidence: "medium",
     });
 }
+/** A fully qualified JVM package symbol, never a same-spelled type from another package. */
+function resolveJvmPackageSymbol(index, packageName, symbolName, languageId, useFile) {
+    const samePackage = getPackageDeclarationName(index, useFile, languageId) === packageName;
+    let target;
+    for (const candidate of index.byFile.values()) {
+        const targetLanguage = supportForFileWithoutHeaderSample(candidate.file, index.languageExtensions)?.id;
+        if (targetLanguage !== "java" && targetLanguage !== "kotlin")
+            continue;
+        if (getPackageDeclarationName(index, candidate.file, targetLanguage) !== packageName)
+            continue;
+        for (const entry of candidate.exports) {
+            if (entry.type !== "local" ||
+                entry.exportedAs !== symbolName ||
+                entry.target.isMember ||
+                !isJvmPackageSymbolVisible(entry.target, targetLanguage, languageId, samePackage))
+                continue;
+            if (target &&
+                (target.file !== entry.target.file || target.range.start.index !== entry.target.range.start.index)) {
+                return undefined;
+            }
+            target = entry.target;
+        }
+    }
+    return target;
+}
+/** Package paths only bind when the leftmost name is not a lexical value or imported alias. */
+function resolveJvmPackageExpression(index, sup, source, expr, resolveLexicalBinding, useFile) {
+    if (sup.id !== "java" && sup.id !== "kotlin")
+        return null;
+    const chain = collectMemberAccessChain({ sup, source, chainNode: expr });
+    if (!chain || !isReceiverNameNode(sup, chain.base.type) || resolveLexicalBinding?.(chain.base))
+        return null;
+    const parts = [sliceText(chain.base, source), ...chain.names.toReversed()];
+    const member = parts.pop();
+    if (!member || !parts.every((part) => /^[\p{L}_][\p{L}\p{N}_]*$/u.test(part)))
+        return null;
+    const target = resolveJvmPackageSymbol(index, parts.join("."), member, sup.id, useFile);
+    return target ? { kind: "resolved", def: target } : null;
+}
 export async function resolveMemberAccessDefinition(params) {
     const { index, mod, node, source, tree, sup, resolveLexicalBinding } = params;
     if (sup.id === "ruby") {
@@ -481,6 +593,11 @@ export async function resolveMemberAccessDefinition(params) {
                     if (result)
                         return result;
                 }
+                if (sup.id === "rust") {
+                    const moduleFile = resolveRustModuleNamespace(index, imp);
+                    if (moduleFile)
+                        return { kind: "namespace", file: moduleFile };
+                }
                 const result = resolveImported(index, imp, imp.kind === "named" ? imp.imported : "default");
                 if (result) {
                     if ("namespace" in result) {
@@ -560,6 +677,11 @@ export async function resolveMemberAccessDefinition(params) {
             }
             if (subObj && subProp) {
                 const base = await resolveExpression(subObj);
+                if (!base) {
+                    const qualified = resolveJvmPackageExpression(index, sup, source, expr, resolveLexicalBinding, mod.file);
+                    if (qualified)
+                        return qualified;
+                }
                 const memberName = sliceText(subProp, source);
                 // `P.Mix` in `P.Mix.M()`: when the leftmost name binds nothing, a C# dotted name is a
                 // namespace-qualified type, which qualified export lookup resolves across every file that
@@ -574,6 +696,24 @@ export async function resolveMemberAccessDefinition(params) {
                     return resolveExport(index, base.file, memberName, { allowLocalFallback: false });
                 }
                 if (base?.kind === "resolved") {
+                    if (sup.id === "go") {
+                        const receiver = await resolveReceiverDefinition(index, subObj, source, sup, resolveExpression, mod, undefined, base);
+                        if (receiver && declaresMembers(receiver.def)) {
+                            const context = await ensureParsedContext(receiver.def.file, undefined, index.languageExtensions);
+                            const embedded = goEmbeddedTypeNames(receiver.def.localName, context, context.sup.normalizeIdentifier);
+                            if (embedded.includes(memberName)) {
+                                const ownerModule = index.byFile.get(fileIdentityKey(receiver.def.file));
+                                const named = ownerModule
+                                    ? resolveNamedDefinition(index, ownerModule, ownerModule.file, context.sup, memberName)
+                                    : null;
+                                if (named?.status === "ok") {
+                                    const type = asMemberContainer(index, named.definition);
+                                    if (type)
+                                        return { kind: "resolved", def: type };
+                                }
+                            }
+                        }
+                    }
                     if (sup.id === "java" || sup.id === "csharp") {
                         const memberDef = await resolveMemberDefinitionForBase(index, base.def, memberName, callArgumentCountFor(expr));
                         return memberDef ? { kind: "resolved", def: memberDef } : null;
@@ -595,6 +735,11 @@ export async function resolveMemberAccessDefinition(params) {
             const subProp = expr.childForFieldName("name") ?? expr.child(2);
             if (subObj && subProp) {
                 const base = await resolveExpression(subObj);
+                if (!base) {
+                    const qualified = resolveJvmPackageExpression(index, sup, source, expr, resolveLexicalBinding, mod.file);
+                    if (qualified)
+                        return qualified;
+                }
                 const memberName = sliceText(subProp, source);
                 if (base?.kind === "namespace") {
                     return resolveExport(index, base.file, memberName, { allowLocalFallback: false });
@@ -607,6 +752,22 @@ export async function resolveMemberAccessDefinition(params) {
         }
         return null;
     };
+    const receiverHasLexicalBinding = sup.id === "python"
+        ? (callee) => {
+            const scope = getOrBuildScopeIndex(index, mod.file, source, sup, mod, tree);
+            return !!findClosestScopeBinding(scope, sliceText(callee, source), callee, sup);
+        }
+        : noLexicalBinding;
+    const resolvedReceiver = obj && prop && node.id === prop.id ? await resolveExpression(obj) : null;
+    const receiverProof = obj && prop && node.id === prop.id
+        ? classifyReceiver(sup, obj, source, null, 0, memberNode, receiverHasLexicalBinding, () => {
+            if (resolvedReceiver?.kind === "namespace")
+                return "module-import";
+            if (resolvedReceiver?.kind === "resolved" && declaresMembers(resolvedReceiver.def))
+                return "static-type";
+            return null;
+        })
+        : null;
     const chain = await resolveExpression(memberNode);
     if (chain && prop && node.id === prop.id) {
         if (chain.kind === "resolved") {
@@ -628,12 +789,10 @@ export async function resolveMemberAccessDefinition(params) {
             }
         }
     }
-    const receiverName = obj ? sliceText(obj, source) : "";
-    const receiverKind = keywordReceiverKind(sup.id, receiverName);
     if (obj && prop && node.id === prop.id && supportsReceiverMemberNavigation(sup.id)) {
         const member = sliceText(prop, source);
         if (sup.id === "python") {
-            const memberDef = await resolvePythonReceiverMember(index, mod, node, obj, member, source, tree, sup, resolveExpression);
+            const memberDef = await resolvePythonReceiverMember(index, mod, node, obj, member, source, sup, resolveExpression, receiverProof);
             if (!memberDef)
                 return null;
             return okGoToResult(index, memberDef, {
@@ -642,11 +801,8 @@ export async function resolveMemberAccessDefinition(params) {
                 confidence: "medium",
             });
         }
-        if (receiverKind && keywordReceiverCrossesDynamicBoundary(sup, node)) {
-            return null;
-        }
-        const keywordScope = receiverKind ? keywordReceiverMemberScope(sup, receiverName, node, source) : "any";
-        if (receiverKind === "own") {
+        const keywordScope = receiverProof?.kind === "own-type" || receiverProof?.kind === "supertype" ? receiverProof.memberScope : "any";
+        if (receiverProof?.kind === "own-type") {
             const memberDef = await resolveKeywordReceiverMember(index, mod, node, member, keywordScope, false, getCallArgumentCount({ languageId: sup.id, source, call: memberNode.parent ?? memberNode }) ?? undefined);
             if (memberDef) {
                 return okGoToResult(index, memberDef, {
@@ -673,7 +829,7 @@ export async function resolveMemberAccessDefinition(params) {
             if (sup.id === "swift")
                 return { status: "not_found", reason: "No matching Swift member definition" };
         }
-        else if (receiverKind === "supertype") {
+        else if (receiverProof?.kind === "supertype") {
             const memberDef = await resolveKeywordReceiverMember(index, mod, node, member, keywordScope, true, getCallArgumentCount({ languageId: sup.id, source, call: memberNode.parent ?? memberNode }) ?? undefined);
             if (!memberDef)
                 return { status: "not_found", reason: "No matching supertype member definition" };
@@ -710,7 +866,7 @@ export async function resolveMemberAccessDefinition(params) {
             // function lookup resolves; the short name must not be read as a same-named class receiver.
             return null;
         }
-        const importType = isJsTsLanguage(sup.id) ? receiverConstructorExpression(obj, source, sup) : null;
+        const importType = isJsTsLanguage(sup.id) && receiverProof?.kind === "named-type" ? receiverProof.typeNode : null;
         const importSpecifier = importType?.type === "type_query" ? importTypeQuerySpecifier(importType) : null;
         if (importSpecifier) {
             const memberDef = resolveImportTypeMember(index, mod.file, importSpecifier, member);
@@ -722,7 +878,7 @@ export async function resolveMemberAccessDefinition(params) {
                 })
                 : null;
         }
-        const receiver = await resolveReceiverDefinition(index, obj, source, sup, resolveExpression, mod);
+        const receiver = await resolveReceiverDefinition(index, obj, source, sup, resolveExpression, mod, receiverProof, resolvedReceiver);
         if (receiver) {
             const objDef = receiver.def;
             const targetContext = await ensureParsedContext(objDef.file, undefined, index.languageExtensions);
@@ -749,22 +905,48 @@ export async function resolveMemberAccessDefinition(params) {
                         : (local) => matchesReceiverMemberScope(local, receiver.memberScope, targetContext, container);
                     const knownArgumentCount = getCallArgumentCount({ languageId: sup.id, source, call: memberNode.parent ?? memberNode }) ?? undefined;
                     let memberDef;
-                    if ((targetContext.sup.id === "ts" || targetContext.sup.id === "tsx") &&
+                    const hierarchyLanguage = isJsTsLanguage(targetContext.sup.id) ||
+                        targetContext.sup.id === "ruby" ||
+                        targetContext.sup.id === "cpp" ||
+                        targetContext.sup.id === "csharp" ||
+                        targetContext.sup.id === "java" ||
+                        targetContext.sup.id === "kotlin" ||
+                        targetContext.sup.id === "php" ||
+                        targetContext.sup.id === "swift";
+                    if (hierarchyLanguage && declaresMembers(objDef) && !receiver.runtimeTypeOnly) {
+                        const report = { named: false, ambiguous: false };
+                        memberDef = await resolveKeywordReceiverMember(index, mod, node, member, receiver.memberScope, false, knownArgumentCount, objDef, report);
+                        if (!memberDef && report.named)
+                            return { status: "not_found", reason: "No unique receiver member" };
+                    }
+                    if (!memberDef &&
+                        (targetContext.sup.id === "ts" || targetContext.sup.id === "tsx") &&
                         (container.type === "internal_module" || container.type === "module")) {
                         memberDef = await findReceiverMemberDefinition(index, targetModule.locals, member, objDef, container, targetContext, normalizeIdentifier, receiver.memberScope, knownArgumentCount);
                     }
-                    else if (receiver.runtimeTypeOnly || targetContext.sup.id === "java") {
+                    else if (!memberDef && (receiver.runtimeTypeOnly || targetContext.sup.id === "java")) {
                         const candidates = findDirectLocalsWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier, memberPredicate);
-                        memberDef = await selectReceiverMemberCandidates(index, candidates, knownArgumentCount);
+                        const selected = selectMember([objDef], indexedMemberModel(index, candidates, targetContext.sup.id), {
+                            name: member,
+                            argumentCount: knownArgumentCount ?? null,
+                            scope: "any",
+                            useFile: mod.file,
+                            phpCaseInsensitive: targetContext.sup.id === "php",
+                            keepUniqueArityMismatch: true,
+                        });
+                        memberDef = selected.status === "unique" ? selected.member : undefined;
                     }
-                    else {
+                    else if (!memberDef) {
                         memberDef = await findReceiverMemberDefinition(index, targetModule.locals, member, objDef, container, targetContext, normalizeIdentifier, receiver.memberScope, knownArgumentCount);
                     }
+                    const memberContext = memberDef && fileIdentityKey(memberDef.file) !== fileIdentityKey(objDef.file)
+                        ? await ensureParsedContext(memberDef.file, undefined, index.languageExtensions)
+                        : targetContext;
                     if (memberDef &&
                         (sup.id === "cpp" ||
                             isGoExportedMemberName(sup.id, member) ||
                             getCompilationUnitPeers(index, mod.file).files.has(memberDef.file)) &&
-                        !crossFilePeerMemberHidden(mod.file, memberDef, targetContext)) {
+                        !crossFilePeerMemberHidden(mod.file, memberDef, memberContext)) {
                         return okGoToResult(index, memberDef, {
                             via: { exportedName: member },
                             resolution: "member-access",
@@ -1135,7 +1317,7 @@ export async function provenClassifiedReceiverOmitsMember(index, fileId, parsed,
         const scope = getOrBuildScopeIndex(index, fileId, parsed.source, parsed.sup, mod, parsed.tree);
         return !!findClosestScopeBinding(scope, sliceText(callee, parsed.source), callee, parsed.sup);
     });
-    if (!receiver)
+    if (receiver.kind === "unknown" || receiver.kind === "module-import")
         return false;
     if (receiver.kind === "named-type") {
         const def = await resolveReceiverTypeName(index, mod, parsed.sup, receiver.typeName);
@@ -1219,6 +1401,11 @@ async function baseRefsFromContainer(index, mod, container, source, sup, supercl
         let def = base.kind === "simple"
             ? resolveNamedMemberContainer(index, mod, base.name, normalize)
             : await resolveQualifiedMemberContainer(index, mod, base.base, base.path, normalize, sup);
+        if (!def && base.kind === "simple" && sup.id !== "php") {
+            const named = resolveNamedDefinition(index, mod, mod.file, sup, base.name, undefined, container.startIndex);
+            if (named?.status === "ok")
+                def = asMemberContainer(index, named.definition);
+        }
         if (!def && sup.id === "php" && base.kind === "simple") {
             def = resolvePhpNamespaceSymbol(index, source, tree, container, base.name, mod.imports, "class") ?? undefined;
         }
@@ -1249,152 +1436,135 @@ async function baseRefsFromContainer(index, mod, container, source, sup, supercl
     }
     return refs;
 }
-const HIERARCHY_OVERLOAD_LANGUAGES = new Set(["java", "kotlin", "csharp"]);
 async function resolveKeywordReceiverMember(index, mod, node, member, memberScope, startAtAncestor, knownArgumentCount, explicitClassDef, report) {
     const current = explicitClassDef
         ? await keywordClassRefFromDef(index, explicitClassDef)
         : await keywordClassRefFromNode(index, mod, node);
     if (!current)
         return undefined;
-    let level = startAtAncestor
-        ? await baseRefsFromContainer(index, current.module, current.container, current.context.source, current.context.sup, true, current.context.tree)
-        : [current];
-    if (level.length === 0)
-        return undefined;
-    // Java, Kotlin, and C# overload across the hierarchy: when no member at one level accepts the
-    // call, a base level may. C++ and Swift hide a base name behind any same-named member.
-    // An unknown count (a Kotlin spread) keeps every non-overridden overload as a candidate.
-    const spansHierarchy = HIERARCHY_OVERLOAD_LANGUAGES.has(current.context.sup.id);
-    // Java, Kotlin, and C# base members that are private are not accessible from a subclass.
-    const filtersPrivateBases = HIERARCHY_OVERLOAD_LANGUAGES.has(current.context.sup.id);
-    let lenient;
-    // Accepted overloads across levels. A deeper one is overridden only by an accepted method with
-    // the same parameter types in a class proven to derive from its owner on the walked path;
-    // unrelated owners with one signature (two interfaces) stay separate and ambiguous.
-    const accepted = [];
+    const spansHierarchy = inheritsMemberOverloads(current.context.sup.id);
+    const ownerKey = (ref) => keywordContainerKey(ref.file, ref.container);
+    const preloadHiddenNames = isJsTsLanguage(current.context.sup.id) && knownArgumentCount !== undefined;
     const memberKey = (def) => `${fileIdentityKey(def.file)}:${def.range.start.index}`;
-    const ownerOf = new Map();
-    const subclassesOf = new Map();
-    const recordOwner = (from, owner) => {
-        for (let at = from; at < matches.length; at += 1)
-            ownerOf.set(memberKey(matches[at]), owner);
-    };
-    let matches = [];
-    const visited = new Set([
-        keywordContainerKey(current.file, current.container),
-        ...level.map((candidate) => keywordContainerKey(candidate.file, candidate.container)),
-    ]);
+    const parentsByKey = new Map();
+    const membersByKey = new Map();
+    const scopeByMember = new Map();
+    const visible = new Set();
+    let level = [current];
+    const seen = new Set([ownerKey(current)]);
     for (let depth = 0; depth < RECEIVER_HIERARCHY_DEPTH && level.length; depth += 1) {
-        matches = [];
-        for (const candidate of level) {
-            const ownerKey = keywordContainerKey(candidate.file, candidate.container);
-            const before = matches.length;
-            const memberPredicate = memberScope === "any"
-                ? undefined
-                : (local) => matchesReceiverMemberScope(local, memberScope, candidate.context, candidate.container);
-            appendDirectKeywordMembers(candidate.module.locals, member, candidate.container, candidate.context, candidate.context.sup.normalizeIdentifier, memberPredicate, matches);
-            recordOwner(before, ownerKey);
-        }
-        for (const candidate of level) {
-            if (candidate.context.sup.id !== "csharp" && candidate.context.sup.id !== "swift")
-                continue;
-            const ownerKey = keywordContainerKey(candidate.file, candidate.container);
-            const before = matches.length;
-            const sharedContainers = await resolveSharedOwnerContainers({
-                index,
-                ownerFile: candidate.file,
-                ownerContainer: candidate.container,
-                ownerSource: candidate.context.source,
-                languageId: candidate.context.sup.id,
-            });
-            for (const shared of sharedContainers) {
-                const crossFileSwift = candidate.context.sup.id === "swift" && fileIdentityKey(candidate.file) !== fileIdentityKey(shared.file);
-                const sharedPredicate = (local) => {
-                    if (memberScope !== "any" &&
-                        !matchesReceiverMemberScope(local, memberScope, shared.context, shared.container)) {
-                        return false;
+        const next = [];
+        let nameFound = false;
+        for (const ref of level) {
+            const key = ownerKey(ref);
+            const matches = [];
+            if (!startAtAncestor || depth) {
+                appendDirectKeywordMembers(ref.module.locals, member, ref.container, ref.context, ref.context.sup.normalizeIdentifier, undefined, matches);
+                if (isJsTsLanguage(ref.context.sup.id) && ref.container.type === "interface_declaration") {
+                    const owner = memberContainerDef(ref.module, ref.container);
+                    if (owner) {
+                        for (const hit of typescriptMergedInterfaceMemberCandidates(ref.module.locals, member, owner, ref.container, ref.context, ref.context.sup.normalizeIdentifier, undefined)) {
+                            if (!matches.includes(hit))
+                                matches.push(hit);
+                        }
                     }
-                    if (!crossFileSwift)
-                        return true;
-                    const nameNode = nameNodeForDef(shared.context, local);
-                    return !!nameNode && !isSwiftCrossFileHiddenSharedOwnerMember("swift", candidate.file, shared.file, nameNode);
-                };
-                appendDirectKeywordMembers(shared.module.locals, member, shared.container, shared.context, shared.context.sup.normalizeIdentifier, sharedPredicate, matches);
-            }
-            // Partial parts of one type share its identity.
-            recordOwner(before, ownerKey);
-        }
-        let uniqueMatches = uniqueReceiverMemberCandidates(matches);
-        // A private member of a base class is not accessible: it neither answers nor stops the walk.
-        // The first level of a `this` lookup is the class itself, including C# partial parts.
-        if (filtersPrivateBases && (startAtAncestor || depth > 0) && uniqueMatches.length) {
-            const inherited = [];
-            for (const candidate of uniqueMatches) {
-                if (!(await isUninheritedPrivateMember(index, mod, node, candidate)))
-                    inherited.push(candidate);
-            }
-            uniqueMatches = inherited;
-        }
-        if (uniqueMatches.length && report)
-            report.named = true;
-        if (uniqueMatches.length) {
-            const allowUniqueArityMismatch = !startAtAncestor && depth === 0;
-            if (!spansHierarchy) {
-                return await selectReceiverMemberCandidates(index, uniqueMatches, knownArgumentCount, allowUniqueArityMismatch);
-            }
-            for (const candidate of uniqueMatches) {
-                if (knownArgumentCount !== undefined &&
-                    (await receiverMemberAcceptsArgumentCount(index, candidate, knownArgumentCount)) === false) {
-                    continue;
                 }
-                const owner = ownerOf.get(memberKey(candidate)) ?? "";
-                const subclasses = subclassesOf.get(owner);
-                let overridden = false;
-                for (const entry of accepted) {
-                    if (subclasses?.has(entry.owner) && (await sameParameterTypes(index, entry.def, candidate))) {
-                        overridden = true;
-                        break;
+                if (ref.context.sup.id === "csharp" || ref.context.sup.id === "swift") {
+                    const shared = await resolveSharedOwnerContainers({
+                        index,
+                        ownerFile: ref.file,
+                        ownerContainer: ref.container,
+                        ownerSource: ref.context.source,
+                        languageId: ref.context.sup.id,
+                    });
+                    for (const peer of shared) {
+                        const peerMatches = [];
+                        appendDirectKeywordMembers(peer.module.locals, member, peer.container, peer.context, peer.context.sup.normalizeIdentifier, undefined, peerMatches);
+                        for (const hit of peerMatches) {
+                            if (peer.context.sup.id === "swift" && crossFilePeerMemberHidden(mod.file, hit, peer.context))
+                                continue;
+                            matches.push(hit);
+                            scopeByMember.set(hit, hasStaticModifier(hit, peer.context, peer.container) ? "static" : "instance");
+                        }
                     }
                 }
-                if (!overridden)
-                    accepted.push({ def: candidate, owner });
             }
-            // Navigation still names the only incompatible candidate when no ancestor accepts the call.
-            if (allowUniqueArityMismatch && !lenient) {
-                lenient = await selectReceiverMemberCandidates(index, uniqueMatches, knownArgumentCount, true);
+            membersByKey.set(key, matches);
+            for (const hit of matches) {
+                if (!scopeByMember.has(hit)) {
+                    scopeByMember.set(hit, hasStaticModifier(hit, ref.context, ref.container) ? "static" : "instance");
+                }
+                if (spansHierarchy && (startAtAncestor || depth) && (await isUninheritedPrivateMember(index, mod, node, hit))) {
+                    continue;
+                }
+                visible.add(hit);
+                nameFound = true;
             }
-        }
-        const next = [];
-        for (const candidate of level) {
-            const childKey = keywordContainerKey(candidate.file, candidate.container);
-            const childSubclasses = subclassesOf.get(childKey);
-            for (const parent of await baseRefsFromContainer(index, candidate.module, candidate.container, candidate.context.source, candidate.context.sup, startAtAncestor, candidate.context.tree)) {
-                const key = keywordContainerKey(parent.file, parent.container);
-                // Every class on a path to this ancestor derives from it, including through a diamond.
-                const subclasses = subclassesOf.get(key) ?? new Set();
-                subclasses.add(childKey);
-                for (const subclass of childSubclasses ?? [])
-                    subclasses.add(subclass);
-                subclassesOf.set(key, subclasses);
-                if (visited.has(key))
+            if (nameFound && !spansHierarchy && !preloadHiddenNames)
+                continue;
+            const bases = await baseRefsFromContainer(index, ref.module, ref.container, ref.context.source, ref.context.sup, startAtAncestor, ref.context.tree);
+            parentsByKey.set(key, bases);
+            for (const base of bases) {
+                const baseKey = ownerKey(base);
+                if (seen.has(baseKey))
                     continue;
-                visited.add(key);
-                next.push(parent);
+                seen.add(baseKey);
+                next.push(base);
             }
         }
+        if (nameFound && !spansHierarchy && !preloadHiddenNames)
+            break;
         level = next;
     }
-    if (!spansHierarchy)
-        return undefined;
-    // Without type ranking, two surviving overloads are ambiguous, including a fixed-arity and a
-    // variable-arity one: `hit(String)` and `hit(int...)` both take one argument, and only argument
-    // types decide.
-    if (accepted.length > 1) {
-        if (report)
-            report.ambiguous = true;
-        return undefined;
+    const sameSignatures = new Map();
+    if (spansHierarchy) {
+        const all = [...membersByKey.values()].flat().filter((candidate) => visible.has(candidate));
+        for (let left = 0; left < all.length; left += 1) {
+            for (let right = left + 1; right < all.length; right += 1) {
+                const a = all[left];
+                const b = all[right];
+                if (!(await sameParameterTypes(index, a, b)))
+                    continue;
+                const aKey = memberKey(a);
+                const bKey = memberKey(b);
+                const identical = sameSignatures.get(aKey) ?? new Set();
+                identical.add(bKey);
+                sameSignatures.set(aKey, identical);
+            }
+        }
+    }
+    const model = {
+        ownerKey,
+        members: (ref) => membersByKey.get(ownerKey(ref)) ?? [],
+        supertypes: (ref) => parentsByKey.get(ownerKey(ref)) ?? [],
+        name: (def) => def.localName,
+        key: (def) => def.callable?.key ?? memberKey(def),
+        callable: (def) => {
+            const facts = def.callable;
+            if (!facts || memberLookupBinding(current.context.sup.id) !== "unbound")
+                return facts;
+            return facts.unboundArity ? { ...facts, arity: facts.unboundArity } : facts;
+        },
+        scope: (def) => scopeByMember.get(def) ?? "any",
+        visible: (def) => visible.has(def),
+        sameSignature: (a, b) => sameSignatures.get(memberKey(a))?.has(memberKey(b)) ?? false,
+    };
+    const selected = selectMember([current], model, {
+        name: member,
+        argumentCount: knownArgumentCount ?? null,
+        scope: memberScope,
+        useFile: mod.file,
+        startAtAncestor,
+        keepUniqueArityMismatch: !startAtAncestor,
+        inheritOverloads: spansHierarchy,
+        phpCaseInsensitive: current.context.sup.id === "php",
+        separateMemberScopes: hasSeparateMemberScopes(current.context.sup.id),
+    });
+    if (report) {
+        report.named = selected.named;
+        report.ambiguous = selected.status === "ambiguous";
     }
-    return accepted[0]?.def ?? lenient;
+    return selected.status === "unique" ? selected.member : undefined;
 }
 /** The parameter list of a Java, Kotlin, or C# method declaration. */
 async function memberParameterList(index, def) {
@@ -1500,7 +1670,7 @@ const BUILTIN_PARAMETER_TYPES = {
  * other. Equal spelling is proof only within one file or for built-in types; elsewhere each
  * spelling must resolve to the same declaration from its own file.
  */
-async function sameParameterTypes(index, left, right) {
+export async function sameParameterTypes(index, left, right) {
     // A type parameter (`T`) names a different type in each declaration after substitution, so
     // equal spelling proves nothing.
     const [leftGenerics, rightGenerics] = await Promise.all([
@@ -1601,7 +1771,7 @@ export async function resolveImplicitSelfMember(index, mod, node, name, source,
     // Any inherited instance method of that name hides the import, even when none applies.
     return instance || instanceReport.named ? null : undefined;
 }
-/** Whether a Java or Kotlin member is `private` and declared outside the class enclosing the use. */
+/** Whether an inherited JVM member is inaccessible through this receiver. */
 async function isUninheritedPrivateMember(index, mod, use, member) {
     const container = findEnclosingClassContainer(use);
     const start = member.range.start.index ?? -1;
@@ -1611,6 +1781,13 @@ async function isUninheritedPrivateMember(index, mod, use, member) {
         start < container.endIndex;
     if (ownMember)
         return false;
+    if (member.javaPackagePrivate && !member.javaProtectedMember) {
+        const memberPackage = getPackageDeclarationName(index, member.file, "java");
+        const useLanguage = supportForFileWithoutHeaderSample(mod.file, index.languageExtensions)?.id;
+        const usePackage = getPackageDeclarationName(index, mod.file, useLanguage === "kotlin" ? "kotlin" : "java");
+        if (memberPackage !== usePackage)
+            return true;
+    }
     const parsed = await ensureParsedContext(member.file, index.parsed?.get(fileIdentityKey(member.file)), index.languageExtensions).catch(() => null);
     const nameNode = parsed?.tree.rootNode.descendantForIndex(start, member.range.end.index ?? start);
     return !!parsed && !!nameNode && isPrivateDeclaration(parsed.sup.id, nameNode);
@@ -1690,7 +1867,7 @@ export async function resolveCppOutOfLineImplicitMember(index, mod, node, name,
     // the name but is not the call's target, so no consumer may fall back to a same-named free function.
     const rejected = requireAcceptedArity &&
         argumentCount !== undefined &&
-        !(await receiverMemberAcceptsArgumentCount(index, member, argumentCount));
+        !receiverMemberAcceptsArgumentCount(index, member, argumentCount);
     return rejected ? null : member;
 }
 export { supportsReceiverCallEdges, supportsReceiverMemberNavigation } from "../util/member-access-tables.js";
@@ -1756,8 +1933,90 @@ export async function resolveRubySuperDefinition(index, mod, node, source, sup)
         return undefined;
     return resolveKeywordReceiverMember(index, mod, node, member, "any", true);
 }
-async function resolveReceiverDefinition(index, obj, source, sup, resolveExpression, mod) {
-    const constructor = receiverConstructorExpression(obj, source, sup);
+/** Follow a Swift typealias only when its right-hand side is a single indexed nominal type. */
+async function resolveSwiftAliasContainer(index, alias) {
+    let current = alias;
+    const seen = new Set();
+    while (current.kind === SymbolKind.TypeAlias) {
+        const key = `${fileIdentityKey(current.file)}:${current.range.start.index}`;
+        if (seen.has(key))
+            return undefined;
+        seen.add(key);
+        const mod = index.byFile.get(fileIdentityKey(current.file));
+        if (!mod)
+            return undefined;
+        const context = await ensureParsedContext(current.file, index.parsed?.get(fileIdentityKey(current.file)), index.languageExtensions);
+        if (context.sup.id !== "swift")
+            return undefined;
+        const declaration = nameNodeForDef(context, current)?.parent;
+        if (declaration?.type !== "typealias_declaration") {
+            return declaration?.type === "class_declaration" && declaresMembers(current) ? current : undefined;
+        }
+        const target = declaration.namedChildren.find((child) => child.type === "user_type");
+        const named = target ? unwrapNamedType(target, context.sup) : null;
+        if (!named || target?.namedChildren.length !== 1)
+            return undefined;
+        const targetName = sliceText(named, context.source);
+        const namedTarget = resolveNamedDefinition(index, mod, mod.file, context.sup, targetName, undefined, declaration.startIndex);
+        const next = resolveNamedMemberContainer(index, mod, targetName, context.sup.normalizeIdentifier) ??
+            (namedTarget?.status === "ok" ? asMemberContainer(index, namedTarget.definition) : undefined);
+        if (!next)
+            return undefined;
+        current = next;
+    }
+    return declaresMembers(current) ? current : undefined;
+}
+async function resolveReceiverDefinition(index, obj, source, sup, resolveExpression, mod, proof, resolvedDirect) {
+    const direct = resolvedDirect === undefined ? await resolveExpression(obj) : resolvedDirect;
+    const receiver = proof ??
+        classifyReceiver(sup, obj, source, null, 0, obj.parent ?? obj, noLexicalBinding, () => {
+            if (direct?.kind === "namespace")
+                return "module-import";
+            if (direct?.kind === "resolved" && declaresMembers(direct.def))
+                return "static-type";
+            return null;
+        });
+    if (receiver.kind === "module-import")
+        return null;
+    if (supportsDeclaredFieldChains(sup.id) && isMemberAccessNode(sup, obj)) {
+        const directType = direct?.kind === "resolved" ? asMemberContainer(index, direct.def) : undefined;
+        if (!directType) {
+            const { object, property } = getMemberAccessParts(sup, obj);
+            if (!object || !property)
+                return null;
+            const owner = await resolveReceiverDefinition(index, object, source, sup, resolveExpression, mod);
+            if (!owner || owner.runtimeTypeOnly)
+                return null;
+            const field = await resolveKeywordReceiverMember(index, mod, property, sliceText(property, source), owner.memberScope, false, undefined, owner.def);
+            if (!field || field.kind !== SymbolKind.Variable || !field.isMember)
+                return null;
+            const fieldContext = await ensureParsedContext(field.file, undefined, index.languageExtensions);
+            const name = nameNodeForDef(fieldContext, field);
+            let declaration = name?.parent ?? null;
+            if (declaration?.type === "variable_declarator")
+                declaration = declaration.parent;
+            if (!declaration)
+                return null;
+            const annotatedType = declaredTypeNameNode(declaration, fieldContext.sup);
+            if (!annotatedType)
+                return null;
+            const fieldModule = index.byFile.get(fileIdentityKey(field.file));
+            if (!fieldModule)
+                return null;
+            const typeText = qualifiedDeclaredTypeText(annotatedType, fieldContext.source);
+            // A type parameter in scope (`class Host<Repo>`) is not a nominal type; bounds are not solved.
+            if (typeParameterNamesInScope(declaration, fieldContext.source).has(typeText.split(/[.:]/)[0]))
+                return null;
+            const type = await resolveReceiverTypeName(index, fieldModule, fieldContext.sup, typeText);
+            return type ? { def: type, memberScope: "instance" } : null;
+        }
+    }
+    if (receiver.kind === "own-type") {
+        const container = nearestMemberContainer(obj);
+        const owner = container ? definitionForContainer(mod, container) : undefined;
+        return owner ? { def: owner, memberScope: receiver.memberScope } : null;
+    }
+    const constructor = receiver.kind === "named-type" && receiver.proof !== "static-type" ? receiver.typeNode : null;
     if (constructor) {
         if (sup.id === "cpp") {
             const qualifiedType = cppQualifiedNameSegments(constructor, source);
@@ -1779,6 +2038,12 @@ async function resolveReceiverDefinition(index, obj, source, sup, resolveExpress
                 memberScope: hasStaticMemberDistinction(sup.id) ? "instance" : "any",
             };
         }
+        if (sup.id === "go") {
+            const named = resolveNamedDefinition(index, mod, mod.file, sup, typeName, undefined, constructor.startIndex);
+            const peer = named?.status === "ok" ? asMemberContainer(index, named.definition) : undefined;
+            if (peer)
+                return { def: peer, memberScope: "any" };
+        }
         if (sup.id === "php") {
             const normalizeTypeName = (name) => foldPhpIdentifierCase(sup.normalizeIdentifier(name));
             const namedContainer = resolveNamedMemberContainer(index, mod, typeName, normalizeTypeName);
@@ -1816,7 +2081,12 @@ async function resolveReceiverDefinition(index, obj, source, sup, resolveExpress
             };
         }
     }
-    const direct = await resolveExpression(obj);
+    if (sup.id === "swift" && direct?.kind === "resolved" && direct.def.kind === SymbolKind.TypeAlias) {
+        const aliased = await resolveSwiftAliasContainer(index, direct.def);
+        if (aliased)
+            return { def: aliased, memberScope: "static" };
+        return null;
+    }
     const directContainer = direct?.kind === "resolved" ? asMemberContainer(index, direct.def) : undefined;
     if (directContainer) {
         if (isJsTsLanguage(sup.id) && directContainer.kind === SymbolKind.TypeAlias) {
@@ -1882,16 +2152,26 @@ async function resolveMemberDefinitionForBase(index, baseDef, member, knownArgum
                 candidates.push(hit);
         }
     }
-    if (candidates.length > 1 && languageId !== "ruby") {
-        const reachable = [];
-        for (const candidate of candidates) {
-            if (!declaresMembers(baseDef) || (await reachableThroughTypeName(index, candidate)))
-                reachable.push(candidate);
+    if (candidates.length) {
+        let reachable = candidates;
+        if (languageId !== "ruby" && candidates.length > 1) {
+            reachable = [];
+            for (const candidate of candidates) {
+                if (!declaresMembers(baseDef) || (await reachableThroughTypeName(index, candidate)))
+                    reachable.push(candidate);
+            }
         }
-        return await selectReceiverMemberCandidates(index, reachable, knownArgumentCount);
+        const selected = selectMember([baseDef], indexedMemberModel(index, reachable, languageId), {
+            name: member,
+            argumentCount: knownArgumentCount ?? null,
+            scope: "any",
+            useFile: baseDef.file,
+            phpCaseInsensitive: languageId === "php",
+            firstDeclarationWins: languageId === "ruby",
+            keepUniqueArityMismatch: true,
+        });
+        return selected.status === "unique" ? selected.member : undefined;
     }
-    if (candidates[0])
-        return candidates[0];
     if (languageId === "java")
         return undefined;
     return await findReceiverMemberDefinition(index, targetModule.locals, member, baseDef, container, targetContext, normalizeIdentifier);
@@ -1956,7 +2236,14 @@ async function findReceiverMemberDefinition(index, locals, member, receiverDef,
     if ((targetContext.sup.id === "ts" || targetContext.sup.id === "tsx") &&
         (container.type === "internal_module" || container.type === "module")) {
         const candidates = findTypeScriptNamespaceMemberCandidates(locals, member, receiverDef, targetContext);
-        return await selectReceiverMemberCandidates(index, candidates, knownArgumentCount);
+        const selected = selectMember([receiverDef], indexedMemberModel(index, candidates, targetContext.sup.id), {
+            name: member,
+            argumentCount: knownArgumentCount ?? null,
+            scope: "any",
+            useFile: receiverDef.file,
+            keepUniqueArityMismatch: true,
+        });
+        return selected.status === "unique" ? selected.member : undefined;
     }
     const allReceiverMatches = typescriptMergedInterfaceMemberCandidates(locals, member, receiverDef, container, targetContext, normalizeIdentifier, memberPredicate);
     if (targetContext.sup.id === "csharp" || targetContext.sup.id === "swift") {
@@ -1975,22 +2262,33 @@ async function findReceiverMemberDefinition(index, locals, member, receiverDef,
         }
     }
     if (allReceiverMatches.length) {
-        return await selectReceiverMemberCandidates(index, allReceiverMatches, knownArgumentCount);
+        const selected = selectMember([receiverDef], indexedMemberModel(index, allReceiverMatches, targetContext.sup.id), {
+            name: member,
+            argumentCount: knownArgumentCount ?? null,
+            scope: "any",
+            useFile: receiverDef.file,
+            phpCaseInsensitive: targetContext.sup.id === "php",
+            keepUniqueArityMismatch: true,
+        });
+        return selected.status === "unique" ? selected.member : undefined;
     }
     if (targetContext.sup.id === "rust") {
-        const matches = [];
-        for (const implNode of findRustImplsForType(targetContext.tree.rootNode, receiverDef.localName, targetContext.source, targetContext.sup)) {
-            appendDirectKeywordMembers(locals, member, implNode, targetContext, normalizeIdentifier, undefined, matches);
-        }
-        return await selectReceiverMemberCandidates(index, matches, knownArgumentCount);
+        return selectRustReceiverMember(index, receiverDef, member, targetContext, locals, knownArgumentCount);
     }
     if (targetContext.sup.id === "go") {
-        return findGoReceiverMember(locals, member, receiverDef.localName, targetContext, normalizeIdentifier);
+        return selectGoReceiverMember(index, receiverDef, member, targetContext.sup.normalizeIdentifier, knownArgumentCount);
     }
     if (targetContext.sup.id === "kotlin") {
         const extensionMatches = kotlinExtensionFunctionsNamedOnType(locals, member, receiverDef.localName, targetContext, normalizeIdentifier);
         if (extensionMatches.length) {
-            return await selectReceiverMemberCandidates(index, extensionMatches, knownArgumentCount);
+            const selected = selectMember([receiverDef], indexedMemberModel(index, extensionMatches, targetContext.sup.id), {
+                name: member,
+                argumentCount: knownArgumentCount ?? null,
+                scope: "any",
+                useFile: receiverDef.file,
+                keepUniqueArityMismatch: true,
+            });
+            return selected.status === "unique" ? selected.member : undefined;
         }
     }
     return undefined;
@@ -2010,108 +2308,55 @@ function findLocalsWithinNode(locals, member, node, normalizeIdentifier = (name)
             (!predicate || predicate(local)));
     });
 }
-function findLocalWithinNode(locals, member, node, normalizeIdentifier = (name) => name, predicate) {
-    return findLocalsWithinNode(locals, member, node, normalizeIdentifier, predicate)[0];
-}
 function matchesReceiverMemberScope(local, memberScope, targetContext, container) {
     if (memberScope === "any")
         return true;
     return hasStaticModifier(local, targetContext, container) === (memberScope === "static");
 }
-async function getCallableArityForDef(index, def) {
-    const context = await ensureParsedContext(def.file, undefined, index.languageExtensions);
-    const start = def.range.start;
-    const position = { row: start.line - 1, column: start.column - 1 };
-    const nameNode = context.tree.rootNode.descendantForPosition(position, position);
-    const container = nearestMemberContainer(nameNode);
-    let current = nameNode;
-    while (current && current !== container) {
-        if (CALLABLE_DECLARATION_NODE_TYPES[current.type]) {
-            const range = getCallableArity({
-                languageId: context.sup.id,
-                source: context.source,
-                declaration: current,
-                binding: memberLookupBinding(context.sup.id),
-            });
-            if (range)
-                return range;
-        }
-        current = current.parent;
-    }
-    return undefined;
-}
 /**
  * Whether a member found for a receiverless call can accept that call's argument count. Unknown
  * counts and unknown arities accept.
  */
-export async function memberAcceptsCallAt(index, member, callee, source, languageId) {
+export function memberAcceptsCallAt(index, member, callee, source, languageId) {
     const argumentCount = getCallArgumentCount({ languageId, source, call: callee.parent ?? callee });
     if (argumentCount === null)
         return true;
-    return (await receiverMemberAcceptsArgumentCount(index, member, argumentCount)) !== false;
+    return receiverMemberAcceptsArgumentCount(index, member, argumentCount) !== false;
 }
-async function receiverMemberAcceptsArgumentCount(index, def, argumentCount) {
-    const context = await ensureParsedContext(def.file, undefined, index.languageExtensions);
-    const start = def.range.start;
-    const position = {
-        row: start.line - 1,
-        column: start.column - 1,
-    };
-    const nameNode = context.tree.rootNode.descendantForPosition(position, position);
-    if (context.sup.id === "cpp") {
-        const shape = cppCallableShapeForNode(nameNode);
-        return shape
-            ? argumentCount >= shape.minArity && (shape.maxArity === null || argumentCount <= shape.maxArity)
-            : undefined;
-    }
-    const range = await getCallableArityForDef(index, def);
+function receiverMemberAcceptsArgumentCount(index, def, argumentCount) {
+    const languageId = supportForFileWithoutHeaderSample(def.file, index.languageExtensions)?.id;
+    if (!languageId)
+        return undefined;
+    const callable = def.callable ??
+        index.byFile
+            .get(fileIdentityKey(def.file))
+            ?.locals.find((local) => local.range.start.index === def.range.start.index && local.localName === def.localName)
+            ?.callable;
+    const range = memberLookupBinding(languageId) === "unbound" ? (callable?.unboundArity ?? callable?.arity) : callable?.arity;
     if (!range)
         return undefined;
     return argumentCount >= range.minArgs && (range.maxArgs === null || argumentCount <= range.maxArgs);
 }
-function uniqueReceiverMemberCandidates(candidates) {
-    const seen = new Set();
-    const unique = [];
-    for (const candidate of candidates) {
-        const key = keywordClassKey(candidate);
-        if (seen.has(key))
-            continue;
-        seen.add(key);
-        unique.push(candidate);
-    }
-    return unique;
-}
-async function selectReceiverMemberCandidates(index, candidates, knownArgumentCount, allowUniqueArityMismatch = true) {
-    if (candidates.length > 1) {
-        const file = candidates[0]?.file;
-        if (file && candidates.every((candidate) => candidate.file === file)) {
-            const context = await ensureParsedContext(file, undefined, index.languageExtensions);
-            if (isJsTsLanguage(context.sup.id)) {
-                // Signature-only overloads still need arity selection before generic member deduplication.
-                return typescriptSelectOverloadCandidate({
-                    group: candidates,
-                    tree: context.tree,
-                    definitionOf: (candidate) => candidate,
-                    declarationOf: (candidate) => nameNodeForDef(context, candidate)?.parent,
-                    source: context.source,
-                    languageId: context.sup.id,
-                    argumentCount: knownArgumentCount ?? null,
-                });
-            }
-        }
-    }
-    const unique = uniqueReceiverMemberCandidates(candidates);
-    if (unique.length === 1 && (allowUniqueArityMismatch || knownArgumentCount === undefined))
-        return unique[0];
-    if (knownArgumentCount === undefined)
-        return undefined;
-    const matches = [];
-    for (const candidate of unique) {
-        if ((await receiverMemberAcceptsArgumentCount(index, candidate, knownArgumentCount)) !== false) {
-            matches.push(candidate);
-        }
-    }
-    return matches.length === 1 ? matches[0] : undefined;
+/** Indexed owner membership and callable facts for direct and merged-owner lookup. */
+function indexedMemberModel(index, members, languageId) {
+    return {
+        ownerKey: keywordClassKey,
+        members: () => members,
+        supertypes: () => [],
+        name: (def) => def.localName,
+        key: (def) => def.callable?.key ?? keywordClassKey(def),
+        callable: (def) => {
+            const facts = def.callable ??
+                index.byFile
+                    .get(fileIdentityKey(def.file))
+                    ?.locals.find((local) => local.range.start.index === def.range.start.index && local.localName === def.localName)?.callable;
+            if (!facts || memberLookupBinding(languageId) !== "unbound" || !facts.unboundArity)
+                return facts;
+            return { ...facts, arity: facts.unboundArity };
+        },
+        scope: () => "any",
+        visible: () => true,
+    };
 }
 function hasStaticModifier(local, targetContext, container) {
     const position = {
@@ -2208,9 +2453,6 @@ function findDirectLocalsWithinNode(locals, member, container, targetContext, no
     }
     return matches;
 }
-function findDirectLocalWithinNode(locals, member, container, targetContext, normalizeIdentifier, predicate) {
-    return findDirectLocalsWithinNode(locals, member, container, targetContext, normalizeIdentifier, predicate)[0];
-}
 function appendDirectKeywordMembers(locals, member, container, targetContext, normalizeIdentifier, predicate, matches) {
     const containerStart = container.startIndex;
     const containerEnd = container.endIndex;
@@ -2336,6 +2578,67 @@ function findRustImplsForType(root, typeName, source, sup) {
     visit(root);
     return found;
 }
+async function selectRustReceiverMember(index, receiverDef, member, context, locals, knownArgumentCount) {
+    const inherent = [];
+    const implemented = [];
+    const traitMembers = new Map();
+    const traitOwners = [];
+    const module = index.byFile.get(fileIdentityKey(receiverDef.file));
+    if (!module)
+        return undefined;
+    for (const impl of findRustImplsForType(context.tree.rootNode, receiverDef.localName, context.source, context.sup)) {
+        const self = rustImplSelfTypeNode(impl, context.sup);
+        const trait = impl.namedChildren.find((child) => child.type === "type_identifier" && child.id !== self?.id);
+        const target = trait ? implemented : inherent;
+        appendDirectKeywordMembers(locals, member, impl, context, context.sup.normalizeIdentifier, undefined, target);
+        if (!trait)
+            continue;
+        const traitName = sliceText(trait, context.source);
+        const traitDef = resolveNamedMemberContainer(index, module, traitName, context.sup.normalizeIdentifier);
+        if (!traitDef)
+            continue;
+        const ref = await keywordClassRefFromDef(index, traitDef);
+        if (!ref || ref.container.type !== "trait_item")
+            continue;
+        const key = keywordClassKey(traitDef);
+        if (traitMembers.has(key))
+            continue;
+        const matches = [];
+        appendDirectKeywordMembers(ref.module.locals, member, ref.container, ref.context, ref.context.sup.normalizeIdentifier, undefined, matches);
+        traitMembers.set(key, matches);
+        traitOwners.push(key);
+    }
+    const model = {
+        ownerKey: (owner) => owner,
+        members: (owner) => {
+            if (owner === "inherent")
+                return inherent;
+            if (owner === "implemented")
+                return implemented;
+            return traitMembers.get(owner) ?? [];
+        },
+        supertypes: (owner) => {
+            if (owner === "type")
+                return ["inherent"];
+            if (owner === "inherent")
+                return ["implemented"];
+            return owner === "implemented" ? traitOwners : [];
+        },
+        name: (def) => context.sup.normalizeIdentifier(def.localName),
+        key: (def) => def.callable?.key ?? keywordClassKey(def),
+        callable: (def) => def.callable,
+        scope: () => "any",
+        visible: () => true,
+    };
+    const selected = selectMember(["type"], model, {
+        name: context.sup.normalizeIdentifier(member),
+        argumentCount: knownArgumentCount ?? null,
+        scope: "any",
+        useFile: receiverDef.file,
+        keepUniqueArityMismatch: true,
+    });
+    return selected.status === "unique" ? selected.member : undefined;
+}
 function goMethodReceiverTypeName(methodNode, source, sup) {
     const receiver = methodNode.childForFieldName("receiver");
     if (!receiver)
@@ -2397,9 +2700,10 @@ function goMethodsNamedOnType(locals, member, typeName, targetContext, normalize
         if (node.type === "method_declaration") {
             const receiverType = goMethodReceiverTypeName(node, targetContext.source, targetContext.sup);
             if (receiverType && normalizeIdentifier(receiverType) === normalizeIdentifier(typeName)) {
-                const local = findLocalWithinNode(locals, member, node, normalizeIdentifier);
-                if (local && !matches.includes(local))
-                    matches.push(local);
+                for (const local of findLocalsWithinNode(locals, member, node, normalizeIdentifier)) {
+                    if (!matches.includes(local))
+                        matches.push(local);
+                }
             }
             return;
         }
@@ -2422,9 +2726,10 @@ function kotlinExtensionFunctionsNamedOnType(locals, member, typeName, targetCon
         if (node.type === "function_declaration") {
             const receiverType = kotlinExtensionReceiverTypeNode(node, targetContext.sup);
             if (receiverType && normalizeIdentifier(sliceText(receiverType, targetContext.source)) === normalizedType) {
-                const local = findLocalWithinNode(locals, member, node, normalizeIdentifier);
-                if (local && !matches.includes(local))
-                    matches.push(local);
+                for (const local of findLocalsWithinNode(locals, member, node, normalizeIdentifier)) {
+                    if (!matches.includes(local))
+                        matches.push(local);
+                }
             }
             return;
         }
@@ -2434,50 +2739,79 @@ function kotlinExtensionFunctionsNamedOnType(locals, member, typeName, targetCon
     visit(targetContext.tree.rootNode);
     return matches;
 }
-function findGoReceiverMember(locals, member, typeName, targetContext, normalizeIdentifier) {
-    const visited = new Set();
-    let level = [typeName];
+async function selectGoReceiverMember(index, receiverDef, member, normalizeIdentifier, knownArgumentCount) {
+    const peers = getCompilationUnitPeers(index, receiverDef.file).files;
+    const files = await Promise.all([...peers].map(async (file) => {
+        const module = index.byFile.get(fileIdentityKey(file));
+        if (!module)
+            return null;
+        const context = await ensureParsedContext(file, index.parsed?.get(fileIdentityKey(file)), index.languageExtensions);
+        return context.sup.id === "go" ? { module, context } : null;
+    }));
+    const contexts = files.filter((file) => file !== null);
+    const members = new Map();
+    const embedded = new Map();
+    const seen = new Set();
+    let level = [receiverDef.localName];
     for (let depth = 0; depth < RECEIVER_HIERARCHY_DEPTH && level.length; depth += 1) {
-        const matches = [];
         const next = [];
-        for (const currentType of level) {
-            if (visited.has(currentType))
+        for (const typeName of level) {
+            if (seen.has(typeName))
                 continue;
-            visited.add(currentType);
-            for (const method of goMethodsNamedOnType(locals, member, currentType, targetContext, normalizeIdentifier)) {
-                if (!matches.includes(method))
-                    matches.push(method);
-            }
-            for (const embedded of goEmbeddedTypeNames(currentType, targetContext, normalizeIdentifier)) {
-                if (!visited.has(embedded) && !next.includes(embedded))
-                    next.push(embedded);
+            seen.add(typeName);
+            const matches = [];
+            const bases = [];
+            for (const { module, context } of contexts) {
+                const normalize = context.sup.normalizeIdentifier;
+                matches.push(...goMethodsNamedOnType(module.locals, member, typeName, context, normalize));
+                const spec = goTypeSpecNamed(context.tree.rootNode, typeName, context.source, normalize);
+                if (!spec)
+                    continue;
+                matches.push(...findDirectLocalsWithinNode(module.locals, member, spec, context, normalize).filter((def) => def.isMember));
+                for (const base of goEmbeddedTypeNames(typeName, context, normalize)) {
+                    if (!bases.includes(base))
+                        bases.push(base);
+                    if (!seen.has(base) && !next.includes(base))
+                        next.push(base);
+                }
             }
+            members.set(typeName, matches);
+            embedded.set(typeName, bases);
         }
-        if (matches.length === 1)
-            return matches[0];
-        if (matches.length > 1)
-            return undefined;
         level = next;
     }
-    return undefined;
+    const model = {
+        ownerKey: (owner) => owner,
+        members: (owner) => members.get(owner) ?? [],
+        supertypes: (owner) => embedded.get(owner) ?? [],
+        name: (def) => normalizeIdentifier(def.localName),
+        key: (def) => def.callable?.key ?? keywordClassKey(def),
+        callable: (def) => def.callable,
+        scope: () => "any",
+        visible: () => true,
+    };
+    const selected = selectMember([receiverDef.localName], model, {
+        name: normalizeIdentifier(member),
+        argumentCount: knownArgumentCount ?? null,
+        scope: "any",
+        useFile: receiverDef.file,
+        keepUniqueArityMismatch: true,
+    });
+    return selected.status === "unique" ? selected.member : undefined;
 }
 function pythonClassKey(def) {
     const start = def.range.start;
     return `${fileIdentityKey(def.file)}:${start.index ?? `${start.line}:${start.column}`}`;
 }
-async function resolvePythonReceiverMember(index, mod, node, obj, member, source, tree, sup, resolveExpression) {
-    const classRef = await pythonReceiverClassRef(index, mod, node, obj, source, tree, sup, resolveExpression);
+async function resolvePythonReceiverMember(index, mod, node, obj, member, source, sup, resolveExpression, proof) {
+    const classRef = await pythonReceiverClassRef(index, mod, node, obj, source, sup, resolveExpression, proof);
     if (!classRef)
         return undefined;
     return lookupPythonClassMember(index, classRef.ref, member, classRef.startAtSupertype);
 }
-async function pythonReceiverClassRef(index, mod, node, obj, source, tree, sup, resolveExpression) {
-    const receiverName = receiverKeywordText(sup, obj, source, (callee) => {
-        const scope = getOrBuildScopeIndex(index, mod.file, source, sup, mod, tree);
-        return !!findClosestScopeBinding(scope, sliceText(callee, source), callee, sup);
-    });
-    const keywordKind = keywordReceiverKind(sup.id, receiverName);
-    if (keywordKind) {
+async function pythonReceiverClassRef(index, mod, node, obj, source, sup, resolveExpression, proof) {
+    const receiver = proof ?? classifyReceiver(sup, obj, source, null, 0, obj.parent ?? obj, noLexicalBinding);
+    if (receiver.kind === "own-type" || receiver.kind === "supertype") {
         const container = findEnclosingClassContainer(node);
         if (!container)
             return null;
@@ -2498,10 +2832,10 @@ async function pythonReceiverClassRef(index, mod, node, obj, source, tree, sup,
         if (!def)
             return null;
         const ref = await pythonClassRefFromDef(index, def);
-        return ref ? { ref, startAtSupertype: keywordKind === "supertype" } : null;
+        return ref ? { ref, startAtSupertype: receiver.kind === "supertype" } : null;
     }
     let classDef;
-    const constructor = receiverConstructorExpression(obj, source, sup);
+    const constructor = receiver.kind === "named-type" && receiver.proof !== "static-type" ? receiver.typeNode : null;
     if (constructor) {
         const result = await resolveExpression(constructor);
         if (result?.kind === "resolved" && result.def.kind === SymbolKind.Class) {
@@ -2539,13 +2873,13 @@ async function pythonClassRefFromDef(index, def) {
 }
 function pythonMembersOnClass(classRef, member) {
     const normalizeIdentifier = classRef.context.sup.normalizeIdentifier;
-    const direct = findDirectLocalWithinNode(classRef.module.locals, member, classRef.container, classRef.context, normalizeIdentifier);
-    if (direct)
-        return [direct];
-    const attribute = findPythonInstanceAttributeWithinClass(classRef.module.locals, member, classRef.container, classRef.context, normalizeIdentifier);
-    return attribute ? [attribute] : [];
+    const direct = findDirectLocalsWithinNode(classRef.module.locals, member, classRef.container, classRef.context, normalizeIdentifier);
+    if (direct.length)
+        return direct;
+    return findPythonInstanceAttributesWithinClass(classRef.module.locals, member, classRef.container, classRef.context, normalizeIdentifier);
 }
-function findPythonInstanceAttributeWithinClass(locals, member, container, targetContext, normalizeIdentifier) {
+function findPythonInstanceAttributesWithinClass(locals, member, container, targetContext, normalizeIdentifier) {
+    const matches = [];
     const containerStart = container.startIndex;
     const containerEnd = container.endIndex;
     const normalizedMember = normalizeIdentifier(member);
@@ -2566,9 +2900,9 @@ function findPythonInstanceAttributeWithinClass(locals, member, container, targe
         };
         const nameNode = targetContext.tree.rootNode.descendantForPosition(position, position);
         if (isPythonReceiverAttributeAssignmentName(nameNode))
-            return local;
+            matches.push(local);
     }
-    return undefined;
+    return matches;
 }
 function pythonBaseIdentifierNodes(classNode) {
     const bases = classNode.childForFieldName("superclasses") ??
@@ -2638,34 +2972,25 @@ async function pythonBaseClassRefs(index, classRef) {
     return refs;
 }
 async function lookupPythonClassMember(index, start, member, startAtSupertype = false) {
-    if (!startAtSupertype) {
-        const own = pythonMembersOnClass(start, member);
-        if (own.length === 1)
-            return own[0];
-        if (own.length > 1)
-            return undefined;
-    }
-    let level = await pythonBaseClassRefs(index, start);
-    const visited = new Set([pythonClassKey(start.def), ...level.map((base) => pythonClassKey(base.def))]);
+    const membersByOwner = new Map();
+    const parentsByOwner = new Map();
+    const visited = new Set([pythonClassKey(start.def)]);
+    let level = [start];
     for (let depth = 0; depth < RECEIVER_HIERARCHY_DEPTH && level.length; depth += 1) {
-        const matches = [];
-        const seenMatch = new Set();
-        for (const base of level) {
-            for (const hit of pythonMembersOnClass(base, member)) {
-                const key = pythonClassKey(hit);
-                if (seenMatch.has(key))
-                    continue;
-                seenMatch.add(key);
-                matches.push(hit);
-            }
-        }
-        if (matches.length === 1)
-            return matches[0];
-        if (matches.length > 1)
-            return undefined;
+        let named = false;
+        for (const ref of level) {
+            const members = startAtSupertype && !depth ? [] : pythonMembersOnClass(ref, member);
+            membersByOwner.set(pythonClassKey(ref.def), members);
+            if (members.length)
+                named = true;
+        }
+        if (named)
+            break;
         const next = [];
-        for (const base of level) {
-            for (const parent of await pythonBaseClassRefs(index, base)) {
+        for (const ref of level) {
+            const parents = await pythonBaseClassRefs(index, ref);
+            parentsByOwner.set(pythonClassKey(ref.def), parents);
+            for (const parent of parents) {
                 const key = pythonClassKey(parent.def);
                 if (visited.has(key))
                     continue;
@@ -2675,6 +3000,23 @@ async function lookupPythonClassMember(index, start, member, startAtSupertype =
         }
         level = next;
     }
-    return undefined;
+    const model = {
+        ownerKey: (ref) => pythonClassKey(ref.def),
+        members: (ref) => membersByOwner.get(pythonClassKey(ref.def)) ?? [],
+        supertypes: (ref) => parentsByOwner.get(pythonClassKey(ref.def)) ?? [],
+        name: (def) => def.localName,
+        key: (def) => def.callable?.key ?? pythonClassKey(def),
+        callable: (def) => def.callable,
+        scope: () => "any",
+        visible: () => true,
+    };
+    const selected = selectMember([start], model, {
+        name: member,
+        argumentCount: null,
+        scope: "any",
+        useFile: start.def.file,
+        startAtAncestor: startAtSupertype,
+    });
+    return selected.status === "unique" ? selected.member : undefined;
 }
 //# sourceMappingURL=navigation-goto.js.map