@lzehrung/codegraph 3.0.1 → 3.1.1

package/dist/indexer/navigation.js

@@ -1,4 +1,7 @@
+import path from "node:path";
 import { supportForFileWithoutHeaderSample } from "../languages.js";
+import { isJsTsLanguage } from "../languages/js-family.js";
+import { pythonPropertyDecorator } from "./python-property-decorator.js";
 import { ensureParsedContext } from "./parse-context.js";
 import { getCompilationUnitPeers, IMPLICIT_UNIT_LANGUAGES } from "./compilation-units.js";
 import { getReverseNeighbors, graphAdjacencyFor } from "../graphs/adjacency.js";
@@ -6,6 +9,7 @@ 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 { isPythonReceiverAttributeAssignmentName } from "../languages/definitions/python.js";
 import { findClosestBinding, findClosestScopeBinding, findDeclarationNameNode, getOrBuildScopeIndex, toModuleRef, } from "./navigation-local.js";
 import { typescriptCallableCandidatesInContainer } from "./ts-callables.js";
 import { isExplicitMethodCall, scopeNodesFor } from "./scope-nodes.js";
@@ -14,24 +18,28 @@ import { effectiveExplicitBinding, findRubyReopenedConstantParts, isExpandedStar
 import { createNavigationProvenance, okGoToResult } from "./navigation-provenance.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, javaStaticNamedImportIncludes, resolveExport, resolveImported, resolveModuleExports, resolvePhpExportByImportType, } from "./navigation-resolve.js";
+import { buildIndexedCandidateCoverage, buildPhpQualifiedNames, markNameEquivalenceGap, cppCanonicalStructuralExport, describeReferenceStrategies, collectVerifiedNamedNodeReferences, isMemberAccessPropertyRange, getCachedScope, exportFromIdentifier, getCachedReferenceCandidateFiles, getCandidateReferenceNames, hasExpandedNamedImport, pythonParentPackageNamespacePaths, importBindingDeclarationRangeKeys, importBindingIdentityVerificationSites, importBindingReferenceSites, rangeIdentityKey, referenceSiteKey, } from "./navigation-references.js";
+import { directModuleValueEntry, csharpNamespaceImportDirectories, csharpShadowedImports, javaStaticNamedImportIncludes, 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 "../types.js";
 import { loadNearestTsconfigFor, resolveImportSpecifier } from "../util/resolution.js";
-import { fileIdentityKey } from "../util/paths.js";
+import { fileIdentityKey, normalizePath } 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 { collectMemberAccessChain, getMemberAccessParts, isMemberAccessNode, isMemberObjectIdentifier, isMemberReferencePropertyIdentifier, isReceiverNameNode, } from "../util/member-access.js";
 import { cppOutOfLineOwnerPath, cppOutOfLineMemberName, cppOutOfLineMemberDeclarationNode, cppQualifiedNameSegments, } from "../graphs/symbol-graph-detailed/receiver-calls.js";
 import { 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 { findSqlReferences, goToSqlDefinition, sqlPositionIsProvenObjectOrRoutineMention } from "../sql/navigation.js";
+import { findScssReferences, goToScssDefinition } from "../scss/navigation.js";
+import { scssBlockLocalExistenceUnproven, scssFactsForFile, scssFlowLocalUnproven, scssLocalSpellingGap, scssMemberForDefinition, scssNearerEquivalentLocal, scssScopedCallableDynamicUnproven, scssScopedCallableReferences, } from "../scss/resolution.js";
 import { findTerraformReferences, goToTerraformDefinition } from "../terraform/navigation.js";
 import { createLoadingParsedFileProvider, fileBindingIsUnshadowed, phpImportTypeAtPosition, resolveBareName, settleNameResolution, withParsedFiles, } from "./name-resolution.js";
 import { resolveCppQualifiedName } from "./name-lookup-policies/c-family.js";
+import { createUnionFind } from "../util/collections.js";
+import { toTreeSitterPosition } from "./shared.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;
@@ -47,6 +55,9 @@ export async function goToDefinition(index, req, parsedContext) {
     const terraformResult = await goToTerraformDefinition(index, req);
     if (terraformResult)
         return terraformResult;
+    const scssResult = await goToScssDefinition(index, req);
+    if (scssResult)
+        return scssResult;
     const context = parsedContext ??
         (await ensureParsedContext(file, index.parsed?.get(fileIdentityKey(file)), index.languageExtensions));
     const sup = context.sup;
@@ -54,10 +65,7 @@ export async function goToDefinition(index, req, parsedContext) {
     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),
-    };
+    const pos = toTreeSitterPosition({ line, column });
     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.
@@ -366,22 +374,7 @@ export async function recoverIncludedCallableStar(index, mod, languageId, name,
         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;
-    };
+    const { find, unite } = createUnionFind(functions.length);
     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) {
@@ -426,7 +419,7 @@ export async function getCppEquivalentCallableDefinitions(index, def, parsedCont
     return [family.definition, ...family.equivalents];
 }
 /** Adds the requested `line` or `block` context to each reference, parsing each file once. */
-async function attachReferenceContext(index, refs, opts) {
+export async function attachReferenceContext(index, refs, opts) {
     if (!opts?.context)
         return;
     const perFileCache = new Map();
@@ -448,22 +441,67 @@ async function attachReferenceContext(index, refs, opts) {
         }
     }
 }
+export async function canonicalizePythonReceiverAttributeDefinition(index, def, position = {
+    file: def.file,
+    line: def.range.start.line,
+    column: def.range.start.column,
+}) {
+    if (supportForFileWithoutHeaderSample(position.file, index.languageExtensions)?.id !== "python")
+        return null;
+    const context = await ensureParsedContext(position.file, index.parsed?.get(fileIdentityKey(position.file)), index.languageExtensions);
+    if (context.sup.id !== "python")
+        return null;
+    const nodePosition = { row: position.line - 1, column: position.column - 1 };
+    const node = context.tree.rootNode.descendantForPosition(nodePosition, nodePosition);
+    if (!isPythonReceiverAttributeAssignmentName(node))
+        return null;
+    return await goToDefinition(index, position, context);
+}
 async function findReferencesInternal(index, req, opts, collectionMode) {
     let def = null;
     let provenance;
     if ("def" in req) {
         def = req.def;
         provenance = createNavigationProvenance("exact", "high");
+        const canonical = await canonicalizePythonReceiverAttributeDefinition(index, def);
+        if (canonical?.status === "ok") {
+            def = canonical.definition;
+            provenance = canonical.provenance;
+        }
     }
     else {
         const module = index.byFile.get(fileIdentityKey(req.file));
+        // A SQL definition spans its whole statement, so a position inside it can name another object: the
+        // function a trigger runs, a call in a routine body, or a table a view reads. Resolve that name first.
+        const sqlTarget = module ? await goToSqlDefinition(index, req) : null;
         const localAtPosition = module?.locals.find((local) => rangeContains(local.range, {
             row: req.line,
             column: req.column,
         }));
-        if (localAtPosition) {
+        // A column can share a table's name. Only a syntactically proven object or routine mention
+        // overrides the definition that encloses the position; a column stays on that definition.
+        const namesObject = sqlTarget && localAtPosition ? await sqlPositionIsProvenObjectOrRoutineMention(index, req) : false;
+        // A proven mention that no single definition owns, such as an overloaded callee, is unresolved.
+        // It is not a reference to the definition around it.
+        if (namesObject && sqlTarget?.status === "not_found")
+            return { status: "not_found", reason: sqlTarget.reason };
+        const sqlMention = sqlTarget?.status === "ok" && (!localAtPosition || namesObject);
+        if (sqlMention && sqlTarget?.status === "ok") {
+            def = sqlTarget.definition;
+            provenance = sqlTarget.provenance;
+        }
+        else if (localAtPosition) {
             def = localAtPosition;
             provenance = createNavigationProvenance("exact", "high");
+            const canonical = await canonicalizePythonReceiverAttributeDefinition(index, def, {
+                file: req.file,
+                line: req.line,
+                column: req.column,
+            });
+            if (canonical?.status === "ok") {
+                def = canonical.definition;
+                provenance = canonical.provenance;
+            }
         }
         else {
             const gotoResult = await goToDefinition(index, req);
@@ -489,7 +527,10 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
     }
     const maxReferences = typeof opts?.maxReferences === "number" && opts.maxReferences > 0 ? opts.maxReferences : undefined;
     const sqlReferences = await findSqlReferences(index, def, {
-        includeDefinition: collectionMode === "all",
+        // A SQL definition spans its whole statement, so rename finds the declaration's name through here.
+        includeDefinition: collectionMode !== "usages",
+        // Rename edits the name in `public.f`, not the qualifier that comes with it.
+        renameRanges: collectionMode === "rename",
         ...(maxReferences === undefined ? {} : { maxReferences }),
     });
     if (sqlReferences)
@@ -503,8 +544,18 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
             await attachReferenceContext(index, terraformReferences.references, opts);
         return terraformReferences;
     }
+    const scssReferences = await findScssReferences(index, def, {
+        includeDefinition: collectionMode === "all",
+        ...(maxReferences === undefined ? {} : { maxReferences }),
+    });
+    if (scssReferences) {
+        if (scssReferences.status === "ok")
+            await attachReferenceContext(index, scssReferences.references, opts);
+        return scssReferences;
+    }
     const definitionFile = def.file;
     const definitionSiteKey = referenceSiteKey(definitionFile, def.range);
+    const explicitNamespaceMemberAliasFiles = new Set();
     const includeReference = (ref) => {
         if (collectionMode === "all")
             return true;
@@ -512,6 +563,10 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
             return false;
         if (collectionMode === "usages")
             return ref.via?.importBinding === undefined;
+        if (ref.via?.namespaceMember) {
+            const hasExplicitAlias = namespaceBindingHasExplicitAlias(ref.via.import);
+            return ref.via.namespaceMember === def.localName && !hasExplicitAlias;
+        }
         const binding = ref.via?.import;
         if (!binding || binding.kind === "star" || binding.kind === "namespace")
             return true;
@@ -583,6 +638,78 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
     }
     const matchesReferenceDefinition = (candidate) => sameDef(candidate, definition, index.languageExtensions) ||
         equivalentDefinitions.some((equivalent) => sameDef(candidate, equivalent, index.languageExtensions));
+    const hasExplicitExportAliasForDefinition = async (candidateModule) => {
+        const definitionExportNames = new Set();
+        for (const entry of candidateModule.exports) {
+            if (!("exportedAs" in entry))
+                continue;
+            const hit = resolveExport(index, candidateModule.file, entry.exportedAs, exportOptions);
+            if (hit?.kind === "resolved" && matchesReferenceDefinition(hit.def)) {
+                definitionExportNames.add(entry.exportedAs);
+            }
+        }
+        if (!definitionExportNames.size)
+            return false;
+        const parsedModule = await ensureParsedContext(candidateModule.file, index.parsed?.get(fileIdentityKey(candidateModule.file)), index.languageExtensions);
+        const pending = [parsedModule.tree.rootNode];
+        while (pending.length) {
+            const node = pending.pop();
+            const alias = node.type === "export_specifier" ? node.childForFieldName("alias") : undefined;
+            if (alias && definitionExportNames.has(alias.text))
+                return true;
+            pending.push(...node.namedChildren);
+        }
+        return false;
+    };
+    // Alias uncertainty only affects rename safety; reference and usage queries skip the scan.
+    for (const candidateModule of collectionMode === "rename" ? index.byFile.values() : []) {
+        if (await hasExplicitExportAliasForDefinition(candidateModule)) {
+            explicitNamespaceMemberAliasFiles.add(fileIdentityKey(candidateModule.file));
+        }
+    }
+    let namespaceExportAliasUncertainty = false;
+    const namespaceBindingHasExplicitAlias = (binding) => {
+        if (!binding)
+            return false;
+        const namespaceFiles = [];
+        if (binding.kind === "namespace" && typeof binding.resolved === "string") {
+            namespaceFiles.push(binding.resolved);
+        }
+        else if (binding.kind === "named" && typeof binding.resolved === "string") {
+            const target = resolveExport(index, binding.resolved, binding.imported);
+            if (target?.kind === "namespace")
+                namespaceFiles.push(target.file);
+        }
+        const visited = new Set();
+        const modulePathHasAlias = (file) => {
+            const fileKey = fileIdentityKey(file);
+            if (visited.has(fileKey))
+                return false;
+            visited.add(fileKey);
+            if (explicitNamespaceMemberAliasFiles.has(fileKey))
+                return true;
+            const targetModule = index.byFile.get(fileKey);
+            for (const entry of targetModule?.exports ?? []) {
+                // A star or namespace forward keeps an aliased export reachable under the forwarding module's own names.
+                if ((entry.type === "namespaceReexport" || entry.type === "exportStar") &&
+                    modulePathHasAlias(entry.fromModule)) {
+                    return true;
+                }
+                if (entry.type !== "reexport")
+                    continue;
+                const hit = resolveExport(index, file, entry.exportedAs, exportOptions);
+                // A named re-export forwards the definition itself or a namespace that can reach it.
+                const forwardsDefinition = hit?.kind === "resolved" && matchesReferenceDefinition(hit.def);
+                if ((forwardsDefinition || hit?.kind === "namespace") && modulePathHasAlias(entry.fromModule))
+                    return true;
+            }
+            return false;
+        };
+        const hasAlias = namespaceFiles.some(modulePathHasAlias);
+        if (hasAlias)
+            namespaceExportAliasUncertainty = true;
+        return hasAlias;
+    };
     const exportedNames = [];
     for (const candidate of [definition, ...equivalentDefinitions]) {
         const candidateModule = index.byFile.get(fileIdentityKey(candidate.file));
@@ -773,6 +900,61 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
             }
             return scopeIndex;
         };
+        const scannedNamespaceMemberRoots = new Set();
+        const scanNamespaceMemberPaths = async (importBinding, namespacePaths) => {
+            const rootPath = namespacePaths[0];
+            if (!rootPath)
+                return;
+            const rootKey = fileIdentityKey(rootPath.file) + "::" + rootPath.name;
+            if (scannedNamespaceMemberRoots.has(rootKey))
+                return;
+            scannedNamespaceMemberRoots.add(rootKey);
+            for (let pathIndex = 0; pathIndex < namespacePaths.length; pathIndex++) {
+                if (hasReachedCollectionLimit())
+                    return;
+                if (pathIndex >= MAX_REFERENCE_NAMESPACE_PATHS) {
+                    receiverProofUnavailableFiles.set(fileIdentityKey(fileId), fileId);
+                    return;
+                }
+                const namespacePath = namespacePaths[pathIndex];
+                const namespaceExports = resolveModuleExports(index, namespacePath.file, { allowLocalFallback: false });
+                if (namespacePath.depth) {
+                    for (const [visibleMemberName, nestedHit] of namespaceExports) {
+                        if (nestedHit.kind !== "resolved" || !matchesReferenceDefinition(nestedHit.def))
+                            continue;
+                        const parsed = await ensureCandidateParsed();
+                        const ranges = await collectNamespaceMemberRefs(fileId, namespacePath.name, visibleMemberName, parsed, index.languageExtensions, importBinding, module.imports, await ensureScope());
+                        for (const range of ranges) {
+                            if (hasReachedCollectionLimit())
+                                return;
+                            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: importBinding, namespaceMember: visibleMemberName },
+                            });
+                        }
+                    }
+                }
+                if (namespacePath.depth >= MAX_REFERENCE_NAMESPACE_DEPTH) {
+                    if ([...namespaceExports.values()].some((entry) => entry.kind === "namespace")) {
+                        receiverProofUnavailableFiles.set(fileIdentityKey(fileId), fileId);
+                    }
+                    continue;
+                }
+                for (const [alias, entry] of namespaceExports) {
+                    if (entry.kind !== "namespace")
+                        continue;
+                    namespacePaths.push({
+                        file: entry.file,
+                        name: `${namespacePath.name}.${alias}`,
+                        depth: namespacePath.depth + 1,
+                    });
+                }
+            }
+        };
         if (supportForFileWithoutHeaderSample(fileId, index.languageExtensions)?.supportsExportFromReferences) {
             for (const entry of module.exports) {
                 if (hasReachedCollectionLimit())
@@ -800,7 +982,31 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
                 break;
             if (cNamespace && imp.kind === "named" && (imp.cNamespace ?? "ordinary") !== cNamespace)
                 continue;
-            const targetFile = typeof imp.resolved === "string" ? imp.resolved : undefined;
+            // A C# directive that an enclosing namespace shadows resolves nothing, so it is verified like an unresolved import.
+            const targetFile = typeof imp.resolved === "string" && !csharpShadowedImports(index).has(imp) ? imp.resolved : undefined;
+            if (!targetFile && parsedContext.sup.id === "csharp" && imp.kind === "namespace") {
+                const namespaceTargets = csharpNamespaceImportDirectories(index).get(imp) ?? [];
+                const targetDirectories = new Set(namespaceTargets.map((target) => fileIdentityKey(path.posix.dirname(normalizePath(target)))));
+                const definitionIsTargeted = [definition, ...equivalentDefinitions].some((candidate) => targetDirectories.has(fileIdentityKey(path.posix.dirname(normalizePath(candidate.file)))));
+                if (definitionIsTargeted) {
+                    for (const exportedName of exportedNames) {
+                        if (hasReachedCollectionLimit())
+                            break;
+                        const ranges = await collectVerifiedNamedNodeReferences(index, fileId, exportedName, 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;
+                            pushRef({
+                                file: fileId,
+                                range,
+                                via: { import: imp, ...(via ?? {}) },
+                                ...(provenance ? { provenance } : {}),
+                            });
+                        }
+                    }
+                }
+                continue;
+            }
             const bindingSites = importBindingReferenceSites(imp);
             let verifiedBindingMatches;
             const bindingMatchesDefinition = async () => {
@@ -873,65 +1079,25 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
                     // 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,
+                    const targetModule = index.byFile.get(fileIdentityKey(targetFile));
+                    if (targetModule?.exports.some((entry) => entry.type === "namespaceReexport" || entry.type === "exportStar" || entry.type === "reexport")) {
+                        // A forwarded namespace can expose 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, await ensureScope());
-                                    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;
+                        await scanNamespaceMemberPaths(imp, [{ file: targetFile, name: namespaceSearchName, depth: 0 }]);
                     }
+                    if (!matchesDef)
+                        continue;
                     const parsed = await ensureCandidateParsed();
                     const ranges = await collectNamespaceMemberRefs(fileId, namespaceSearchName, exportedName, parsed, index.languageExtensions, imp, module.imports, await ensureScope());
                     for (const range of ranges) {
                         if (hasReachedCollectionLimit())
                             break;
+                        if (parsed.sup.id === "csharp" && imp.localRange) {
+                            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,
@@ -1030,6 +1196,17 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
                             continue;
                         }
                     }
+                    const candidateLanguage = supportForFileWithoutHeaderSample(fileId, index.languageExtensions)?.id;
+                    if (!matchesDef &&
+                        imp.kind === "named" &&
+                        hit?.kind === "namespace" &&
+                        candidateLanguage &&
+                        isJsTsLanguage(candidateLanguage)) {
+                        // `import { nested }` binds the namespace object. Member lookup starts in that
+                        // module; `import * as ns` still starts at the barrel and descends. Goto proves the site.
+                        await scanNamespaceMemberPaths(imp, [{ file: hit.file, name: imp.local, depth: 1 }]);
+                        continue;
+                    }
                     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
@@ -1167,6 +1344,38 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
             }
         }
     }
+    // A scoped mixin or function is not a module member. The scope walker misses function calls
+    // (`function_name` is not an identifier) and treats `-` and `_` as different spellings, and a
+    // later include outside the block can attach to the nested mixin. Bare same-kind calls and
+    // includes inside the scanned scope are the references; anything else the walker added is not.
+    let scssScopedCallableUnproven = false;
+    if (parsedContext.sup.id === "scss") {
+        const scoped = await scssScopedCallableReferences(index, definition);
+        if (scoped?.unproven) {
+            scssScopedCallableUnproven = true;
+        }
+        else if (scoped) {
+            const owned = new Set(scoped.ranges.map((range) => referenceSiteKey(definitionFile, range)));
+            const definitionKey = referenceSiteKey(definition.file, definition.range);
+            const kept = [];
+            seenRefs.clear();
+            for (const ref of refs) {
+                const key = referenceSiteKey(ref.file, ref.range);
+                if (key !== definitionSiteKey && key !== definitionKey && !owned.has(key))
+                    continue;
+                seenRefs.set(key, kept.length);
+                kept.push(ref);
+            }
+            refs.length = 0;
+            refs.push(...kept);
+            for (const range of scoped.ranges)
+                pushRef({ file: definitionFile, range });
+            // Those static uses stay. A lookup in the same span may still name the callable by a
+            // string, which this walk does not edit, so coverage must not claim to be complete.
+            if (await scssScopedCallableDynamicUnproven(index, definition))
+                scssScopedCallableUnproven = true;
+        }
+    }
     const truncated = maxReferences !== undefined && refs.length > maxReferences;
     if (truncated) {
         refs.length = maxReferences;
@@ -1179,6 +1388,40 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
         }
         return left.file.localeCompare(right.file);
     });
+    // A block local's lexical scope can run past the block. A use the SCSS resolver proves is a
+    // module member is not a reference of that local. The local's own uses stay: they resolve as a
+    // shadow and the generic walker keeps them. A nearer binding with the same Sass name and a
+    // different `-`/`_` spelling owns the read; the exact-name walk would keep it on this declaration.
+    let scssNearerSpellingDropped = false;
+    if (parsedContext.sup.id === "scss" &&
+        definition.localName.startsWith("$") &&
+        !(await scssMemberForDefinition(index, definition))) {
+        const facts = await scssFactsForFile(index, definition.file);
+        const definitionKey = fileIdentityKey(definition.file);
+        const kept = [];
+        for (const ref of refs) {
+            if (referenceSiteKey(ref.file, ref.range) === definitionSiteKey) {
+                kept.push(ref);
+                continue;
+            }
+            const resolved = await goToScssDefinition(index, {
+                file: ref.file,
+                line: ref.range.start.line,
+                column: ref.range.start.column,
+            });
+            if (resolved?.status === "ok")
+                continue;
+            if (facts &&
+                fileIdentityKey(ref.file) === definitionKey &&
+                scssNearerEquivalentLocal(facts, definition, ref.range.start)) {
+                scssNearerSpellingDropped = true;
+                continue;
+            }
+            kept.push(ref);
+        }
+        refs.length = 0;
+        refs.push(...kept);
+    }
     await attachReferenceContext(index, refs, opts);
     const scannedFiles = [definitionFile, ...candidateFiles, ...receiverScannedFiles];
     // Top-level implicit-unit names and C# partial / Swift shared-owner members are both bounded
@@ -1186,6 +1429,26 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
     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 strategyUnavailableFiles = [
+        ...receiverProofUnavailableFiles.values(),
+        ...(rubyReopen?.incomplete ? [definition.file] : []),
+        ...(namespaceExportAliasUncertainty ? [definition.file] : []),
+    ];
+    if (parsedContext.sup.id === "scss" && definition.localName.startsWith("$")) {
+        const facts = await scssFactsForFile(index, definition.file);
+        if (scssNearerSpellingDropped || (facts && scssLocalSpellingGap(facts, definition))) {
+            markNameEquivalenceGap(index, definition);
+        }
+        if (await scssFlowLocalUnproven(index, definition))
+            strategyUnavailableFiles.push(definition.file);
+        if (await scssBlockLocalExistenceUnproven(index, definition))
+            strategyUnavailableFiles.push(definition.file);
+    }
+    if (parsedContext.sup.id === "python" && pythonPropertyAccessorNeedsPartialCoverage(parsedContext, definition)) {
+        strategyUnavailableFiles.push(definition.file);
+    }
+    if (scssScopedCallableUnproven)
+        strategyUnavailableFiles.push(definition.file);
     const referenceCoverage = buildIndexedCandidateCoverage({
         index,
         def: definition,
@@ -1210,10 +1473,7 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
                 ? { implicitUnitPeers: { applicable: true, executed: implicitUnitComplete } }
                 : {}),
         }),
-        strategyUnavailableFiles: [
-            ...receiverProofUnavailableFiles.values(),
-            ...(rubyReopen?.incomplete ? [definition.file] : []),
-        ],
+        strategyUnavailableFiles,
     });
     return {
         status: "ok",
@@ -1223,11 +1483,43 @@ async function findReferencesInternal(index, req, opts, collectionMode) {
         ...(provenance ? { provenance } : {}),
     };
 }
+function pythonPropertyAccessorNeedsPartialCoverage(parsedContext, definition) {
+    const nameNode = syntaxNodeForDefinition(parsedContext, definition);
+    if (nameNode.type !== "identifier")
+        return false;
+    const assignment = nameNode.parent;
+    if (assignment?.type === "assignment" && assignment.childForFieldName("left")?.id === nameNode.id) {
+        const value = assignment.childForFieldName("right");
+        const argumentsNode = value?.childForFieldName("arguments");
+        if (value?.type === "call" && value.childForFieldName("function")?.text === "property" && argumentsNode) {
+            const positionalArguments = argumentsNode.namedChildren.filter((argument) => argument.type !== "keyword_argument");
+            if (positionalArguments[1] && positionalArguments[1].text !== "None")
+                return true;
+            return argumentsNode.namedChildren.some((argument) => argument.type === "keyword_argument" &&
+                argument.childForFieldName("name")?.text === "fset" &&
+                argument.childForFieldName("value")?.text !== "None");
+        }
+    }
+    let functionNode = nameNode;
+    while (functionNode && functionNode.type !== "function_definition")
+        functionNode = functionNode.parent;
+    if (functionNode?.type !== "function_definition")
+        return false;
+    const functionName = functionNode.childForFieldName("name");
+    if (functionName?.startIndex !== nameNode.startIndex || functionName.endIndex !== nameNode.endIndex)
+        return false;
+    const decoratedDefinition = functionNode.parent;
+    if (decoratedDefinition?.type !== "decorated_definition")
+        return false;
+    return decoratedDefinition.namedChildren.some((child) => {
+        const decorator = pythonPropertyDecorator(child);
+        if (decorator?.kind === "property")
+            return true;
+        return decorator?.kind === "accessor" && decorator.propertyName === definition.localName;
+    });
+}
 function syntaxNodeForDefinition(parsedContext, def) {
-    const position = {
-        row: def.range.start.line - 1,
-        column: def.range.start.column - 1,
-    };
+    const position = toTreeSitterPosition(def.range.start);
     return parsedContext.tree.rootNode.descendantForPosition(position, position);
 }
 /**
@@ -1593,6 +1885,7 @@ export async function collectNamespaceMemberRefs(file, ns, member, parsedContext
     // Identifier equality follows the language rule, so C# `@X::@Target` matches alias `X` member `Target`.
     const normalize = sup.normalizeIdentifier;
     const normalizedNs = normalize(ns);
+    const namespaceSegments = normalizedNs.includes(".") ? normalizedNs.split(".") : undefined;
     const normalizedMember = normalize(member);
     let effectivePythonBinding;
     if (sup.id === "python" && importBinding && imports) {
@@ -1616,13 +1909,23 @@ export async function collectNamespaceMemberRefs(file, ns, member, parsedContext
             if (obj && prop && isMemberReferencePropertyIdentifier(sup, prop.type)) {
                 const objectName = sliceText(obj, source);
                 const propertyName = sliceText(prop, source);
-                // 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;
+                let objectMatches = false;
+                if (namespaceSegments) {
+                    const chain = collectMemberAccessChain({ sup, source, chainNode: obj });
+                    if (chain &&
+                        isMemberObjectIdentifier(chain.base.type) &&
+                        chain.names.length === namespaceSegments.length - 1) {
+                        objectMatches = normalize(sliceText(chain.base, source)) === namespaceSegments[0];
+                        for (let segmentIndex = 0; objectMatches && segmentIndex < chain.names.length; segmentIndex += 1) {
+                            objectMatches =
+                                normalize(chain.names[segmentIndex]) ===
+                                    namespaceSegments[namespaceSegments.length - 1 - segmentIndex];
+                        }
+                    }
+                }
+                else {
+                    objectMatches = isMemberObjectIdentifier(obj.type) && normalize(objectName) === normalizedNs;
+                }
                 if (objectMatches && normalize(propertyName) === normalizedMember) {
                     let receiver = obj;
                     while (!isMemberObjectIdentifier(receiver.type) && receiver.namedChildren.length) {