@lzehrung/codegraph 2.3.30 → 2.4.0

package/dist/indexer/navigation.js

@@ -1,22 +1,40 @@
 import { supportForFileWithoutHeaderSample } from "../languages.js";
 import { ensureParsedContext } from "./parse-context.js";
-import { resolveMemberAccessDefinition, supportsReceiverMemberNavigation } from "./navigation-goto.js";
-import { findClosestBinding, findDeclarationNameNode, getOrBuildScopeIndex, resolveNamedDefinition, } from "./navigation-local.js";
+import { getCompilationUnitPeers, IMPLICIT_UNIT_LANGUAGES } from "./compilation-units.js";
+import { getReverseNeighbors, graphAdjacencyFor } from "../graphs/adjacency.js";
+import { isGoExportedMemberName } from "./declaration-visibility.js";
+import { memberSyntaxNamesFreeFunction } from "../util/member-access-tables.js";
+import { phpObjectCreationKeyword } from "../graphs/symbol-graph-detailed/receiver-calls.js";
+import { findCsharpPartialTypeEquivalents, innermostNamespaceImport, resolveMemberAccessDefinition, resolvePhpObjectCreationTarget, resolveRubySuperDefinition, sharedOwnerMemberUnitComplete, supportsReceiverMemberNavigation, } from "./navigation-goto.js";
+import { findClosestBinding, findClosestScopeBinding, findDeclarationNameNode, getOrBuildScopeIndex, toModuleRef, } from "./navigation-local.js";
+import { typescriptCallableCandidatesInContainer } from "./ts-callables.js";
+import { isExplicitMethodCall, scopeNodesFor } from "./scope-nodes.js";
+import { AMBIGUOUS_CPP_OVERLOAD_REASON } from "./ambiguous-resolution.js";
+import { effectiveExplicitBinding, findRubyReopenedConstantParts, isExpandedStarBinding, resolveStarImportedDefinition, resolveStarImportedNamespace, } from "./star-import-precedence.js";
 import { createNavigationProvenance, okGoToResult } from "./navigation-provenance.js";
-import { getPhpQualifiedReference, inferPhpQualifiedReferenceImportType, normalizePhpQualifiedReference, } from "./navigation-php.js";
-import { buildIndexedCandidateCoverage, buildPhpQualifiedNames, collectVerifiedNamedNodeReferences, getCachedScope, exportFromIdentifier, getCachedReferenceCandidateFiles, getCandidateReferenceNames, hasExpandedNamedImport, importBindingDeclarationRangeKeys, importBindingIdentityVerificationSites, importBindingReferenceSites, rangeIdentityKey, referenceSiteKey, } from "./navigation-references.js";
-import { resolveExport, resolveImported } from "./navigation-resolve.js";
+import { getPhpQualifiedReference, inferPhpQualifiedReferenceImportType, isPhpCaseInsensitiveSymbolKind, normalizePhpQualifiedReference, phpLastIdentifierSegment, } from "./navigation-php.js";
+import { ensurePhpNamespaceSymbolIndex, phpReferenceRoleMatchesKind } from "./php-namespace-symbols.js";
+import { buildIndexedCandidateCoverage, buildPhpQualifiedNames, cppCanonicalStructuralExport, describeReferenceStrategies, collectVerifiedNamedNodeReferences, isMemberAccessPropertyRange, getCachedScope, exportFromIdentifier, getCachedReferenceCandidateFiles, getCandidateReferenceNames, hasExpandedNamedImport, pythonParentPackageNamespacePaths, importBindingDeclarationRangeKeys, importBindingIdentityVerificationSites, importBindingReferenceSites, rangeIdentityKey, referenceSiteKey, } from "./navigation-references.js";
+import { directModuleValueEntry, resolveExport, resolveImported, resolveModuleExports, resolvePhpExportByImportType, } from "./navigation-resolve.js";
 import { extractEnclosingBlock, extractLineContext, rangeContains, sameDef } from "./reference-context.js";
 import { DEFAULT_REF_CONTEXT_LINES } from "./shared.js";
-import {} from "./scope.js";
 import {} from "../types.js";
 import { loadNearestTsconfigFor, resolveImportSpecifier } from "../util/resolution.js";
 import { fileIdentityKey } from "../util/paths.js";
 import { sliceText, toRange } from "../util/ast.js";
+import { foldPhpIdentifierCase } from "../util/identifiers.js";
 import { getMemberAccessParts, isMemberAccessNode, isMemberObjectIdentifier, isMemberReferencePropertyIdentifier, isReceiverNameNode, } from "../util/member-access.js";
+import { cppOutOfLineOwnerPath, cppOutOfLineMemberName, cppOutOfLineMemberDeclarationNode, cppQualifiedNameSegments, } from "../graphs/symbol-graph-detailed/receiver-calls.js";
+import { cppCallableShapeForNode, cppEquivalentCallableBindings } from "./cpp-callables.js";
+import { resolveCppExportedCallables, resolveCppQualifiedMemberContainer } from "./navigation-cpp.js";
 import { SymbolKind, } from "./types.js";
 import { findSqlReferences, goToSqlDefinition } from "../sql/navigation.js";
+import { createLoadingParsedFileProvider, phpImportTypeAtPosition, resolveBareName, settleNameResolution, withParsedFiles, } from "./name-resolution.js";
+import { resolveCppQualifiedName } from "./name-lookup-policies/c-family.js";
 export { resolveExport, resolveImported } from "./navigation-resolve.js";
+const CPP_MEMBER_CONTAINER_TYPES = new Set(["class_specifier", "struct_specifier", "union_specifier"]);
+const MAX_REFERENCE_NAMESPACE_DEPTH = 8;
+const MAX_REFERENCE_NAMESPACE_PATHS = 64;
 export async function goToDefinition(index, req, parsedContext) {
     const { file, line, column } = req;
     const mod = index.byFile.get(fileIdentityKey(file));
@@ -30,11 +48,20 @@ export async function goToDefinition(index, req, parsedContext) {
     const sup = context.sup;
     const source = context.source;
     const tree = context.tree;
+    if (sup.id === "php")
+        await ensurePhpNamespaceSymbolIndex(index);
     const pos = {
         row: Math.max(0, line - 1),
         column: Math.max(0, column - 1),
     };
     let node = tree.rootNode.descendantForPosition(pos, pos);
+    // A position at the start of `b` in `a?.b` also touches the end of the `?.` token, which the
+    // parser reports first. The use is the name that starts at the position.
+    if (node?.type === "optional_chain" && node.parent) {
+        const startsHere = node.parent.namedChildren.find((child) => child.startPosition.row === pos.row && child.startPosition.column === pos.column);
+        if (startsHere)
+            node = startsHere;
+    }
     if (node && node.type === "variable_declarator") {
         const value = node.childForFieldName("value");
         if (value && value.type === "call_expression") {
@@ -52,6 +79,21 @@ export async function goToDefinition(index, req, parsedContext) {
         node = node.parent;
     if (!node)
         return { status: "not_found", reason: "No node at position" };
+    if (sup.id === "ruby" && node.type === "super") {
+        const target = await resolveRubySuperDefinition(index, mod, node, source, sup);
+        if (!target)
+            return { status: "not_found", reason: "No matching Ruby superclass method" };
+        return okGoToResult(index, target, { resolution: "member-access", confidence: "medium" });
+    }
+    if (sup.id === "php") {
+        const keyword = phpObjectCreationKeyword(node, source, sup);
+        if (keyword) {
+            const created = resolvePhpObjectCreationTarget(index, mod, keyword, source, sup);
+            if (!created)
+                return { status: "not_found", reason: "No matching PHP class" };
+            return okGoToResult(index, created, { resolution: "member-access", confidence: "medium" });
+        }
+    }
     const shorthandId = sup.nodeTypes.shorthandPropertyIdentifier ?? [];
     const isId = sup.nodeTypes.identifier.includes(node.type) || shorthandId.includes(node.type);
     let name = isId ? sliceText(node, source) : null;
@@ -62,6 +104,9 @@ export async function goToDefinition(index, req, parsedContext) {
             name = sliceText(declNameNode, source);
         }
     }
+    const phpImportType = sup.id === "php"
+        ? (phpImportTypeAtPosition(mod.imports, pos.row, pos.column) ?? inferPhpQualifiedReferenceImportType(node))
+        : undefined;
     if (node && sup.supportsExportFromReferences && index.projectRoot) {
         const exportFrom = exportFromIdentifier(index, file, toRange(node), context);
         if (exportFrom?.entry) {
@@ -93,28 +138,60 @@ export async function goToDefinition(index, req, parsedContext) {
         }
     }
     if (sup.supportsCrossModuleSymbols) {
-        const scopeIndex = node.parent && isMemberAccessNode(sup, node.parent)
-            ? getOrBuildScopeIndex(index, file, source, sup, mod, tree)
-            : null;
-        const memberAccessResult = await resolveMemberAccessDefinition({
-            index,
-            mod,
-            node,
-            source,
-            sup,
-            ...(scopeIndex
-                ? {
-                    resolveLexicalBinding: (receiver) => {
-                        if (!isReceiverNameNode(sup, receiver.type))
-                            return null;
-                        return findClosestBinding(scopeIndex, file, sliceText(receiver, source), receiver, sup);
-                    },
-                }
-                : {}),
-        });
+        let memberAccessNode = null;
+        if (node.parent && isMemberAccessNode(sup, node.parent)) {
+            memberAccessNode = node.parent;
+        }
+        else if (node.parent?.type === "template_function" &&
+            node.parent.parent &&
+            isMemberAccessNode(sup, node.parent.parent)) {
+            memberAccessNode = node.parent.parent;
+        }
+        if (sup.id === "cpp") {
+            while (memberAccessNode?.parent && isMemberAccessNode(sup, memberAccessNode.parent)) {
+                memberAccessNode = memberAccessNode.parent;
+            }
+        }
+        // A receiverless call (Java `hit()`) reuses the member-call node with the name in both slots;
+        // it is a bare name, so the shared lookup (implicit members, imports, package) decides it.
+        const receiverless = !!memberAccessNode && isReceiverlessMemberCall(sup, memberAccessNode);
+        const scopeIndex = memberAccessNode ? getOrBuildScopeIndex(index, file, source, sup, mod, tree) : null;
+        const memberAccessResult = !receiverless &&
+            !isExplicitMethodCall(scopeNodesFor(sup.id), node) &&
+            (await resolveMemberAccessDefinition({
+                index,
+                mod,
+                node,
+                source,
+                tree,
+                sup,
+                ...(scopeIndex
+                    ? {
+                        resolveLexicalBinding: (receiver) => {
+                            if (!isReceiverNameNode(sup, receiver.type))
+                                return null;
+                            const receiverName = sliceText(receiver, source);
+                            const binding = findClosestScopeBinding(scopeIndex, receiverName, receiver, sup);
+                            if (binding?.kind === "importDefault" ||
+                                binding?.kind === "importNamed" ||
+                                binding?.kind === "namespace") {
+                                return null;
+                            }
+                            return findClosestBinding(scopeIndex, file, receiverName, receiver, sup, source, tree);
+                        },
+                    }
+                    : {}),
+            }));
         if (memberAccessResult) {
             return memberAccessResult;
         }
+        if (sup.id === "cpp" && scopeIndex && memberAccessNode) {
+            const files = createLoadingParsedFileProvider(index, { file, parsed: context });
+            const qualifiedName = cppQualifiedNameSegments(memberAccessNode, source).join("::");
+            const qualified = await withParsedFiles(files, () => resolveCppQualifiedName({ index, mod, file, parsed: context, scopeIndex, files, node, name: qualifiedName }));
+            if (qualified)
+                return qualified;
+        }
         if (isUnresolvedReceiverMemberProperty(sup, node)) {
             return { status: "not_found", reason: "No matching receiver member definition" };
         }
@@ -122,23 +199,14 @@ export async function goToDefinition(index, req, parsedContext) {
     if (sup.id === "php" && phpQualifiedReference && index.projectRoot) {
         const normalizedQualifiedReference = normalizePhpQualifiedReference(phpQualifiedReference, source, tree, node);
         if (normalizedQualifiedReference?.includes("\\")) {
-            const phpImportType = inferPhpQualifiedReferenceImportType(node);
+            const qualifiedImportType = phpImportType;
             const resolvedTarget = await resolveImportSpecifier(index.projectRoot, file, normalizedQualifiedReference, "php", {
-                ...(phpImportType ? { phpImportType } : {}),
+                ...(qualifiedImportType ? { phpImportType: qualifiedImportType } : {}),
             });
             if (typeof resolvedTarget === "string") {
                 const exportedName = normalizedQualifiedReference.split("\\").filter(Boolean).pop() ?? null;
                 if (exportedName) {
-                    let preferredKind;
-                    if (phpImportType === "function") {
-                        preferredKind = SymbolKind.Function;
-                    }
-                    else if (phpImportType === "class") {
-                        preferredKind = SymbolKind.Class;
-                    }
-                    const hit = resolveExport(index, resolvedTarget, exportedName, {
-                        ...(preferredKind ? { preferredKind } : {}),
-                    });
+                    const hit = resolvePhpExportByImportType(index, resolvedTarget, exportedName, qualifiedImportType);
                     if (hit?.kind === "resolved") {
                         return okGoToResult(index, hit.def, {
                             via: { importedFrom: resolvedTarget, exportedName },
@@ -152,24 +220,26 @@ export async function goToDefinition(index, req, parsedContext) {
     }
     if (name) {
         const scopeIndex = getOrBuildScopeIndex(index, file, source, sup, mod, tree);
-        const local = findClosestBinding(scopeIndex, file, name, node, sup);
-        if (local) {
-            return okGoToResult(index, local, {
-                resolution: "exact",
-                confidence: "high",
-            });
-        }
-        if (sup.supportsCrossModuleSymbols) {
-            const resolvedName = resolveNamedDefinition(index, mod, file, sup, name);
-            if (resolvedName) {
-                return resolvedName;
-            }
-        }
+        const files = createLoadingParsedFileProvider(index, { file, parsed: context });
+        const use = {
+            index,
+            mod,
+            file,
+            parsed: context,
+            scopeIndex,
+            files,
+            node,
+            name,
+            ...(phpImportType ? { phpImportType } : {}),
+        };
+        const resolution = await withParsedFiles(files, () => resolveBareName(use));
+        const settled = await settleNameResolution(use, resolution, {
+            recoverIncludedStar: (lookupName, cNamespace) => recoverIncludedCallableStar(index, mod, sup.id, lookupName, cNamespace, node, source),
+        });
+        if (settled)
+            return settled;
     }
-    const localAtPosition = mod.locals.find((local) => rangeContains(local.range, {
-        row: line,
-        column: column,
-    }));
+    const localAtPosition = mod.locals.find((local) => local.range.start.index === node.startIndex && local.range.end.index === node.endIndex);
     if (localAtPosition) {
         return okGoToResult(index, localAtPosition, {
             resolution: "exact",
@@ -181,9 +251,23 @@ export async function goToDefinition(index, req, parsedContext) {
         reason: "No matching local or imported definition",
     };
 }
+/** Whether a member-access node has no receiver distinct from its member name. */
+function isReceiverlessMemberCall(sup, access) {
+    // Java `<T>hit()` has no `object` field; the generic parts fall back to the type arguments.
+    if (access.type === "method_invocation")
+        return !access.childForFieldName("object");
+    const { object, property } = getMemberAccessParts(sup, access);
+    return !!property && (!object || object.startIndex === property.startIndex);
+}
+function swiftNavigationMemberAccess(sup, node) {
+    if (sup.id !== "swift" || node.parent?.type !== "navigation_suffix")
+        return null;
+    const access = node.parent.parent;
+    return access && isMemberAccessNode(sup, access) ? access : null;
+}
 function isUnresolvedReceiverMemberProperty(sup, node) {
-    const parent = node.parent;
-    if (!parent || !supportsReceiverMemberNavigation(sup.id) || !isMemberAccessNode(sup, parent)) {
+    const parent = swiftNavigationMemberAccess(sup, node) ?? node.parent;
+    if (!parent || (!supportsReceiverMemberNavigation(sup.id) && sup.id !== "c") || !isMemberAccessNode(sup, parent)) {
         return false;
     }
     const { object, property } = getMemberAccessParts(sup, parent);
@@ -195,6 +279,7 @@ function isUnresolvedReceiverMemberProperty(sup, node) {
     // Namespace and nested-type qualification still resolve through the language
     // paths below; only value-receiver members must not fall back to a bare name.
     if (parent.type === "qualified_name" ||
+        parent.type === "alias_qualified_name" ||
         parent.type === "qualified_identifier" ||
         parent.type === "qualified_type" ||
         parent.type === "scoped_identifier" ||
@@ -232,6 +317,110 @@ export async function findUsageReferences(index, req, opts) {
 export async function findRenameReferences(index, def, opts) {
     return findReferencesInternal(index, { def }, opts, "rename");
 }
+/**
+ * Proven equivalent callable definition family for one definition site.
+ *
+ * Returns the incoming definition first — enriched to its indexed SymbolDef when the definition
+ * file's module.locals holds an exact identity match (same file, kind, localName, and full range
+ * span), restoring metadata such as `isMember` — followed by every equivalent
+ * declaration/definition that reference collection itself proves: same-scope prototype/definition
+ * pairs (C and C++), C prototypes linked to definitions through an include, namespace-qualified
+ * equivalents, the in-class declaration for out-of-line
+ * member definitions, and out-of-line definitions for in-class member declarations linked through
+ * the export index. Matching stays conservative: candidates must already exist in the definition
+ * file's scope bindings or the export index with a proven signature; no name-only or arity-only
+ * equivalence is introduced, and overload sets are never collapsed.
+ *
+ * `parsedContext` is optional; when omitted the definition file is parsed on demand. Definitions
+ * outside C/C++ return just the enriched definition.
+ */
+/**
+ * Two included declarations of one C/C++ function are one callable, using
+ * {@link getCppEquivalentCallableDefinitions}. Different signatures stay an
+ * overload set and are chosen by call arity. Non-callables (typedefs, structs)
+ * are left to the star-import ambiguity result.
+ */
+export async function recoverIncludedCallableStar(index, mod, languageId, name, cNamespace, node, source) {
+    const candidates = [];
+    for (const imp of mod.imports) {
+        if (isExpandedStarBinding(imp, mod.imports) || imp.kind !== "star")
+            continue;
+        const def = resolveStarImportedDefinition(index, imp, name, languageId, cNamespace);
+        if (def)
+            candidates.push({ imp, def });
+    }
+    const functions = candidates.filter((candidate) => candidate.def.kind === SymbolKind.Function && !candidate.def.cTag);
+    if (functions.length < 2)
+        return null;
+    const familyOf = new Map();
+    const family = async (def) => {
+        const key = referenceSiteKey(def.file, def.range);
+        const cached = familyOf.get(key);
+        if (cached)
+            return cached;
+        const defs = await getCppEquivalentCallableDefinitions(index, def);
+        familyOf.set(key, defs);
+        return defs;
+    };
+    const parent = functions.map((_, candidateIndex) => candidateIndex);
+    const find = (start) => {
+        let current = start;
+        while (parent[current] !== current) {
+            const next = parent[current];
+            parent[current] = parent[next] ?? next;
+            current = next;
+        }
+        return current;
+    };
+    const unite = (left, right) => {
+        const leftRoot = find(left);
+        const rightRoot = find(right);
+        if (leftRoot !== rightRoot)
+            parent[rightRoot] = leftRoot;
+    };
+    for (let left = 0; left < functions.length; left += 1) {
+        const defs = await family(functions[left].def);
+        for (let right = left + 1; right < functions.length; right += 1) {
+            if (defs.some((item) => sameDef(item, functions[right].def, index.languageExtensions)))
+                unite(left, right);
+        }
+    }
+    const roots = new Set(functions.map((_, candidateIndex) => find(candidateIndex)));
+    if (roots.size === 1) {
+        const chosen = functions[0];
+        const importedFrom = toModuleRef(chosen.imp.resolved);
+        return okGoToResult(index, chosen.def, {
+            via: { ...(importedFrom ? { importedFrom } : {}), exportedName: name },
+            resolution: "import-star",
+            confidence: "medium",
+        });
+    }
+    const parsedByFile = new Map();
+    for (const candidate of functions) {
+        const key = fileIdentityKey(candidate.def.file);
+        if (parsedByFile.has(key))
+            continue;
+        try {
+            parsedByFile.set(key, await ensureParsedContext(candidate.def.file, index.parsed?.get(key), index.languageExtensions));
+        }
+        catch {
+            return languageId === "cpp"
+                ? { status: "not_found", reason: AMBIGUOUS_CPP_OVERLOAD_REASON }
+                : { status: "not_found", reason: "No matching local or imported definition" };
+        }
+    }
+    const selected = resolveCppExportedCallables(index, functions.map((candidate) => candidate.def), node, source, (targetFile) => parsedByFile.get(fileIdentityKey(targetFile)) ?? null);
+    if (selected) {
+        return okGoToResult(index, selected, { resolution: "exact", confidence: "high" });
+    }
+    return languageId === "cpp"
+        ? { status: "not_found", reason: AMBIGUOUS_CPP_OVERLOAD_REASON }
+        : { status: "not_found", reason: "No matching local or imported definition" };
+}
+export async function getCppEquivalentCallableDefinitions(index, def, parsedContext) {
+    const family = await cppEquivalentCallableFamily(index, def, parsedContext);
+    return [family.definition, ...family.equivalents];
+}
 async function findReferencesInternal(index, req, opts, collectionMode) {
     let def = null;
     let provenance;
@@ -260,6 +449,17 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
     if (!def) {
         return { status: "not_found", reason: "Could not resolve definition" };
     }
+    if (def.cTag) {
+        const canonical = await goToDefinition(index, {
+            file: def.file,
+            line: def.range.start.line,
+            column: def.range.start.column,
+        });
+        if (canonical.status === "ok") {
+            def = canonical.definition;
+            provenance = canonical.provenance;
+        }
+    }
     const maxReferences = typeof opts?.maxReferences === "number" && opts.maxReferences > 0 ? opts.maxReferences : undefined;
     const sqlReferences = await findSqlReferences(index, def, {
         includeDefinition: collectionMode === "all",
@@ -293,16 +493,23 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
     };
     const parsedDef = index.parsed?.get(fileIdentityKey(definitionFile));
     const parsedContext = await ensureParsedContext(definitionFile, parsedDef, index.languageExtensions);
+    let cNamespace;
+    if (parsedContext.sup.id === "c")
+        cNamespace = def.cTag ? "tag" : "ordinary";
+    const exportOptions = cNamespace ? { cNamespace } : undefined;
     const mod = index.byFile.get(fileIdentityKey(definitionFile));
     if (!mod)
         return { status: "not_found", reason: "Module not found" };
-    const scope = getCachedScope(index, definitionFile, mod, parsedContext);
     const refs = [];
     const seenRefs = new Map();
     const collectionLimit = maxReferences !== undefined ? maxReferences + 1 : undefined;
     const hasReachedCollectionLimit = () => collectionLimit !== undefined && refs.length >= collectionLimit;
     const remainingCollectionSlots = () => collectionLimit !== undefined ? Math.max(0, collectionLimit - refs.length) : undefined;
-    const importBindingRank = (ref) => (ref.via?.importBinding === "imported" ? 1 : 0);
+    const referenceMetadataRank = (ref) => {
+        if (ref.via?.importBinding === "imported")
+            return 2;
+        return ref.via?.namespaceMember ? 1 : 0;
+    };
     const pushRef = (ref) => {
         if (!includeReference(ref))
             return;
@@ -310,7 +517,7 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
         const existingIndex = seenRefs.get(key);
         if (existingIndex !== undefined) {
             const existing = refs[existingIndex];
-            if (importBindingRank(ref) > importBindingRank(existing)) {
+            if (referenceMetadataRank(ref) > referenceMetadataRank(existing)) {
                 refs[existingIndex] = ref;
             }
             return;
@@ -320,29 +527,128 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
         seenRefs.set(key, refs.length);
         refs.push(ref);
     };
-    const normalizedLocalName = parsedContext.sup.normalizeIdentifier(def.localName);
-    const localBindings = scope.bindings.get(normalizedLocalName) ?? [];
-    const localBinding = localBindings.find((binding) => binding.def && binding.def.start.index === def.range.start.index);
-    pushRef({ file: definitionFile, range: def.range });
-    if (localBinding) {
+    const family = await cppEquivalentCallableFamily(index, def, parsedContext);
+    const definition = family.definition;
+    const referenceDef = family.referenceDef;
+    const localBinding = family.localBinding;
+    pushRef({ file: definitionFile, range: definition.range });
+    const receiverMemberDefinition = isReceiverMemberDefinition(definition, parsedContext, !!family.receiverOwner);
+    const csharpPartialEquivalents = parsedContext.sup.id === "csharp" &&
+        !definition.isMember &&
+        (definition.kind === SymbolKind.Class ||
+            definition.kind === SymbolKind.Interface ||
+            definition.kind === SymbolKind.TypeAlias)
+        ? await findCsharpPartialTypeEquivalents(index, definition)
+        : [];
+    const rubyReopen = parsedContext.sup.id === "ruby" ? findRubyReopenedConstantParts(index, definition) : undefined;
+    const equivalentDefinitions = [...family.equivalents, ...csharpPartialEquivalents, ...(rubyReopen?.parts ?? [])];
+    for (const equivalent of equivalentDefinitions) {
+        pushRef({ file: equivalent.file, range: equivalent.range });
+    }
+    const matchesReferenceDefinition = (candidate) => sameDef(candidate, definition, index.languageExtensions) ||
+        equivalentDefinitions.some((equivalent) => sameDef(candidate, equivalent, index.languageExtensions));
+    const exportedNames = [];
+    for (const candidate of [definition, ...equivalentDefinitions]) {
+        const candidateModule = index.byFile.get(fileIdentityKey(candidate.file));
+        for (const entry of candidateModule?.exports ?? []) {
+            if (entry.type === "local" &&
+                sameDef(entry.target, candidate, index.languageExtensions) &&
+                !exportedNames.includes(entry.exportedAs)) {
+                exportedNames.push(entry.exportedAs);
+            }
+        }
+    }
+    if (!exportedNames.length && !receiverMemberDefinition) {
+        exportedNames.push(definition.localName);
+    }
+    const exportedNameSet = new Set(exportedNames);
+    const phpQualifiedNames = await buildPhpQualifiedNames(index, definitionFile, definition);
+    const scansReceiverReferences = shouldScanVerifiedReferences(definition, parsedContext, receiverMemberDefinition);
+    const scansNamespaceReferences = parsedContext.sup.id === "csharp" &&
+        !definition.isMember &&
+        (definition.kind === SymbolKind.Class ||
+            definition.kind === SymbolKind.Interface ||
+            definition.kind === SymbolKind.TypeAlias);
+    let requiresTypeScriptOverloadVerifiedScan = false;
+    if ((parsedContext.sup.id === "ts" || parsedContext.sup.id === "tsx") &&
+        definition.kind === SymbolKind.Function &&
+        !receiverMemberDefinition &&
+        localBinding?.sameScopeFunctionBindings) {
+        const start = definition.range.start.index ?? 0;
+        const end = definition.range.end.index ?? start;
+        const overloadBindings = typescriptCallableCandidatesInContainer(localBinding.sameScopeFunctionBindings, parsedContext.tree, (binding) => binding.def, start, end);
+        requiresTypeScriptOverloadVerifiedScan = overloadBindings.length > 1;
+    }
+    const requiresSameFileVerifiedScan = ((parsedContext.sup.id === "c" || parsedContext.sup.id === "cpp") &&
+        definition.kind === SymbolKind.Function &&
+        !receiverMemberDefinition) ||
+        scansNamespaceReferences ||
+        requiresTypeScriptOverloadVerifiedScan;
+    let sameFileVerifiedScanExecuted = false;
+    const receiverProofUnavailableFiles = new Map();
+    let memberCallOccurrencesNeedVerification = false;
+    if (localBinding &&
+        localBinding.occurrencesComplete !== false &&
+        !requiresSameFileVerifiedScan &&
+        !scansReceiverReferences &&
+        !requiresTypeScriptOverloadVerifiedScan) {
+        const verifyMemberCalls = memberSyntaxNamesFreeFunction(parsedContext.sup.id);
         for (const occurrence of localBinding.occurrences) {
             if (hasReachedCollectionLimit())
                 break;
+            // A scope occurrence is not proof of a member call. Languages that invoke a free
+            // function that way verify the site; an unresolvable receiver stays unavailable.
+            if (verifyMemberCalls && isMemberAccessPropertyRange(parsedContext, occurrence)) {
+                memberCallOccurrencesNeedVerification = true;
+                continue;
+            }
             pushRef({ file: definitionFile, range: occurrence });
         }
     }
-    const exportedNames = [];
-    for (const entry of mod.exports) {
-        if (entry.type === "local" && sameDef(entry.target, def, index.languageExtensions)) {
-            exportedNames.push(entry.exportedAs);
+    if (memberCallOccurrencesNeedVerification && !hasReachedCollectionLimit()) {
+        const ranges = await collectVerifiedNamedNodeReferences(index, definitionFile, referenceDef.localName, referenceDef, (params, parsed) => goToDefinition(index, params, parsed), remainingCollectionSlots(), verifiedReferenceFilter(definitionFile), (unavailableFile) => receiverProofUnavailableFiles.set(fileIdentityKey(unavailableFile), unavailableFile), equivalentDefinitions);
+        for (const { range, provenance, via } of ranges) {
+            if (hasReachedCollectionLimit())
+                break;
+            pushRef({ file: definitionFile, range, ...(via ? { via } : {}), ...(provenance ? { provenance } : {}) });
         }
     }
-    if (!exportedNames.length && shouldUseLocalNameAsExportFallback(def, parsedContext)) {
-        exportedNames.push(def.localName);
+    if (requiresSameFileVerifiedScan && !hasReachedCollectionLimit()) {
+        const ranges = await collectVerifiedNamedNodeReferences(index, definitionFile, referenceDef.localName, referenceDef, (params, parsed) => goToDefinition(index, params, parsed), remainingCollectionSlots(), verifiedReferenceFilter(definitionFile), (unavailableFile) => receiverProofUnavailableFiles.set(fileIdentityKey(unavailableFile), unavailableFile), equivalentDefinitions);
+        sameFileVerifiedScanExecuted = true;
+        for (const { range, provenance, via } of ranges) {
+            if (hasReachedCollectionLimit())
+                break;
+            pushRef({
+                file: definitionFile,
+                range,
+                ...(via ? { via } : {}),
+                ...(provenance ? { provenance } : {}),
+            });
+        }
     }
-    const exportedNameSet = new Set(exportedNames);
-    const phpQualifiedNames = await buildPhpQualifiedNames(index, definitionFile, def);
-    let candidateFiles = getCachedReferenceCandidateFiles(index, def, exportedNames, !!phpQualifiedNames.length);
+    let candidateFiles = [
+        ...new Map([referenceDef, ...equivalentDefinitions]
+            .flatMap((candidate) => getCachedReferenceCandidateFiles(index, candidate, exportedNames, !!phpQualifiedNames.length, parsedContext.sup.id))
+            .map((candidateFile) => [fileIdentityKey(candidateFile), candidateFile])).values(),
+    ].sort((left, right) => left.localeCompare(right));
+    // Candidates that share a compilation unit with the definition (or an equivalent
+    // declaration) can name it without an import edge; the per-candidate scan below treats
+    // them as bare-name reference sources in addition to the import-derived branches.
+    const unitPeerKeys = new Set();
+    for (const candidate of [referenceDef, ...equivalentDefinitions]) {
+        for (const unitPeer of getCompilationUnitPeers(index, candidate.file, parsedContext.sup.id === "csharp" ? { csharpQualifiedName: true } : undefined).files) {
+            unitPeerKeys.add(fileIdentityKey(unitPeer));
+        }
+    }
+    // A bloom filter holds each candidate file's identifiers in that file's own spelling, and a
+    // probe can only test one spelling. PHP resolves class, interface, trait, enum, and function
+    // names case-insensitively, so `new \App\sErViCe()` must still match a `Service` definition.
+    // `buildBloomFilterFromSource` stores every PHP file's identifiers both in their own spelling
+    // and ASCII-case-folded, so folding the probe's last identifier segment here narrows those
+    // kinds exactly instead of skipping narrowing and walking every indexed PHP file. Variables,
+    // properties, and constants stay case-sensitive and probe with their own spelling.
+    const phpCaseInsensitiveDefinition = phpQualifiedNames.length && isPhpCaseInsensitiveSymbolKind(definition.kind);
     if (index.bloomFilters && phpQualifiedNames.length) {
         candidateFiles = candidateFiles.filter((candidateFile) => {
             const module = index.byFile.get(fileIdentityKey(candidateFile));
@@ -355,12 +661,62 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
             const normalizeIdentifier = supportForFileWithoutHeaderSample(candidateFile, index.languageExtensions)?.normalizeIdentifier ??
                 ((name) => name);
             const aliases = getCandidateReferenceNames(module, definitionFile, exportedNameSet);
-            if (!aliases.length) {
-                return [...exportedNames, ...phpQualifiedNames].some((candidateName) => filter.mightContain(normalizeIdentifier(candidateName)));
+            const probeNames = aliases.length ? aliases : [...exportedNames, ...phpQualifiedNames];
+            if (phpCaseInsensitiveDefinition) {
+                return probeNames.some((candidateName) => filter.mightContain(foldPhpIdentifierCase(normalizeIdentifier(phpLastIdentifierSegment(candidateName)))));
             }
-            return aliases.some((alias) => filter.mightContain(normalizeIdentifier(alias)));
+            return probeNames.some((candidateName) => filter.mightContain(normalizeIdentifier(phpLastIdentifierSegment(candidateName))));
         });
     }
+    // A file reached only through a dynamic import, or another construct that never creates a
+    // modeled ImportBinding, still leaves a real file-dependency edge behind. Without this, such
+    // a file is never a scan candidate at all, so a genuine same-name use inside it is silently
+    // invisible instead of making coverage `partial` — exactly the gap F3 forbids. Member
+    // definitions already get every file scanned below, so this only adds files for the narrower,
+    // import-graph-driven search.
+    if (!definition.isMember && !scansReceiverReferences) {
+        const candidateFileKeys = new Set(candidateFiles.map((file) => fileIdentityKey(file)));
+        const adjacency = index.graphAdjacency ?? graphAdjacencyFor(index.graph);
+        const graphLinkedOrphans = new Map();
+        for (const candidate of [definition, ...equivalentDefinitions]) {
+            for (const importer of getReverseNeighbors(adjacency, candidate.file)) {
+                const key = fileIdentityKey(importer);
+                if (key === fileIdentityKey(definitionFile) || candidateFileKeys.has(key))
+                    continue;
+                graphLinkedOrphans.set(key, importer);
+            }
+        }
+        // A star import can expose a namespace reexport rather than the member definition itself.
+        // Include direct star importers of that package so their namespace member use is verified.
+        const namespaceTargetKeys = new Set([definition, ...equivalentDefinitions].map((candidate) => fileIdentityKey(candidate.file)));
+        for (const namespaceOwner of index.byFile.values()) {
+            const reexportsDefinitionAsNamespace = namespaceOwner.exports.some((entry) => entry.type === "namespaceReexport" && namespaceTargetKeys.has(fileIdentityKey(entry.fromModule)));
+            if (!reexportsDefinitionAsNamespace)
+                continue;
+            const namespaceOwnerKey = fileIdentityKey(namespaceOwner.file);
+            if (namespaceOwnerKey !== fileIdentityKey(definitionFile) && !candidateFileKeys.has(namespaceOwnerKey)) {
+                graphLinkedOrphans.set(namespaceOwnerKey, namespaceOwner.file);
+            }
+            for (const importer of getReverseNeighbors(adjacency, namespaceOwner.file)) {
+                const key = fileIdentityKey(importer);
+                if (key === fileIdentityKey(definitionFile) || candidateFileKeys.has(key))
+                    continue;
+                const importerModule = index.byFile.get(key);
+                const importsNamespaceOwner = importerModule?.imports.some((candidate) => candidate.kind === "star" &&
+                    typeof candidate.resolved === "string" &&
+                    fileIdentityKey(candidate.resolved) === namespaceOwnerKey);
+                if (importsNamespaceOwner)
+                    graphLinkedOrphans.set(key, importer);
+            }
+        }
+        for (const [key, file] of graphLinkedOrphans) {
+            candidateFiles.push(file);
+            candidateFileKeys.add(key);
+            unitPeerKeys.add(key);
+        }
+        if (graphLinkedOrphans.size)
+            candidateFiles.sort((left, right) => left.localeCompare(right));
+    }
     for (const fileId of candidateFiles) {
         if (hasReachedCollectionLimit())
             break;
@@ -392,10 +748,10 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
                 if (!exportedNameSet.has(entry.sourceSpecifier))
                     continue;
                 const resolved = resolveExport(index, entry.fromModule, entry.sourceSpecifier);
-                if (resolved?.kind === "resolved" && !sameDef(resolved.def, def, index.languageExtensions))
+                if (resolved?.kind === "resolved" && !matchesReferenceDefinition(resolved.def))
                     continue;
                 const remainingReferences = remainingCollectionSlots();
-                const ranges = await collectVerifiedNamedNodeReferences(index, fileId, entry.sourceSpecifier, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences, verifiedReferenceFilter(fileId));
+                const ranges = await collectVerifiedNamedNodeReferences(index, fileId, entry.sourceSpecifier, definition, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences, verifiedReferenceFilter(fileId), (unavailableFile) => receiverProofUnavailableFiles.set(fileIdentityKey(unavailableFile), unavailableFile));
                 for (const { range, provenance, via } of ranges) {
                     if (hasReachedCollectionLimit())
                         break;
@@ -408,6 +764,8 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
         for (const imp of module.imports) {
             if (hasReachedCollectionLimit())
                 break;
+            if (cNamespace && imp.kind === "named" && (imp.cNamespace ?? "ordinary") !== cNamespace)
+                continue;
             const targetFile = typeof imp.resolved === "string" ? imp.resolved : undefined;
             const bindingSites = importBindingReferenceSites(imp);
             let verifiedBindingMatches;
@@ -415,6 +773,11 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
                 if (verifiedBindingMatches !== undefined)
                     return verifiedBindingMatches;
                 verifiedBindingMatches = false;
+                if (imp.kind === "named" &&
+                    imp.mechanism === "php" &&
+                    !phpReferenceRoleMatchesKind(imp.phpImportType ?? "class", definition.kind)) {
+                    return verifiedBindingMatches;
+                }
                 const parsed = await ensureCandidateParsed();
                 for (const verificationSite of importBindingIdentityVerificationSites(imp)) {
                     const resolved = await goToDefinition(index, {
@@ -422,7 +785,7 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
                         line: verificationSite.range.start.line,
                         column: verificationSite.range.start.column,
                     }, parsed);
-                    if (resolved.status === "ok" && sameDef(resolved.definition, def, index.languageExtensions)) {
+                    if (resolved.status === "ok" && matchesReferenceDefinition(resolved.definition)) {
                         verifiedBindingMatches = true;
                         break;
                     }
@@ -443,20 +806,95 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
                         via: { import: imp, importBinding: site.importBinding },
                     });
                 }
+                if (!hasReachedCollectionLimit() && imp.kind === "named") {
+                    const ranges = await collectVerifiedNamedNodeReferences(index, fileId, imp.local, definition, (params, parsed) => goToDefinition(index, params, parsed), remainingCollectionSlots(), verifiedReferenceFilter(fileId), (unavailableFile) => receiverProofUnavailableFiles.set(fileIdentityKey(unavailableFile), unavailableFile));
+                    for (const { range, provenance, via } of ranges) {
+                        if (hasReachedCollectionLimit())
+                            break;
+                        pushRef({
+                            file: fileId,
+                            range,
+                            via: { import: imp, ...(via ?? {}) },
+                            ...(provenance ? { provenance } : {}),
+                        });
+                    }
+                }
                 continue;
             }
+            const cjsTargetModule = imp.kind === "namespace" && imp.mechanism === "cjs" ? index.byFile.get(fileIdentityKey(targetFile)) : undefined;
+            const cjsExportedName = cjsTargetModule && directModuleValueEntry(cjsTargetModule)?.exportedAs;
             for (const exportedName of exportedNames) {
                 if (hasReachedCollectionLimit())
                     break;
-                if (imp.kind === "namespace") {
-                    const hit = resolveExport(index, targetFile, exportedName);
+                const cjsModuleValue = cjsExportedName === exportedName;
+                if (imp.kind === "namespace" && !cjsModuleValue) {
+                    if (!isGoExportedMemberName(supportForFileWithoutHeaderSample(fileId, index.languageExtensions)?.id, exportedName)) {
+                        continue;
+                    }
+                    const hit = resolveExport(index, targetFile, exportedName, exportOptions);
                     const matchesDef = hit?.kind === "resolved"
-                        ? sameDef(hit.def, def, index.languageExtensions)
-                        : imp.kind === "namespace" && fileIdentityKey(targetFile) === fileIdentityKey(definitionFile);
-                    if (!matchesDef)
+                        ? matchesReferenceDefinition(hit.def)
+                        : imp.kind === "namespace" &&
+                            [definition, ...equivalentDefinitions].some((candidate) => fileIdentityKey(targetFile) === fileIdentityKey(candidate.file));
+                    // Python binds the first segment of an unaliased dotted import, while an alias
+                    // binds the whole module. Other namespaces use their local name directly.
+                    const namespaceSearchName = imp.mechanism === "python" && imp.from.includes(".") && !imp.explicitAlias ? imp.from : imp.localNS;
+                    if (!matchesDef) {
+                        const targetModule = index.byFile.get(fileIdentityKey(targetFile));
+                        if (!targetModule?.exports.some((entry) => entry.type === "namespaceReexport" || entry.type === "exportStar")) {
+                            continue;
+                        }
+                        // A namespace re-export exposes a member at paths such as W.helpers.helper,
+                        // not as a bare export of the intermediate module. Follow only export-proven
+                        // namespace edges, then verify each use through the same goto resolver.
+                        const namespacePaths = [
+                            { file: targetFile, name: namespaceSearchName, depth: 0 },
+                        ];
+                        for (let pathIndex = 0; pathIndex < namespacePaths.length; pathIndex++) {
+                            if (pathIndex >= MAX_REFERENCE_NAMESPACE_PATHS) {
+                                receiverProofUnavailableFiles.set(fileIdentityKey(fileId), fileId);
+                                break;
+                            }
+                            const namespacePath = namespacePaths[pathIndex];
+                            if (namespacePath.depth) {
+                                const nestedHit = resolveExport(index, namespacePath.file, exportedName, {
+                                    allowLocalFallback: false,
+                                    ...(exportOptions ?? {}),
+                                });
+                                if (nestedHit?.kind === "resolved" && matchesReferenceDefinition(nestedHit.def)) {
+                                    const parsed = await ensureCandidateParsed();
+                                    const ranges = await collectNamespaceMemberRefs(fileId, namespacePath.name, exportedName, parsed, index.languageExtensions, imp, module.imports);
+                                    for (const range of ranges) {
+                                        if (hasReachedCollectionLimit())
+                                            break;
+                                        const proof = await goToDefinition(index, { file: fileId, line: range.start.line, column: range.start.column }, parsed);
+                                        if (proof.status !== "ok" || !matchesReferenceDefinition(proof.definition))
+                                            continue;
+                                        pushRef({ file: fileId, range, via: { import: imp, namespaceMember: exportedName } });
+                                    }
+                                }
+                            }
+                            const exports = resolveModuleExports(index, namespacePath.file, { allowLocalFallback: false });
+                            if (namespacePath.depth >= MAX_REFERENCE_NAMESPACE_DEPTH) {
+                                if ([...exports.values()].some((entry) => entry.kind === "namespace")) {
+                                    receiverProofUnavailableFiles.set(fileIdentityKey(fileId), fileId);
+                                }
+                                continue;
+                            }
+                            for (const [alias, entry] of exports) {
+                                if (entry.kind !== "namespace")
+                                    continue;
+                                namespacePaths.push({
+                                    file: entry.file,
+                                    name: `${namespacePath.name}.${alias}`,
+                                    depth: namespacePath.depth + 1,
+                                });
+                            }
+                        }
                         continue;
+                    }
                     const parsed = await ensureCandidateParsed();
-                    const ranges = await collectNamespaceMemberRefs(fileId, imp.localNS, exportedName, parsed, index.languageExtensions);
+                    const ranges = await collectNamespaceMemberRefs(fileId, namespaceSearchName, exportedName, parsed, index.languageExtensions, imp, module.imports);
                     for (const range of ranges) {
                         if (hasReachedCollectionLimit())
                             break;
@@ -468,51 +906,130 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
                     }
                 }
                 else if (imp.kind === "star") {
-                    const result = resolveImported(index, imp, exportedName);
-                    const matchesDef = !!result && !("namespace" in result) && sameDef(result, def, index.languageExtensions);
-                    if (!matchesDef)
-                        continue;
-                    if (hasExpandedNamedImport(module, targetFile, exportedName)) {
+                    const result = resolveImported(index, imp, exportedName, exportOptions);
+                    const matchesDef = !!result && !("namespace" in result) && matchesReferenceDefinition(result);
+                    const matchesStructural = cppCanonicalStructuralExport(index, targetFile, exportedName, definition, parsedContext.sup.id);
+                    if (matchesDef || matchesStructural) {
+                        if (hasExpandedNamedImport(module, targetFile, exportedName)) {
+                            continue;
+                        }
+                        const remainingReferences = remainingCollectionSlots();
+                        const ranges = await collectVerifiedNamedNodeReferences(index, fileId, parsedContext.sup.id === "cpp" || parsedContext.sup.id === "ruby"
+                            ? (exportedName.split("::").pop() ?? exportedName)
+                            : exportedName, definition, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences, verifiedReferenceFilter(fileId), (unavailableFile) => receiverProofUnavailableFiles.set(fileIdentityKey(unavailableFile), unavailableFile), equivalentDefinitions);
+                        for (const { range, provenance, via } of ranges) {
+                            if (hasReachedCollectionLimit())
+                                break;
+                            pushRef({
+                                file: fileId,
+                                range,
+                                via: { import: imp, ...(via ?? {}) },
+                                ...(provenance ? { provenance } : {}),
+                            });
+                        }
                         continue;
                     }
-                    const remainingReferences = remainingCollectionSlots();
-                    const ranges = await collectVerifiedNamedNodeReferences(index, fileId, exportedName, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences, verifiedReferenceFilter(fileId));
-                    for (const { range, provenance, via } of ranges) {
-                        if (hasReachedCollectionLimit())
-                            break;
-                        pushRef({
-                            file: fileId,
-                            range,
-                            via: { import: imp, ...(via ?? {}) },
-                            ...(provenance ? { provenance } : {}),
-                        });
+                    // A star import can publish a namespace such as a package submodule. Resolve that
+                    // namespace under the same precedence as navigation before attributing its member use.
+                    const namespaceExports = resolveModuleExports(index, targetFile);
+                    const parsed = await ensureCandidateParsed();
+                    for (const [namespaceName, namespaceResult] of namespaceExports) {
+                        if (namespaceResult.kind !== "namespace")
+                            continue;
+                        if (![definition, ...equivalentDefinitions].some((candidate) => fileIdentityKey(namespaceResult.file) === fileIdentityKey(candidate.file))) {
+                            continue;
+                        }
+                        const namespaceDecision = resolveStarImportedNamespace(index, module, parsed.sup.id, namespaceName);
+                        if (namespaceDecision.status !== "resolved" || namespaceDecision.imp !== imp)
+                            continue;
+                        const ranges = await collectNamespaceMemberRefs(fileId, namespaceName, exportedName, parsed, index.languageExtensions, undefined, module.imports);
+                        for (const range of ranges) {
+                            if (hasReachedCollectionLimit())
+                                break;
+                            pushRef({ file: fileId, range, via: { import: imp, namespaceMember: exportedName } });
+                        }
                     }
                 }
                 else {
                     let exported = exportedName;
+                    const importedLocalName = imp.kind === "namespace" ? imp.localNS : imp.local;
                     if (imp.kind === "named") {
                         exported = imp.imported;
                     }
                     else if (imp.kind === "default") {
                         exported = "default";
                     }
-                    const hit = resolveExport(index, targetFile, exported);
-                    let matchesDef = hit?.kind === "resolved" && sameDef(hit.def, def, index.languageExtensions);
+                    const hit = resolveExport(index, targetFile, exported, exportOptions);
+                    let matchesDef = hit?.kind === "resolved" && matchesReferenceDefinition(hit.def);
+                    let attributedByProof = matchesDef;
                     if (!matchesDef && bindingSites.length) {
                         matchesDef = await bindingMatchesDefinition();
+                        attributedByProof = matchesDef;
+                    }
+                    if (!matchesDef &&
+                        cppCanonicalStructuralExport(index, targetFile, exported, definition, parsedContext.sup.id)) {
+                        // Recover candidates, but prove each overload call through goToDefinition.
+                        // Structural visibility alone cannot attribute the import token.
+                        matchesDef = true;
+                    }
+                    // A python `from pkg import name` binds `name` from the package's own namespace.
+                    // Usually that is a real re-exported symbol (handled above); when the package has no
+                    // such export, Python's own import system falls back to treating `name` as an
+                    // implicit submodule attribute instead. Reuse the namespace-style dotted scan the
+                    // `imp.kind === "namespace"` branch above runs, rather than the bare-identifier scan
+                    // this branch runs next, so a same-name use through the bound local still counts.
+                    if (!matchesDef && imp.kind === "named" && imp.mechanism === "python") {
+                        const importedResult = resolveImported(index, imp, exported, exportOptions);
+                        const submoduleFile = importedResult && "namespace" in importedResult ? importedResult.namespace : undefined;
+                        if (submoduleFile &&
+                            [definition, ...equivalentDefinitions].some((candidate) => fileIdentityKey(submoduleFile) === fileIdentityKey(candidate.file))) {
+                            const parsed = await ensureCandidateParsed();
+                            const ranges = await collectNamespaceMemberRefs(fileId, imp.local, exportedName, parsed, index.languageExtensions, undefined, module.imports);
+                            for (const range of ranges) {
+                                if (hasReachedCollectionLimit())
+                                    break;
+                                pushRef({ file: fileId, range, via: { import: imp, namespaceMember: exportedName } });
+                            }
+                            continue;
+                        }
                     }
-                    if (!matchesDef)
+                    if (!matchesDef) {
+                        // The requested export slot itself does not exist at all (as opposed to existing
+                        // and structurally naming a different, already-proven definition): the binding may
+                        // still be a whole-module handle onto this exact file under a shape resolution does
+                        // not model (a misclassified default import, for example). Verify every same-name
+                        // occurrence directly instead of silently treating the file as clean.
+                        if (!hasReachedCollectionLimit() &&
+                            hit?.kind !== "resolved" &&
+                            [definition, ...equivalentDefinitions].some((candidate) => fileIdentityKey(targetFile) === fileIdentityKey(candidate.file))) {
+                            const remainingReferences = remainingCollectionSlots();
+                            const ranges = await collectVerifiedNamedNodeReferences(index, fileId, exportedName, definition, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences, verifiedReferenceFilter(fileId), (unavailableFile) => receiverProofUnavailableFiles.set(fileIdentityKey(unavailableFile), unavailableFile), equivalentDefinitions);
+                            for (const { range, provenance, via } of ranges) {
+                                if (hasReachedCollectionLimit())
+                                    break;
+                                pushRef({
+                                    file: fileId,
+                                    range,
+                                    via: { import: imp, ...(via ?? {}) },
+                                    ...(provenance ? { provenance } : {}),
+                                });
+                            }
+                        }
                         continue;
-                    for (const site of bindingSites) {
-                        pushRef({
-                            file: fileId,
-                            range: site.range,
-                            via: { import: imp, importBinding: site.importBinding },
-                        });
                     }
-                    if (fileIdentityKey(targetFile) !== fileIdentityKey(definitionFile)) {
+                    if (attributedByProof) {
+                        for (const site of bindingSites) {
+                            pushRef({
+                                file: fileId,
+                                range: site.range,
+                                via: { import: imp, importBinding: site.importBinding },
+                            });
+                        }
+                    }
+                    const scansQualifiedCppImport = parsedContext.sup.id === "cpp" && imp.kind === "named" && imp.local.includes("::");
+                    if (imp.kind === "named" || fileIdentityKey(targetFile) !== fileIdentityKey(definitionFile)) {
                         const remainingReferences = remainingCollectionSlots();
-                        const ranges = await collectVerifiedNamedNodeReferences(index, fileId, imp.local, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences, verifiedReferenceFilter(fileId));
+                        const ranges = await collectVerifiedNamedNodeReferences(index, fileId, scansQualifiedCppImport ? (importedLocalName.split("::").pop() ?? importedLocalName) : importedLocalName, definition, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences, verifiedReferenceFilter(fileId), (unavailableFile) => receiverProofUnavailableFiles.set(fileIdentityKey(unavailableFile), unavailableFile), equivalentDefinitions);
                         for (const { range, provenance, via } of ranges) {
                             if (hasReachedCollectionLimit())
                                 break;
@@ -527,7 +1044,7 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
                     }
                     const parsed = await ensureCandidateParsed();
                     const resolvedScope = await ensureScope();
-                    const localName = parsed.sup.normalizeIdentifier(imp.local);
+                    const localName = parsed.sup.normalizeIdentifier(importedLocalName);
                     const declarationKeys = importBindingDeclarationRangeKeys(module);
                     const bindings = resolvedScope.bindings.get(localName) ?? [];
                     for (const binding of bindings) {
@@ -544,34 +1061,67 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
                 }
             }
         }
-        if (phpQualifiedNames.length) {
-            const remainingReferences = remainingCollectionSlots();
-            for (const candidateName of [...exportedNames, ...phpQualifiedNames]) {
+        // A unit peer names the definition directly (Go and JVM package siblings, C# namespace
+        // peers, Swift module siblings), with no import binding to attribute. The single bare-name
+        // scan keeps reference sites in agreement with what bare-name resolution can prove.
+        if (!definition.isMember &&
+            fileIdentityKey(fileId) !== fileIdentityKey(definitionFile) &&
+            unitPeerKeys.has(fileIdentityKey(fileId)) &&
+            !hasReachedCollectionLimit()) {
+            const ranges = await collectVerifiedNamedNodeReferences(index, fileId, referenceDef.localName, definition, (params, parsed) => goToDefinition(index, params, parsed), remainingCollectionSlots(), verifiedReferenceFilter(fileId), (unavailableFile) => receiverProofUnavailableFiles.set(fileIdentityKey(unavailableFile), unavailableFile), equivalentDefinitions);
+            for (const { range, provenance, via } of ranges) {
                 if (hasReachedCollectionLimit())
                     break;
-                const ranges = await collectVerifiedNamedNodeReferences(index, fileId, candidateName, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences, verifiedReferenceFilter(fileId));
-                for (const { range, provenance, via } of ranges) {
+                pushRef({ file: fileId, range, ...(via ? { via } : {}), ...(provenance ? { provenance } : {}) });
+            }
+        }
+        // Only the exact dotted submodule path can refer to this definition through a
+        // parent-package import. Other same-name uses are proven unrelated.
+        if (parsedContext.sup.id === "python" && !definition.isMember && !hasReachedCollectionLimit()) {
+            for (const { namespace, importBinding } of pythonParentPackageNamespacePaths(module, definitionFile)) {
+                const parsed = await ensureCandidateParsed();
+                const ranges = await collectNamespaceMemberRefs(fileId, namespace, referenceDef.localName, parsed, index.languageExtensions, importBinding, module.imports);
+                for (const range of ranges) {
                     if (hasReachedCollectionLimit())
                         break;
-                    pushRef({ file: fileId, range, ...(via ? { via } : {}), ...(provenance ? { provenance } : {}) });
+                    const hit = await goToDefinition(index, { file: fileId, line: range.start.line, column: range.start.column }, parsed);
+                    if (hit.status === "ok") {
+                        if (matchesReferenceDefinition(hit.definition))
+                            pushRef({ file: fileId, range });
+                    }
+                    else {
+                        receiverProofUnavailableFiles.set(fileIdentityKey(fileId), fileId);
+                    }
                 }
             }
         }
+        if (phpQualifiedNames.length) {
+            const remainingReferences = remainingCollectionSlots();
+            const ranges = await collectVerifiedNamedNodeReferences(index, fileId, referenceDef.localName, referenceDef, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences, verifiedReferenceFilter(fileId), (unavailableFile) => receiverProofUnavailableFiles.set(fileIdentityKey(unavailableFile), unavailableFile));
+            for (const { range, provenance, via } of ranges) {
+                if (hasReachedCollectionLimit())
+                    break;
+                pushRef({ file: fileId, range, ...(via ? { via } : {}), ...(provenance ? { provenance } : {}) });
+            }
+        }
     }
     const receiverScannedFiles = [];
-    if (shouldScanVerifiedReferences(def, phpQualifiedNames, parsedContext)) {
+    if (scansReceiverReferences) {
         for (const fileId of Array.from(index.byFile.values(), (module) => module.file).sort((left, right) => left.localeCompare(right))) {
             if (hasReachedCollectionLimit())
                 break;
             receiverScannedFiles.push(fileId);
             const filter = index.bloomFilters?.get(fileIdentityKey(fileId));
-            // Bloom filters contain names normalized by the candidate file's language, so probes must use that rule.
-            const canonicalName = supportForFileWithoutHeaderSample(fileId, index.languageExtensions)?.normalizeIdentifier(def.localName) ??
-                def.localName;
+            const candidateSupport = supportForFileWithoutHeaderSample(fileId, index.languageExtensions);
+            // Bloom filters store folded PHP identifiers in addition to their source spelling.
+            const normalizedName = candidateSupport?.normalizeIdentifier(referenceDef.localName) ?? referenceDef.localName;
+            const canonicalName = candidateSupport?.id === "php" && isPhpCaseInsensitiveSymbolKind(definition.kind)
+                ? foldPhpIdentifierCase(normalizedName)
+                : normalizedName;
             if (filter && !filter.mightContain(canonicalName))
                 continue;
             const remainingReferences = remainingCollectionSlots();
-            const ranges = await collectVerifiedNamedNodeReferences(index, fileId, def.localName, def, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences, verifiedReferenceFilter(fileId));
+            const ranges = await collectVerifiedNamedNodeReferences(index, fileId, referenceDef.localName, referenceDef, (params, parsed) => goToDefinition(index, params, parsed), remainingReferences, verifiedReferenceFilter(fileId), (unavailableFile) => receiverProofUnavailableFiles.set(fileIdentityKey(unavailableFile), unavailableFile), equivalentDefinitions);
             for (const { range, provenance, via } of ranges) {
                 if (hasReachedCollectionLimit())
                     break;
@@ -612,44 +1162,385 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
         }
     }
     const scannedFiles = [definitionFile, ...candidateFiles, ...receiverScannedFiles];
+    // Top-level implicit-unit names and C# partial / Swift shared-owner members are both bounded
+    // by the source-unit relation; an unproven boundary leaves their reference set partial.
+    const implicitUnitComplete = !definition.isMember && IMPLICIT_UNIT_LANGUAGES[parsedContext.sup.id]
+        ? getCompilationUnitPeers(index, definitionFile, parsedContext.sup.id === "csharp" ? { csharpQualifiedName: true } : undefined).complete
+        : await sharedOwnerMemberUnitComplete(index, definition);
     const referenceCoverage = buildIndexedCandidateCoverage({
         index,
-        def,
+        def: definition,
+        languageId: parsedContext.sup.id,
         exportedNames,
         candidateFiles,
         scannedFiles,
         truncated,
+        strategies: describeReferenceStrategies({
+            languageId: parsedContext.sup.id,
+            phpQualifiedNames,
+            sameFileOccurrence: {
+                // C/C++ callable siblings and reopened C# namespace regions can refer to a
+                // declaration without sharing its lexical scope. Verify those uses through
+                // navigation; parameters and local variables remain lexical-only.
+                applicable: requiresSameFileVerifiedScan,
+                executed: sameFileVerifiedScanExecuted,
+            },
+            // An unproven compilation-unit boundary means the peer universe may extend beyond the
+            // enumerated files, so coverage must not imply that every possible consumer was scanned.
+            ...(implicitUnitComplete !== null
+                ? { implicitUnitPeers: { applicable: true, executed: implicitUnitComplete } }
+                : {}),
+        }),
+        strategyUnavailableFiles: [
+            ...receiverProofUnavailableFiles.values(),
+            ...(rubyReopen?.incomplete ? [definition.file] : []),
+        ],
     });
     return {
         status: "ok",
-        definition: def,
+        definition,
         references: refs,
         referenceCoverage,
         ...(provenance ? { provenance } : {}),
     };
 }
-function shouldScanVerifiedReferences(def, phpQualifiedNames, parsedContext) {
-    if (phpQualifiedNames.length)
-        return false;
-    if (!supportsReceiverMemberNavigation(parsedContext.sup.id))
+function syntaxNodeForDefinition(parsedContext, def) {
+    const position = {
+        row: def.range.start.line - 1,
+        column: def.range.start.column - 1,
+    };
+    return parsedContext.tree.rootNode.descendantForPosition(position, position);
+}
+/**
+ * Restores indexed metadata for definitions that arrive without it — impact fabricates reference
+ * defs from changed-symbol projections, dropping fields such as `isMember`. Matching is exact
+ * identity against the definition file's module.locals: same kind, localName, and full range span.
+ * Definitions without byte indices or without a matching local are returned unchanged.
+ */
+function indexedDefinitionByIdentity(index, def) {
+    const mod = index.byFile.get(fileIdentityKey(def.file));
+    if (!mod)
+        return def;
+    const startIndex = def.range.start.index;
+    const endIndex = def.range.end.index;
+    if (startIndex === undefined || endIndex === undefined)
+        return def;
+    return (mod.locals.find((candidate) => candidate.kind === def.kind &&
+        candidate.localName === def.localName &&
+        candidate.range.start.index === startIndex &&
+        candidate.range.end.index === endIndex) ?? def);
+}
+/**
+ * Reverse include edges for one index. Rebuilt only when the index object is
+ * new, matching the WeakMap caches in navigation-references.ts.
+ */
+const cIncludedByCache = new WeakMap();
+function cIncludedBy(index) {
+    const cached = cIncludedByCache.get(index);
+    if (cached)
+        return cached;
+    const includedBy = new Map();
+    for (const moduleEntry of index.byFile.values()) {
+        const includerKey = fileIdentityKey(moduleEntry.file);
+        for (const imp of moduleEntry.imports) {
+            if (typeof imp.resolved !== "string")
+                continue;
+            const includedKey = fileIdentityKey(imp.resolved);
+            const includers = includedBy.get(includedKey);
+            if (includers)
+                includers.push(includerKey);
+            else
+                includedBy.set(includedKey, [includerKey]);
+        }
+    }
+    const stored = new Map();
+    for (const [key, includers] of includedBy)
+        stored.set(key, includers);
+    cIncludedByCache.set(index, stored);
+    return stored;
+}
+/** Indexed files linked to `startFile` by `#include` in either direction, excluding the file itself. */
+function cIncludeLinkedModules(index, startFile) {
+    const startKey = fileIdentityKey(startFile);
+    const includedBy = cIncludedBy(index);
+    const linked = new Set();
+    const walk = (origin, neighbors) => {
+        const pending = [origin];
+        const seen = new Set([origin]);
+        while (pending.length) {
+            const current = pending.pop();
+            for (const neighbor of neighbors(current)) {
+                if (seen.has(neighbor))
+                    continue;
+                seen.add(neighbor);
+                linked.add(neighbor);
+                pending.push(neighbor);
+            }
+        }
+    };
+    walk(startKey, (key) => {
+        const moduleEntry = index.byFile.get(key);
+        if (!moduleEntry)
+            return [];
+        const included = [];
+        for (const imp of moduleEntry.imports) {
+            if (typeof imp.resolved === "string")
+                included.push(fileIdentityKey(imp.resolved));
+        }
+        return included;
+    });
+    walk(startKey, (key) => includedBy.get(key) ?? []);
+    linked.delete(startKey);
+    const modules = [];
+    for (const key of linked) {
+        const moduleEntry = index.byFile.get(key);
+        if (moduleEntry)
+            modules.push(moduleEntry);
+    }
+    return modules;
+}
+/**
+ * C prototype and definition of one signature, joined only when one file includes
+ * the other. Two translation units that merely share an unrelated header stay apart,
+ * and `static` functions are not exports so they never join the family.
+ */
+async function cIncludeLinkedCallableEquivalents(index, def, definitionNameNode) {
+    if (def.kind !== SymbolKind.Function || def.cTag)
+        return [];
+    const expected = cppCallableShapeForNode(definitionNameNode);
+    if (!expected)
+        return [];
+    const origin = index.byFile.get(fileIdentityKey(def.file));
+    const exported = origin?.exports.some((entry) => entry.type === "local" && sameDef(entry.target, def, index.languageExtensions));
+    if (!exported)
+        return [];
+    const equivalents = new Map();
+    for (const moduleEntry of cIncludeLinkedModules(index, def.file)) {
+        const candidates = [];
+        for (const entry of moduleEntry.exports) {
+            if (entry.type !== "local")
+                continue;
+            if (entry.exportedAs !== def.localName || entry.target.localName !== def.localName)
+                continue;
+            if (entry.target.kind !== SymbolKind.Function || entry.target.cTag)
+                continue;
+            candidates.push(entry.target);
+        }
+        if (!candidates.length)
+            continue;
+        let candidateParsed;
+        try {
+            candidateParsed = await ensureParsedContext(moduleEntry.file, index.parsed?.get(fileIdentityKey(moduleEntry.file)), index.languageExtensions);
+        }
+        catch {
+            continue;
+        }
+        if (candidateParsed.sup.id !== "c")
+            continue;
+        for (const candidate of candidates) {
+            if (sameDef(candidate, def, index.languageExtensions))
+                continue;
+            const candidateNode = syntaxNodeForDefinition(candidateParsed, candidate);
+            if (cppCallableShapeForNode(candidateNode)?.signature !== expected.signature)
+                continue;
+            equivalents.set(referenceSiteKey(candidate.file, candidate.range), candidate);
+        }
+    }
+    return [...equivalents.values()];
+}
+/**
+ * Single calculation behind reference collection and getCppEquivalentCallableDefinitions: resolves
+ * the receiver owner, the normalized reference name, the definition-site scope binding, and the
+ * proven equivalent definition family for one callable definition site.
+ */
+async function cppEquivalentCallableFamily(index, def, parsedContext) {
+    const definition = indexedDefinitionByIdentity(index, def);
+    const mod = index.byFile.get(fileIdentityKey(definition.file));
+    if (!mod) {
+        return { definition, referenceDef: definition, receiverOwner: null, localBinding: undefined, equivalents: [] };
+    }
+    const context = parsedContext ??
+        (await ensureParsedContext(definition.file, index.parsed?.get(fileIdentityKey(definition.file)), index.languageExtensions));
+    const definitionNameNode = syntaxNodeForDefinition(context, definition);
+    const receiverOwner = await cppOutOfLineReceiverOwner(index, mod, definition, context, definitionNameNode);
+    const memberName = receiverOwner ? cppOutOfLineMemberName(definitionNameNode, context.source, context.sup) : null;
+    const referenceDef = memberName && memberName !== definition.localName ? { ...definition, localName: memberName } : definition;
+    const normalizedLocalName = context.sup.normalizeIdentifier(referenceDef.localName);
+    const scope = getCachedScope(index, definition.file, mod, context);
+    const localBindings = scope.bindings.get(normalizedLocalName) ?? [];
+    const localBinding = localBindings.find((binding) => binding.def && binding.def.start.index === definition.range.start.index);
+    let sameFileFunctionBindings = localBindings;
+    if (context.sup.id === "cpp") {
+        sameFileFunctionBindings = localBinding ? cppEquivalentCallableBindings(localBinding) : [];
+    }
+    const sameFileFunctionEquivalentDefinitions = (context.sup.id === "c" || context.sup.id === "cpp") && definition.kind === SymbolKind.Function
+        ? sameFileFunctionBindings.flatMap((binding) => {
+            const bindingRange = binding.def;
+            if (!bindingRange || bindingRange.start.index === definition.range.start.index)
+                return [];
+            const local = mod.locals.find((candidate) => candidate.kind === SymbolKind.Function &&
+                candidate.localName === definition.localName &&
+                candidate.range.start.index === bindingRange.start.index &&
+                candidate.range.end.index === bindingRange.end.index);
+            return local ? [local] : [];
+        })
+        : [];
+    let equivalents;
+    if (receiverOwner) {
+        equivalents = await cppOutOfLineEquivalentDefinitions(index, referenceDef, context, definitionNameNode, receiverOwner);
+    }
+    else if (definition.isMember && context.sup.id === "cpp") {
+        equivalents = await cppInClassMemberEquivalentDefinitions(index, definition, context, definitionNameNode);
+    }
+    else if (context.sup.id === "cpp") {
+        equivalents = [
+            ...sameFileFunctionEquivalentDefinitions,
+            ...(await cppNamespaceFunctionEquivalentDefinitions(index, definition, context, definitionNameNode)),
+        ];
+    }
+    else if (context.sup.id === "c" && definition.kind === SymbolKind.Function && !definition.cTag) {
+        const linked = await cIncludeLinkedCallableEquivalents(index, definition, definitionNameNode);
+        const seen = new Set(sameFileFunctionEquivalentDefinitions.map((item) => referenceSiteKey(item.file, item.range)));
+        equivalents = [
+            ...sameFileFunctionEquivalentDefinitions,
+            ...linked.filter((item) => !seen.has(referenceSiteKey(item.file, item.range))),
+        ];
+    }
+    else {
+        equivalents = sameFileFunctionEquivalentDefinitions;
+    }
+    return { definition, referenceDef, receiverOwner, localBinding, equivalents };
+}
+async function cppOutOfLineReceiverOwner(index, mod, def, parsedContext, definitionNameNode) {
+    if (parsedContext.sup.id !== "cpp" || def.kind !== SymbolKind.Function)
+        return null;
+    const ownerPath = cppOutOfLineOwnerPath(definitionNameNode, parsedContext.source, parsedContext.sup);
+    return ownerPath ? await resolveCppQualifiedMemberContainer(index, mod, ownerPath) : null;
+}
+async function cppOutOfLineEquivalentDefinitions(index, def, parsedContext, definitionNameNode, owner) {
+    const ownerModule = index.byFile.get(fileIdentityKey(owner.file));
+    if (!ownerModule)
+        return [];
+    const ownerParsed = await ensureParsedContext(owner.file, index.parsed?.get(fileIdentityKey(owner.file)), index.languageExtensions);
+    const ownerNameNode = syntaxNodeForDefinition(ownerParsed, owner);
+    const declaration = cppOutOfLineMemberDeclarationNode(definitionNameNode, def.localName, ownerNameNode, ownerParsed.source, parsedContext.sup);
+    if (!declaration)
+        return [];
+    const normalizedName = parsedContext.sup.normalizeIdentifier(def.localName);
+    return ownerModule.locals.filter((candidate) => parsedContext.sup.normalizeIdentifier(candidate.localName) === normalizedName &&
+        candidate.range.start.index === declaration.nameNode.startIndex);
+}
+async function cppInClassMemberEquivalentDefinitions(index, def, parsedContext, definitionNameNode) {
+    if (def.kind !== SymbolKind.Function)
+        return [];
+    const ownerSegments = [];
+    let current = definitionNameNode.parent;
+    while (current) {
+        if (CPP_MEMBER_CONTAINER_TYPES.has(current.type) || current.type === "namespace_definition") {
+            const name = current.childForFieldName("name");
+            if (!name)
+                return [];
+            ownerSegments.unshift(cppQualifiedNameSegments(name, parsedContext.source));
+        }
+        current = current.parent;
+    }
+    const owners = ownerSegments.flat();
+    if (!owners.length)
+        return [];
+    const qualifiedName = [...owners, def.localName].join("::");
+    const expectedShape = cppCallableShapeForNode(definitionNameNode);
+    if (!expectedShape)
+        return [];
+    const equivalents = new Map();
+    for (const module of index.byFile.values()) {
+        for (const entry of module.exports) {
+            if (entry.type !== "local" ||
+                entry.exportedAs !== qualifiedName ||
+                entry.target.kind !== SymbolKind.Function ||
+                sameDef(entry.target, def, index.languageExtensions)) {
+                continue;
+            }
+            const candidateParsed = await ensureParsedContext(entry.target.file, index.parsed?.get(fileIdentityKey(entry.target.file)), index.languageExtensions);
+            const candidateNode = syntaxNodeForDefinition(candidateParsed, entry.target);
+            const candidateShape = cppCallableShapeForNode(candidateNode);
+            if (!candidateShape)
+                continue;
+            let explicitSpecialization = false;
+            let current = candidateNode;
+            while (current) {
+                if (current.type === "template_declaration" &&
+                    /^\s*template\s*<\s*>/u.test(sliceText(current, candidateParsed.source))) {
+                    explicitSpecialization = true;
+                    break;
+                }
+                current = current.parent;
+            }
+            const arityMatches = candidateShape.minArity === expectedShape.minArity && candidateShape.maxArity === expectedShape.maxArity;
+            if (candidateShape.signature !== expectedShape.signature && !(explicitSpecialization && arityMatches)) {
+                continue;
+            }
+            equivalents.set(referenceSiteKey(entry.target.file, entry.target.range), entry.target);
+        }
+    }
+    return [...equivalents.values()];
+}
+function shouldScanVerifiedReferences(def, parsedContext, receiverMemberDefinition) {
+    if (parsedContext.sup.id === "php" && !isPhpCaseInsensitiveSymbolKind(def.kind))
         return false;
-    return isReceiverMemberDefinition(def, parsedContext);
+    return supportsReceiverMemberNavigation(parsedContext.sup.id) && receiverMemberDefinition;
 }
-function shouldUseLocalNameAsExportFallback(def, parsedContext) {
-    return !isReceiverMemberDefinition(def, parsedContext);
+async function cppNamespaceFunctionEquivalentDefinitions(index, def, parsedContext, definitionNameNode) {
+    if (parsedContext.sup.id !== "cpp" || def.kind !== SymbolKind.Function)
+        return [];
+    const ownerPath = cppOutOfLineOwnerPath(definitionNameNode, parsedContext.source, parsedContext.sup);
+    const namespacePath = [];
+    if (!ownerPath) {
+        let current = definitionNameNode.parent;
+        while (current) {
+            if (CPP_MEMBER_CONTAINER_TYPES.has(current.type))
+                return [];
+            if (current.type === "namespace_definition") {
+                const name = current.childForFieldName("name");
+                if (!name)
+                    return [];
+                namespacePath.unshift(cppQualifiedNameSegments(name, parsedContext.source));
+            }
+            current = current.parent;
+        }
+    }
+    const owners = ownerPath ?? namespacePath.flat();
+    if (!owners.length)
+        return [];
+    const memberName = cppOutOfLineMemberName(definitionNameNode, parsedContext.source, parsedContext.sup) ?? def.localName;
+    const qualifiedName = [...owners, memberName].join("::");
+    const expectedShape = cppCallableShapeForNode(definitionNameNode);
+    if (!expectedShape)
+        return [];
+    const equivalents = new Map();
+    for (const module of index.byFile.values()) {
+        for (const entry of module.exports) {
+            if (entry.type !== "local" ||
+                entry.exportedAs !== qualifiedName ||
+                entry.target.kind !== SymbolKind.Function ||
+                sameDef(entry.target, def, index.languageExtensions)) {
+                continue;
+            }
+            const candidateParsed = await ensureParsedContext(entry.target.file, index.parsed?.get(fileIdentityKey(entry.target.file)), index.languageExtensions);
+            const candidateNode = syntaxNodeForDefinition(candidateParsed, entry.target);
+            if (cppCallableShapeForNode(candidateNode)?.signature !== expectedShape.signature)
+                continue;
+            equivalents.set(referenceSiteKey(entry.target.file, entry.target.range), entry.target);
+        }
+    }
+    return [...equivalents.values()];
 }
-function isReceiverMemberDefinition(def, parsedContext) {
-    if (def.isMember)
+function isReceiverMemberDefinition(def, parsedContext, hasCppOutOfLineOwner) {
+    if (def.isMember || hasCppOutOfLineOwner)
         return true;
-    if (def.kind !== SymbolKind.Function) {
+    if (def.kind !== SymbolKind.Function)
         return false;
-    }
-    const start = def.range.start;
-    const position = {
-        row: start.line - 1,
-        column: start.column - 1,
-    };
-    let current = parsedContext.tree.rootNode.descendantForPosition(position, position);
+    let current = syntaxNodeForDefinition(parsedContext, def);
+    let sawCppFunction = false;
     let sawRustImplFunction = false;
     while (current) {
         if (current.type === "method_definition" ||
@@ -659,33 +1550,73 @@ function isReceiverMemberDefinition(def, parsedContext) {
             current.type === "method") {
             return true;
         }
+        if (parsedContext.sup.id === "cpp") {
+            if (current.type === "function_definition")
+                sawCppFunction = true;
+            if (sawCppFunction && CPP_MEMBER_CONTAINER_TYPES.has(current.type))
+                return true;
+        }
         if (parsedContext.sup.id === "rust" && current.type === "function_item") {
             sawRustImplFunction = true;
         }
-        if (sawRustImplFunction && current.type === "impl_item") {
+        if (sawRustImplFunction && current.type === "impl_item")
             return true;
-        }
-        if (current.type === "function_declaration" || current.type === "program") {
+        if (current.type === "function_declaration" || current.type === "program")
             return false;
-        }
         current = current.parent;
     }
     return false;
 }
-export async function collectNamespaceMemberRefs(file, ns, member, parsedContext, languageExtensions) {
+export async function collectNamespaceMemberRefs(file, ns, member, parsedContext, languageExtensions, importBinding, imports) {
     const parsed = parsedContext ?? (await ensureParsedContext(file, undefined, languageExtensions));
     const sup = parsed.sup;
     const source = parsed.source;
     const tree = parsed.tree;
     const ranges = [];
+    // Identifier equality follows the language rule, so C# `@X::@Target` matches alias `X` member `Target`.
+    const normalize = sup.normalizeIdentifier;
+    const normalizedNs = normalize(ns);
+    const normalizedMember = normalize(member);
+    let effectivePythonBinding;
+    if (sup.id === "python" && importBinding && imports) {
+        let bindingName;
+        if (importBinding.kind === "namespace")
+            bindingName = importBinding.localNS;
+        else if (importBinding.kind === "named" || importBinding.kind === "default")
+            bindingName = importBinding.local;
+        if (bindingName) {
+            const normalizedBindingName = normalize(bindingName);
+            effectivePythonBinding = effectiveExplicitBinding(imports, sup.id, (binding) => {
+                if (binding.kind === "namespace")
+                    return normalize(binding.localNS) === normalizedBindingName;
+                return ((binding.kind === "named" || binding.kind === "default") && normalize(binding.local) === normalizedBindingName);
+            });
+        }
+    }
     const walk = (node) => {
         if (isMemberAccessNode(sup, node)) {
             const { object: obj, property: prop } = getMemberAccessParts(sup, node);
-            if (obj && prop && isMemberObjectIdentifier(obj.type) && isMemberReferencePropertyIdentifier(sup, prop.type)) {
+            if (obj && prop && isMemberReferencePropertyIdentifier(sup, prop.type)) {
                 const objectName = sliceText(obj, source);
                 const propertyName = sliceText(prop, source);
-                if (objectName === ns && propertyName === member) {
-                    ranges.push(toRange(prop));
+                // A python multi-segment dotted import (`import a.b`) binds only the first segment;
+                // the source only ever repeats the whole dotted phrase to reach the resolved leaf
+                // module again, so `ns` can be that literal phrase and `obj` a compound chain rather
+                // than the single bare identifier every other caller passes.
+                const objectMatches = normalizedNs.includes(".")
+                    ? normalize(objectName) === normalizedNs
+                    : isMemberObjectIdentifier(obj.type) && normalize(objectName) === normalizedNs;
+                if (objectMatches && normalize(propertyName) === normalizedMember) {
+                    const inPythonBindingScope = sup.id !== "python" || !effectivePythonBinding || effectivePythonBinding === importBinding;
+                    const inAliasScope = inPythonBindingScope &&
+                        (sup.id !== "csharp" ||
+                            !importBinding ||
+                            !imports ||
+                            importBinding.kind !== "namespace" ||
+                            !importBinding.localRange ||
+                            innermostNamespaceImport(imports, objectName, obj, normalize) === importBinding);
+                    if (inAliasScope)
+                        ranges.push(toRange(prop));
                 }
             }
         }