@lzehrung/codegraph 2.3.31 → 3.0.0

package/dist/indexer/scope.js

@@ -1,12 +1,67 @@
 import { sliceText, toRange } from "../util/ast.js";
 import { getNativeSyntaxTreeExecution } from "../native/tree-sitter-native.js";
 import { ProjectedSyntaxTree } from "../native/projected-tree.js";
+import { getMemberAccessParts, isMemberAccessNode } from "../util/member-access.js";
 import { declarationKindToBindingKind } from "./declarations.js";
-import { scopeNodesFor } from "./scope-nodes.js";
+import { callableIdentityForDeclaration } from "./callable-identity.js";
+import { cppSelectCallableBinding } from "./cpp-callables.js";
+import { typescriptCallableCandidatesInContainer } from "./ts-callables.js";
+import { cppQualifiedNameSegments, importTypeQuerySpecifier, typescriptImportTypeQuery, } from "../graphs/symbol-graph-detailed/receiver-calls.js";
+import { phpConstructorPromotedVariable } from "./navigation-php.js";
+import { cScopeName, cTagRole } from "../languages/definitions/c.js";
+import { bindingCoversUse, isExplicitMethodCall, laterLocalBlocksOuterUse, scopeAllowsUse, scopeIdentifierKey, scopeNodesFor, } from "./scope-nodes.js";
+import { isJsTsLanguage } from "../languages/js-family.js";
+import { SymbolKind } from "./types.js";
+const FUNCTION_DECLARATOR_NAME_TYPES = {
+    identifier: true,
+    field_identifier: true,
+    destructor_name: true,
+    operator_name: true,
+};
+function nestedFunctionDeclaratorName(node) {
+    let current = node;
+    for (let depth = 0; current && depth < 8; depth += 1) {
+        if (FUNCTION_DECLARATOR_NAME_TYPES[current.type])
+            return current;
+        current = current.childForFieldName("name");
+    }
+    return null;
+}
+function declaredNameNode(node, row) {
+    const directName = node.childForFieldName("name");
+    if (directName)
+        return directName;
+    if (!row.functionNameTypes?.has(node.type))
+        return null;
+    let current = node.childForFieldName("declarator");
+    for (let depth = 0; current && depth < 8; depth += 1) {
+        const name = current.childForFieldName("name");
+        const declaredName = name ? nestedFunctionDeclaratorName(name) : nestedFunctionDeclaratorName(current);
+        if (declaredName)
+            return declaredName;
+        current =
+            current.childForFieldName("declarator") ??
+                (current.type === "reference_declarator" ? (current.namedChildren[0] ?? null) : null);
+    }
+    return null;
+}
+function qualifiedCppIdentifierForName(nameNode, boundary) {
+    let current = nameNode.parent;
+    while (current && current !== boundary) {
+        if (current.type === "qualified_identifier") {
+            const memberName = current.childForFieldName("name");
+            const containsName = memberName && memberName.startIndex <= nameNode.startIndex && memberName.endIndex >= nameNode.endIndex;
+            if (containsName && current.parent?.type !== "qualified_identifier")
+                return current;
+        }
+        current = current.parent;
+    }
+    return null;
+}
 export function buildScopeIndexFromSource(file, source, support, imports = [], opts) {
     let tree = opts?.tree ?? null;
     if (!tree) {
-        const nativeTreeExecution = getNativeSyntaxTreeExecution(source, support, opts?.nativeMode);
+        const nativeTreeExecution = getNativeSyntaxTreeExecution(source, support);
         if (nativeTreeExecution.tree) {
             tree = new ProjectedSyntaxTree(source, nativeTreeExecution.tree);
         }
@@ -22,15 +77,60 @@ export function buildScopeIndexFromSource(file, source, support, imports = [], o
     };
     const stack = [rootScope];
     const allScopes = [rootScope];
+    const cppNamespaceMaps = new Map();
+    const cppNamespaceScopes = new Map();
+    const cppNamespacePath = [];
+    const cppNamespacePathByMap = new WeakMap();
     const extraBindings = [];
+    const cppQualifiedMemberBindings = new Map();
+    const cppQualifiedMemberOccurrences = new Map();
+    const cppFunctionCollisionGroups = new Set();
+    const cppFunctionOccurrences = [];
+    // Retain imported C tag forwards only when a later same-file declaration completes the tag.
+    let cImportedForwardTags;
+    const extraBindingSpans = new Set();
+    const bindingSpanKey = (binding) => {
+        const start = binding.def?.start.index;
+        const end = binding.def?.end.index;
+        return `${binding.canonicalName}:${start ?? ""}:${end ?? ""}`;
+    };
+    const preserveExtraBinding = (binding) => {
+        const key = bindingSpanKey(binding);
+        if (extraBindingSpans.has(key))
+            return;
+        extraBindingSpans.add(key);
+        extraBindings.push(binding);
+    };
+    /**
+     * Name nodes already registered before their construct's own scope was pushed. Keyed by source
+     * span rather than `node.id`, which the projected tree leaves optional.
+     */
+    const preRegisteredNameSpans = new Set();
+    const nameSpanKey = (node) => `${node.startIndex}:${node.endIndex}`;
     const normalizeIdentifier = support.normalizeIdentifier;
+    const indexedCallables = opts?.locals ? new Map() : undefined;
+    if (indexedCallables && opts?.locals) {
+        for (const local of opts.locals) {
+            if (local.kind === SymbolKind.Function && local.callable) {
+                indexedCallables.set(`${local.range.start.index}:${local.range.end.index}`, local.callable);
+            }
+        }
+    }
     const buildBinding = (nameNode, kind) => {
         const name = sliceText(nameNode, source);
+        const def = toRange(nameNode);
+        const callable = kind === "function"
+            ? (indexedCallables?.get(`${nameNode.startIndex}:${nameNode.endIndex}`) ??
+                callableIdentityForDeclaration({ file, name, range: def, languageId: support.id, source, node: nameNode }))
+            : undefined;
+        const heldModuleSpecifier = kind === "local" && isJsTsLanguage(support.id) ? heldModuleSpecifierForDeclaration(nameNode) : undefined;
         return {
             name,
-            canonicalName: normalizeIdentifier(name),
+            canonicalName: scopeIdentifierKey(row, name, nameNode, normalizeIdentifier),
             kind,
-            def: toRange(nameNode),
+            def,
+            ...(callable ? { callable } : {}),
+            ...(heldModuleSpecifier !== undefined ? { heldModuleSpecifier } : {}),
             node: nameNode,
             occurrences: [],
         };
@@ -43,7 +143,10 @@ export function buildScopeIndexFromSource(file, source, support, imports = [], o
             occurrences: [],
             import: importBinding,
         };
-        rootScope.map.set(binding.canonicalName, binding);
+        const key = support.id === "c" && importBinding.kind === "named" && importBinding.cNamespace === "tag"
+            ? cScopeName(binding.canonicalName, "tag")
+            : binding.canonicalName;
+        rootScope.map.set(key, binding);
     };
     for (const imp of imports) {
         if (imp.kind === "default") {
@@ -57,6 +160,28 @@ export function buildScopeIndexFromSource(file, source, support, imports = [], o
         }
     }
     const row = scopeNodesFor(support.id);
+    /** Covering-declaration names collected before a scope's body is walked, keyed by syntax node id. */
+    const pendingNamesByNodeId = new Map();
+    /**
+     * JS and TS record let/const/class/type names during the existing hoist walk. A use defers only
+     * when one of those names is still ahead, so the queue stays the forward references.
+     */
+    const tracksLexicalNames = !!(row.hoistedFunctionTypes || row.hoistedVariableDeclarationTypes);
+    const canDeferForward = !tracksLexicalNames &&
+        (!!row.wholeScopeKinds?.size ||
+            !!row.wholeScopeDeclarationTypes?.size ||
+            !!row.variableTargetScopeKinds?.size ||
+            !!row.laterLocalBlocksOuterKinds?.size ||
+            !!row.moduleBindingsAtFunctionRuntime);
+    const nodeById = (id) => tree instanceof ProjectedSyntaxTree ? tree.nodeById(id) : undefined;
+    const attachPendingNames = (scope) => {
+        const nodeId = scope.node.id;
+        if (nodeId === undefined)
+            return;
+        const names = pendingNamesByNodeId.get(nodeId);
+        if (names && names.size > 0)
+            scope.pendingCoveringNames = names;
+    };
     const idSet = new Set([...support.nodeTypes.identifier, ...(support.nodeTypes.shorthandPropertyIdentifier ?? [])]);
     const scopeDeclarationNames = support.scopeDeclarationNames;
     const isParamNode = (node) => {
@@ -68,9 +193,216 @@ export function buildScopeIndexFromSource(file, source, support, imports = [], o
         }
         return false;
     };
+    const declarationCoversScope = (nameNode) => {
+        const types = row.wholeScopeDeclarationTypes;
+        const memberTypes = row.wholeScopeMemberDeclarationTypes;
+        if (!types && !memberTypes)
+            return false;
+        let current = nameNode.parent;
+        for (let depth = 0; current && depth < 8; depth += 1) {
+            const functionScope = support.createsFunctionScope(current);
+            if (functionScope) {
+                const declaredName = current.childForFieldName("name");
+                if (!declaredName ||
+                    declaredName.startIndex !== nameNode.startIndex ||
+                    declaredName.endIndex !== nameNode.endIndex)
+                    break;
+            }
+            if (types?.has(current.type))
+                return true;
+            if (memberTypes?.has(current.type) && current.parent && row.memberContainerTypes?.has(current.parent.type)) {
+                return true;
+            }
+            if (current.type === "variable_declarator" && current.parent && types?.has(current.parent.type))
+                return true;
+            // A local inside a function is not the function's own declaration.
+            if (functionScope || support.createsBlockScope(current))
+                break;
+            current = current.parent;
+        }
+        return false;
+    };
+    const stealCoveredOccurrences = (target, binding, key) => {
+        if (!binding.coversEnclosingScope)
+            return;
+        const sources = [];
+        const pushChain = (found) => {
+            let current = found;
+            while (current && current !== binding) {
+                sources.push(current);
+                current = current.earlierSameScope;
+            }
+        };
+        // A same-scope redeclaration keeps its own uses. Only an outer binding can be shadowed.
+        let parent = target.parent;
+        while (parent) {
+            const found = parent.map.get(key);
+            if (found) {
+                pushChain(found);
+                break;
+            }
+            parent = parent.parent;
+        }
+        const start = target.node.startIndex;
+        const end = target.node.endIndex;
+        const seen = new Set();
+        for (const source of sources) {
+            if (seen.has(source.occurrences))
+                continue;
+            seen.add(source.occurrences);
+            const occurrences = source.occurrences;
+            let write = 0;
+            let moved = 0;
+            for (let index = 0; index < occurrences.length; index += 1) {
+                const occurrence = occurrences[index];
+                const occurrenceStart = occurrence.start.index;
+                const occurrenceEnd = occurrence.end.index;
+                if (occurrenceStart !== undefined &&
+                    occurrenceEnd !== undefined &&
+                    occurrenceStart >= start &&
+                    occurrenceEnd <= end) {
+                    binding.occurrences.push(occurrence);
+                    moved += 1;
+                }
+                else {
+                    occurrences[write++] = occurrence;
+                }
+            }
+            if (moved > 0)
+                occurrences.length = write;
+        }
+    };
     const addBinding = (target, nameNode, kind) => {
         const binding = buildBinding(nameNode, kind);
-        target.map.set(binding.canonicalName, binding);
+        if (row.wholeScopeKinds?.has(target.kind) || declarationCoversScope(nameNode)) {
+            binding.coversEnclosingScope = true;
+        }
+        const tagRole = support.id === "c" ? cTagRole(nameNode) : undefined;
+        const key = tagRole ? cScopeName(binding.canonicalName, "tag") : binding.canonicalName;
+        if (tagRole === "reference") {
+            const visible = lookup(binding.name, nameNode);
+            if (visible) {
+                visible.occurrences.push(binding.def);
+                return;
+            }
+        }
+        const existing = target.map.get(key);
+        if (tagRole === "forward" && existing?.import) {
+            existing.occurrences.push(binding.def);
+            cImportedForwardTags ??= new Map();
+            if (!cImportedForwardTags.has(existing))
+                cImportedForwardTags.set(existing, binding);
+            return;
+        }
+        if (tagRole === "declaration" && existing?.import) {
+            binding.occurrences = existing.occurrences;
+            const forward = cImportedForwardTags?.get(existing);
+            if (forward) {
+                forward.occurrences = binding.occurrences;
+                binding.earlierSameScope = forward;
+            }
+            binding.occurrences.push(binding.def);
+            preserveExtraBinding(existing);
+        }
+        if (tagRole && existing?.def) {
+            if (existing.def.start.index === binding.def?.start.index)
+                return;
+            binding.occurrences = existing.occurrences;
+            if (tagRole === "declaration" && existing.node && cTagRole(existing.node) !== "declaration") {
+                binding.occurrences.push(existing.def);
+                preserveExtraBinding(existing);
+                // The forward tag remains visible from its declaration until this completion.
+                binding.earlierSameScope = existing;
+                target.map.set(key, binding);
+                return;
+            }
+            binding.occurrences.push(binding.def);
+            preserveExtraBinding(binding);
+            return;
+        }
+        if (kind === "function" && existing?.kind === "function") {
+            if (support.id === "c") {
+                // C prototypes and their definitions are declarations of one function. Keep each
+                // declaration addressable while sharing the occurrence list collected for that name.
+                binding.occurrences = existing.occurrences;
+                preserveExtraBinding(binding);
+                return;
+            }
+            if (support.id === "cpp") {
+                const collisions = existing.sameScopeFunctionBindings ?? [existing];
+                collisions.push(binding);
+                for (const collision of collisions)
+                    collision.sameScopeFunctionBindings = collisions;
+                cppFunctionCollisionGroups.add(collisions);
+                preserveExtraBinding(existing);
+            }
+            if (support.id === "ts" || support.id === "tsx") {
+                const candidates = existing.sameScopeFunctionBindings ?? [existing];
+                const collisions = typescriptCallableCandidatesInContainer(candidates, (candidate) => candidate.callable, binding.callable?.key);
+                if (collisions.includes(existing)) {
+                    let grouped = candidates;
+                    if (collisions !== candidates)
+                        grouped = [...collisions];
+                    grouped.push(binding);
+                    for (const collision of grouped)
+                        collision.sameScopeFunctionBindings = grouped;
+                    const existingRole = existing.callable?.role ?? "other";
+                    const nextRole = binding.callable?.role ?? "other";
+                    if (existingRole === "implementation" && nextRole === "signature") {
+                        preserveExtraBinding(binding);
+                        return;
+                    }
+                    if (existingRole === "signature" && nextRole === "implementation") {
+                        preserveExtraBinding(existing);
+                    }
+                    else if (existingRole === "signature" && nextRole === "signature") {
+                        preserveExtraBinding(binding);
+                        return;
+                    }
+                }
+            }
+        }
+        const sameSpan = !!existing?.def &&
+            !!binding.def &&
+            existing.def.start.index === binding.def.start.index &&
+            existing.def.end.index === binding.def.end.index;
+        // Pattern walks can register one name node twice. A second pass with a different kind is the
+        // real classification (`module` is pre-registered as a class, then as a type) and replaces it.
+        if (sameSpan && existing?.kind === kind)
+            return;
+        // A second local in a whole-scope scope is the same binding (Python assignments). Keep the
+        // first declaration and record the later one as an occurrence so an earlier use does not get
+        // attached only to the textually last declaration.
+        if (!sameSpan &&
+            existing &&
+            kind === "local" &&
+            existing.kind === "local" &&
+            !tagRole &&
+            !!row.variableTargetScopeKinds &&
+            row.wholeScopeKinds?.has(target.kind)) {
+            if (binding.def)
+                existing.occurrences.push(binding.def);
+            return;
+        }
+        // Preserving an overload as an extra binding must not hide it from earlier C++ uses.
+        if (!sameSpan &&
+            existing &&
+            (!extraBindingSpans.has(bindingSpanKey(existing)) ||
+                (support.id === "cpp" && kind === "function" && existing.kind === "function"))) {
+            binding.earlierSameScope = existing;
+        }
+        target.map.set(key, binding);
+        if (binding.coversEnclosingScope)
+            target.pendingCoveringNames?.delete(binding.canonicalName);
+        if (!tracksLexicalNames)
+            stealCoveredOccurrences(target, binding, key);
+        const cppNamespace = cppNamespacePathByMap.get(target.map);
+        if (support.id === "cpp" && kind === "function" && cppNamespace) {
+            const qualifiedKey = `${cppNamespace}::${binding.name}`;
+            const qualifiedBindings = cppQualifiedMemberBindings.get(qualifiedKey) ?? [];
+            qualifiedBindings.push(binding);
+            cppQualifiedMemberBindings.set(qualifiedKey, qualifiedBindings);
+        }
     };
     const addDecl = (nameNode, kind) => {
         const target = stack[stack.length - 1];
@@ -89,26 +421,119 @@ export function buildScopeIndexFromSource(file, source, support, imports = [], o
     // type parameter: Go struct fields are accessed through a receiver from
     // anywhere in the file, unlike a type parameter, which is scoped to its own
     // declaration.
+    const variableDeclarationScope = () => {
+        const current = stack[stack.length - 1] ?? rootScope;
+        const targetKinds = row.variableTargetScopeKinds;
+        if (!targetKinds)
+            return current;
+        const boundary = row.variableScopeBoundaryTypes;
+        for (let index = stack.length - 1; index >= 0; index -= 1) {
+            const scope = stack[index];
+            if (boundary) {
+                const parentType = scope.node.parent?.type;
+                if (boundary.has(scope.node.type) || (parentType !== undefined && boundary.has(parentType)))
+                    return scope;
+            }
+            if (targetKinds.has(scope.kind))
+                return scope;
+        }
+        return current;
+    };
+    const addVariableDecl = (nameNode, kind) => {
+        addBinding(variableDeclarationScope(), nameNode, kind);
+    };
     const addDeclSkippingTypeScope = (nameNode, kind) => {
+        if (kind === "local" && row.variableTargetScopeKinds) {
+            addVariableDecl(nameNode, kind);
+            return;
+        }
         const target = [...stack].reverse().find((scope) => scope.kind !== "type") ?? rootScope;
         addBinding(target, nameNode, kind);
     };
-    const lookup = (name) => {
-        const canonicalName = normalizeIdentifier(name);
+    const lookup = (name, node) => {
+        const normalizedName = node ? scopeIdentifierKey(row, name, node, normalizeIdentifier) : normalizeIdentifier(name);
+        const canonicalName = support.id === "c" && node && cTagRole(node) ? cScopeName(normalizedName, "tag") : normalizedName;
+        const methodCall = !!node && isExplicitMethodCall(row, node);
         for (let index = stack.length - 1; index >= 0; index--) {
-            const hit = stack[index].map.get(canonicalName);
+            const scope = stack[index];
+            if (node && !scopeAllowsUse(row, scope, node))
+                continue;
+            let hit = scope.map.get(canonicalName);
+            while (methodCall && hit?.kind === "local")
+                hit = hit.earlierSameScope;
+            if (hit)
+                return hit;
+        }
+        let root = rootScope.map.get(canonicalName);
+        while (methodCall && root?.kind === "local")
+            root = root.earlierSameScope;
+        return root;
+    };
+    const lookupOutsideFunctions = (name) => {
+        const canonicalName = `$${normalizeIdentifier(name)}`;
+        for (let index = stack.length - 1; index >= 0; index -= 1) {
+            const scope = stack[index];
+            if (scope.kind === "function")
+                continue;
+            const hit = scope.map.get(canonicalName);
             if (hit)
                 return hit;
         }
         return rootScope.map.get(canonicalName);
     };
+    const isPhpThisPropertyName = (nameNode) => {
+        const parent = nameNode.parent;
+        if (!parent || parent.type !== "member_access_expression")
+            return false;
+        const property = parent.childForFieldName("name") ?? parent.namedChildren.find((child) => child.type === "name") ?? null;
+        if (!property || property.startIndex !== nameNode.startIndex || property.endIndex !== nameNode.endIndex) {
+            return false;
+        }
+        const object = parent.childForFieldName("object") ?? parent.namedChildren[0] ?? null;
+        if (!object || object.startIndex === property.startIndex)
+            return false;
+        return sliceText(object, source) === "$this";
+    };
+    const promotedVariablesInClass = (classNode) => {
+        const variables = [];
+        const visit = (current) => {
+            if (current !== classNode &&
+                (current.type === "class_declaration" ||
+                    current.type === "trait_declaration" ||
+                    current.type === "enum_declaration" ||
+                    current.type === "function_definition")) {
+                return;
+            }
+            if (current.type === "method_declaration") {
+                const name = current.childForFieldName("name");
+                if (!name || sliceText(name, source) !== "__construct")
+                    return;
+                const params = current.childForFieldName("parameters");
+                for (const child of params?.namedChildren ?? []) {
+                    const variable = phpConstructorPromotedVariable(child, source);
+                    if (variable)
+                        variables.push(variable);
+                }
+                return;
+            }
+            for (const child of current.namedChildren)
+                visit(child);
+        };
+        visit(classNode);
+        return variables;
+    };
     const addPatternDecls = (pattern, kind, addBindingToScope = addDecl) => {
+        if (pattern.type === "property_promotion_parameter" && phpConstructorPromotedVariable(pattern, source)) {
+            return;
+        }
         if (idSet.has(pattern.type)) {
             addBindingToScope(pattern, kind);
             return;
         }
-        // Parameter nodes put names and types as siblings. Walking the whole subtree
-        // would register type-position identifiers (`int`, `T`, package qualifiers).
+        // Parameter nodes put names and types as siblings. Walking the whole subtree for bindings
+        // would register type-position identifiers (`int`, `T`, package qualifiers) as new locals;
+        // `walk` still visits the type field so a proven declaration (e.g. a struct name used as a
+        // parameter type) records this position as one of its occurrences.
         if (row.destructuringTypeFieldTypes?.has(pattern.type)) {
             const typeNode = pattern.childForFieldName("type");
             for (const child of pattern.namedChildren) {
@@ -116,6 +541,8 @@ export function buildScopeIndexFromSource(file, source, support, imports = [], o
                     continue;
                 addPatternDecls(child, kind, addBindingToScope);
             }
+            if (typeNode)
+                walk(typeNode);
             return;
         }
         if (row.destructuringPairPatternTypes?.has(pattern.type)) {
@@ -129,6 +556,15 @@ export function buildScopeIndexFromSource(file, source, support, imports = [], o
             addPatternDecls(child, kind, addBindingToScope);
         }
     };
+    const isAwaitedDynamicImport = (node) => {
+        if (!node || node.type !== "await_expression")
+            return false;
+        const call = node.namedChildren.find((child) => child.type === "call_expression");
+        if (!call)
+            return false;
+        const callee = call.childForFieldName("function") ?? call.child(0);
+        return callee?.type === "import";
+    };
     const isStaticRequireCall = (node) => {
         const requireCall = row.requireCall;
         if (!node || !requireCall?.callTypes.has(node.type))
@@ -139,6 +575,43 @@ export function buildScopeIndexFromSource(file, source, support, imports = [], o
         const args = node.childForFieldName("arguments");
         return !!args && requireCall.argumentsPattern.test(sliceText(args, source));
     };
+    const moduleSpecifierFromCall = (call) => {
+        const args = call?.childForFieldName("arguments");
+        if (args?.namedChildren.length !== 1)
+            return null;
+        const literal = args.namedChildren[0];
+        if (literal?.type !== "string" || literal.namedChildren.length !== 1)
+            return null;
+        const fragment = literal.namedChildren[0];
+        return fragment?.type === "string_fragment" ? sliceText(fragment, source) : null;
+    };
+    const moduleSpecifierFromValue = (value) => {
+        let current = value;
+        while (current?.type === "parenthesized_expression")
+            current = current.namedChildren[0] ?? null;
+        if (isAwaitedDynamicImport(current)) {
+            const call = current.namedChildren.find((child) => child.type === "call_expression") ?? null;
+            return moduleSpecifierFromCall(call);
+        }
+        return isStaticRequireCall(current) ? moduleSpecifierFromCall(current) : null;
+    };
+    const heldModuleSpecifierForDeclaration = (nameNode) => {
+        const declaration = nameNode.parent;
+        const declaredName = declaration?.childForFieldName("name");
+        if (declaration?.type !== "variable_declarator" || declaredName?.startIndex !== nameNode.startIndex) {
+            return undefined;
+        }
+        const annotation = declaration.childForFieldName("type");
+        const query = annotation ? typescriptImportTypeQuery(annotation) : null;
+        const typedSpecifier = query ? importTypeQuerySpecifier(query) : null;
+        const value = declaration.childForFieldName("value");
+        if (!value)
+            return typedSpecifier ?? undefined;
+        const initializedSpecifier = moduleSpecifierFromValue(value);
+        if (!initializedSpecifier || (typedSpecifier && typedSpecifier !== initializedSpecifier))
+            return null;
+        return initializedSpecifier;
+    };
     const hasImportBinding = (nameNode) => {
         const name = normalizeIdentifier(sliceText(nameNode, source));
         const binding = rootScope.map.get(name);
@@ -209,13 +682,19 @@ export function buildScopeIndexFromSource(file, source, support, imports = [], o
                 const name = child.childForFieldName("name");
                 const value = child.childForFieldName("value");
                 if (name) {
-                    if (isStaticRequireCall(value))
+                    if (isStaticRequireCall(value) || isAwaitedDynamicImport(value)) {
                         addUnsupportedRequirePatternDecls(name, addBindingToScope);
+                    }
                     else
                         addPatternDecls(name, "local", addBindingToScope);
                 }
             }
             else if (row.assignmentIdentifierTypes?.has(child.type) && row.assignmentDeclarationTypes?.has(node.type)) {
+                const left = node.childForFieldName("left");
+                // `y = x` names both identifiers. Only the left-hand side declares; the right-hand side
+                // is a use and must not become a same-scope binding that hides the real declaration.
+                if (left && (left.startIndex !== child.startIndex || left.endIndex !== child.endIndex))
+                    continue;
                 addBindingToScope(child, "local");
             }
             else if (row.patternBindingTypes?.has(node.type)) {
@@ -225,11 +704,55 @@ export function buildScopeIndexFromSource(file, source, support, imports = [], o
             }
         }
     };
+    const rememberPatternNames = (pattern, names) => {
+        if (idSet.has(pattern.type)) {
+            names.add(normalizeIdentifier(sliceText(pattern, source)));
+            return;
+        }
+        if (row.destructuringTypeFieldTypes?.has(pattern.type)) {
+            const typeNode = pattern.childForFieldName("type");
+            for (const child of pattern.namedChildren) {
+                if (typeNode && child.startIndex === typeNode.startIndex && child.endIndex === typeNode.endIndex)
+                    continue;
+                rememberPatternNames(child, names);
+            }
+            return;
+        }
+        if (row.destructuringPairPatternTypes?.has(pattern.type)) {
+            const value = pattern.childForFieldName("value");
+            if (value)
+                rememberPatternNames(value, names);
+            return;
+        }
+        for (const child of pattern.namedChildren)
+            rememberPatternNames(child, names);
+    };
+    const rememberLexicalNames = (declaration, names) => {
+        for (const child of declaration.namedChildren) {
+            if (!row.variableDeclaratorTypes?.has(child.type))
+                continue;
+            const name = child.childForFieldName("name");
+            if (name)
+                rememberPatternNames(name, names);
+        }
+    };
     const collectHoistedDeclarations = (scopeNode) => {
         if (!row.hoistedFunctionTypes && !row.hoistedVariableDeclarationTypes)
             return;
+        let pending;
+        const ensurePending = () => {
+            if (!pending) {
+                pending = new Set();
+                if (scopeNode.id !== undefined)
+                    pendingNamesByNodeId.set(scopeNode.id, pending);
+            }
+            return pending;
+        };
+        const addPending = (nameNode) => {
+            ensurePending().add(normalizeIdentifier(sliceText(nameNode, source)));
+        };
         const visit = (node) => {
-            if (support.createsFunctionScope(node)) {
+            if (node !== scopeNode && support.createsFunctionScope(node)) {
                 if (row.hoistedFunctionTypes?.has(node.type)) {
                     const name = node.childForFieldName("name");
                     if (name)
@@ -237,16 +760,40 @@ export function buildScopeIndexFromSource(file, source, support, imports = [], o
                 }
                 return;
             }
+            if (node !== scopeNode &&
+                !row.moduleRootTypes?.has(node.type) &&
+                (support.createsBlockScope(node) || !!row.typeScopeTypes?.has(node.type))) {
+                collectHoistedDeclarations(node);
+                return;
+            }
             if (row.hoistedVariableDeclarationTypes?.has(node.type)) {
                 addVariableDeclarations(node, addHoistedDecl);
             }
-            for (const child of node.namedChildren) {
-                visit(child);
+            else if (row.variableDeclarationTypes?.has(node.type)) {
+                rememberLexicalNames(node, ensurePending());
+            }
+            if (row.classNameTypes?.has(node.type) || row.typeNameTypes?.has(node.type)) {
+                const name = node.childForFieldName("name");
+                if (name)
+                    addPending(name);
+            }
+            if (row.enumAssignmentTypes?.has(node.type)) {
+                const name = node.childForFieldName("name");
+                if (name)
+                    addPending(name);
             }
+            else if (row.enumBodyMemberTypes?.has(node.type) &&
+                node.parent &&
+                row.enumBodyParentTypes?.has(node.parent.type)) {
+                addPending(node);
+            }
+            if (idSet.has(node.type) && scopeDeclarationNames(node))
+                addPending(node);
+            for (const child of node.namedChildren)
+                visit(child);
         };
-        for (const child of scopeNode.namedChildren) {
+        for (const child of scopeNode.namedChildren)
             visit(child);
-        }
     };
     const isMemberFunction = (node) => {
         if (row.memberFunctionTypes?.has(node.type)) {
@@ -261,18 +808,188 @@ export function buildScopeIndexFromSource(file, source, support, imports = [], o
         }
         return false;
     };
+    const canonicalUseName = (name, node) => {
+        const normalized = scopeIdentifierKey(row, name, node, normalizeIdentifier);
+        if (support.id === "php" && isPhpThisPropertyName(node))
+            return `$${normalized}`;
+        return support.id === "c" && cTagRole(node) ? cScopeName(normalized, "tag") : normalized;
+    };
+    const scopeOwnsBinding = (scope, canonical, binding) => {
+        let current = scope.map.get(canonical);
+        while (current) {
+            if (current === binding)
+                return true;
+            current = current.earlierSameScope;
+        }
+        return false;
+    };
+    const deferToScope = (canonical, binding) => {
+        if (row.variableTargetScopeKinds) {
+            for (let index = stack.length - 1; index >= 0; index -= 1) {
+                const scope = stack[index];
+                if (binding && scopeOwnsBinding(scope, canonical, binding))
+                    return undefined;
+                if (row.variableTargetScopeKinds.has(scope.kind))
+                    return scope;
+            }
+        }
+        if (row.laterLocalBlocksOuterKinds) {
+            for (let index = stack.length - 1; index >= 0; index -= 1) {
+                const scope = stack[index];
+                if (binding && scopeOwnsBinding(scope, canonical, binding))
+                    return undefined;
+                if (row.laterLocalBlocksOuterKinds.has(scope.kind))
+                    return scope;
+            }
+        }
+        if (tracksLexicalNames) {
+            const current = stack[stack.length - 1] ?? rootScope;
+            // A covering declaration still ahead in this scope shadows an outer binding (TDZ, hoisting).
+            if (current.pendingCoveringNames?.has(canonical))
+                return current;
+            if (binding && current.map.get(canonical) === binding)
+                return undefined;
+            for (let index = stack.length - 1; index >= 0; index -= 1) {
+                const scope = stack[index];
+                if (binding && scopeOwnsBinding(scope, canonical, binding))
+                    return undefined;
+                if (scope.pendingCoveringNames?.has(canonical))
+                    return scope;
+            }
+            return undefined;
+        }
+        if (!binding && canDeferForward) {
+            for (let index = stack.length - 1; index >= 0; index -= 1) {
+                const scope = stack[index];
+                if (scopeCanGainCoveringBinding(scope))
+                    return scope;
+            }
+        }
+        return undefined;
+    };
+    const scopeCanGainCoveringBinding = (scope) => !!row.wholeScopeKinds?.has(scope.kind) ||
+        !!row.variableTargetScopeKinds?.has(scope.kind) ||
+        !!row.laterLocalBlocksOuterKinds?.has(scope.kind) ||
+        !!row.wholeScopeDeclarationTypes?.size ||
+        (scope.kind === "module" && !!row.moduleBindingsAtFunctionRuntime);
+    const moduleBindingAtFunctionRuntime = (useNode) => {
+        if (!row.moduleBindingsAtFunctionRuntime)
+            return false;
+        for (let current = useNode.parent; current; current = current.parent) {
+            if (!support.createsFunctionScope(current))
+                continue;
+            const body = current.childForFieldName("body");
+            return !!body && useNode.startIndex >= body.startIndex && useNode.endIndex <= body.endIndex;
+        }
+        return false;
+    };
+    const lookupCovering = (start, useNode, canonical, phpThis) => {
+        const useStart = useNode.startIndex;
+        const methodCall = isExplicitMethodCall(row, useNode);
+        let scope = start;
+        while (scope) {
+            if (!scopeAllowsUse(row, scope, useNode)) {
+                scope = scope.parent;
+                continue;
+            }
+            if (!(phpThis && scope.kind === "function")) {
+                let binding = scope.map.get(canonical);
+                const atModuleRuntime = scope.kind === "module" && moduleBindingAtFunctionRuntime(useNode);
+                while (binding &&
+                    ((methodCall && binding.kind === "local") ||
+                        (!atModuleRuntime && !bindingCoversUse(row, scope.kind, binding, useStart)))) {
+                    binding = binding.earlierSameScope;
+                }
+                if (binding)
+                    return binding;
+            }
+            if (laterLocalBlocksOuterUse(row, scope, canonical, useStart))
+                return undefined;
+            scope = scope.parent;
+        }
+        return undefined;
+    };
+    const attachOccurrence = (binding, useNode) => {
+        const range = toRange(useNode);
+        if (support.id === "cpp" && binding.kind === "function") {
+            cppFunctionOccurrences.push({ binding, node: useNode, range });
+        }
+        else {
+            binding.occurrences.push(range);
+        }
+    };
+    const queueUse = (scope, id) => {
+        let queued = scope.queuedUseIds;
+        if (!queued)
+            scope.queuedUseIds = queued = [];
+        queued.push(id);
+    };
+    const closeScope = (scope) => {
+        const queued = scope.queuedUseIds;
+        if (!queued)
+            return;
+        delete scope.queuedUseIds;
+        let receiver;
+        if (!tracksLexicalNames) {
+            receiver = scope.parent;
+            while (receiver && !scopeCanGainCoveringBinding(receiver))
+                receiver = receiver.parent;
+        }
+        for (let index = 0; index < queued.length; index += 1) {
+            const id = queued[index];
+            const useNode = nodeById(id);
+            if (!useNode)
+                continue;
+            const phpThis = support.id === "php" && isPhpThisPropertyName(useNode);
+            const canonical = canonicalUseName(sliceText(useNode, source), useNode);
+            const binding = lookupCovering(scope, useNode, canonical, phpThis);
+            if (!binding) {
+                if (laterLocalBlocksOuterUse(row, scope, canonical, useNode.startIndex))
+                    continue;
+                if (receiver)
+                    queueUse(receiver, id);
+                continue;
+            }
+            if (receiver && !scopeOwnsBinding(scope, canonical, binding)) {
+                queueUse(receiver, id);
+                continue;
+            }
+            attachOccurrence(binding, useNode);
+        }
+    };
     const walk = (node) => {
+        let scopedFunctionName = null;
+        let qualifiedNamespaceScope;
         // A name-registering node puts its name in the *current* (enclosing) scope before the push
         // below creates the node's own scope. C# local functions need that: they are callable from
         // sibling statements in the enclosing method, unlike a JS named function expression's
         // self-only visibility, which the language's `scopeDeclarationNames` hook handles instead.
         if (row.functionNameTypes?.has(node.type)) {
-            const name = node.childForFieldName("name");
+            const name = declaredNameNode(node, row);
             if (name && (support.membersAreImplicitlyInScope || !isMemberFunction(node))) {
-                if (row.hoistedFunctionTypes?.has(node.type))
+                // The declarator chain that carries a C-family function name also carries its parameter
+                // list, so the child walk must still descend into it. Remember the exact name node instead
+                // and skip only that node below, which keeps one binding per function without hiding
+                // `function_declarator > parameter_list` from parameter registration.
+                preRegisteredNameSpans.add(nameSpanKey(name));
+                const qualifiedName = support.id === "cpp" ? qualifiedCppIdentifierForName(name, node) : null;
+                if (qualifiedName) {
+                    const qualifiedKey = cppQualifiedNameSegments(qualifiedName, source).join("::");
+                    const ownerKey = qualifiedKey.slice(0, qualifiedKey.lastIndexOf("::"));
+                    qualifiedNamespaceScope = cppNamespaceScopes.get(ownerKey);
+                    if (qualifiedNamespaceScope) {
+                        addBinding(qualifiedNamespaceScope, name, "function");
+                    }
+                    else {
+                        scopedFunctionName = { node: name, qualifiedKey };
+                    }
+                }
+                else if (row.hoistedFunctionTypes?.has(node.type)) {
                     addHoistedDecl(name, "function");
-                else
+                }
+                else {
                     addDecl(name, "function");
+                }
             }
         }
         if (row.classNameTypes?.has(node.type)) {
@@ -305,32 +1022,78 @@ export function buildScopeIndexFromSource(file, source, support, imports = [], o
             addDecl(node, "local");
         }
         let pushed = false;
-        if (support.createsFunctionScope(node)) {
+        let pushedScopeCount = 0;
+        const namespacePathStart = cppNamespacePath.length;
+        const cppNamespaceName = support.id === "cpp" && node.type === "namespace_definition" ? node.childForFieldName("name") : null;
+        const cppNamespaceIsInline = !!cppNamespaceName && /^\s*inline\s+namespace\b/u.test(sliceText(node, source));
+        const createsCppNamespaceScope = !!cppNamespaceName && !cppNamespaceIsInline;
+        const createsMemberScope = !!row.memberScopeTypes?.has(node.type);
+        if (createsCppNamespaceScope) {
+            const name = cppNamespaceName;
+            const segments = sliceText(name, source).replace(/\s+/gu, "").split("::").filter(Boolean);
+            for (const segment of segments) {
+                cppNamespacePath.push(segment);
+                const key = cppNamespacePath.join("::");
+                const map = cppNamespaceMaps.get(key) ?? new Map();
+                cppNamespaceMaps.set(key, map);
+                cppNamespacePathByMap.set(map, key);
+                const scope = {
+                    kind: "block",
+                    map,
+                    node,
+                    parent: stack[stack.length - 1],
+                };
+                stack.push(scope);
+                allScopes.push(scope);
+                if (!cppNamespaceScopes.has(key))
+                    cppNamespaceScopes.set(key, scope);
+                pushed = true;
+                pushedScopeCount += 1;
+            }
+        }
+        else if (support.createsFunctionScope(node)) {
             const scope = {
                 kind: "function",
                 map: new Map(),
                 node,
-                parent: stack[stack.length - 1],
+                parent: qualifiedNamespaceScope ?? stack[stack.length - 1],
             };
             stack.push(scope);
             allScopes.push(scope);
             pushed = true;
+            pushedScopeCount = 1;
+            if (scopedFunctionName) {
+                addDecl(scopedFunctionName.node, "function");
+                const binding = scope.map.get(normalizeIdentifier(sliceText(scopedFunctionName.node, source)));
+                if (binding) {
+                    const bindings = cppQualifiedMemberBindings.get(scopedFunctionName.qualifiedKey) ?? [];
+                    bindings.push(binding);
+                    cppQualifiedMemberBindings.set(scopedFunctionName.qualifiedKey, bindings);
+                }
+            }
             const params = node.childForFieldName("parameters");
             if (params)
                 addPatternDecls(params, "param");
             collectHoistedDeclarations(node);
+            attachPendingNames(scope);
         }
-        else if (support.createsBlockScope(node)) {
+        else if (support.createsBlockScope(node) || createsMemberScope) {
             if (!row.moduleRootTypes?.has(node.type)) {
                 const scope = {
-                    kind: "block",
+                    kind: createsMemberScope ? "member" : "block",
                     map: new Map(),
                     node,
                     parent: stack[stack.length - 1],
                 };
+                attachPendingNames(scope);
                 stack.push(scope);
                 allScopes.push(scope);
                 pushed = true;
+                pushedScopeCount = 1;
+                const blockParams = node.childForFieldName("parameters");
+                if (blockParams && (blockParams.type === "block_parameters" || blockParams.type === "lambda_parameters")) {
+                    addPatternDecls(blockParams, "param");
+                }
             }
         }
         else if (row.typeScopeTypes?.has(node.type)) {
@@ -345,12 +1108,30 @@ export function buildScopeIndexFromSource(file, source, support, imports = [], o
                 node,
                 parent: stack[stack.length - 1],
             };
+            attachPendingNames(scope);
             stack.push(scope);
             allScopes.push(scope);
             pushed = true;
+            pushedScopeCount = 1;
         }
         if (row.variableDeclarationTypes?.has(node.type)) {
-            addVariableDeclarations(node, row.hoistedVariableDeclarationTypes?.has(node.type) ? addHoistedDecl : addDecl);
+            addVariableDeclarations(node, row.hoistedVariableDeclarationTypes?.has(node.type) ? addHoistedDecl : addVariableDecl);
+        }
+        if (isJsTsLanguage(support.id) &&
+            (node.type === "assignment_expression" || node.type === "augmented_assignment_expression")) {
+            const left = node.childForFieldName("left");
+            if (left && idSet.has(left.type)) {
+                const binding = lookup(sliceText(left, source), left);
+                if (binding?.kind === "local" && binding.heldModuleSpecifier !== null) {
+                    const assigned = node.type === "assignment_expression" ? moduleSpecifierFromValue(node.childForFieldName("right")) : null;
+                    if (!assigned || (binding.heldModuleSpecifier && binding.heldModuleSpecifier !== assigned)) {
+                        binding.heldModuleSpecifier = null;
+                    }
+                    else {
+                        binding.heldModuleSpecifier = assigned;
+                    }
+                }
+            }
         }
         if (row.declarationPatternTypes?.has(node.type)) {
             // C# is-pattern bound variable: `if (o is string text)`. The walker registers the bound name
@@ -369,54 +1150,194 @@ export function buildScopeIndexFromSource(file, source, support, imports = [], o
             if (name)
                 addDecl(name, "type");
         }
+        let declarationName = idSet.has(node.type) && support.isDeclarationName(node);
+        if (declarationName && row.shortVariableDeclarationTypes) {
+            for (let current = node.parent; current; current = current.parent) {
+                if (row.shortVariableDeclarationTypes.has(current.type)) {
+                    const left = current.childForFieldName("left");
+                    declarationName = !!left && node.startIndex >= left.startIndex && node.endIndex <= left.endIndex;
+                    break;
+                }
+                if (support.createsFunctionScope(current) || support.createsBlockScope(current))
+                    break;
+            }
+        }
         if (scopeDeclarationNames(node) &&
-            idSet.has(node.type) &&
-            support.isDeclarationName(node) &&
-            !isScopedEnumeratorName(node)) {
+            declarationName &&
+            !isScopedEnumeratorName(node) &&
+            !preRegisteredNameSpans.has(nameSpanKey(node))) {
             const kind = isParamNode(node) ? "param" : declarationKindToBindingKind(support.classifyDefinition(node));
             addDeclSkippingTypeScope(node, kind);
         }
-        if (idSet.has(node.type) && !support.isDeclarationName(node)) {
-            const binding = lookup(sliceText(node, source));
-            if (binding) {
-                binding.occurrences.push(toRange(node));
+        const nestedIdentifier = node.parent && idSet.has(node.parent.type) && row.childSkipNameTypes?.has(node.type);
+        if (idSet.has(node.type) && !declarationName && !nestedIdentifier) {
+            const qualifiedName = support.id === "cpp" ? qualifiedCppIdentifierForName(node) : null;
+            if (qualifiedName) {
+                const key = cppQualifiedNameSegments(qualifiedName, source).join("::");
+                const occurrences = cppQualifiedMemberOccurrences.get(key) ?? [];
+                const fallback = lookup(sliceText(node, source));
+                occurrences.push({ node, range: toRange(node), ...(fallback ? { fallback } : {}) });
+                cppQualifiedMemberOccurrences.set(key, occurrences);
+            }
+            else {
+                const parent = node.parent;
+                const memberProperty = parent &&
+                    (row.nonLexicalMemberPropertyTypes?.has(parent.type) ||
+                        (support.id === "cpp" && isMemberAccessNode(support, parent)))
+                    ? getMemberAccessParts(support, parent).property
+                    : null;
+                const isMemberProperty = !!memberProperty && memberProperty.startIndex <= node.startIndex && memberProperty.endIndex >= node.endIndex;
+                if (!isMemberProperty) {
+                    const phpThis = support.id === "php" && isPhpThisPropertyName(node);
+                    const name = sliceText(node, source);
+                    const binding = phpThis ? lookupOutsideFunctions(name) : lookup(name, node);
+                    const canonical = canonicalUseName(name, node);
+                    const deferred = deferToScope(canonical, binding);
+                    const useId = node.id;
+                    if (deferred && useId !== undefined)
+                        queueUse(deferred, useId);
+                    else if (binding)
+                        attachOccurrence(binding, node);
+                }
             }
         }
+        if (support.id === "php" && node.type === "class_declaration") {
+            const target = stack[stack.length - 1] ?? rootScope;
+            for (const variable of promotedVariablesInClass(node))
+                addBinding(target, variable, "local");
+        }
         for (const child of node.namedChildren) {
             if (pushed) {
                 const params = node.childForFieldName("parameters");
                 const skipsFunctionParameters = support.createsFunctionScope(node) && params?.id === child.id;
+                const skipsBlockParameters = support.createsBlockScope(node) &&
+                    (child.type === "block_parameters" || child.type === "lambda_parameters") &&
+                    params?.startIndex === child.startIndex &&
+                    params.endIndex === child.endIndex;
                 const skipsNameOrParameters = (row.functionNameTypes?.has(node.type) || row.classNameTypes?.has(node.type)) &&
                     row.childSkipNameTypes?.has(child.type);
-                if (skipsFunctionParameters || skipsNameOrParameters) {
+                const skipsCppNamespaceName = createsCppNamespaceScope && node.childForFieldName("name")?.id === child.id;
+                if (skipsFunctionParameters || skipsBlockParameters || skipsNameOrParameters || skipsCppNamespaceName) {
                     continue;
                 }
             }
             walk(child);
         }
-        if (pushed)
+        for (let index = 0; index < pushedScopeCount; index += 1) {
+            const closed = stack[stack.length - 1];
+            if (closed)
+                closeScope(closed);
             stack.pop();
+        }
+        cppNamespacePath.length = namespacePathStart;
+    };
+    const prepareCppCallableBindings = (bindings) => {
+        const bySignature = new Map();
+        for (const binding of bindings) {
+            const callable = binding.callable;
+            if (!callable?.signature || !callable.arity) {
+                for (const candidate of bindings)
+                    candidate.occurrencesComplete = false;
+                return false;
+            }
+            const entity = bySignature.get(callable.key) ?? [];
+            entity.push(binding);
+            bySignature.set(callable.key, entity);
+        }
+        for (const entity of bySignature.values()) {
+            const occurrences = entity.flatMap((binding) => (binding.def ? [binding.def] : []));
+            for (const binding of entity) {
+                binding.occurrences = occurrences;
+                delete binding.occurrencesComplete;
+            }
+        }
+        return true;
+    };
+    const assignCppCallableOccurrence = (bindings, node, range) => {
+        const selected = cppSelectCallableBinding(bindings, node, source, file, file);
+        if (selected) {
+            selected.occurrences.push(range);
+            return;
+        }
+        for (const binding of bindings)
+            binding.occurrencesComplete = false;
+    };
+    const cppOccurrenceBindings = (binding) => {
+        const collisions = binding.sameScopeFunctionBindings ?? [binding];
+        if (collisions.length > 1 || binding.callable?.signature)
+            return collisions;
+        return null;
     };
     collectHoistedDeclarations(tree.rootNode);
+    attachPendingNames(rootScope);
     walk(tree.rootNode);
+    closeScope(rootScope);
+    for (const collisions of cppFunctionCollisionGroups)
+        prepareCppCallableBindings(collisions);
+    const cppQualifiedCallableBindings = new Map();
+    for (const [key, memberBindings] of cppQualifiedMemberBindings) {
+        const callableBindings = [
+            ...new Set(memberBindings.flatMap((binding) => binding.sameScopeFunctionBindings ?? [binding])),
+        ];
+        if (prepareCppCallableBindings(callableBindings))
+            cppQualifiedCallableBindings.set(key, callableBindings);
+    }
+    for (const occurrence of cppFunctionOccurrences) {
+        const group = cppOccurrenceBindings(occurrence.binding);
+        if (group) {
+            assignCppCallableOccurrence(group, occurrence.node, occurrence.range);
+        }
+        else {
+            occurrence.binding.occurrences.push(occurrence.range);
+        }
+    }
+    for (const [key, callableBindings] of cppQualifiedCallableBindings) {
+        for (const occurrence of cppQualifiedMemberOccurrences.get(key) ?? []) {
+            assignCppCallableOccurrence(callableBindings, occurrence.node, occurrence.range);
+        }
+    }
+    for (const [key, occurrences] of cppQualifiedMemberOccurrences) {
+        if (cppQualifiedCallableBindings.has(key))
+            continue;
+        for (const occurrence of occurrences) {
+            const fallback = occurrence.fallback;
+            if (!fallback)
+                continue;
+            const group = cppOccurrenceBindings(fallback);
+            if (group) {
+                assignCppCallableOccurrence(group, occurrence.node, occurrence.range);
+            }
+            else {
+                fallback.occurrences.push(occurrence.range);
+            }
+        }
+    }
     const bindings = new Map();
     const all = [];
-    const flush = (scope) => {
-        for (const binding of scope.map.values()) {
-            if (!bindings.has(binding.canonicalName))
-                bindings.set(binding.canonicalName, []);
-            bindings.get(binding.canonicalName).push(binding);
-            all.push(binding);
-        }
-    };
-    for (const scope of allScopes)
-        flush(scope);
-    for (const binding of extraBindings) {
+    const flushedMaps = new Set();
+    const seenBindings = new Set();
+    const pushBinding = (binding) => {
+        if (seenBindings.has(binding))
+            return;
+        seenBindings.add(binding);
         if (!bindings.has(binding.canonicalName))
             bindings.set(binding.canonicalName, []);
         bindings.get(binding.canonicalName).push(binding);
         all.push(binding);
-    }
-    return { bindings, all, allScopes };
+        if (binding.earlierSameScope)
+            pushBinding(binding.earlierSameScope);
+    };
+    const flush = (scope) => {
+        if (flushedMaps.has(scope.map))
+            return;
+        flushedMaps.add(scope.map);
+        for (const binding of scope.map.values())
+            pushBinding(binding);
+    };
+    for (const scope of allScopes)
+        flush(scope);
+    for (const binding of extraBindings)
+        pushBinding(binding);
+    return { bindings, all, allScopes, cppQualifiedFunctionBindings: cppQualifiedCallableBindings };
 }
 //# sourceMappingURL=scope.js.map