@lzehrung/codegraph 2.3.31 → 3.0.0

package/dist/indexer/navigation-goto.js

@@ -1,16 +1,517 @@
+import { CSHARP_SUPPORT, supportForFileWithoutHeaderSample } from "../languages.js";
 import { isJsTsLanguage } from "../languages/js-family.js";
 import { isPythonReceiverAttributeAssignmentName } from "../languages/definitions/python.js";
 import { sliceText } from "../util/ast.js";
+import { foldPhpIdentifierCase } from "../util/identifiers.js";
 import { fileIdentityKey } from "../util/paths.js";
-import { getMemberAccessParts, getNavigationExpressionProperty, isMemberAccessNode, isReceiverNameNode, memberAccessTraversalTypes, } from "../util/member-access.js";
-import { isKeywordReceiver, supportsReceiverMemberNavigation } from "../util/member-access-tables.js";
-import { declaresMembers, hasStaticMemberDistinction, nearestMemberContainer, receiverConstructorExpression, unwrapNamedType, } from "../graphs/symbol-graph-detailed/receiver-calls.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, 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";
 import { okGoToResult } from "./navigation-provenance.js";
-import { resolveExport, resolveImported } from "./navigation-resolve.js";
+import { comparePhpReferenceNames, findPhpImportAlias } from "./navigation-php.js";
+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
+ * resource bound rather than a cycle guard; keeping a single constant stops the three walks from
+ * drifting to different semantic cutoffs.
+ */
+const RECEIVER_HIERARCHY_DEPTH = 16;
+function collectSharedOwnerContainers(root, languageId, out) {
+    if (languageId === "csharp") {
+        if (CSHARP_PARTIAL_CONTAINER_TYPES.has(root.type))
+            out.push(root);
+    }
+    else if (languageId === "swift") {
+        if (root.type === "class_declaration")
+            out.push(root);
+    }
+    for (const child of root.namedChildren ?? [])
+        collectSharedOwnerContainers(child, languageId, out);
+}
+const sharedOwnerContainersByRoot = new WeakMap();
+function sharedOwnerContainersInTree(root, languageId) {
+    let byLanguage = sharedOwnerContainersByRoot.get(root);
+    if (!byLanguage) {
+        byLanguage = new Map();
+        sharedOwnerContainersByRoot.set(root, byLanguage);
+    }
+    const cached = byLanguage.get(languageId);
+    if (cached)
+        return cached;
+    const collected = [];
+    collectSharedOwnerContainers(root, languageId, collected);
+    byLanguage.set(languageId, collected);
+    return collected;
+}
+export async function resolveSharedOwnerContainers(params) {
+    const { index, ownerFile, ownerContainer, ownerSource, languageId } = params;
+    if (languageId !== "csharp" && languageId !== "swift")
+        return [];
+    const ownerIdentity = getSharedOwnerIdentity(ownerContainer, ownerSource, languageId, ownerFile);
+    if (!ownerIdentity)
+        return [];
+    // A C# `file` owner has only same-file parts, so no other file is a candidate peer.
+    const peers = ownerIdentity.fileLocalTo
+        ? { files: new Set([ownerFile]), complete: true }
+        : getCompilationUnitPeers(index, ownerFile);
+    const out = [];
+    const seen = new Set();
+    const ownerIsExtension = languageId === "swift" ? isSwiftExtensionContainer(ownerContainer, ownerSource) : false;
+    const ownerKey = fileIdentityKey(ownerFile);
+    const units = [];
+    for (const file of peers.files) {
+        const peer = index.byFile.get(fileIdentityKey(file));
+        if (peer)
+            units.push(peer);
+    }
+    for (const peer of units) {
+        let peerContext;
+        try {
+            peerContext = await ensureParsedContext(peer.file, index.parsed?.get(fileIdentityKey(peer.file)), index.languageExtensions);
+        }
+        catch {
+            continue;
+        }
+        if (peerContext.sup.id !== languageId)
+            continue;
+        const containers = sharedOwnerContainersInTree(peerContext.tree.rootNode, languageId);
+        for (const container of containers) {
+            if (fileIdentityKey(peer.file) === ownerKey &&
+                container.startIndex === ownerContainer.startIndex &&
+                container.endIndex === ownerContainer.endIndex) {
+                continue;
+            }
+            const identity = getSharedOwnerIdentity(container, peerContext.source, languageId, peer.file);
+            if (!identity || !sharedOwnerCanUseMembers(ownerIdentity, identity))
+                continue;
+            if (languageId === "swift") {
+                const peerIsExtension = isSwiftExtensionContainer(container, peerContext.source);
+                if (!ownerIsExtension && !peerIsExtension)
+                    continue;
+            }
+            const key = fileIdentityKey(peer.file) + ":" + container.startIndex + ":" + container.endIndex;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({ file: peer.file, container, context: peerContext, module: peer });
+        }
+    }
+    return out;
+}
+/**
+ * Unit-boundary completeness for a C# partial or Swift type/extension member. Its other
+ * owner parts, and therefore its uses, are bounded by `getCompilationUnitPeers`, so an
+ * unproven unit boundary leaves the member's reference set incomplete. Returns null when
+ * the member's owner cannot be shared across files.
+ */
+export async function sharedOwnerMemberUnitComplete(index, def) {
+    if (!def.isMember)
+        return null;
+    let context;
+    try {
+        context = await ensureParsedContext(def.file, index.parsed?.get(fileIdentityKey(def.file)), index.languageExtensions);
+    }
+    catch {
+        return null;
+    }
+    const languageId = context.sup.id;
+    if (languageId !== "csharp" && languageId !== "swift")
+        return null;
+    const nameNode = nameNodeForDef(context, def);
+    const container = nameNode ? nearestMemberContainer(nameNode) : null;
+    const identity = container ? getSharedOwnerIdentity(container, context.source, languageId, def.file) : null;
+    if (!identity)
+        return null;
+    // File-local owners have no parts in other files, so the reference set is complete.
+    if (identity.fileLocalTo)
+        return true;
+    // A C# member is reachable through a qualified owner (`P.Box`) from any namespace, so use the
+    // same qualified peer relation as reference candidate discovery.
+    return getCompilationUnitPeers(index, def.file, languageId === "csharp" ? { csharpQualifiedName: true } : undefined)
+        .complete;
+}
+/**
+ * Other C# `partial` type parts that share owner identity with `def`.
+ * Reference collection treats them as one type so uses that resolve to the
+ * coalesced representative still match a query started on any part.
+ */
+export async function findCsharpPartialTypeEquivalents(index, def) {
+    if (!declaresMembers(def))
+        return [];
+    const module = index.byFile.get(fileIdentityKey(def.file));
+    if (!module)
+        return [];
+    let context;
+    try {
+        context = await ensureParsedContext(def.file, index.parsed?.get(fileIdentityKey(def.file)), index.languageExtensions);
+    }
+    catch {
+        return [];
+    }
+    if (context.sup.id !== "csharp")
+        return [];
+    const start = def.range.start;
+    const nameNode = context.tree.rootNode.descendantForPosition({ row: start.line - 1, column: start.column - 1 }, { row: start.line - 1, column: start.column - 1 });
+    const container = nearestMemberContainer(nameNode);
+    if (!container)
+        return [];
+    const peers = await resolveSharedOwnerContainers({
+        index,
+        ownerFile: def.file,
+        ownerContainer: container,
+        ownerSource: context.source,
+        languageId: "csharp",
+    });
+    const out = [];
+    for (const peer of peers) {
+        const peerName = peer.container.childForFieldName("name");
+        if (!peerName)
+            continue;
+        const peerDef = peer.module.locals.find((local) => declaresMembers(local) && local.range.start.index === peerName.startIndex);
+        if (peerDef)
+            out.push(peerDef);
+    }
+    return out;
+}
+/** Reusable shared-owner member lookup for keyword navigation and receiver graphs. */
+export async function findSharedOwnerMemberDefinitions(params) {
+    const { index, ownerFile, ownerContainer, ownerSource, languageId, member, memberScope } = params;
+    const peers = await resolveSharedOwnerContainers({ index, ownerFile, ownerContainer, ownerSource, languageId });
+    const out = [];
+    for (const peer of peers) {
+        const predicate = !memberScope || memberScope === "any"
+            ? undefined
+            : (local) => matchesReceiverMemberScope(local, memberScope, peer.context, peer.container);
+        const hits = findDirectLocalsWithinNode(peer.module.locals, member, peer.container, peer.context, peer.context.sup.normalizeIdentifier, predicate);
+        for (const hit of hits) {
+            const hitNode = nameNodeForDef(peer.context, hit);
+            if (languageId === "swift" && fileIdentityKey(ownerFile) !== fileIdentityKey(peer.file)) {
+                if (!hitNode || isSwiftCrossFileHiddenSharedOwnerMember(languageId, ownerFile, peer.file, hitNode))
+                    continue;
+            }
+            if (!out.includes(hit))
+                out.push(hit);
+        }
+    }
+    return out;
+}
+function nameNodeForDef(context, def) {
+    const start = def.range.start;
+    const index = start.index;
+    if (index !== undefined)
+        return context.tree.rootNode.descendantForIndex(index, index);
+    const position = { row: start.line - 1, column: start.column - 1 };
+    return context.tree.rootNode.descendantForPosition(position, position);
+}
+function enclosingImportScope(declarationName) {
+    let current = declarationName;
+    while (current && current.type !== "variable_declaration" && current.type !== "using_directive") {
+        current = current.parent;
+    }
+    return current?.parent ?? null;
+}
+/**
+ * Rewrites a valid C# `using X = Namespace; X::Target` lookup into the dotted form
+ * export resolution already understands. `global::` and ordinary dotted names keep
+ * their source spelling; an unknown alias stays `X::Target` instead of a bare name.
+ */
+export function csharpAliasQualifiedLookupName(node, source, fallback, imports) {
+    const raw = csharpLookupName(node, source, fallback);
+    if (raw.startsWith("global::"))
+        return raw;
+    const chainNode = csharpQualifiedNameNode(node);
+    if (!chainNode || !raw.includes("::"))
+        return raw;
+    const names = [];
+    let current = chainNode;
+    let base = null;
+    while (current && (current.type === "qualified_name" || current.type === "alias_qualified_name")) {
+        const parts = getMemberAccessParts(CSHARP_SUPPORT, current);
+        base = parts.object ?? base;
+        let property = parts.property;
+        if (property?.type === "generic_name") {
+            property = property.childForFieldName("name") ?? property.namedChildren[0] ?? property;
+        }
+        if (property?.type === "identifier")
+            names.push(sliceText(property, source));
+        current = base;
+    }
+    if (!base || !isReceiverNameNode(CSHARP_SUPPORT, base.type) || !names.length)
+        return raw;
+    const alias = sliceText(base, source);
+    if (alias === "global")
+        return raw;
+    const imported = innermostNamespaceImport(imports, alias, base, CSHARP_SUPPORT.normalizeIdentifier);
+    if (!imported)
+        return raw;
+    return `${imported.from}.${[...names].reverse().join(".")}`;
+}
+/**
+ * Innermost in-scope namespace import bound to `alias`. `normalize` applies the language's
+ * identifier equality (C# `@X` and `X` are one alias); the default compares exact spelling.
+ */
+export function innermostNamespaceImport(imports, alias, useNode, normalize = (name) => name) {
+    const normalizedAlias = normalize(alias);
+    const matches = imports.filter((candidate) => candidate.kind === "namespace" && normalize(candidate.localNS) === normalizedAlias);
+    if (!matches.length)
+        return undefined;
+    let root = useNode;
+    while (root.parent)
+        root = root.parent;
+    let best;
+    let bestScopeSpan = Number.POSITIVE_INFINITY;
+    let bestStart = -1;
+    for (const match of matches) {
+        const start = match.localRange?.start.index;
+        if (start === undefined)
+            continue;
+        let nameNode = root;
+        for (;;) {
+            const child = nameNode.namedChildren.find((candidate) => candidate.startIndex <= start && start < candidate.endIndex);
+            if (!child)
+                break;
+            nameNode = child;
+        }
+        const scope = enclosingImportScope(nameNode);
+        if (!scope)
+            continue;
+        if (start > useNode.startIndex && scope.parent)
+            continue;
+        if (scope.startIndex > useNode.startIndex || scope.endIndex < useNode.endIndex)
+            continue;
+        const span = scope.endIndex - scope.startIndex;
+        if (span < bestScopeSpan || (span === bestScopeSpan && start >= bestStart)) {
+            bestScopeSpan = span;
+            bestStart = start;
+            best = match;
+        }
+    }
+    if (best)
+        return best;
+    const unlocated = matches.filter((match) => match.localRange?.start.index === undefined);
+    if (unlocated.length === 1)
+        return unlocated[0];
+    const files = new Map();
+    for (const match of unlocated) {
+        if (typeof match.resolved !== "string")
+            continue;
+        const key = fileIdentityKey(match.resolved);
+        if (!files.has(key))
+            files.set(key, match);
+    }
+    if (files.size === 1)
+        return [...files.values()][0];
+    return undefined;
+}
+function rubyScopeResolutionPath(node, source) {
+    if (node.type !== "constant")
+        return null;
+    const owner = node.parent;
+    if (owner?.type !== "scope_resolution")
+        return null;
+    const ownerName = owner.childForFieldName("name");
+    if (!ownerName || ownerName.startIndex !== node.startIndex || ownerName.endIndex !== node.endIndex)
+        return null;
+    // `Outer::Inner::Tool` nests scope_resolution on `scope`, so flatten from the
+    // clicked name instead of stopping at the first nested scope.
+    const segments = [];
+    let current = owner;
+    while (current?.type === "scope_resolution") {
+        const name = current.childForFieldName("name");
+        const scope = current.childForFieldName("scope");
+        if (!name || name.type !== "constant")
+            return null;
+        const text = sliceText(name, source);
+        if (!text)
+            return null;
+        segments.unshift(text);
+        current = scope;
+    }
+    if (!current || current.type !== "constant" || segments.length === 0)
+        return null;
+    const root = sliceText(current, source);
+    if (!root)
+        return null;
+    return { path: `${root}::${segments.join("::")}`, root };
+}
+/**
+ * `Outer::Inner::Tool` is one constant path. Nested classes are exported under that
+ * path, not as bare `Tool`, so the chain has to ask for the qualified export.
+ */
+function resolveRubyQualifiedConstantDefinition(index, mod, node, source) {
+    const qualified = rubyScopeResolutionPath(node, source);
+    if (!qualified)
+        return null;
+    const files = [];
+    const seen = new Set();
+    const add = (file) => {
+        if (!file)
+            return;
+        const key = fileIdentityKey(file);
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        files.push(file);
+    };
+    for (const imp of mod.imports) {
+        if (imp.kind === "namespace" && imp.localNS === qualified.root && typeof imp.resolved === "string") {
+            add(imp.resolved);
+        }
+    }
+    add(mod.file);
+    const hits = [];
+    for (const file of files) {
+        const hit = resolveExport(index, file, qualified.path, { allowLocalFallback: false });
+        if (hit?.kind !== "resolved")
+            continue;
+        if (hits.some((candidate) => fileIdentityKey(candidate.file) === fileIdentityKey(hit.def.file) &&
+            candidate.localName === hit.def.localName &&
+            candidate.range.start.line === hit.def.range.start.line &&
+            candidate.range.start.column === hit.def.range.start.column)) {
+            continue;
+        }
+        hits.push(hit.def);
+    }
+    if (hits.length !== 1)
+        return null;
+    return okGoToResult(index, hits[0], {
+        via: { exportedName: qualified.path },
+        resolution: "member-access",
+        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, sup, resolveLexicalBinding } = params;
+    const { index, mod, node, source, tree, sup, resolveLexicalBinding } = params;
+    if (sup.id === "ruby") {
+        const qualified = resolveRubyQualifiedConstantDefinition(index, mod, node, source);
+        if (qualified)
+            return qualified;
+    }
     const parent = node.parent;
     if (!parent || !sup.supportsCrossModuleSymbols) {
         return null;
@@ -26,46 +527,148 @@ export async function resolveMemberAccessDefinition(params) {
         return null;
     const { object: obj, property: prop } = getMemberAccessParts(sup, memberNode);
     const optionalMemberTypes = memberAccessTraversalTypes(sup);
+    // Only the outermost access is the callee; an inner hop (`A.B` in `A.B.C()`) is not called.
+    const callArgumentCountFor = (expr) => expr.id === memberNode.id
+        ? (getCallArgumentCount({ languageId: sup.id, source, call: memberNode.parent ?? memberNode }) ?? undefined)
+        : undefined;
     const resolveExpression = async (expr) => {
         const exprIsId = isReceiverNameNode(sup, expr.type) && !isMemberAccessNode(sup, expr);
         if (exprIsId) {
-            const lexicalBinding = resolveLexicalBinding?.(expr);
-            if (lexicalBinding)
-                return { kind: "resolved", def: lexicalBinding };
+            const aliasQualifier = sup.id === "csharp" &&
+                expr.parent?.type === "alias_qualified_name" &&
+                getMemberAccessParts(sup, expr.parent).object?.id === expr.id;
+            if (!aliasQualifier) {
+                const lexicalBinding = resolveLexicalBinding?.(expr);
+                if (lexicalBinding)
+                    return { kind: "resolved", def: lexicalBinding };
+            }
             const exprName = sliceText(expr, source);
-            const imp = mod.imports.find((candidate) => (candidate.kind === "named" && candidate.local === exprName) ||
-                (candidate.kind === "default" && candidate.local === exprName) ||
-                (candidate.kind === "namespace" && candidate.localNS === exprName));
+            let imp;
+            if (sup.id === "php") {
+                imp = findPhpImportAlias(mod.imports, exprName, "class") ?? undefined;
+            }
+            else if (sup.id === "zig") {
+                imp = innermostNamespaceImport(mod.imports, exprName, expr);
+                if (!imp) {
+                    imp = mod.imports.find((candidate) => (candidate.kind === "named" || candidate.kind === "default") && candidate.local === exprName);
+                }
+            }
+            else if (sup.id === "csharp") {
+                if (aliasQualifier) {
+                    if (exprName !== "global")
+                        imp = innermostNamespaceImport(mod.imports, exprName, expr, sup.normalizeIdentifier);
+                    if (!imp)
+                        return null;
+                }
+                else {
+                    imp = innermostNamespaceImport(mod.imports, exprName, expr, sup.normalizeIdentifier);
+                    if (!imp) {
+                        imp = mod.imports.find((candidate) => (candidate.kind === "named" || candidate.kind === "default") &&
+                            candidate.local === exprName &&
+                            !isExpandedStarBinding(candidate, mod.imports));
+                    }
+                }
+            }
+            else {
+                imp = effectiveExplicitBinding(mod.imports, sup.id, (candidate) => ((candidate.kind === "named" || candidate.kind === "default") && candidate.local === exprName) ||
+                    (candidate.kind === "namespace" && candidate.localNS === exprName));
+                if (!imp && isJsTsLanguage(sup.id)) {
+                    imp = innermostNamespaceImport(mod.imports, exprName, expr);
+                }
+            }
             if (imp) {
                 if (imp.kind === "namespace") {
+                    if (imp.mechanism === "cjs" && typeof imp.resolved === "string") {
+                        const classValue = cjsRequireValueBinding(index, imp.resolved);
+                        if (classValue)
+                            return { kind: "resolved", def: classValue };
+                    }
                     return {
                         kind: "namespace",
                         file: typeof imp.resolved === "string" ? imp.resolved.replace(/\\/g, "/") : imp.resolved?.external || "",
                     };
                 }
+                if (sup.id === "php" && imp.kind === "named" && typeof imp.resolved === "string") {
+                    const result = resolvePhpExportByImportType(index, imp.resolved, imp.imported, "class");
+                    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) {
                         return { kind: "namespace", file: result.namespace };
                     }
-                    return { kind: "resolved", def: result };
+                    const container = asMemberContainer(index, result);
+                    return { kind: "resolved", def: container ?? result };
                 }
+                // Last-wins precedence (Python): the explicit import rebound the name, and an
+                // unresolved winner stays unresolved instead of falling back to an older star import.
+                if (starImportPrecedence(sup.id) === "last-wins")
+                    return null;
             }
-            const local = mod.locals.find((candidate) => candidate.localName === exprName);
-            if (local)
-                return { kind: "resolved", def: local };
-            for (const starImport of mod.imports.filter((candidate) => candidate.kind === "star")) {
-                const result = resolveImported(index, starImport, exprName);
-                if (result) {
-                    if ("namespace" in result) {
-                        return { kind: "namespace", file: result.namespace };
-                    }
-                    return { kind: "resolved", def: result };
+            if (sup.id === "csharp") {
+                const local = resolveExport(index, mod.file, exprName, { referenceIndex: expr.startIndex });
+                if (local)
+                    return local;
+            }
+            else {
+                const local = mod.locals.find((candidate) => {
+                    if (candidate.localName === exprName)
+                        return true;
+                    return (sup.id === "php" &&
+                        declaresMembers(candidate) &&
+                        foldPhpIdentifierCase(candidate.localName) === foldPhpIdentifierCase(exprName));
+                });
+                if (local)
+                    return { kind: "resolved", def: local };
+                if (sup.id === "java" || sup.id === "kotlin" || sup.id === "swift") {
+                    const peer = resolveExport(index, mod.file, exprName);
+                    if (peer)
+                        return peer;
+                }
+                else if (sup.id === "php") {
+                    const phpClass = resolveIndexedPhpClassReference(index, source, tree, expr, exprName, mod.imports);
+                    if (phpClass)
+                        return { kind: "resolved", def: phpClass };
                 }
             }
+            const starDecision = resolveStarImportedName(index, mod, sup.id, exprName);
+            if (starDecision.status === "resolved")
+                return { kind: "resolved", def: starDecision.definition };
+            if (starDecision.status === "ambiguous")
+                return null;
+            const starNamespaceDecision = resolveStarImportedNamespace(index, mod, sup.id, exprName);
+            if (starNamespaceDecision.status === "resolved") {
+                return { kind: "namespace", file: starNamespaceDecision.namespace };
+            }
+            if (starNamespaceDecision.status === "ambiguous")
+                return null;
             return null;
         }
         if (optionalMemberTypes.has(expr.type)) {
+            // A Python unaliased dotted import (`import a.b`) binds only the first segment `a`,
+            // resolved to the leaf module `a.b` names; the source can only ever repeat that whole
+            // dotted phrase to reach it again (`a.b.symbol(...)`), never a bare intermediate segment
+            // on its own. Recognize that literal phrase up front so the chain walk below lands on the
+            // leaf module the import machinery already resolved, instead of treating each dot as an
+            // ordinary member-access hop and failing on the segment duplicating the import's spelling.
+            if (sup.id === "python") {
+                const dottedText = sliceText(expr, source);
+                if (dottedText.includes(".")) {
+                    const dottedImport = mod.imports.find((imp) => imp.kind === "namespace" &&
+                        imp.mechanism === "python" &&
+                        imp.from === dottedText &&
+                        typeof imp.resolved === "string");
+                    if (dottedImport && typeof dottedImport.resolved === "string") {
+                        return { kind: "namespace", file: dottedImport.resolved.replace(/\\/g, "/") };
+                    }
+                }
+            }
             const parts = getMemberAccessParts(sup, expr);
             const subObj = parts.object;
             let subProp = parts.property;
@@ -74,16 +677,48 @@ 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
+                // declares the namespace.
+                const dottedRoot = !base && sup.id === "csharp" ? csharpDottedNameRoot(expr) : null;
+                if (dottedRoot && !resolveLexicalBinding?.(dottedRoot)) {
+                    return resolveCsharpQualifiedName(index, mod, sliceText(expr, source).replace(/\s+/gu, ""), expr.startIndex);
+                }
                 if (base?.kind === "namespace") {
+                    if (!isGoExportedMemberName(sup.id, memberName))
+                        return null;
                     return resolveExport(index, base.file, memberName, { allowLocalFallback: false });
                 }
                 if (base?.kind === "resolved") {
-                    if (sup.id === "java") {
-                        const memberDef = await resolveMemberDefinitionForBase(index, base.def, memberName);
+                    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;
                     }
-                    if (sup.id === "ruby") {
+                    if (sup.id === "ruby" && declaresMembers(base.def)) {
                         const memberDef = await resolveMemberDefinitionForBase(index, base.def, memberName);
                         if (memberDef)
                             return { kind: "resolved", def: memberDef };
@@ -100,18 +735,39 @@ 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 });
                 }
                 if (base?.kind === "resolved") {
-                    const memberDef = await resolveMemberDefinitionForBase(index, base.def, memberName);
+                    const memberDef = await resolveMemberDefinitionForBase(index, base.def, memberName, callArgumentCountFor(expr));
                     return memberDef ? { kind: "resolved", def: memberDef } : null;
                 }
             }
         }
         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") {
@@ -133,12 +789,10 @@ export async function resolveMemberAccessDefinition(params) {
             }
         }
     }
-    const receiverName = obj ? sliceText(obj, source) : "";
-    const implicitClassReceiver = isKeywordReceiver(sup.id, receiverName);
-    if (obj && prop && node.id === prop.id && (supportsReceiverMemberNavigation(sup.id) || implicitClassReceiver)) {
+    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, sup, resolveExpression);
+            const memberDef = await resolvePythonReceiverMember(index, mod, node, obj, member, source, sup, resolveExpression, receiverProof);
             if (!memberDef)
                 return null;
             return okGoToResult(index, memberDef, {
@@ -147,11 +801,9 @@ export async function resolveMemberAccessDefinition(params) {
                 confidence: "medium",
             });
         }
-        if (!sup.membersAreImplicitlyInScope && implicitClassReceiver) {
-            const classContainer = findEnclosingClassContainer(node);
-            const memberDef = classContainer
-                ? findLocalWithinNode(mod.locals, member, classContainer, sup.normalizeIdentifier)
-                : undefined;
+        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, {
                     via: { exportedName: member },
@@ -159,8 +811,74 @@ export async function resolveMemberAccessDefinition(params) {
                     confidence: "medium",
                 });
             }
+            const outOfLineOwnerPath = cppOutOfLineOwnerPath(node, source, sup);
+            const outOfLineOwner = outOfLineOwnerPath
+                ? await resolveCppQualifiedMemberContainer(index, mod, outOfLineOwnerPath)
+                : null;
+            if (outOfLineOwner) {
+                const outOfLineMember = await resolveKeywordReceiverMember(index, mod, node, member, keywordScope, false, getCallArgumentCount({ languageId: sup.id, source, call: memberNode.parent ?? memberNode }) ?? undefined, outOfLineOwner);
+                if (outOfLineMember) {
+                    return okGoToResult(index, outOfLineMember, {
+                        resolution: "exact",
+                        confidence: "high",
+                    });
+                }
+            }
+            // A failed `self` lookup is not a license to bind an unrelated same-file
+            // extension member by its bare name (including an unproven where clause).
+            if (sup.id === "swift")
+                return { status: "not_found", reason: "No matching Swift member definition" };
+        }
+        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" };
+            return okGoToResult(index, memberDef, {
+                via: { exportedName: member },
+                resolution: "member-access",
+                confidence: "medium",
+            });
+        }
+        if (sup.id === "cpp" && memberNode.type === "qualified_identifier") {
+            // `a::C::run` nests `C::run` inside `a::(...)`; only the outermost node carries the full owner.
+            let outermost = memberNode;
+            while (outermost.parent?.type === "qualified_identifier")
+                outermost = outermost.parent;
+            // The declarator of an out-of-line definition (`int Box<T>::f() {}`) names the declaration
+            // itself, not a member call; the declaration lookup below resolves it.
+            if (outermost.parent?.type === "function_declarator")
+                return null;
+            const qualified = cppQualifiedNameSegments(outermost, source);
+            const ownerPath = qualified.slice(0, -1);
+            const owner = await resolveCppQualifiedMemberContainer(index, mod, ownerPath);
+            if (owner) {
+                const knownArgumentCount = getCallArgumentCount({ languageId: sup.id, source, call: memberNode.parent ?? memberNode }) ?? undefined;
+                // Inside a member function, `Owner::member()` can name an instance member of the class or a
+                // base through the implicit `this`; elsewhere only static members qualify.
+                const implicitThis = await cppQualifiedOwnerHasImplicitThis(index, mod, memberNode, source, sup, owner);
+                const memberScope = implicitThis ? "any" : "static";
+                const memberDef = await resolveKeywordReceiverMember(index, mod, node, member, memberScope, false, knownArgumentCount, owner);
+                return memberDef
+                    ? okGoToResult(index, memberDef, { resolution: "member-access", confidence: "high" })
+                    : { status: "not_found", reason: "No matching C++ static member definition" };
+            }
+            // A qualifier that is not a class (a namespace) names a free function, which the qualified
+            // function lookup resolves; the short name must not be read as a same-named class receiver.
+            return null;
         }
-        const receiver = await resolveReceiverDefinition(obj, source, sup, resolveExpression, mod);
+        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);
+            return memberDef
+                ? okGoToResult(index, memberDef, {
+                    via: { exportedName: member },
+                    resolution: "member-access",
+                    confidence: "medium",
+                })
+                : null;
+        }
+        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);
@@ -185,14 +903,50 @@ export async function resolveMemberAccessDefinition(params) {
                     const memberPredicate = receiver.memberScope === "any"
                         ? undefined
                         : (local) => matchesReceiverMemberScope(local, receiver.memberScope, targetContext, container);
+                    const knownArgumentCount = getCallArgumentCount({ languageId: sup.id, source, call: memberNode.parent ?? memberNode }) ?? undefined;
                     let memberDef;
-                    if (receiver.runtimeTypeOnly || targetContext.sup.id === "java") {
-                        memberDef = findDirectLocalWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier, memberPredicate);
+                    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 {
-                        memberDef = findReceiverMemberDefinition(targetModule.locals, member, objDef, container, targetContext, normalizeIdentifier, receiver.memberScope);
+                    else if (!memberDef && (receiver.runtimeTypeOnly || targetContext.sup.id === "java")) {
+                        const candidates = findDirectLocalsWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier, memberPredicate);
+                        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 if (!memberDef) {
+                        memberDef = await findReceiverMemberDefinition(index, targetModule.locals, member, objDef, container, targetContext, normalizeIdentifier, receiver.memberScope, knownArgumentCount);
                     }
-                    if (memberDef) {
+                    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, memberContext)) {
                         return okGoToResult(index, memberDef, {
                             via: { exportedName: member },
                             resolution: "member-access",
@@ -205,17 +959,1077 @@ export async function resolveMemberAccessDefinition(params) {
     }
     return null;
 }
-function findEnclosingClassContainer(node) {
-    return nearestMemberContainer(node);
+function findEnclosingClassContainer(node) {
+    return nearestMemberContainer(node);
+}
+function keywordClassKey(def) {
+    const start = def.range.start;
+    return `${fileIdentityKey(def.file)}:${start.index ?? `${start.line}:${start.column}`}`;
+}
+function keywordContainerKey(file, container) {
+    return `${fileIdentityKey(file)}:${container.startIndex}:${container.endIndex}`;
+}
+function peelTypeWrappers(node) {
+    let current = node;
+    while (current) {
+        if (current.type === "type_annotation" ||
+            current.type === "named_type" ||
+            current.type === "user_type" ||
+            current.type === "type" ||
+            current.type === "parenthesized_type" ||
+            current.type === "pointer_type" ||
+            current.type === "reference_type" ||
+            current.type === "optional_type" ||
+            current.type === "nullable_type" ||
+            current.type === "generic_type" ||
+            current.type === "generic_name") {
+            current = current.childForFieldName("type") ?? current.namedChildren[0] ?? null;
+            continue;
+        }
+        break;
+    }
+    return current ?? node;
+}
+function isSimpleTypeNameNode(node, sup) {
+    return isReceiverNameNode(sup, node.type) || node.type === "type_identifier" || node.type === "name";
+}
+function parseCppBaseType(node, source) {
+    let current = node;
+    while (current.type === "base_class_clause" ||
+        current.type === "access_specifier" ||
+        current.type === "virtual_specifier" ||
+        current.type === "type_descriptor") {
+        const nested = current.namedChildren.at(-1);
+        if (!nested || nested.id === current.id)
+            break;
+        current = nested;
+    }
+    const names = cppQualifiedNameSegments(current, source);
+    return names.length ? { base: names[0], path: names.slice(1) } : null;
+}
+function collectDeclaredBaseTypes(container, source, sup, superclassOnly = false) {
+    const ancestry = MEMBER_ACCESS_ROWS[sup.id]?.receiverAncestry;
+    if (!ancestry || (ancestry.clauses.length === 0 && !ancestry.mixinCalls?.length))
+        return [];
+    const bases = [];
+    const seen = new Set();
+    let usedFirstMatch = false;
+    const addSimple = (name, invoked) => {
+        if (!name || seen.has(name))
+            return;
+        seen.add(name);
+        bases.push(invoked ? { kind: "simple", name, invoked } : { kind: "simple", name });
+    };
+    const addQualified = (base, path, invoked) => {
+        if (!base || path.length === 0)
+            return;
+        const key = `${base}.${path.join(".")}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        bases.push(invoked ? { kind: "qualified", base, path, invoked } : { kind: "qualified", base, path });
+    };
+    const collectType = (node, invoked) => {
+        const core = peelTypeWrappers(node);
+        if (core.type === "constructor_invocation") {
+            // Kotlin writes the superclass as a constructor invocation (`Base()`); its callees are
+            // superclass entries, while bare types in the same base list are interfaces.
+            for (const child of core.namedChildren) {
+                if (child.type === "value_arguments")
+                    continue;
+                collectType(child, true);
+            }
+            return;
+        }
+        // A computed heritage expression can name the runtime base factory rather than a class.
+        // Its descendants do not prove an inheritance edge.
+        if (isUnprovenHeritageExpression(core))
+            return;
+        if (sup.id === "cpp" && core.type === "base_class_clause") {
+            for (const child of core.namedChildren) {
+                if (child.type === "access_specifier" || child.type === "virtual_specifier")
+                    continue;
+                collectType(child, invoked);
+            }
+            return;
+        }
+        if (sup.id === "cpp") {
+            const qualified = parseCppBaseType(core, source);
+            if (qualified) {
+                if (qualified.path.length)
+                    addQualified(qualified.base, qualified.path, invoked);
+                else
+                    addSimple(qualified.base, invoked);
+                return;
+            }
+        }
+        const unwrapped = unwrapNamedType(core, sup);
+        if (unwrapped) {
+            addSimple(sliceText(unwrapped, source), invoked);
+            return;
+        }
+        if (isMemberAccessNode(sup, core)) {
+            const chain = collectMemberAccessChain({ sup, source, chainNode: core });
+            if (chain && isSimpleTypeNameNode(chain.base, sup) && chain.names.length) {
+                addQualified(sliceText(chain.base, source), [...chain.names].reverse(), invoked);
+            }
+            return;
+        }
+        if (memberAccessTraversalTypes(sup).has(core.type))
+            return;
+        for (const child of core.namedChildren) {
+            if (child.type === "type_arguments")
+                continue;
+            collectType(child, invoked);
+        }
+    };
+    const consider = (node) => {
+        for (const rule of ancestry.clauses) {
+            if (node.type !== rule.nodeType)
+                continue;
+            if (superclassOnly && !rule.supertype)
+                continue;
+            if (superclassOnly && rule.supertype === "first-match") {
+                if (usedFirstMatch)
+                    continue;
+                usedFirstMatch = true;
+            }
+            let target = node;
+            if (superclassOnly && rule.supertype === "first-child") {
+                target = target.namedChildren[0] ?? target;
+            }
+            collectType(target, false);
+        }
+        if (superclassOnly || node.type !== "call" || !ancestry.mixinCalls?.length)
+            return;
+        if (node.childForFieldName("receiver"))
+            return;
+        const methodNode = node.childForFieldName("method");
+        const methodName = methodNode ? sliceText(methodNode, source) : undefined;
+        if (!methodName || !ancestry.mixinCalls.includes(methodName))
+            return;
+        const args = node.childForFieldName("arguments");
+        if (args)
+            collectType(args, false);
+    };
+    for (const child of container.namedChildren) {
+        consider(child);
+        for (const grand of child.namedChildren)
+            consider(grand);
+    }
+    return bases;
+}
+function asMemberContainer(index, def) {
+    return memberContainerForDefinition(index, def);
+}
+function importedMemberContainer(index, result) {
+    if (!result || "namespace" in result)
+        return undefined;
+    return asMemberContainer(index, result);
+}
+function resolveNamedMemberContainer(index, mod, name, normalize) {
+    const typedLocals = memberDeclaringLocals(mod, name, normalize);
+    const topLevel = typedLocals.filter((local) => !local.isMember);
+    const candidates = topLevel.length ? topLevel : typedLocals;
+    if (candidates.length === 1)
+        return candidates[0];
+    if (candidates.length > 1)
+        return undefined;
+    const normalizedName = normalize(name);
+    const languageId = supportForFileWithoutHeaderSample(mod.file, index.languageExtensions)?.id;
+    const explicitBinding = effectiveExplicitBinding(mod.imports, languageId ?? "", (binding) => (binding.kind === "named" || binding.kind === "default") && normalize(binding.local) === normalizedName);
+    if (explicitBinding?.kind === "named") {
+        const container = importedMemberContainer(index, resolveImported(index, explicitBinding, explicitBinding.imported));
+        if (container)
+            return container;
+    }
+    else if (explicitBinding?.kind === "default") {
+        const container = importedMemberContainer(index, resolveImported(index, explicitBinding, "default"));
+        if (container)
+            return container;
+    }
+    if (languageId) {
+        const starDecision = resolveStarImportedName(index, mod, languageId, name);
+        if (starDecision.status === "ambiguous")
+            return undefined;
+        if (starDecision.status === "resolved") {
+            const container = asMemberContainer(index, starDecision.definition);
+            if (container)
+                return container;
+        }
+    }
+    const exported = resolveExport(index, mod.file, name, { allowLocalFallback: false });
+    if (exported?.kind === "resolved")
+        return asMemberContainer(index, exported.def);
+    return undefined;
+}
+async function resolveQualifiedMemberContainer(index, mod, baseName, path, normalize, sup) {
+    if (path.length === 0)
+        return undefined;
+    if (sup.id === "cpp") {
+        return (await resolveCppQualifiedMemberContainer(index, mod, [baseName, ...path])) ?? undefined;
+    }
+    const namespaceImports = mod.imports.filter((imp) => imp.kind === "namespace" && normalize(imp.localNS) === normalize(baseName));
+    if (namespaceImports.length !== 1)
+        return undefined;
+    const resolved = namespaceImports[0].resolved;
+    let file = typeof resolved === "string" ? resolved : undefined;
+    if (!file)
+        return undefined;
+    for (let partIndex = 0; partIndex < path.length; partIndex += 1) {
+        const part = path[partIndex];
+        const last = partIndex === path.length - 1;
+        const hit = resolveExport(index, file, part, { allowLocalFallback: false });
+        if (!hit)
+            return undefined;
+        if (hit.kind === "namespace") {
+            if (last)
+                return undefined;
+            file = hit.file;
+            continue;
+        }
+        if (!last)
+            return undefined;
+        return asMemberContainer(index, hit.def);
+    }
+    return undefined;
+}
+function nodeContainsUnprovenHeritage(node) {
+    if (isUnprovenHeritageExpression(node))
+        return true;
+    return node.namedChildren.some((child) => nodeContainsUnprovenHeritage(child));
+}
+/** A heritage or mixin clause whose type expression is not a resolvable name. */
+function containerHeritageIsUnproven(container, source, sup) {
+    const ancestry = MEMBER_ACCESS_ROWS[sup.id]?.receiverAncestry;
+    if (!ancestry)
+        return false;
+    const clauseTypes = new Set(ancestry.clauses.map((rule) => rule.nodeType));
+    const nodes = [];
+    for (const child of container.namedChildren) {
+        nodes.push(child);
+        for (const grand of child.namedChildren)
+            nodes.push(grand);
+    }
+    if (nodes.some((node) => clauseTypes.has(node.type) && nodeContainsUnprovenHeritage(node)))
+        return true;
+    const mixinCalls = ancestry.mixinCalls;
+    if (!mixinCalls?.length)
+        return false;
+    return nodes.some((node) => {
+        if (node.type !== "call" || node.childForFieldName("receiver"))
+            return false;
+        const methodNode = node.childForFieldName("method");
+        const methodName = methodNode ? sliceText(methodNode, source) : undefined;
+        if (!methodName || !mixinCalls.includes(methodName))
+            return false;
+        const args = node.childForFieldName("arguments");
+        return !!args && nodeContainsUnprovenHeritage(args);
+    });
+}
+function definitionForContainer(mod, container) {
+    const nameNode = container.childForFieldName("name");
+    if (!nameNode)
+        return undefined;
+    const matches = mod.locals.filter((local) => declaresMembers(local) && local.range.start.index === nameNode.startIndex);
+    return matches.length === 1 ? matches[0] : undefined;
+}
+async function resolveReceiverTypeName(index, mod, sup, typeName) {
+    const trimmed = typeName.trim().replace(/^\\+/, "");
+    if (!trimmed)
+        return undefined;
+    const normalize = sup.normalizeIdentifier;
+    for (const separator of ["::", "\\", "."]) {
+        if (!trimmed.includes(separator))
+            continue;
+        const parts = trimmed.split(separator).filter(Boolean);
+        if (parts.length < 2)
+            return undefined;
+        return resolveQualifiedMemberContainer(index, mod, parts[0], parts.slice(1), normalize, sup);
+    }
+    return resolveNamedMemberContainer(index, mod, trimmed, normalize);
+}
+async function resolveDeclaredBase(index, mod, sup, base) {
+    const normalize = sup.normalizeIdentifier;
+    if (base.kind === "simple")
+        return resolveNamedMemberContainer(index, mod, base.name, normalize);
+    return resolveQualifiedMemberContainer(index, mod, base.base, base.path, normalize, sup);
+}
+/**
+ * True when `def` and every resolved supertype lack a direct `memberName`. An unresolved
+ * supertype, an unreadable declaration, or a declared member returns false.
+ */
+async function hierarchyOmitsMember(index, def, memberName, memberScope, seen) {
+    const containerDef = asMemberContainer(index, def);
+    if (!containerDef)
+        return false;
+    const start = containerDef.range.start;
+    const key = `${fileIdentityKey(containerDef.file)}:${start.index ?? `${start.line}:${start.column}`}`;
+    if (seen.has(key))
+        return true;
+    seen.add(key);
+    const ref = await keywordClassRefFromDef(index, containerDef);
+    if (!ref)
+        return false;
+    const normalize = ref.context.sup.normalizeIdentifier;
+    const memberPredicate = memberScope === "any"
+        ? undefined
+        : (local) => matchesReceiverMemberScope(local, memberScope, ref.context, ref.container);
+    if (findDirectLocalsWithinNode(ref.module.locals, memberName, ref.container, ref.context, normalize, memberPredicate)
+        .length > 0) {
+        return false;
+    }
+    if (ref.context.sup.id === "csharp" || ref.context.sup.id === "swift") {
+        const shared = await findSharedOwnerMemberDefinitions({
+            index,
+            ownerFile: containerDef.file,
+            ownerContainer: ref.container,
+            ownerSource: ref.context.source,
+            languageId: ref.context.sup.id,
+            member: memberName,
+            memberScope,
+        });
+        if (shared.length > 0)
+            return false;
+    }
+    if (containerHeritageIsUnproven(ref.container, ref.context.source, ref.context.sup))
+        return false;
+    const bases = collectDeclaredBaseTypes(ref.container, ref.context.source, ref.context.sup, false);
+    for (const base of bases) {
+        const baseDef = await resolveDeclaredBase(index, ref.module, ref.context.sup, base);
+        if (!baseDef)
+            return false;
+        if (!(await hierarchyOmitsMember(index, baseDef, memberName, memberScope, seen)))
+            return false;
+    }
+    return true;
+}
+/**
+ * A classified receiver (`new Widget()`, a named type, `this`, or `super`) excludes a failed
+ * member lookup only when its type resolves to a member-declaring definition, no supertype is
+ * unresolved, and that type does not declare `memberName`. Otherwise the site stays unproven.
+ */
+export async function provenClassifiedReceiverOmitsMember(index, fileId, parsed, accessNode, objectNode, memberName) {
+    const mod = index.byFile.get(fileIdentityKey(fileId));
+    if (!mod)
+        return false;
+    const receiver = classifyReceiver(parsed.sup, objectNode, parsed.source, new Map(), accessNode.startIndex, accessNode, (callee) => {
+        const scope = getOrBuildScopeIndex(index, fileId, parsed.source, parsed.sup, mod, parsed.tree);
+        return !!findClosestScopeBinding(scope, sliceText(callee, parsed.source), callee, parsed.sup);
+    });
+    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);
+        if (!def)
+            return false;
+        return hierarchyOmitsMember(index, def, memberName, receiver.memberScope, new Set());
+    }
+    const container = nearestMemberContainer(accessNode);
+    if (!container)
+        return false;
+    if (receiver.kind === "supertype") {
+        if (containerHeritageIsUnproven(container, parsed.source, parsed.sup))
+            return false;
+        const bases = collectDeclaredBaseTypes(container, parsed.source, parsed.sup, true);
+        if (!bases.length)
+            return false;
+        const seen = new Set();
+        for (const base of bases) {
+            const baseDef = await resolveDeclaredBase(index, mod, parsed.sup, base);
+            if (!baseDef)
+                return false;
+            if (!(await hierarchyOmitsMember(index, baseDef, memberName, receiver.memberScope, seen)))
+                return false;
+        }
+        return true;
+    }
+    const def = definitionForContainer(mod, container);
+    if (!def)
+        return false;
+    return hierarchyOmitsMember(index, def, memberName, receiver.memberScope, new Set());
+}
+async function keywordClassRefFromDef(index, def) {
+    const module = index.byFile.get(fileIdentityKey(def.file));
+    if (!module)
+        return null;
+    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);
+    if (!container)
+        return null;
+    return { file: def.file, container, context, module };
+}
+async function keywordClassRefFromNode(index, mod, node) {
+    const context = await ensureParsedContext(mod.file, undefined, index.languageExtensions);
+    const memberNode = context.tree.rootNode.descendantForPosition(node.startPosition, node.startPosition);
+    const container = findEnclosingClassContainer(memberNode);
+    if (!container)
+        return null;
+    return { file: mod.file, container, context, module: mod };
+}
+function crossFilePeerMemberHidden(useFile, memberDef, targetContext) {
+    const languageId = targetContext.sup.id;
+    if (languageId !== "java" && languageId !== "kotlin" && languageId !== "swift")
+        return false;
+    const start = memberDef.range.start;
+    const position = { row: Math.max(0, start.line - 1), column: Math.max(0, start.column - 1) };
+    const nameNode = targetContext.tree.rootNode.descendantForPosition(position, position);
+    if (!nameNode)
+        return false;
+    if (languageId === "swift") {
+        return isSwiftCrossFileHiddenSharedOwnerMember(languageId, useFile, memberDef.file, nameNode);
+    }
+    if (fileIdentityKey(useFile) === fileIdentityKey(memberDef.file))
+        return false;
+    return !isExportedDeclaration(languageId, nameNode);
+}
+async function baseRefsFromContainer(index, mod, container, source, sup, superclassOnly, tree) {
+    const bases = collectDeclaredBaseTypes(container, source, sup, superclassOnly);
+    const refs = [];
+    const seen = new Set();
+    const normalize = (name) => {
+        const normalized = sup.normalizeIdentifier(name);
+        return sup.id === "php" ? foldPhpIdentifierCase(normalized) : normalized;
+    };
+    for (const base of bases) {
+        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;
+        }
+        if (!def)
+            continue;
+        const ref = await keywordClassRefFromDef(index, def);
+        if (!ref)
+            continue;
+        // `super`, `base`, and `parent` follow class ancestors only. An own receiver also inherits
+        // interface or protocol members, so apply the class-only filter only to supertype lookup.
+        const interfaceLike = ref.container.type === "interface_declaration" ||
+            ref.container.type === "protocol_declaration" ||
+            ref.container.type === "trait_item" ||
+            /^(?:interface|protocol|trait)\b/.test(sliceText(ref.container, ref.context.source).trimStart());
+        if (superclassOnly && (def.kind !== SymbolKind.Class || interfaceLike))
+            continue;
+        // Kotlin classifies interfaces as SymbolKind.Class too, so the superclass is identified
+        // syntactically: `Base()` is a constructor invocation, while bare delegation-specifier
+        // entries (`Face`, `by` delegations) are interfaces. Interface-only super lookup stays
+        // unresolved, while an own receiver can inherit their default members.
+        if (superclassOnly && sup.id === "kotlin" && !base.invoked)
+            continue;
+        const key = keywordClassKey(def);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        refs.push(ref);
+    }
+    return refs;
+}
+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;
+    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 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) {
+        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 (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");
+                        }
+                    }
+                }
+            }
+            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;
+            }
+            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;
+                seen.add(baseKey);
+                next.push(base);
+            }
+        }
+        if (nameFound && !spansHierarchy && !preloadHiddenNames)
+            break;
+        level = next;
+    }
+    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 selected.status === "unique" ? selected.member : undefined;
+}
+/** The parameter list of a Java, Kotlin, or C# method declaration. */
+async function memberParameterList(index, def) {
+    const context = await ensureParsedContext(def.file, index.parsed?.get(fileIdentityKey(def.file)), index.languageExtensions).catch(() => null);
+    const start = def.range.start.index;
+    if (!context || start === undefined)
+        return null;
+    const declaration = context.tree.rootNode.descendantForIndex(start, def.range.end.index ?? start).parent;
+    return (declaration?.childForFieldName("parameters") ??
+        declaration?.namedChildren.find((child) => child.type === "function_value_parameters") ??
+        null);
+}
+/** Parameter type texts of a Java, Kotlin, or C# method; null when a type cannot be read. */
+async function memberParameterTypes(index, def) {
+    const parameters = await memberParameterList(index, def);
+    if (!parameters)
+        return null;
+    const types = [];
+    for (const parameter of parameters.namedChildren) {
+        const type = parameter.childForFieldName("type") ?? parameter.namedChildren.at(-1);
+        if (!type)
+            return null;
+        types.push(type.text.replace(/\s+/g, ""));
+    }
+    return types;
+}
+/** The import that binds a type name in a module, as text; empty when no import binds it. */
+function importedTypeSource(module, name) {
+    for (const imp of module.imports) {
+        if (imp.kind !== "named" || imp.local !== name)
+            continue;
+        const target = typeof imp.resolved === "string" ? imp.resolved : (imp.resolved?.external ?? "");
+        return `${target}:${imp.imported}`;
+    }
+    return "";
+}
+/** Type parameter names declared by a method or any type enclosing it. */
+async function typeParameterNamesAround(index, def) {
+    const names = new Set();
+    const context = await ensureParsedContext(def.file, index.parsed?.get(fileIdentityKey(def.file)), index.languageExtensions).catch(() => null);
+    const start = def.range.start.index;
+    if (!context || start === undefined)
+        return names;
+    let current = context.tree.rootNode.descendantForIndex(start, def.range.end.index ?? start);
+    for (; current; current = current.parent) {
+        const parameters = current.childForFieldName("type_parameters") ??
+            current.namedChildren.find((child) => child.type === "type_parameters" || child.type === "type_parameter_list");
+        if (!parameters)
+            continue;
+        for (const parameter of parameters.namedChildren) {
+            const name = parameter.childForFieldName("name") ??
+                parameter.namedChildren.find((child) => /identifier/u.test(child.type)) ??
+                (/identifier/u.test(parameter.type) ? parameter : null);
+            if (name)
+                names.add(name.text);
+        }
+    }
+    return names;
+}
+/** Built-in parameter types whose spelling names one type in every file. */
+const BUILTIN_PARAMETER_TYPES = {
+    java: new Set([
+        "int",
+        "long",
+        "short",
+        "byte",
+        "char",
+        "boolean",
+        "float",
+        "double",
+        "String",
+        "Object",
+        "Integer",
+        "Long",
+        "Boolean",
+        "Double",
+        "Float",
+        "Short",
+        "Byte",
+        "Character",
+    ]),
+    kotlin: new Set(["Int", "Long", "Short", "Byte", "Char", "Boolean", "Float", "Double", "String", "Any", "Unit"]),
+    csharp: new Set([
+        "int",
+        "long",
+        "short",
+        "byte",
+        "char",
+        "bool",
+        "float",
+        "double",
+        "decimal",
+        "string",
+        "object",
+        "uint",
+        "ulong",
+        "ushort",
+        "sbyte",
+    ]),
+};
+/**
+ * Whether two methods take the same parameter types, so the one in a derived class overrides the
+ * 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.
+ */
+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([
+        typeParameterNamesAround(index, left),
+        typeParameterNamesAround(index, right),
+    ]);
+    const [leftTypes, rightTypes] = await Promise.all([
+        memberParameterTypes(index, left),
+        memberParameterTypes(index, right),
+    ]);
+    if (!leftTypes || !rightTypes || leftTypes.length !== rightTypes.length)
+        return false;
+    const sameFile = fileIdentityKey(left.file) === fileIdentityKey(right.file);
+    const leftContext = await ensureParsedContext(left.file, index.parsed?.get(fileIdentityKey(left.file)), index.languageExtensions).catch(() => null);
+    if (!leftContext)
+        return false;
+    for (let at = 0; at < leftTypes.length; at += 1) {
+        const text = leftTypes[at];
+        if (text !== rightTypes[at])
+            return false;
+        const typeNames = text.match(/[\p{L}_][\p{L}\p{N}_]*/gu) ?? [];
+        if (typeNames.some((typeName) => leftGenerics.has(typeName) || rightGenerics.has(typeName)))
+            return false;
+        // One Java or Kotlin file declares one package; a C# file can open several namespaces, so the
+        // same spelling there still needs resolution.
+        if (sameFile && leftContext.sup.id !== "csharp")
+            continue;
+        const base = text
+            .replace(/<.*$/su, "")
+            .replace(/[?\[\].]+$/u, "")
+            .split(".")
+            .pop() ?? text;
+        if (BUILTIN_PARAMETER_TYPES[leftContext.sup.id]?.has(base))
+            continue;
+        const rightContext = await ensureParsedContext(right.file, index.parsed?.get(fileIdentityKey(right.file)), index.languageExtensions).catch(() => null);
+        const leftModule = index.byFile.get(fileIdentityKey(left.file));
+        const rightModule = index.byFile.get(fileIdentityKey(right.file));
+        if (!rightContext || !leftModule || !rightModule)
+            return false;
+        // Resolve at each declaration so a C# spelling reads its own namespace region.
+        const leftType = resolveNamedDefinition(index, leftModule, left.file, leftContext.sup, base, undefined, left.range.start.index);
+        const rightType = resolveNamedDefinition(index, rightModule, right.file, rightContext.sup, base, undefined, right.range.start.index);
+        if (leftType?.status !== "ok" && rightType?.status !== "ok") {
+            // Neither names a project type: both files must name it through the same import (or none).
+            if (importedTypeSource(leftModule, base) !== importedTypeSource(rightModule, base))
+                return false;
+            continue;
+        }
+        if (leftType?.status !== "ok" || rightType?.status !== "ok")
+            return false;
+        if (fileIdentityKey(leftType.definition.file) !== fileIdentityKey(rightType.definition.file) ||
+            leftType.definition.range.start.index !== rightType.definition.range.start.index) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Validate an unqualified member use against its actual lexical owner, including shared
+ * owner parts in other files and inherited members. Swift checks every bare name; C#, Java, and
+ * Kotlin check only bare call callees. A static context reaches only static members.
+ */
+/** The callee of a receiverless call (`f()`), which may name a member through the implicit `this`. */
+export function implicitSelfCallee(languageId, call) {
+    if (languageId === "csharp")
+        return call.type === "invocation_expression" ? call.childForFieldName("function") : null;
+    if (languageId === "java") {
+        if (call.type !== "method_invocation" || call.childForFieldName("object"))
+            return null;
+        return call.childForFieldName("name");
+    }
+    if (languageId === "kotlin")
+        return call.type === "call_expression" ? (call.namedChildren[0] ?? null) : null;
+    return null;
+}
+export async function resolveImplicitSelfMember(index, mod, node, name, source, languageId) {
+    const call = node.parent ?? node;
+    if (languageId !== "swift" && implicitSelfCallee(languageId, call)?.id !== node.id)
+        return undefined;
+    const jvm = languageId === "java" || languageId === "kotlin";
+    const staticScoped = languageId === "csharp" || jvm;
+    const memberScope = staticScoped && nodeInStaticMemberContext(node, source) ? "static" : "any";
+    const argumentCount = getCallArgumentCount({ languageId, source, call }) ?? undefined;
+    const report = { named: false, ambiguous: false };
+    const member = await resolveKeywordReceiverMember(index, mod, node, name, memberScope, false, argumentCount, undefined, report);
+    if (member)
+        return member;
+    // Two inherited overloads of one arity are ambiguous without type ranking; in Java and C# any
+    // inherited method of that name hides imports even when none accepts the call.
+    if (report.ambiguous || (report.named && (languageId === "java" || languageId === "csharp")))
+        return null;
+    if (memberScope !== "static" || !jvm)
+        return undefined;
+    // In a static context an inherited instance method still shadows a static import or package
+    // function; the call is invalid, so it has no target.
+    const instanceReport = { named: false, ambiguous: false };
+    const instance = await resolveKeywordReceiverMember(index, mod, node, name, "any", false, argumentCount, undefined, instanceReport);
+    // Any inherited instance method of that name hides the import, even when none applies.
+    return instance || instanceReport.named ? null : undefined;
+}
+/** 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;
+    const ownMember = !!container &&
+        fileIdentityKey(member.file) === fileIdentityKey(mod.file) &&
+        start >= container.startIndex &&
+        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);
+}
+/**
+ * Whether `Owner::member()` at `use` can reach an instance member of `owner` through an implicit
+ * `this`: the enclosing function is a non-static member function of `owner` or of a class that
+ * derives from `owner` through proven bases. Any other context can only name a static member.
+ */
+export async function cppQualifiedOwnerHasImplicitThis(index, mod, use, source, sup, owner) {
+    const definition = cppEnclosingFunctionDefinition(use);
+    if (!definition || !(await cppFunctionHasImplicitThis(index, mod, definition, source, sup)))
+        return false;
+    const outOfLinePath = cppOutOfLineOwnerPath(definition, source, sup);
+    const enclosingDef = outOfLinePath ? await resolveCppQualifiedMemberContainer(index, mod, outOfLinePath) : null;
+    const enclosing = enclosingDef
+        ? await keywordClassRefFromDef(index, enclosingDef)
+        : await keywordClassRefFromNode(index, mod, definition);
+    const target = await keywordClassRefFromDef(index, owner);
+    if (!enclosing || !target)
+        return false;
+    const targetKey = keywordContainerKey(target.file, target.container);
+    const visited = new Set();
+    let level = [enclosing];
+    for (let depth = 0; depth < RECEIVER_HIERARCHY_DEPTH && level.length; depth += 1) {
+        const next = [];
+        for (const candidate of level) {
+            const key = keywordContainerKey(candidate.file, candidate.container);
+            if (key === targetKey)
+                return true;
+            if (visited.has(key))
+                continue;
+            visited.add(key);
+            next.push(...(await baseRefsFromContainer(index, candidate.module, candidate.container, candidate.context.source, candidate.context.sup, false, candidate.context.tree)));
+        }
+        level = next;
+    }
+    return false;
+}
+/** The C++ function definition enclosing a use, if any. */
+export function cppEnclosingFunctionDefinition(node) {
+    for (let current = node.parent; current; current = current.parent) {
+        if (current.type === "function_definition")
+            return current;
+    }
+    return null;
+}
+/** Proven unqualified member call from an out-of-line C++ method definition. */
+export async function resolveCppOutOfLineImplicitMember(index, mod, node, name, source, sup, requireAcceptedArity = false) {
+    if (node.parent?.type !== "call_expression" || node.parent.childForFieldName("function")?.id !== node.id) {
+        return undefined;
+    }
+    const ownerPath = cppOutOfLineOwnerPath(node, source, sup);
+    const owner = ownerPath ? await resolveCppQualifiedMemberContainer(index, mod, ownerPath) : null;
+    if (!owner)
+        return undefined;
+    const argumentCount = getCallArgumentCount({ languageId: "cpp", source, call: node.parent }) ?? undefined;
+    const enclosingFunction = cppEnclosingFunctionDefinition(node);
+    const memberScope = enclosingFunction && (await cppFunctionHasImplicitThis(index, mod, enclosingFunction, source, sup))
+        ? "any"
+        : "static";
+    const matching = await resolveKeywordReceiverMember(index, mod, node, name, memberScope, false, argumentCount, owner);
+    // A class member hides a same-named global even when this call cannot accept its arity. The
+    // only member is still the call's target for navigation; an ambiguous overload set is not.
+    const member = matching ??
+        (argumentCount === undefined
+            ? undefined
+            : await resolveKeywordReceiverMember(index, mod, node, name, memberScope, false, undefined, owner));
+    if (!member) {
+        // In a static member function, an instance member still hides a same-named global: the call
+        // is ill-formed, so neither consumer may fall back to the global.
+        const hidden = memberScope === "static" &&
+            (await resolveKeywordReceiverMember(index, mod, node, name, "any", false, undefined, owner));
+        return hidden ? null : undefined;
+    }
+    // The call graph records no edge for a call its target cannot accept. `null` means a member hides
+    // 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 &&
+        !receiverMemberAcceptsArgumentCount(index, member, argumentCount);
+    return rejected ? null : member;
 }
 export { supportsReceiverCallEdges, supportsReceiverMemberNavigation } from "../util/member-access-tables.js";
 function memberDeclaringLocals(mod, typeName, normalize) {
     const normalized = normalize(typeName);
     return mod.locals.filter((local) => normalize(local.localName) === normalized && declaresMembers(local));
 }
-async function resolveReceiverDefinition(obj, source, sup, resolveExpression, mod) {
-    const constructor = receiverConstructorExpression(obj, source, sup);
+/**
+ * Ruby constant visible the same way go-to-definition resolves a bare `Widget`:
+ * a same-file declaration, or the class a `require` brought in. Not project-wide.
+ */
+export function resolveRubyVisibleConstant(index, mod, sup, typeName) {
+    if (sup.id !== "ruby")
+        return null;
+    const resolved = resolveNamedDefinition(index, mod, mod.file, sup, typeName);
+    if (resolved?.status !== "ok")
+        return null;
+    return declaresMembers(resolved.definition) ? resolved.definition : null;
+}
+/** Proven PHP `extends` base, using the same simple-name lookup as `parent::`. */
+function resolvePhpProvenBaseClass(index, mod, classNode, source, sup) {
+    const bases = collectDeclaredBaseTypes(classNode, source, sup, true);
+    if (bases.length !== 1)
+        return null;
+    const base = bases[0];
+    if (!base || base.kind !== "simple")
+        return null;
+    const normalize = (name) => foldPhpIdentifierCase(sup.normalizeIdentifier(name));
+    return resolveNamedMemberContainer(index, mod, base.name, normalize) ?? null;
+}
+/**
+ * Class named by `new self()`, `new static()`, or `new parent()`.
+ * `self` and `static` are the enclosing class. `parent` is the proven base.
+ * Returns null when the keyword is not proven, so a class named `Parent` cannot win.
+ */
+export function resolvePhpObjectCreationTarget(index, mod, keyword, source, sup) {
+    if (!keyword.classNode)
+        return null;
+    if (keyword.keyword === "self" || keyword.keyword === "static") {
+        return memberContainerDef(mod, keyword.classNode);
+    }
+    return resolvePhpProvenBaseClass(index, mod, keyword.classNode, source, sup);
+}
+function enclosingRubyMethod(node) {
+    let current = node.parent;
+    while (current) {
+        if (current.type === "method" || current.type === "singleton_method")
+            return current;
+        current = current.parent;
+    }
+    return null;
+}
+/** Bare `super` / `super()` targets the same-named method on a proven superclass. */
+export async function resolveRubySuperDefinition(index, mod, node, source, sup) {
+    if (sup.id !== "ruby" || node.type !== "super")
+        return undefined;
+    const method = enclosingRubyMethod(node);
+    const nameNode = method?.childForFieldName("name") ?? null;
+    if (!nameNode)
+        return undefined;
+    const member = sliceText(nameNode, source);
+    if (!member)
+        return undefined;
+    return resolveKeywordReceiverMember(index, mod, node, member, "any", true);
+}
+/** 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);
+            if (qualifiedType.length > 1) {
+                const def = await resolveCppQualifiedMemberContainer(index, mod, qualifiedType);
+                if (def) {
+                    return {
+                        def,
+                        memberScope: hasStaticMemberDistinction(sup.id) ? "instance" : "any",
+                    };
+                }
+            }
+        }
         const typeName = sliceText(constructor, source);
         const typedLocals = memberDeclaringLocals(mod, typeName, sup.normalizeIdentifier);
         if (typedLocals.length === 1) {
@@ -224,13 +2038,42 @@ async function resolveReceiverDefinition(obj, source, sup, resolveExpression, mo
                 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);
+            if (namedContainer) {
+                return {
+                    def: namedContainer,
+                    memberScope: hasStaticMemberDistinction(sup.id) ? "instance" : "any",
+                };
+            }
+        }
         const result = await resolveExpression(constructor);
-        if (result?.kind === "resolved" && declaresMembers(result.def)) {
+        const constructed = result?.kind === "resolved" ? asMemberContainer(index, result.def) : undefined;
+        if (constructed) {
             return {
-                def: result.def,
+                def: constructed,
                 memberScope: hasStaticMemberDistinction(sup.id) ? "instance" : "any",
             };
         }
+        // Ruby `require` exposes a class as a namespace import. A bare constant already
+        // resolves through resolveNamedDefinition; `Klass.new` must use that same path
+        // so goto, references, and call edges agree. Same-file classes returned above.
+        if (sup.id === "ruby" && typedLocals.length === 0) {
+            const rubyType = resolveRubyVisibleConstant(index, mod, sup, typeName);
+            if (rubyType) {
+                return {
+                    def: rubyType,
+                    memberScope: hasStaticMemberDistinction(sup.id) ? "instance" : "any",
+                };
+            }
+        }
         if (typedLocals[0]) {
             return {
                 def: typedLocals[0],
@@ -238,13 +2081,19 @@ async function resolveReceiverDefinition(obj, source, sup, resolveExpression, mo
             };
         }
     }
-    const direct = await resolveExpression(obj);
-    if (direct?.kind === "resolved" && declaresMembers(direct.def)) {
-        if (isJsTsLanguage(sup.id) && direct.def.kind === SymbolKind.TypeAlias) {
-            return { def: direct.def, memberScope: "any", runtimeTypeOnly: true };
+    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) {
+            return { def: directContainer, memberScope: "any", runtimeTypeOnly: true };
         }
-        const memberScope = hasStaticMemberDistinction(sup.id) ? "static" : "any";
-        return { def: direct.def, memberScope };
+        const memberScope = supportsStaticMemberScope(sup.id) ? "static" : "any";
+        return { def: directContainer, memberScope };
     }
     if (isJsTsLanguage(sup.id) && isReceiverNameNode(sup, obj.type)) {
         return null;
@@ -254,7 +2103,25 @@ async function resolveReceiverDefinition(obj, source, sup, resolveExpression, mo
     }
     return null;
 }
-async function resolveMemberDefinitionForBase(index, baseDef, member) {
+/** Whether a type-qualified access (`Util.M`) can name `def`: a nested type or a static member. */
+async function reachableThroughTypeName(index, def) {
+    if (declaresMembers(def))
+        return true;
+    const context = await ensureParsedContext(def.file, index.parsed?.get(fileIdentityKey(def.file)), index.languageExtensions);
+    const nameNode = nameNodeForDef(context, def);
+    if (!nameNode)
+        return false;
+    return hasStaticModifier(def, context, nearestMemberContainer(nameNode) ?? context.tree.rootNode);
+}
+/**
+ * A member declared directly in the type `baseDef` names (`Util.Two`), including the other parts
+ * of a C# partial type, or inherited through it. Same-named overloads are narrowed to members a
+ * type name reaches (static members and nested types) when the base is a type, then chosen by
+ * the call's argument count; without a count, or when several accept it, the lookup is
+ * ambiguous. A sole reachable candidate is kept even when the count does not fit, as for other
+ * calls; the graph records no edge for it. Ruby reopens a method by redefining it, so it keeps the first match.
+ */
+async function resolveMemberDefinitionForBase(index, baseDef, member, knownArgumentCount) {
     const targetContext = await ensureParsedContext(baseDef.file, undefined, index.languageExtensions);
     const start = baseDef.range.start;
     const targetPosition = {
@@ -268,37 +2135,169 @@ async function resolveMemberDefinitionForBase(index, baseDef, member) {
     const targetModule = index.byFile.get(fileIdentityKey(baseDef.file));
     if (!targetModule)
         return undefined;
+    const languageId = targetContext.sup.id;
     const normalizeIdentifier = targetContext.sup.normalizeIdentifier;
-    const directHit = findDirectLocalWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier);
-    if (directHit)
-        return directHit;
-    if (targetContext.sup.id === "java")
+    const candidates = findDirectLocalsWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier);
+    if (languageId === "csharp") {
+        const partialParts = await findSharedOwnerMemberDefinitions({
+            index,
+            ownerFile: baseDef.file,
+            ownerContainer: container,
+            ownerSource: targetContext.source,
+            languageId,
+            member,
+        });
+        for (const hit of partialParts) {
+            if (!candidates.includes(hit))
+                candidates.push(hit);
+        }
+    }
+    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);
+            }
+        }
+        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 (languageId === "java")
         return undefined;
-    return findReceiverMemberDefinition(targetModule.locals, member, baseDef, container, targetContext, normalizeIdentifier);
+    return await findReceiverMemberDefinition(index, targetModule.locals, member, baseDef, container, targetContext, normalizeIdentifier);
+}
+function typescriptMergedInterfaceMemberCandidates(locals, member, receiverDef, container, targetContext, normalizeIdentifier, predicate) {
+    const matches = findDirectLocalsWithinNode(locals, member, container, targetContext, normalizeIdentifier, predicate);
+    if (!isJsTsLanguage(targetContext.sup.id) || container.type !== "interface_declaration")
+        return matches;
+    const receiverStart = receiverDef.range.start.index ?? 0;
+    const receiverEnd = receiverDef.range.end.index ?? receiverStart;
+    const receiverContainerKey = typescriptCallableContainerKey(targetContext.tree, receiverStart, receiverEnd);
+    const seenBodies = new Set();
+    const appendMembers = (interfaceDeclaration) => {
+        const body = interfaceDeclaration.childForFieldName("body");
+        if (!body)
+            return;
+        const bodyKey = typescriptCallableContainerKey(targetContext.tree, body.startIndex, body.endIndex);
+        if (seenBodies.has(bodyKey))
+            return;
+        seenBodies.add(bodyKey);
+        for (const candidate of findDirectLocalsWithinNode(locals, member, interfaceDeclaration, targetContext, normalizeIdentifier, predicate)) {
+            if (!matches.includes(candidate))
+                matches.push(candidate);
+        }
+    };
+    const normalizedReceiverName = normalizeIdentifier(receiverDef.localName);
+    for (const local of locals) {
+        if (normalizeIdentifier(local.localName) !== normalizedReceiverName)
+            continue;
+        const start = local.range.start.index;
+        if (start === undefined)
+            continue;
+        const end = local.range.end.index ?? start;
+        if (typescriptCallableContainerKey(targetContext.tree, start, end) !== receiverContainerKey)
+            continue;
+        const nameNode = targetContext.tree.rootNode.descendantForIndex(start, end);
+        const interfaceDeclaration = nameNode.parent;
+        if (interfaceDeclaration?.type !== "interface_declaration")
+            continue;
+        appendMembers(interfaceDeclaration);
+    }
+    return matches;
+}
+/** Same-name namespace reopenings, excluding members of a decoy namespace or nested owner. */
+export function findTypeScriptNamespaceMemberCandidates(locals, member, receiverDef, context) {
+    if (!isJsTsLanguage(context.sup.id))
+        return [];
+    const containers = typescriptMergedNamespaceContainers(context.tree, locals, receiverDef);
+    const matches = [];
+    for (const container of containers) {
+        for (const candidate of findDirectLocalsWithinNode(locals, member, container, context, context.sup.normalizeIdentifier)) {
+            if (!matches.includes(candidate))
+                matches.push(candidate);
+        }
+    }
+    return matches;
 }
-function findReceiverMemberDefinition(locals, member, receiverDef, container, targetContext, normalizeIdentifier, memberScope = "any") {
+async function findReceiverMemberDefinition(index, locals, member, receiverDef, container, targetContext, normalizeIdentifier, memberScope = "any", knownArgumentCount) {
     const memberPredicate = memberScope === "any"
         ? undefined
         : (local) => matchesReceiverMemberScope(local, memberScope, targetContext, container);
-    const containerHit = memberScope === "any"
-        ? findLocalWithinNode(locals, member, container, normalizeIdentifier)
-        : findDirectLocalWithinNode(locals, member, container, targetContext, normalizeIdentifier, memberPredicate);
-    if (containerHit)
-        return containerHit;
+    if ((targetContext.sup.id === "ts" || targetContext.sup.id === "tsx") &&
+        (container.type === "internal_module" || container.type === "module")) {
+        const candidates = findTypeScriptNamespaceMemberCandidates(locals, member, receiverDef, targetContext);
+        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") {
+        const shared = await findSharedOwnerMemberDefinitions({
+            index,
+            ownerFile: receiverDef.file,
+            ownerContainer: container,
+            ownerSource: targetContext.source,
+            languageId: targetContext.sup.id,
+            member,
+            memberScope,
+        });
+        for (const hit of shared) {
+            if (!allReceiverMatches.includes(hit))
+                allReceiverMatches.push(hit);
+        }
+    }
+    if (allReceiverMatches.length) {
+        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 implNode = findRustImplForType(targetContext.tree.rootNode, receiverDef.localName, targetContext.source);
-        return implNode ? findLocalWithinNode(locals, member, implNode, normalizeIdentifier) : undefined;
+        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) {
+            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;
 }
-function findLocalWithinNode(locals, member, node, normalizeIdentifier = (name) => name, predicate) {
+function findLocalsWithinNode(locals, member, node, normalizeIdentifier = (name) => name, predicate) {
     const containerStart = node.startIndex;
     const containerEnd = node.endIndex;
     const normalizedMember = normalizeIdentifier(member);
-    return locals.find((local) => {
+    return locals.filter((local) => {
         const startIndex = local.range.start.index;
         const endIndex = local.range.end.index;
         return (normalizeIdentifier(local.localName) === normalizedMember &&
@@ -314,22 +2313,50 @@ function matchesReceiverMemberScope(local, memberScope, targetContext, container
         return true;
     return hasStaticModifier(local, targetContext, container) === (memberScope === "static");
 }
-function nodeDeclaresStatic(node, source) {
-    if (node.type === "static" || node.type === "static_modifier")
+/**
+ * Whether a member found for a receiverless call can accept that call's argument count. Unknown
+ * counts and unknown arities accept.
+ */
+export function memberAcceptsCallAt(index, member, callee, source, languageId) {
+    const argumentCount = getCallArgumentCount({ languageId, source, call: callee.parent ?? callee });
+    if (argumentCount === null)
         return true;
-    if (node.type === "storage_class_specifier" || node.type === "modifier" || node.type === "property_modifier") {
-        return sliceText(node, source).trim() === "static";
-    }
-    if (node.type === "modifiers") {
-        for (let childIndex = 0;; childIndex += 1) {
-            const child = node.child(childIndex);
-            if (!child)
-                break;
-            if (nodeDeclaresStatic(child, source))
-                return true;
-        }
-    }
-    return false;
+    return receiverMemberAcceptsArgumentCount(index, member, argumentCount) !== false;
+}
+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);
+}
+/** 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 = {
@@ -337,19 +2364,21 @@ function hasStaticModifier(local, targetContext, container) {
         column: local.range.start.column - 1,
     };
     let current = targetContext.tree.rootNode.descendantForPosition(position, position);
+    if (declarationIsStaticEquivalent(targetContext.sup.id, current))
+        return true;
     while (current && current !== container) {
-        for (let childIndex = 0;; childIndex += 1) {
-            const child = current.child(childIndex);
-            if (!child)
-                break;
-            if (nodeDeclaresStatic(child, targetContext.source))
-                return true;
-        }
+        if (targetContext.sup.id === "php" && (current.type === "const_declaration" || current.type === "enum_case"))
+            return true;
+        if (declarationNodeIsStatic(current, targetContext.source))
+            return true;
         current = current.parent;
     }
     return false;
 }
 const NESTED_MEMBER_LOCAL_CONTAINERS = new Set([
+    "formal_parameters",
+    "parameter_list",
+    "parameters",
     "block",
     "class",
     "class_declaration",
@@ -368,14 +2397,22 @@ const NESTED_MEMBER_LOCAL_CONTAINERS = new Set([
     "module",
     "statement_block",
 ]);
-function findDirectLocalWithinNode(locals, member, container, targetContext, normalizeIdentifier, predicate) {
+function matchesReceiverMemberName(local, normalizedMember, targetContext, normalizeIdentifier) {
+    const localName = normalizeIdentifier(local.localName);
+    if (targetContext.sup.id === "php") {
+        return comparePhpReferenceNames(normalizedMember, localName, { symbolKind: local.kind }) === "equivalent";
+    }
+    return localName === normalizedMember;
+}
+function findDirectLocalsWithinNode(locals, member, container, targetContext, normalizeIdentifier, predicate) {
+    const matches = [];
     const containerStart = container.startIndex;
     const containerEnd = container.endIndex;
     const normalizedMember = normalizeIdentifier(member);
     for (const local of locals) {
         const startIndex = local.range.start.index;
         const endIndex = local.range.end.index;
-        if (normalizeIdentifier(local.localName) !== normalizedMember ||
+        if (!matchesReceiverMemberName(local, normalizedMember, targetContext, normalizeIdentifier) ||
             startIndex === undefined ||
             endIndex === undefined ||
             startIndex < containerStart ||
@@ -391,8 +2428,18 @@ function findDirectLocalWithinNode(locals, member, container, targetContext, nor
         let isDeclarationParent = true;
         while (current && current !== container) {
             const isDirectBody = (current.type === "statement_block" || current.type === "block") && current.parent === container;
+            // A transparent container (Kotlin's `companion object`) donates its body's members to its
+            // own enclosing class; the grammar never lets one nest under any other declaration, so its
+            // body never counts as evidence of a foreign nested class here.
+            const isTransparentBody = current.type === "class_body" &&
+                !!current.parent &&
+                TRANSPARENT_MEMBER_CONTAINER_TYPES[current.parent.type] === true;
+            const definingDeclarator = current.type === "function_definition" ? current.childForFieldName("declarator") : null;
+            const isOwnFunctionDeclaration = !!definingDeclarator && definingDeclarator.startIndex <= startIndex && definingDeclarator.endIndex >= endIndex;
             if (!isDeclarationParent &&
                 !isDirectBody &&
+                !isOwnFunctionDeclaration &&
+                !isTransparentBody &&
                 ((current.type === "class_body" && current.parent !== container) ||
                     NESTED_MEMBER_LOCAL_CONTAINERS.has(current.type))) {
                 current = null;
@@ -402,30 +2449,196 @@ function findDirectLocalWithinNode(locals, member, container, targetContext, nor
             current = current.parent;
         }
         if (current && (!predicate || predicate(local)))
-            return local;
+            matches.push(local);
     }
-    return undefined;
+    return matches;
 }
-function findRustImplForType(root, typeName, source) {
-    let found = null;
-    const visit = (node) => {
-        if (node.type === "impl_item") {
-            const text = sliceText(node, source);
-            if (new RegExp(`^\\s*impl\\s+${escapeRegExp(typeName)}\\b`).test(text)) {
-                found = node;
-                return false;
-            }
+function appendDirectKeywordMembers(locals, member, container, targetContext, normalizeIdentifier, predicate, matches) {
+    const containerStart = container.startIndex;
+    const containerEnd = container.endIndex;
+    const normalizedMember = normalizeIdentifier(member);
+    for (const local of locals) {
+        const startIndex = local.range.start.index;
+        const endIndex = local.range.end.index;
+        if (!matchesReceiverMemberName(local, normalizedMember, targetContext, normalizeIdentifier) ||
+            startIndex === undefined ||
+            endIndex === undefined ||
+            startIndex < containerStart ||
+            endIndex > containerEnd) {
+            continue;
         }
-        for (const child of node.namedChildren) {
-            if (!visit(child))
-                return false;
+        const start = local.range.start;
+        const position = {
+            row: start.line - 1,
+            column: start.column - 1,
+        };
+        const declarationNode = targetContext.tree.rootNode.descendantForPosition(position, position);
+        if (!isDirectKeywordMemberDeclaration(declarationNode, container) || (predicate && !predicate(local))) {
+            continue;
         }
+        matches.push(local);
+    }
+}
+const SWIFT_PARAMETER_OWNER_TYPES = {
+    init_declaration: true,
+    function_declaration: true,
+    deinit_declaration: true,
+    subscript_declaration: true,
+    lambda_literal: true,
+    protocol_function_declaration: true,
+};
+/**
+ * Swift parameters and function-body locals share the type's byte span, but
+ * `self.name` names the member. A parameter or local that shadows the bare name
+ * is not a member candidate. Only `simple_identifier` names are Swift.
+ */
+function isSwiftShadowingNonMember(declarationNode) {
+    if (declarationNode.type !== "simple_identifier")
+        return false;
+    let current = declarationNode.parent;
+    while (current) {
+        if (current.type === "parameter" && current.parent && SWIFT_PARAMETER_OWNER_TYPES[current.parent.type]) {
+            return true;
+        }
+        if (current.type === "function_body" ||
+            current.type === "lambda_literal" ||
+            current.type === "computed_property" ||
+            current.type === "willset_didset_block") {
+            return true;
+        }
+        if (current.type === "class_declaration" ||
+            current.type === "protocol_declaration" ||
+            current.type === "enum_class_body") {
+            return false;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+/** Parameter lists whose entries are locals of the function, not members of its type. */
+const PARAMETER_LIST_TYPES = new Set([
+    "formal_parameters",
+    "parameter_list",
+    "parameters",
+    "function_value_parameters",
+]);
+/**
+ * A parameter that also declares a property of the enclosing type: a TypeScript parameter
+ * property (`constructor(readonly path: string)`) or a PHP promoted constructor property.
+ */
+function isPropertyParameter(declarationNode, list) {
+    let parameter = declarationNode;
+    while (parameter && parameter.parent !== list)
+        parameter = parameter.parent;
+    if (!parameter)
+        return false;
+    if (parameter.type === "property_promotion_parameter")
         return true;
+    return parameter.namedChildren.some((child) => child.type === "accessibility_modifier" || child.type === "override_modifier" || child.text === "readonly");
+}
+export function isDirectKeywordMemberDeclaration(declarationNode, container) {
+    if (isSwiftShadowingNonMember(declarationNode))
+        return false;
+    if (nearestMemberContainer(declarationNode) !== container)
+        return false;
+    let functionDepth = 0;
+    let current = declarationNode;
+    while (current && current !== container) {
+        // Swift local functions can nest inside a member; only the outer function is a member.
+        if (current.type === "function_declaration" && ++functionDepth > 1)
+            return false;
+        const isMethodBody = (current.type === "block" || current.type === "compound_statement" || current.type === "statement_block") &&
+            current.parent !== container;
+        if (isMethodBody)
+            return false;
+        // A method parameter is a local of that method, unless it also declares a property.
+        if (PARAMETER_LIST_TYPES.has(current.type))
+            return isPropertyParameter(declarationNode, current);
+        current = current.parent;
+    }
+    return current === container;
+}
+/**
+ * Every Rust `impl` block whose self type is `typeName`, across inherent (`impl Circle`),
+ * trait (`impl Shape for Circle`), and generic (`impl<T> Box<T>`) forms. The shared
+ * self-type extraction keeps navigation and detailed-graph member ownership in agreement.
+ */
+function findRustImplsForType(root, typeName, source, sup) {
+    const normalized = sup.normalizeIdentifier(typeName);
+    const found = [];
+    const visit = (node) => {
+        if (node.type === "impl_item") {
+            const selfType = rustImplSelfTypeNode(node, sup);
+            if (selfType && sup.normalizeIdentifier(sliceText(selfType, source)) === normalized)
+                found.push(node);
+        }
+        for (const child of node.namedChildren)
+            visit(child);
     };
     visit(root);
     return found;
 }
-const GO_EMBED_DEPTH = 16;
+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)
@@ -487,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;
         }
@@ -499,47 +2713,105 @@ function goMethodsNamedOnType(locals, member, typeName, targetContext, normalize
     visit(targetContext.tree.rootNode);
     return matches;
 }
-function findGoReceiverMember(locals, member, typeName, targetContext, normalizeIdentifier) {
-    const visited = new Set();
-    let level = [typeName];
-    for (let depth = 0; depth < GO_EMBED_DEPTH && level.length; depth += 1) {
-        const matches = [];
+/**
+ * Kotlin extension functions declared `fun Type.member()` for a receiver type, searched across
+ * the receiver type's own declaring file the same way `goMethodsNamedOnType` searches Go's file
+ * for a receiver method. An ordinary class member never carries a receiver-type prefix, so this
+ * never matches a real member and cannot shadow one.
+ */
+function kotlinExtensionFunctionsNamedOnType(locals, member, typeName, targetContext, normalizeIdentifier) {
+    const matches = [];
+    const normalizedType = normalizeIdentifier(typeName);
+    const visit = (node) => {
+        if (node.type === "function_declaration") {
+            const receiverType = kotlinExtensionReceiverTypeNode(node, targetContext.sup);
+            if (receiverType && normalizeIdentifier(sliceText(receiverType, targetContext.source)) === normalizedType) {
+                for (const local of findLocalsWithinNode(locals, member, node, normalizeIdentifier)) {
+                    if (!matches.includes(local))
+                        matches.push(local);
+                }
+            }
+            return;
+        }
+        for (const child of node.namedChildren)
+            visit(child);
+    };
+    visit(targetContext.tree.rootNode);
+    return matches;
+}
+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 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;
 }
-const PYTHON_SUPERTYPE_DEPTH = 16;
 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, sup, resolveExpression) {
-    const classRef = await pythonReceiverClassRef(index, mod, node, obj, source, 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, member);
+    return lookupPythonClassMember(index, classRef.ref, member, classRef.startAtSupertype);
 }
-async function pythonReceiverClassRef(index, mod, node, obj, source, sup, resolveExpression) {
-    const receiverName = sliceText(obj, source);
-    if (receiverName === "self" || receiverName === "cls") {
+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;
@@ -559,10 +2831,11 @@ async function pythonReceiverClassRef(index, mod, node, obj, source, sup, resolv
         });
         if (!def)
             return null;
-        return pythonClassRefFromDef(index, def);
+        const ref = await pythonClassRefFromDef(index, def);
+        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) {
@@ -577,7 +2850,8 @@ async function pythonReceiverClassRef(index, mod, node, obj, source, sup, resolv
     }
     if (!classDef)
         return null;
-    return pythonClassRefFromDef(index, classDef);
+    const ref = await pythonClassRefFromDef(index, classDef);
+    return ref ? { ref, startAtSupertype: false } : null;
 }
 async function pythonClassRefFromDef(index, def) {
     const module = index.byFile.get(fileIdentityKey(def.file));
@@ -599,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);
@@ -626,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") ??
@@ -664,17 +2938,15 @@ function resolvePythonNamedClass(index, mod, name) {
         return candidates[0];
     if (candidates.length > 1)
         return undefined;
-    for (const imp of mod.imports) {
-        if (imp.kind === "named" && imp.local === name) {
-            const result = resolveImported(index, imp, imp.imported);
-            if (result && !("namespace" in result) && result.kind === SymbolKind.Class)
-                return result;
-        }
-        if (imp.kind === "star") {
-            const result = resolveImported(index, imp, name);
-            if (result && !("namespace" in result) && result.kind === SymbolKind.Class)
-                return result;
-        }
+    const explicitBinding = effectiveExplicitBinding(mod.imports, "python", (binding) => binding.kind === "named" && binding.local === name);
+    if (explicitBinding?.kind === "named") {
+        const result = resolveImported(index, explicitBinding, explicitBinding.imported);
+        if (result && !("namespace" in result) && result.kind === SymbolKind.Class)
+            return result;
+    }
+    const starDecision = resolveStarImportedName(index, mod, "python", name);
+    if (starDecision.status === "resolved") {
+        return starDecision.definition.kind === SymbolKind.Class ? starDecision.definition : undefined;
     }
     const exported = resolveExport(index, mod.file, name, { preferredKind: SymbolKind.Class, allowLocalFallback: false });
     if (exported?.kind === "resolved" && exported.def.kind === SymbolKind.Class)
@@ -699,33 +2971,26 @@ async function pythonBaseClassRefs(index, classRef) {
     }
     return refs;
 }
-async function lookupPythonClassMember(index, start, member) {
-    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))]);
-    for (let depth = 0; depth < PYTHON_SUPERTYPE_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);
-            }
+async function lookupPythonClassMember(index, start, member, startAtSupertype = false) {
+    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) {
+        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 (matches.length === 1)
-            return matches[0];
-        if (matches.length > 1)
-            return undefined;
+        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;
@@ -735,9 +3000,23 @@ async function lookupPythonClassMember(index, start, member) {
         }
         level = next;
     }
-    return undefined;
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    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