@lzehrung/codegraph 2.3.31 → 2.4.0

package/dist/indexer/navigation-goto.js

@@ -1,16 +1,405 @@
+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, receiverKeywordText, } from "../util/member-access.js";
+import { keywordReceiverKind, MEMBER_ACCESS_ROWS, supportsReceiverMemberNavigation, } from "../util/member-access-tables.js";
+import { cppCallableShapeForNode } from "./cpp-callables.js";
+import { typescriptCallableContainerKey, typescriptMergedNamespaceContainers, typescriptSelectOverloadCandidate, } from "./ts-callables.js";
+import { effectiveExplicitBinding, isExpandedStarBinding, resolveStarImportedName, resolveStarImportedNamespace, starImportPrecedence, } from "./star-import-precedence.js";
+import { classifyReceiver, cppOutOfLineOwnerPath, cppQualifiedNameSegments, declarationIsStaticEquivalent, declarationNodeIsStatic, declaresMembers, hasStaticMemberDistinction, memberContainerDef, nearestMemberContainer, keywordReceiverCrossesDynamicBoundary, isUnprovenHeritageExpression, keywordReceiverMemberScope, kotlinExtensionReceiverTypeNode, csharpDottedNameRoot, nodeInStaticMemberContext, importTypeQuerySpecifier, receiverConstructorExpression, rustImplSelfTypeNode, supportsStaticMemberScope, TRANSPARENT_MEMBER_CONTAINER_TYPES, unwrapNamedType, } from "../graphs/symbol-graph-detailed/receiver-calls.js";
+import { CALLABLE_DECLARATION_NODE_TYPES, getCallableArity, getCallArgumentCount, memberLookupBinding, } from "../languages/callable-arity.js";
+import { getCompilationUnitPeers } from "./compilation-units.js";
+import { isExportedDeclaration, isPrivateDeclaration, isGoExportedMemberName, isSwiftCrossFileHiddenSharedOwnerMember, } from "./declaration-visibility.js";
 import { 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 { SymbolKind, } from "./types.js";
+/**
+ * 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",
+    });
+}
 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 +415,143 @@ 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;
+                }
                 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;
@@ -75,15 +561,24 @@ export async function resolveMemberAccessDefinition(params) {
             if (subObj && subProp) {
                 const base = await resolveExpression(subObj);
                 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 === "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 };
@@ -105,7 +600,7 @@ export async function resolveMemberAccessDefinition(params) {
                     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;
                 }
             }
@@ -134,11 +629,11 @@ 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)) {
+    const receiverKind = keywordReceiverKind(sup.id, receiverName);
+    if (obj && prop && node.id === prop.id && supportsReceiverMemberNavigation(sup.id)) {
         const member = sliceText(prop, source);
         if (sup.id === "python") {
-            const memberDef = await resolvePythonReceiverMember(index, mod, node, obj, member, source, sup, resolveExpression);
+            const memberDef = await resolvePythonReceiverMember(index, mod, node, obj, member, source, tree, sup, resolveExpression);
             if (!memberDef)
                 return null;
             return okGoToResult(index, memberDef, {
@@ -147,11 +642,12 @@ 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;
+        if (receiverKind && keywordReceiverCrossesDynamicBoundary(sup, node)) {
+            return null;
+        }
+        const keywordScope = receiverKind ? keywordReceiverMemberScope(sup, receiverName, node, source) : "any";
+        if (receiverKind === "own") {
+            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 +655,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" };
         }
-        const receiver = await resolveReceiverDefinition(obj, source, sup, resolveExpression, mod);
+        else if (receiverKind === "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 importType = isJsTsLanguage(sup.id) ? receiverConstructorExpression(obj, source, sup) : 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);
         if (receiver) {
             const objDef = receiver.def;
             const targetContext = await ensureParsedContext(objDef.file, undefined, index.languageExtensions);
@@ -185,37 +747,1030 @@ 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);
+                    if ((targetContext.sup.id === "ts" || targetContext.sup.id === "tsx") &&
+                        (container.type === "internal_module" || container.type === "module")) {
+                        memberDef = await findReceiverMemberDefinition(index, targetModule.locals, member, objDef, container, targetContext, normalizeIdentifier, receiver.memberScope, knownArgumentCount);
+                    }
+                    else if (receiver.runtimeTypeOnly || targetContext.sup.id === "java") {
+                        const candidates = findDirectLocalsWithinNode(targetModule.locals, member, container, targetContext, normalizeIdentifier, memberPredicate);
+                        memberDef = await selectReceiverMemberCandidates(index, candidates, knownArgumentCount);
                     }
                     else {
-                        memberDef = findReceiverMemberDefinition(targetModule.locals, member, objDef, container, targetContext, normalizeIdentifier, receiver.memberScope);
+                        memberDef = await findReceiverMemberDefinition(index, targetModule.locals, member, objDef, container, targetContext, normalizeIdentifier, receiver.memberScope, knownArgumentCount);
+                    }
+                    if (memberDef &&
+                        (sup.id === "cpp" ||
+                            isGoExportedMemberName(sup.id, member) ||
+                            getCompilationUnitPeers(index, mod.file).files.has(memberDef.file)) &&
+                        !crossFilePeerMemberHidden(mod.file, memberDef, targetContext)) {
+                        return okGoToResult(index, memberDef, {
+                            via: { exportedName: member },
+                            resolution: "member-access",
+                            confidence: "medium",
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return null;
+}
+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)
+        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 && 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;
+}
+const HIERARCHY_OVERLOAD_LANGUAGES = new Set(["java", "kotlin", "csharp"]);
+async function resolveKeywordReceiverMember(index, mod, node, member, memberScope, startAtAncestor, knownArgumentCount, explicitClassDef, report) {
+    const current = explicitClassDef
+        ? await keywordClassRefFromDef(index, explicitClassDef)
+        : await keywordClassRefFromNode(index, mod, node);
+    if (!current)
+        return undefined;
+    let level = startAtAncestor
+        ? await baseRefsFromContainer(index, current.module, current.container, current.context.source, current.context.sup, true, current.context.tree)
+        : [current];
+    if (level.length === 0)
+        return undefined;
+    // Java, Kotlin, and C# overload across the hierarchy: when no member at one level accepts the
+    // call, a base level may. C++ and Swift hide a base name behind any same-named member.
+    // An unknown count (a Kotlin spread) keeps every non-overridden overload as a candidate.
+    const spansHierarchy = HIERARCHY_OVERLOAD_LANGUAGES.has(current.context.sup.id);
+    // Java, Kotlin, and C# base members that are private are not accessible from a subclass.
+    const filtersPrivateBases = HIERARCHY_OVERLOAD_LANGUAGES.has(current.context.sup.id);
+    let lenient;
+    // Accepted overloads across levels. A deeper one is overridden only by an accepted method with
+    // the same parameter types in a class proven to derive from its owner on the walked path;
+    // unrelated owners with one signature (two interfaces) stay separate and ambiguous.
+    const accepted = [];
+    const memberKey = (def) => `${fileIdentityKey(def.file)}:${def.range.start.index}`;
+    const ownerOf = new Map();
+    const subclassesOf = new Map();
+    const recordOwner = (from, owner) => {
+        for (let at = from; at < matches.length; at += 1)
+            ownerOf.set(memberKey(matches[at]), owner);
+    };
+    let matches = [];
+    const visited = new Set([
+        keywordContainerKey(current.file, current.container),
+        ...level.map((candidate) => keywordContainerKey(candidate.file, candidate.container)),
+    ]);
+    for (let depth = 0; depth < RECEIVER_HIERARCHY_DEPTH && level.length; depth += 1) {
+        matches = [];
+        for (const candidate of level) {
+            const ownerKey = keywordContainerKey(candidate.file, candidate.container);
+            const before = matches.length;
+            const memberPredicate = memberScope === "any"
+                ? undefined
+                : (local) => matchesReceiverMemberScope(local, memberScope, candidate.context, candidate.container);
+            appendDirectKeywordMembers(candidate.module.locals, member, candidate.container, candidate.context, candidate.context.sup.normalizeIdentifier, memberPredicate, matches);
+            recordOwner(before, ownerKey);
+        }
+        for (const candidate of level) {
+            if (candidate.context.sup.id !== "csharp" && candidate.context.sup.id !== "swift")
+                continue;
+            const ownerKey = keywordContainerKey(candidate.file, candidate.container);
+            const before = matches.length;
+            const sharedContainers = await resolveSharedOwnerContainers({
+                index,
+                ownerFile: candidate.file,
+                ownerContainer: candidate.container,
+                ownerSource: candidate.context.source,
+                languageId: candidate.context.sup.id,
+            });
+            for (const shared of sharedContainers) {
+                const crossFileSwift = candidate.context.sup.id === "swift" && fileIdentityKey(candidate.file) !== fileIdentityKey(shared.file);
+                const sharedPredicate = (local) => {
+                    if (memberScope !== "any" &&
+                        !matchesReceiverMemberScope(local, memberScope, shared.context, shared.container)) {
+                        return false;
                     }
-                    if (memberDef) {
-                        return okGoToResult(index, memberDef, {
-                            via: { exportedName: member },
-                            resolution: "member-access",
-                            confidence: "medium",
-                        });
+                    if (!crossFileSwift)
+                        return true;
+                    const nameNode = nameNodeForDef(shared.context, local);
+                    return !!nameNode && !isSwiftCrossFileHiddenSharedOwnerMember("swift", candidate.file, shared.file, nameNode);
+                };
+                appendDirectKeywordMembers(shared.module.locals, member, shared.container, shared.context, shared.context.sup.normalizeIdentifier, sharedPredicate, matches);
+            }
+            // Partial parts of one type share its identity.
+            recordOwner(before, ownerKey);
+        }
+        let uniqueMatches = uniqueReceiverMemberCandidates(matches);
+        // A private member of a base class is not accessible: it neither answers nor stops the walk.
+        // The first level of a `this` lookup is the class itself, including C# partial parts.
+        if (filtersPrivateBases && (startAtAncestor || depth > 0) && uniqueMatches.length) {
+            const inherited = [];
+            for (const candidate of uniqueMatches) {
+                if (!(await isUninheritedPrivateMember(index, mod, node, candidate)))
+                    inherited.push(candidate);
+            }
+            uniqueMatches = inherited;
+        }
+        if (uniqueMatches.length && report)
+            report.named = true;
+        if (uniqueMatches.length) {
+            const allowUniqueArityMismatch = !startAtAncestor && depth === 0;
+            if (!spansHierarchy) {
+                return await selectReceiverMemberCandidates(index, uniqueMatches, knownArgumentCount, allowUniqueArityMismatch);
+            }
+            for (const candidate of uniqueMatches) {
+                if (knownArgumentCount !== undefined &&
+                    (await receiverMemberAcceptsArgumentCount(index, candidate, knownArgumentCount)) === false) {
+                    continue;
+                }
+                const owner = ownerOf.get(memberKey(candidate)) ?? "";
+                const subclasses = subclassesOf.get(owner);
+                let overridden = false;
+                for (const entry of accepted) {
+                    if (subclasses?.has(entry.owner) && (await sameParameterTypes(index, entry.def, candidate))) {
+                        overridden = true;
+                        break;
                     }
                 }
+                if (!overridden)
+                    accepted.push({ def: candidate, owner });
+            }
+            // Navigation still names the only incompatible candidate when no ancestor accepts the call.
+            if (allowUniqueArityMismatch && !lenient) {
+                lenient = await selectReceiverMemberCandidates(index, uniqueMatches, knownArgumentCount, true);
+            }
+        }
+        const next = [];
+        for (const candidate of level) {
+            const childKey = keywordContainerKey(candidate.file, candidate.container);
+            const childSubclasses = subclassesOf.get(childKey);
+            for (const parent of await baseRefsFromContainer(index, candidate.module, candidate.container, candidate.context.source, candidate.context.sup, startAtAncestor, candidate.context.tree)) {
+                const key = keywordContainerKey(parent.file, parent.container);
+                // Every class on a path to this ancestor derives from it, including through a diamond.
+                const subclasses = subclassesOf.get(key) ?? new Set();
+                subclasses.add(childKey);
+                for (const subclass of childSubclasses ?? [])
+                    subclasses.add(subclass);
+                subclassesOf.set(key, subclasses);
+                if (visited.has(key))
+                    continue;
+                visited.add(key);
+                next.push(parent);
             }
         }
+        level = next;
+    }
+    if (!spansHierarchy)
+        return undefined;
+    // Without type ranking, two surviving overloads are ambiguous, including a fixed-arity and a
+    // variable-arity one: `hit(String)` and `hit(int...)` both take one argument, and only argument
+    // types decide.
+    if (accepted.length > 1) {
+        if (report)
+            report.ambiguous = true;
+        return undefined;
+    }
+    return accepted[0]?.def ?? lenient;
+}
+/** 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.
+ */
+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;
 }
-function findEnclosingClassContainer(node) {
-    return nearestMemberContainer(node);
+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 a Java or Kotlin member is `private` and declared outside the class enclosing the use. */
+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;
+    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 &&
+        !(await 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) {
+/**
+ * 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);
+}
+async function resolveReceiverDefinition(index, obj, source, sup, resolveExpression, mod) {
     const constructor = receiverConstructorExpression(obj, source, sup);
     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 +1779,36 @@ async function resolveReceiverDefinition(obj, source, sup, resolveExpression, mo
                 memberScope: hasStaticMemberDistinction(sup.id) ? "instance" : "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],
@@ -239,12 +1817,13 @@ 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 };
+    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 +1833,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 +1865,141 @@ 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 > 1 && languageId !== "ruby") {
+        const reachable = [];
+        for (const candidate of candidates) {
+            if (!declaresMembers(baseDef) || (await reachableThroughTypeName(index, candidate)))
+                reachable.push(candidate);
+        }
+        return await selectReceiverMemberCandidates(index, reachable, knownArgumentCount);
+    }
+    if (candidates[0])
+        return candidates[0];
+    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);
+        return await selectReceiverMemberCandidates(index, candidates, knownArgumentCount);
+    }
+    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) {
+        return await selectReceiverMemberCandidates(index, allReceiverMatches, knownArgumentCount);
+    }
     if (targetContext.sup.id === "rust") {
-        const implNode = findRustImplForType(targetContext.tree.rootNode, receiverDef.localName, targetContext.source);
-        return implNode ? findLocalWithinNode(locals, member, implNode, normalizeIdentifier) : undefined;
+        const matches = [];
+        for (const implNode of findRustImplsForType(targetContext.tree.rootNode, receiverDef.localName, targetContext.source, targetContext.sup)) {
+            appendDirectKeywordMembers(locals, member, implNode, targetContext, normalizeIdentifier, undefined, matches);
+        }
+        return await selectReceiverMemberCandidates(index, matches, knownArgumentCount);
     }
     if (targetContext.sup.id === "go") {
         return findGoReceiverMember(locals, member, receiverDef.localName, targetContext, normalizeIdentifier);
     }
+    if (targetContext.sup.id === "kotlin") {
+        const extensionMatches = kotlinExtensionFunctionsNamedOnType(locals, member, receiverDef.localName, targetContext, normalizeIdentifier);
+        if (extensionMatches.length) {
+            return await selectReceiverMemberCandidates(index, extensionMatches, knownArgumentCount);
+        }
+    }
     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 &&
@@ -309,27 +2010,108 @@ function findLocalWithinNode(locals, member, node, normalizeIdentifier = (name)
             (!predicate || predicate(local)));
     });
 }
+function findLocalWithinNode(locals, member, node, normalizeIdentifier = (name) => name, predicate) {
+    return findLocalsWithinNode(locals, member, node, normalizeIdentifier, predicate)[0];
+}
 function matchesReceiverMemberScope(local, memberScope, targetContext, container) {
     if (memberScope === "any")
         return true;
     return hasStaticModifier(local, targetContext, container) === (memberScope === "static");
 }
-function nodeDeclaresStatic(node, source) {
-    if (node.type === "static" || node.type === "static_modifier")
+async function getCallableArityForDef(index, def) {
+    const context = await ensureParsedContext(def.file, undefined, index.languageExtensions);
+    const start = def.range.start;
+    const position = { row: start.line - 1, column: start.column - 1 };
+    const nameNode = context.tree.rootNode.descendantForPosition(position, position);
+    const container = nearestMemberContainer(nameNode);
+    let current = nameNode;
+    while (current && current !== container) {
+        if (CALLABLE_DECLARATION_NODE_TYPES[current.type]) {
+            const range = getCallableArity({
+                languageId: context.sup.id,
+                source: context.source,
+                declaration: current,
+                binding: memberLookupBinding(context.sup.id),
+            });
+            if (range)
+                return range;
+        }
+        current = current.parent;
+    }
+    return undefined;
+}
+/**
+ * Whether a member found for a receiverless call can accept that call's argument count. Unknown
+ * counts and unknown arities accept.
+ */
+export async function memberAcceptsCallAt(index, member, callee, source, languageId) {
+    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";
+    return (await receiverMemberAcceptsArgumentCount(index, member, argumentCount)) !== false;
+}
+async function receiverMemberAcceptsArgumentCount(index, def, argumentCount) {
+    const context = await ensureParsedContext(def.file, undefined, index.languageExtensions);
+    const start = def.range.start;
+    const position = {
+        row: start.line - 1,
+        column: start.column - 1,
+    };
+    const nameNode = context.tree.rootNode.descendantForPosition(position, position);
+    if (context.sup.id === "cpp") {
+        const shape = cppCallableShapeForNode(nameNode);
+        return shape
+            ? argumentCount >= shape.minArity && (shape.maxArity === null || argumentCount <= shape.maxArity)
+            : undefined;
     }
-    if (node.type === "modifiers") {
-        for (let childIndex = 0;; childIndex += 1) {
-            const child = node.child(childIndex);
-            if (!child)
-                break;
-            if (nodeDeclaresStatic(child, source))
-                return true;
+    const range = await getCallableArityForDef(index, def);
+    if (!range)
+        return undefined;
+    return argumentCount >= range.minArgs && (range.maxArgs === null || argumentCount <= range.maxArgs);
+}
+function uniqueReceiverMemberCandidates(candidates) {
+    const seen = new Set();
+    const unique = [];
+    for (const candidate of candidates) {
+        const key = keywordClassKey(candidate);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        unique.push(candidate);
+    }
+    return unique;
+}
+async function selectReceiverMemberCandidates(index, candidates, knownArgumentCount, allowUniqueArityMismatch = true) {
+    if (candidates.length > 1) {
+        const file = candidates[0]?.file;
+        if (file && candidates.every((candidate) => candidate.file === file)) {
+            const context = await ensureParsedContext(file, undefined, index.languageExtensions);
+            if (isJsTsLanguage(context.sup.id)) {
+                // Signature-only overloads still need arity selection before generic member deduplication.
+                return typescriptSelectOverloadCandidate({
+                    group: candidates,
+                    tree: context.tree,
+                    definitionOf: (candidate) => candidate,
+                    declarationOf: (candidate) => nameNodeForDef(context, candidate)?.parent,
+                    source: context.source,
+                    languageId: context.sup.id,
+                    argumentCount: knownArgumentCount ?? null,
+                });
+            }
         }
     }
-    return false;
+    const unique = uniqueReceiverMemberCandidates(candidates);
+    if (unique.length === 1 && (allowUniqueArityMismatch || knownArgumentCount === undefined))
+        return unique[0];
+    if (knownArgumentCount === undefined)
+        return undefined;
+    const matches = [];
+    for (const candidate of unique) {
+        if ((await receiverMemberAcceptsArgumentCount(index, candidate, knownArgumentCount)) !== false) {
+            matches.push(candidate);
+        }
+    }
+    return matches.length === 1 ? matches[0] : undefined;
 }
 function hasStaticModifier(local, targetContext, container) {
     const position = {
@@ -337,19 +2119,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 +2152,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 +2183,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 +2204,138 @@ 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 findDirectLocalWithinNode(locals, member, container, targetContext, normalizeIdentifier, predicate) {
+    return findDirectLocalsWithinNode(locals, member, container, targetContext, normalizeIdentifier, predicate)[0];
+}
+function appendDirectKeywordMembers(locals, member, container, targetContext, normalizeIdentifier, predicate, matches) {
+    const containerStart = container.startIndex;
+    const containerEnd = container.endIndex;
+    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;
 function goMethodReceiverTypeName(methodNode, source, sup) {
     const receiver = methodNode.childForFieldName("receiver");
     if (!receiver)
@@ -499,10 +2409,35 @@ function goMethodsNamedOnType(locals, member, typeName, targetContext, normalize
     visit(targetContext.tree.rootNode);
     return 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) {
+                const local = findLocalWithinNode(locals, member, node, normalizeIdentifier);
+                if (local && !matches.includes(local))
+                    matches.push(local);
+            }
+            return;
+        }
+        for (const child of node.namedChildren)
+            visit(child);
+    };
+    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) {
+    for (let depth = 0; depth < RECEIVER_HIERARCHY_DEPTH && level.length; depth += 1) {
         const matches = [];
         const next = [];
         for (const currentType of level) {
@@ -526,20 +2461,23 @@ function findGoReceiverMember(locals, member, typeName, targetContext, normalize
     }
     return 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, tree, sup, resolveExpression) {
+    const classRef = await pythonReceiverClassRef(index, mod, node, obj, source, tree, sup, resolveExpression);
     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, tree, sup, resolveExpression) {
+    const receiverName = receiverKeywordText(sup, obj, source, (callee) => {
+        const scope = getOrBuildScopeIndex(index, mod.file, source, sup, mod, tree);
+        return !!findClosestScopeBinding(scope, sliceText(callee, source), callee, sup);
+    });
+    const keywordKind = keywordReceiverKind(sup.id, receiverName);
+    if (keywordKind) {
         const container = findEnclosingClassContainer(node);
         if (!container)
             return null;
@@ -559,7 +2497,8 @@ 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: keywordKind === "supertype" } : null;
     }
     let classDef;
     const constructor = receiverConstructorExpression(obj, source, sup);
@@ -577,7 +2516,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));
@@ -664,17 +2604,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,15 +2637,17 @@ 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;
+async function lookupPythonClassMember(index, start, member, startAtSupertype = false) {
+    if (!startAtSupertype) {
+        const own = pythonMembersOnClass(start, member);
+        if (own.length === 1)
+            return own[0];
+        if (own.length > 1)
+            return undefined;
+    }
     let level = await pythonBaseClassRefs(index, start);
     const visited = new Set([pythonClassKey(start.def), ...level.map((base) => pythonClassKey(base.def))]);
-    for (let depth = 0; depth < PYTHON_SUPERTYPE_DEPTH && level.length; depth += 1) {
+    for (let depth = 0; depth < RECEIVER_HIERARCHY_DEPTH && level.length; depth += 1) {
         const matches = [];
         const seenMatch = new Set();
         for (const base of level) {
@@ -737,7 +2677,4 @@ async function lookupPythonClassMember(index, start, member) {
     }
     return undefined;
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
 //# sourceMappingURL=navigation-goto.js.map