@lzehrung/codegraph 2.3.31 → 3.0.0

package/dist/indexer/navigation-cpp.js

@@ -0,0 +1,935 @@
+import { supportForFileWithoutHeaderSample } from "../languages.js";
+import { cppOutOfLineOwnerPath, cppQualifiedNameSegments } from "../graphs/symbol-graph-detailed/receiver-calls.js";
+import { sliceText } from "../util/ast.js";
+import { fileIdentityKey } from "../util/paths.js";
+import { ensureParsedContext } from "./parse-context.js";
+import { cppEquivalentCallableBindings, cppSelectCallableByCallArity, cppSelectCallableBinding, } from "./cpp-callables.js";
+import { getOrBuildScopeIndex } from "./navigation-local.js";
+import { fileScopeDefinitionCoversUse } from "./scope-nodes.js";
+import { definitionIdentityKey } from "./reference-context.js";
+import { SymbolKind } from "./types.js";
+const CPP_MEMBER_CONTAINER_TYPES = new Set(["class_specifier", "struct_specifier", "union_specifier"]);
+const resolutionCache = new WeakMap();
+function cppBindingDefinition(file, binding) {
+    if (!binding.def)
+        return null;
+    return {
+        file,
+        localName: binding.name,
+        kind: SymbolKind.Function,
+        range: binding.def,
+        ...(binding.callable ? { callable: binding.callable } : {}),
+    };
+}
+export function resolveCppCallableBindings(file, bindings, node, source) {
+    const target = cppSelectCallableBinding(bindings, node, source, file, file);
+    return target ? cppBindingDefinition(file, target) : null;
+}
+/**
+ * Undefined means the lexical binding is not a C++ callable that needs arity
+ * selection. Null means no unique target after declaration-site and known-call-arity checks.
+ */
+export function resolveCppCollidingBinding(file, binding, node, source) {
+    if (binding.kind !== "function")
+        return undefined;
+    const collisions = binding.sameScopeFunctionBindings ?? [binding];
+    if (collisions.length < 2 && !binding.callable?.signature)
+        return undefined;
+    return resolveCppCallableBindings(file, collisions, node, source);
+}
+/** A using-declaration introduces its target, not a new local definition. */
+export function cppUsingDeclarationTarget(binding, source) {
+    const qualified = binding.node?.parent;
+    if (qualified?.type !== "qualified_identifier" || qualified.parent?.type !== "using_declaration") {
+        return undefined;
+    }
+    return cppQualifiedNameSegments(qualified, source).join("::") || undefined;
+}
+function addCppFunctionExportTargets(index, moduleEntry, name, defs, seen) {
+    const moduleKey = `${fileIdentityKey(moduleEntry.file)}\0${name}`;
+    if (seen.has(moduleKey))
+        return;
+    seen.add(moduleKey);
+    for (const entry of moduleEntry.exports) {
+        if (entry.type === "exportStar" || entry.exportedAs !== name)
+            continue;
+        if (entry.type === "local" && entry.target.kind === SymbolKind.Function) {
+            const key = definitionIdentityKey(entry.target);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            defs.push(entry.target);
+        }
+        else if (entry.type === "reexport") {
+            const target = index.byFile.get(fileIdentityKey(entry.fromModule));
+            if (target)
+                addCppFunctionExportTargets(index, target, entry.sourceSpecifier, defs, seen);
+        }
+    }
+    for (const imp of moduleEntry.imports) {
+        if (imp.kind !== "star" || typeof imp.resolved !== "string")
+            continue;
+        const target = index.byFile.get(fileIdentityKey(imp.resolved));
+        if (target)
+            addCppFunctionExportTargets(index, target, name, defs, seen);
+    }
+}
+/** Function exports visible as `name` in this module, including include and using-alias targets. */
+export function collectVisibleCppFunctionExports(index, sourceModule, name) {
+    const defs = [];
+    const seen = new Set();
+    addCppFunctionExportTargets(index, sourceModule, name, defs, seen);
+    for (const imp of sourceModule.imports) {
+        const targetFile = typeof imp.resolved === "string" ? imp.resolved : undefined;
+        if (!targetFile)
+            continue;
+        const targetModule = index.byFile.get(fileIdentityKey(targetFile));
+        if (!targetModule)
+            continue;
+        if (imp.kind === "named") {
+            if (imp.local === name || imp.imported === name) {
+                addCppFunctionExportTargets(index, targetModule, imp.imported, defs, seen);
+            }
+        }
+    }
+    return defs;
+}
+/** A same-file overload enters the visible set at its first declaration, not its definition. */
+function visibleCppFunctionExportsAt(index, sourceModule, defs, node, loadParsedFile) {
+    const sourceKey = fileIdentityKey(sourceModule.file);
+    const useStart = node.startIndex;
+    const laterInFile = (def) => fileIdentityKey(def.file) === sourceKey && !fileScopeDefinitionCoversUse("cpp", def.range, useStart);
+    if (!defs.some(laterInFile))
+        return defs;
+    const parsed = loadParsedFile(sourceModule.file);
+    const support = parsed?.sup ?? supportForFileWithoutHeaderSample(sourceModule.file, index.languageExtensions);
+    const scopeIndex = parsed && support
+        ? getOrBuildScopeIndex(index, sourceModule.file, parsed.source, support, sourceModule, parsed.tree)
+        : null;
+    return defs.filter((def) => {
+        if (!laterInFile(def))
+            return true;
+        const binding = scopeIndex?.all.find((candidate) => candidate.kind === "function" &&
+            candidate.def?.start.index === def.range.start.index &&
+            candidate.def?.end.index === def.range.end.index);
+        return (!!binding &&
+            cppEquivalentCallableBindings(binding).some((equivalent) => !!equivalent.def && fileScopeDefinitionCoversUse("cpp", equivalent.def, useStart)));
+    });
+}
+function localDefForBinding(index, file, binding) {
+    const synthesized = cppBindingDefinition(file, binding);
+    if (!synthesized)
+        return null;
+    const moduleEntry = index.byFile.get(fileIdentityKey(file));
+    return (moduleEntry?.locals.find((candidate) => candidate.kind === SymbolKind.Function &&
+        candidate.range.start.index === binding.def?.start.index &&
+        candidate.range.end.index === binding.def?.end.index) ?? synthesized);
+}
+/**
+ * Selects among already-collected C++ function definitions by known call arity,
+ * without treating a consumer's source position as a declaration site.
+ */
+export function resolveCppExportedCallables(index, defs, node, source, loadParsedFile, canonicalNameForDef) {
+    const ownedBindings = [];
+    const handled = new Set();
+    const canonicalNames = new Map();
+    const defsByFile = new Map();
+    for (const def of defs) {
+        const fileKey = fileIdentityKey(def.file);
+        const group = defsByFile.get(fileKey);
+        if (group)
+            group.defs.push(def);
+        else
+            defsByFile.set(fileKey, { file: def.file, defs: [def] });
+    }
+    for (const { file, defs: fileDefs } of defsByFile.values()) {
+        const moduleEntry = index.byFile.get(fileIdentityKey(file));
+        const parsed = loadParsedFile(file);
+        const support = parsed?.sup ?? supportForFileWithoutHeaderSample(file, index.languageExtensions);
+        if (!moduleEntry || !parsed || !support)
+            return null;
+        const scopeIndex = getOrBuildScopeIndex(index, file, parsed.source, support, moduleEntry, parsed.tree);
+        for (const def of fileDefs) {
+            const binding = scopeIndex.all.find((candidate) => candidate.kind === "function" &&
+                candidate.def?.start.index === def.range.start.index &&
+                candidate.def?.end.index === def.range.end.index);
+            if (!binding)
+                return null;
+            const explicitName = canonicalNameForDef?.(def);
+            let canonicalName = explicitName ?? binding.canonicalName;
+            if (!explicitName) {
+                for (const [qualifiedName, bindings] of scopeIndex.cppQualifiedFunctionBindings) {
+                    if (!bindings.includes(binding))
+                        continue;
+                    canonicalName = qualifiedName;
+                    break;
+                }
+            }
+            for (const equivalent of cppEquivalentCallableBindings(binding)) {
+                if (handled.has(equivalent))
+                    continue;
+                handled.add(equivalent);
+                canonicalNames.set(equivalent, canonicalName);
+                ownedBindings.push({ file, binding: equivalent });
+            }
+        }
+    }
+    if (!ownedBindings.length)
+        return null;
+    // Bindings may come from included headers; the query node is in the consumer.
+    // Skip the declaration-site shortcut so coincident offsets cannot bypass arity.
+    const selected = cppSelectCallableByCallArity(ownedBindings.map((entry) => entry.binding), node, source, canonicalNames);
+    if (!selected)
+        return null;
+    const owner = ownedBindings.find((entry) => entry.binding === selected);
+    return owner ? localDefForBinding(index, owner.file, selected) : null;
+}
+/**
+ * Undefined means this name has no visible C++ function exports. Null means no
+ * unique target remains after known-call-arity checks.
+ */
+export function resolveVisibleCppCallableName(index, sourceModule, name, node, source, loadParsedFile) {
+    const defs = collectVisibleCppFunctionExports(index, sourceModule, name);
+    if (!defs.length)
+        return undefined;
+    const visibleDefs = visibleCppFunctionExportsAt(index, sourceModule, defs, node, loadParsedFile);
+    if (!visibleDefs.length)
+        return undefined;
+    return resolveCppExportedCallables(index, visibleDefs, node, source, loadParsedFile);
+}
+const CPP_USING_DIRECTIVE_NAME_TYPES = {
+    identifier: true,
+    namespace_identifier: true,
+    type_identifier: true,
+    qualified_identifier: true,
+    nested_namespace_specifier: true,
+};
+const CPP_USING_DIRECTIVE_REJECT_SCOPES = {
+    function_definition: true,
+    lambda_expression: true,
+    class_specifier: true,
+    struct_specifier: true,
+    union_specifier: true,
+};
+/**
+ * Directives belong to the parsed tree. The star-import closure belongs to the
+ * index and module. Bare-name lookup filters those lists per use. Both maps
+ * disappear with their key, the same way the per-index WeakMaps in
+ * navigation-references.ts do.
+ */
+const cppUsingDirectivesByTree = new WeakMap();
+const cppStarImportClosureCache = new WeakMap();
+export function cppStarImportClosure(index, sourceModule) {
+    let byModule = cppStarImportClosureCache.get(index);
+    if (!byModule) {
+        byModule = new Map();
+        cppStarImportClosureCache.set(index, byModule);
+    }
+    const moduleKey = fileIdentityKey(sourceModule.file);
+    const cached = byModule.get(moduleKey);
+    if (cached)
+        return cached;
+    const modules = [];
+    const pending = [sourceModule];
+    const seen = new Set();
+    while (pending.length) {
+        const current = pending.pop();
+        const key = fileIdentityKey(current.file);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        modules.push(current);
+        for (const imp of current.imports) {
+            if (imp.kind !== "star" || typeof imp.resolved !== "string")
+                continue;
+            const target = index.byFile.get(fileIdentityKey(imp.resolved));
+            if (target)
+                pending.push(target);
+        }
+    }
+    byModule.set(moduleKey, modules);
+    return modules;
+}
+function cppUsingDirectiveIsFileOrNamespaceScope(node) {
+    let current = node.parent;
+    while (current) {
+        if (CPP_USING_DIRECTIVE_REJECT_SCOPES[current.type])
+            return false;
+        current = current.parent;
+    }
+    return true;
+}
+function cppEnclosingNamespace(node, source, fileKey) {
+    const nested = [];
+    let current = node.parent;
+    while (current) {
+        if (current.type === "namespace_definition") {
+            const name = current.childForFieldName("name");
+            if (name) {
+                const segments = cppQualifiedNameSegments(name, source);
+                if (segments.length)
+                    nested.push(segments);
+            }
+            else {
+                nested.push([`\0anon:${fileKey}:${current.startIndex}`]);
+            }
+        }
+        current = current.parent;
+    }
+    const path = [];
+    for (let index = nested.length - 1; index >= 0; index -= 1)
+        path.push(...nested[index]);
+    return path;
+}
+function cppNamespaceIsPrefix(prefix, path) {
+    if (prefix.length > path.length)
+        return false;
+    for (let index = 0; index < prefix.length; index += 1) {
+        if (prefix[index] !== path[index])
+            return false;
+    }
+    return true;
+}
+function cppUsingDirectiveFromNode(node, source, fileKey) {
+    if (node.type !== "using_declaration")
+        return null;
+    let hasNamespaceKeyword = false;
+    let target = null;
+    for (let index = 0;; index += 1) {
+        const child = node.child(index);
+        if (!child)
+            break;
+        if (child.type === "namespace")
+            hasNamespaceKeyword = true;
+        else if (CPP_USING_DIRECTIVE_NAME_TYPES[child.type]) {
+            if (!target || child.type === "qualified_identifier" || child.type === "nested_namespace_specifier") {
+                target = child;
+            }
+        }
+    }
+    if (!hasNamespaceKeyword || !target || !cppUsingDirectiveIsFileOrNamespaceScope(node))
+        return null;
+    const namespacePath = target.type === "identifier" || target.type === "namespace_identifier" || target.type === "type_identifier"
+        ? [target.text.trim()]
+        : cppQualifiedNameSegments(target, source);
+    if (!namespacePath.length || namespacePath.some((segment) => segment.length === 0))
+        return null;
+    return {
+        fileKey,
+        startIndex: node.startIndex,
+        namespacePath,
+        enclosing: cppEnclosingNamespace(node, source, fileKey),
+    };
+}
+function collectCppUsingDirectives(root, source, fileKey, out) {
+    const visit = (node) => {
+        if (node.type === "using_declaration") {
+            const directive = cppUsingDirectiveFromNode(node, source, fileKey);
+            if (directive)
+                out.push(directive);
+        }
+        for (const child of node.namedChildren)
+            visit(child);
+    };
+    visit(root);
+}
+function cppUsingDirectivesForFile(tree, source, fileKey) {
+    const cached = cppUsingDirectivesByTree.get(tree);
+    if (cached?.fileKey === fileKey)
+        return cached.directives;
+    const directives = [];
+    collectCppUsingDirectives(tree.rootNode, source, fileKey, directives);
+    cppUsingDirectivesByTree.set(tree, { fileKey, directives });
+    return directives;
+}
+function addCppNamedExportTargets(index, moduleEntry, name, defs, seen) {
+    const moduleKey = `${fileIdentityKey(moduleEntry.file)}\0${name}`;
+    if (seen.has(moduleKey))
+        return;
+    seen.add(moduleKey);
+    for (const entry of moduleEntry.exports) {
+        if (entry.type === "exportStar" || entry.exportedAs !== name)
+            continue;
+        if (entry.type === "local") {
+            const key = definitionIdentityKey(entry.target);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            defs.push(entry.target);
+        }
+        else if (entry.type === "reexport") {
+            const target = index.byFile.get(fileIdentityKey(entry.fromModule));
+            if (target)
+                addCppNamedExportTargets(index, target, entry.sourceSpecifier, defs, seen);
+        }
+    }
+    for (const imp of moduleEntry.imports) {
+        if (imp.kind !== "star" || typeof imp.resolved !== "string")
+            continue;
+        const target = index.byFile.get(fileIdentityKey(imp.resolved));
+        if (target)
+            addCppNamedExportTargets(index, target, name, defs, seen);
+    }
+}
+function collectVisibleCppExportTargets(index, sourceModule, name) {
+    const defs = [];
+    const seen = new Set();
+    addCppNamedExportTargets(index, sourceModule, name, defs, seen);
+    for (const imp of sourceModule.imports) {
+        if (imp.kind !== "named" || typeof imp.resolved !== "string")
+            continue;
+        if (imp.local !== name && imp.imported !== name)
+            continue;
+        const targetModule = index.byFile.get(fileIdentityKey(imp.resolved));
+        if (targetModule)
+            addCppNamedExportTargets(index, targetModule, imp.imported, defs, seen);
+    }
+    return defs;
+}
+function cppIncludeSpec(pathNode) {
+    const raw = pathNode.text.trim();
+    if (pathNode.type === "string_literal" && raw.length >= 2)
+        return { text: raw.slice(1, -1), form: "literal" };
+    if (pathNode.type === "system_lib_string" && raw.length >= 2)
+        return { text: raw.slice(1, -1), form: "angle" };
+    return undefined;
+}
+/**
+ * The earliest offset in the use file at which each file enters the translation unit through
+ * an `#include`, directly or transitively. A file reached only through an include whose target
+ * cannot be read from the source (a macro include) is absent.
+ */
+function cppIncludeEntryOffsets(index, sourceModule, node) {
+    let root = node;
+    while (root.parent)
+        root = root.parent;
+    const offsets = new Map();
+    const visit = (current) => {
+        if (current.type === "preproc_include") {
+            const pathNode = current.childForFieldName("path");
+            const spec = pathNode ? cppIncludeSpec(pathNode) : undefined;
+            if (!spec)
+                return;
+            for (const imp of sourceModule.imports) {
+                if (imp.kind !== "star" || imp.from !== spec.text || typeof imp.resolved !== "string")
+                    continue;
+                if (imp.includeForm && imp.includeForm !== spec.form)
+                    continue;
+                const target = index.byFile.get(fileIdentityKey(imp.resolved));
+                if (!target)
+                    continue;
+                // Document order: the first include to reach a file is its earliest entry.
+                for (const reached of cppStarImportClosure(index, target)) {
+                    const key = fileIdentityKey(reached.file);
+                    if (!offsets.has(key))
+                        offsets.set(key, current.startIndex);
+                }
+            }
+            return;
+        }
+        for (const child of current.namedChildren)
+            visit(child);
+    };
+    visit(root);
+    return offsets;
+}
+const cppNamespaceAliasesByTree = new WeakMap();
+function cppNamespaceAliasTargetSegments(node, source) {
+    const name = node.childForFieldName("name");
+    for (const child of node.namedChildren) {
+        if (name && child.startIndex === name.startIndex && child.endIndex === name.endIndex)
+            continue;
+        if (child.type !== "namespace_identifier" &&
+            child.type !== "nested_namespace_specifier" &&
+            child.type !== "splice_specifier") {
+            continue;
+        }
+        const segments = cppQualifiedNameSegments(child, source);
+        if (segments.length)
+            return segments;
+    }
+    return null;
+}
+function collectCppNamespaceAliases(root, source, fileKey) {
+    const aliases = [];
+    const visit = (node) => {
+        if (node.type === "namespace_alias_definition") {
+            const nameNode = node.childForFieldName("name");
+            const name = nameNode ? sliceText(nameNode, source) : "";
+            const target = cppNamespaceAliasTargetSegments(node, source);
+            if (name && target) {
+                aliases.push({
+                    startIndex: node.startIndex,
+                    name,
+                    target,
+                    enclosing: cppEnclosingNamespace(node, source, fileKey),
+                    namespaceScope: cppUsingDirectiveIsFileOrNamespaceScope(node),
+                });
+            }
+        }
+        for (const child of node.namedChildren)
+            visit(child);
+    };
+    visit(root);
+    return aliases;
+}
+function cppNamespaceAliasesForTree(tree, source, fileKey) {
+    const cached = cppNamespaceAliasesByTree.get(tree);
+    if (cached?.fileKey === fileKey)
+        return cached.aliases;
+    const aliases = collectCppNamespaceAliases(tree.rootNode, source, fileKey);
+    cppNamespaceAliasesByTree.set(tree, { fileKey, aliases });
+    return aliases;
+}
+function sameNamespacePath(left, right) {
+    return left.length === right.length && left.every((segment, index) => segment === right[index]);
+}
+/** A block-scope alias hides namespace aliases. The innermost preceding alias wins. */
+function cppBlockNamespaceAliasTarget(node, source, name, useStart) {
+    for (let current = node.parent; current; current = current.parent) {
+        if (current.type !== "compound_statement")
+            continue;
+        let found;
+        for (const child of current.namedChildren) {
+            if (child.type !== "namespace_alias_definition" || child.startIndex >= useStart)
+                continue;
+            const nameNode = child.childForFieldName("name");
+            if (!nameNode || sliceText(nameNode, source) !== name)
+                continue;
+            const target = cppNamespaceAliasTargetSegments(child, source);
+            if (target)
+                found = target;
+        }
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+/**
+ * Latest visible namespace-scope alias of `name` in `enclosing`. A later declaration in the
+ * translation unit wins; two aliases at the same position with different targets are ambiguous.
+ */
+function cppNamespaceScopeAliasTarget(files, enclosing, name) {
+    let best;
+    let ambiguous = false;
+    for (const file of files) {
+        for (const alias of file.aliases) {
+            if (!alias.namespaceScope || alias.name !== name || !sameNamespacePath(alias.enclosing, enclosing))
+                continue;
+            const position = file.positionOf(alias.startIndex);
+            if (position === undefined)
+                continue;
+            if (!best || position > best.position || (position === best.position && alias.startIndex > best.tie)) {
+                best = { position, tie: alias.startIndex, target: alias.target };
+                ambiguous = false;
+            }
+            else if (position === best.position &&
+                alias.startIndex === best.tie &&
+                alias.target.join("::") !== best.target.join("::")) {
+                ambiguous = true;
+            }
+        }
+    }
+    if (ambiguous)
+        return null;
+    return best?.target;
+}
+/** A namespace or type declared in this scope hides names in every outer namespace. */
+function cppNamespaceScopeOwnerPath(files, enclosing, name) {
+    const path = [...enclosing, name];
+    const qualified = path.join("::");
+    for (const file of files) {
+        for (const entry of file.module.exports) {
+            if (entry.type !== "local" || entry.exportedAs !== qualified)
+                continue;
+            if (entry.target.kind !== SymbolKind.Class && entry.target.kind !== SymbolKind.TypeAlias)
+                continue;
+            const start = entry.target.range.start.index;
+            if (start !== undefined && file.positionOf(start) !== undefined)
+                return path;
+        }
+    }
+    return undefined;
+}
+/**
+ * Find the first qualifier where it is used: a block alias, then namespace aliases,
+ * nested namespaces, and type names in the enclosing namespaces, innermost first.
+ * Undefined means no binding was found; null means an ambiguous or cyclic alias.
+ */
+export function cppQualifiedNameThroughVisiblePrefix(index, sourceModule, name, node, source, tree, loadParsedFile) {
+    if (!name.includes("::"))
+        return undefined;
+    let qualifiedNode = node;
+    while (qualifiedNode.parent?.type === "qualified_identifier")
+        qualifiedNode = qualifiedNode.parent;
+    const absolute = name.startsWith("::") ||
+        (qualifiedNode.type === "qualified_identifier" && source.startsWith("::", qualifiedNode.startIndex));
+    const segments = name.split("::").filter(Boolean);
+    if (segments.length < 2)
+        return undefined;
+    const useFileKey = fileIdentityKey(sourceModule.file);
+    const useStart = node.startIndex;
+    const useNamespace = cppEnclosingNamespace(node, source, useFileKey);
+    const files = [
+        {
+            module: sourceModule,
+            aliases: cppNamespaceAliasesForTree(tree, source, useFileKey),
+            positionOf: (startIndex) => (startIndex < useStart ? startIndex : undefined),
+        },
+    ];
+    let entryOffsets;
+    for (const moduleEntry of cppStarImportClosure(index, sourceModule)) {
+        const fileKey = fileIdentityKey(moduleEntry.file);
+        if (fileKey === useFileKey)
+            continue;
+        const parsed = loadParsedFile(moduleEntry.file);
+        if (!parsed?.tree)
+            continue;
+        entryOffsets ??= cppIncludeEntryOffsets(index, sourceModule, node);
+        const entry = entryOffsets.get(fileKey);
+        files.push({
+            module: moduleEntry,
+            aliases: cppNamespaceAliasesForTree(parsed.tree, parsed.source, fileKey),
+            positionOf: () => (entry !== undefined && entry < useStart ? entry : undefined),
+        });
+    }
+    const firstBinding = (segment) => {
+        if (!absolute) {
+            const block = cppBlockNamespaceAliasTarget(node, source, segment, useStart);
+            if (block)
+                return { path: block, alias: true };
+        }
+        for (let length = absolute ? 0 : useNamespace.length; length >= 0; length -= 1) {
+            const enclosing = useNamespace.slice(0, length);
+            const alias = cppNamespaceScopeAliasTarget(files, enclosing, segment);
+            if (alias === null)
+                return null;
+            if (alias)
+                return { path: alias, alias: true };
+            const owner = cppNamespaceScopeOwnerPath(files, enclosing, segment);
+            if (owner)
+                return { path: owner, alias: false };
+        }
+        return undefined;
+    };
+    const expandPrefix = (prefix, seen) => {
+        let resolved = [];
+        let bound = false;
+        for (const segment of prefix) {
+            let alias;
+            if (!resolved.length) {
+                const first = firstBinding(segment);
+                if (first === null)
+                    return null;
+                if (first && !first.alias) {
+                    resolved = [...first.path];
+                    bound = true;
+                    continue;
+                }
+                alias = first?.path;
+            }
+            else {
+                alias = cppNamespaceScopeAliasTarget(files, resolved, segment);
+            }
+            if (alias === null)
+                return null;
+            if (!alias) {
+                resolved.push(segment);
+                continue;
+            }
+            const key = `${resolved.join("::")}\0${segment}`;
+            if (seen.has(key))
+                return null;
+            seen.add(key);
+            bound = true;
+            const nested = expandPrefix(alias, seen);
+            if (nested === null)
+                return null;
+            resolved = [...(nested ?? alias)];
+        }
+        return bound ? resolved : undefined;
+    };
+    const expanded = expandPrefix(segments.slice(0, -1), new Set());
+    if (expanded === null)
+        return null;
+    if (!expanded)
+        return undefined;
+    return [...expanded, segments[segments.length - 1]].join("::");
+}
+/**
+ * Bare lookup through `using namespace`. Undefined means no directive nominates
+ * this name. Null means more than one viable candidate, or the candidate could
+ * not be proved unique. Block-scope directives are ignored.
+ */
+export function resolveCppUsingDirectiveName(index, sourceModule, name, node, source, loadParsedFile) {
+    if (!name || name.includes("::"))
+        return undefined;
+    const useFileKey = fileIdentityKey(sourceModule.file);
+    const useNamespace = cppEnclosingNamespace(node, source, useFileKey);
+    const directives = [];
+    for (const moduleEntry of cppStarImportClosure(index, sourceModule)) {
+        const parsed = loadParsedFile(moduleEntry.file);
+        if (!parsed?.tree)
+            continue;
+        directives.push(...cppUsingDirectivesForFile(parsed.tree, parsed.source, fileIdentityKey(moduleEntry.file)));
+    }
+    let entryOffsets;
+    const unordered = [];
+    const applicable = directives.filter((directive) => {
+        if (!cppNamespaceIsPrefix(directive.enclosing, useNamespace))
+            return false;
+        if (directive.fileKey === useFileKey)
+            return directive.startIndex < node.startIndex;
+        // A header's directive is in scope only after the `#include` that brings it in.
+        entryOffsets ??= cppIncludeEntryOffsets(index, sourceModule, node);
+        const entry = entryOffsets.get(directive.fileKey);
+        if (entry === undefined) {
+            unordered.push(directive);
+            return false;
+        }
+        return entry < node.startIndex;
+    });
+    // A directive whose include position cannot be read (a macro include) may or may not be
+    // in scope. When it would nominate this name, the use stays unresolved.
+    const unorderedNominates = unordered.some((directive) => collectVisibleCppExportTargets(index, sourceModule, `${directive.namespacePath.join("::")}::${name}`).length);
+    if (unorderedNominates)
+        return null;
+    if (!applicable.length)
+        return undefined;
+    const functionDefs = [];
+    const otherDefs = [];
+    const seen = new Set();
+    const qualifiedByDef = new Map();
+    for (const directive of applicable) {
+        const qualified = `${directive.namespacePath.join("::")}::${name}`;
+        for (const def of collectVisibleCppExportTargets(index, sourceModule, qualified)) {
+            const key = definitionIdentityKey(def);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            qualifiedByDef.set(key, qualified);
+            if (def.kind === SymbolKind.Function)
+                functionDefs.push(def);
+            else
+                otherDefs.push(def);
+        }
+    }
+    if (!functionDefs.length && !otherDefs.length)
+        return undefined;
+    if (functionDefs.length) {
+        return resolveCppExportedCallables(index, functionDefs, node, source, loadParsedFile, (def) => qualifiedByDef.get(definitionIdentityKey(def)));
+    }
+    if (otherDefs.length === 1)
+        return otherDefs[0];
+    return null;
+}
+function cppMemberContainerForDefinition(tree, def) {
+    const position = {
+        row: Math.max(0, def.range.start.line - 1),
+        column: Math.max(0, def.range.start.column - 1),
+    };
+    let current = tree.rootNode.descendantForPosition(position, position);
+    while (current) {
+        if (CPP_MEMBER_CONTAINER_TYPES.has(current.type)) {
+            const name = current.childForFieldName("name");
+            if (name && name.startPosition.row === position.row && name.startPosition.column === position.column) {
+                return current;
+            }
+        }
+        current = current.parent;
+    }
+    return null;
+}
+function cppMemberContainerPath(container, source) {
+    const nested = [];
+    let current = container;
+    while (current) {
+        if (CPP_MEMBER_CONTAINER_TYPES.has(current.type) || current.type === "namespace_definition") {
+            const name = current.childForFieldName("name");
+            if (name) {
+                const segments = cppQualifiedNameSegments(name, source);
+                if (segments.length)
+                    nested.push(segments);
+            }
+        }
+        current = current.parent;
+    }
+    const path = [];
+    for (let index = nested.length - 1; index >= 0; index -= 1)
+        path.push(...nested[index]);
+    return path;
+}
+function sameCppPath(left, right) {
+    return left.length === right.length && left.every((segment, index) => segment === right[index]);
+}
+async function resolveCppQualifiedMemberContainerUncached(index, sourceModule, ownerPath, loadParsedFile) {
+    const ownerName = ownerPath.at(-1);
+    if (!ownerName)
+        return null;
+    const reachable = [];
+    const pending = [sourceModule];
+    const visited = new Set();
+    while (pending.length) {
+        const module = pending.pop();
+        const moduleKey = fileIdentityKey(module.file);
+        if (visited.has(moduleKey))
+            continue;
+        visited.add(moduleKey);
+        reachable.push(module);
+        for (const imp of module.imports) {
+            if (typeof imp.resolved !== "string")
+                continue;
+            const imported = index.byFile.get(fileIdentityKey(imp.resolved));
+            if (imported)
+                pending.push(imported);
+        }
+    }
+    const matches = [];
+    const seen = new Set();
+    for (const module of reachable) {
+        for (const candidate of module.locals) {
+            if (candidate.localName !== ownerName)
+                continue;
+            const key = `${fileIdentityKey(candidate.file)}:${candidate.range.start.index ?? ""}:${candidate.range.end.index ?? ""}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            let parsed;
+            if (loadParsedFile) {
+                parsed = await loadParsedFile(candidate.file);
+            }
+            else {
+                parsed = await ensureParsedContext(candidate.file, index.parsed?.get(fileIdentityKey(candidate.file)), index.languageExtensions).catch(() => null);
+            }
+            if (!parsed)
+                continue;
+            const container = cppMemberContainerForDefinition(parsed.tree, candidate);
+            if (!container || !sameCppPath(cppMemberContainerPath(container, parsed.source), ownerPath))
+                continue;
+            matches.push({ def: candidate, complete: !!container.childForFieldName("body") });
+        }
+    }
+    const completeMatches = matches.filter((match) => match.complete);
+    if (completeMatches.length === 1)
+        return completeMatches[0].def;
+    return matches.length === 1 ? matches[0].def : null;
+}
+/** Resolves one reachable C++ class/struct/union by its exact namespace and nesting path. */
+export function resolveCppQualifiedMemberContainer(index, sourceModule, ownerPath, loadParsedFile) {
+    let byPath = resolutionCache.get(index);
+    if (!byPath) {
+        byPath = new Map();
+        resolutionCache.set(index, byPath);
+    }
+    const key = `${fileIdentityKey(sourceModule.file)}\0${ownerPath.join("::")}`;
+    let pending = byPath.get(key);
+    if (!pending) {
+        pending = resolveCppQualifiedMemberContainerUncached(index, sourceModule, ownerPath, loadParsedFile);
+        byPath.set(key, pending);
+    }
+    return pending;
+}
+function hasStaticStorageClass(node) {
+    return node.namedChildren.some((child) => child.type === "storage_class_specifier" && child.text === "static");
+}
+/** Select a proven static class member named through a namespace-qualified type. */
+export function resolveCppVisibleStaticCallableName(index, sourceModule, qualifiedName, node, source, loadParsedFile) {
+    const separator = qualifiedName.lastIndexOf("::");
+    if (separator < 0)
+        return undefined;
+    const owner = qualifiedName.slice(0, separator);
+    const member = qualifiedName.slice(separator + 2);
+    const ownerPath = owner.split("::");
+    const useFileKey = fileIdentityKey(sourceModule.file);
+    let entryOffsets;
+    const defs = [];
+    for (const moduleEntry of cppStarImportClosure(index, sourceModule)) {
+        const fileKey = fileIdentityKey(moduleEntry.file);
+        let parsed;
+        let includeVisible;
+        for (const def of moduleEntry.locals) {
+            if (def.kind !== SymbolKind.Function || def.localName !== member || def.callable?.owner !== owner)
+                continue;
+            if (fileKey !== useFileKey) {
+                if (includeVisible === undefined) {
+                    entryOffsets ??= cppIncludeEntryOffsets(index, sourceModule, node);
+                    const entry = entryOffsets.get(fileKey);
+                    includeVisible = entry !== undefined && entry < node.startIndex;
+                }
+                if (!includeVisible)
+                    break;
+            }
+            const start = def.range.start.index;
+            if (start === undefined || (fileKey === useFileKey && start >= node.startIndex))
+                continue;
+            if (parsed === undefined)
+                parsed = loadParsedFile(moduleEntry.file);
+            if (!parsed)
+                break;
+            const position = { row: def.range.start.line - 1, column: def.range.start.column - 1 };
+            let current = parsed.tree.rootNode.descendantForPosition(position, position);
+            let staticMember = false;
+            while (current && !CPP_MEMBER_CONTAINER_TYPES.has(current.type)) {
+                if (current.type === "function_definition" || current.type === "declaration") {
+                    staticMember = hasStaticStorageClass(current);
+                    break;
+                }
+                current = current.parent;
+            }
+            if (!staticMember)
+                continue;
+            while (current && !CPP_MEMBER_CONTAINER_TYPES.has(current.type))
+                current = current.parent;
+            if (current && sameCppPath(cppMemberContainerPath(current, parsed.source), ownerPath))
+                defs.push(def);
+        }
+    }
+    if (!defs.length)
+        return undefined;
+    return resolveCppExportedCallables(index, defs, node, source, loadParsedFile, () => qualifiedName);
+}
+/** The name a member declarator declares: `f` in `int f(int)`, `int A::f(int)`, or `int* f()`. */
+function cppDeclaredMemberName(declaration, source) {
+    let declarator = declaration.childForFieldName("declarator");
+    while (declarator && declarator.type !== "function_declarator") {
+        declarator = declarator.childForFieldName("declarator");
+    }
+    const name = declarator?.childForFieldName("declarator");
+    if (!name)
+        return null;
+    return cppQualifiedNameSegments(name, source).at(-1) ?? null;
+}
+/**
+ * Whether code inside a C++ function definition has an implicit `this`: the function is a
+ * non-static member function, defined in its class body or out of line as `Owner::f`. A free
+ * function (including a namespace-qualified one) and a static member function have none, so an
+ * instance member cannot be named without an object there. Mixed static and non-static
+ * declarations of the same name are not proven either way and count as static.
+ */
+export async function cppFunctionHasImplicitThis(index, sourceModule, definition, source, sup, loadParsedFile) {
+    if (sup.id !== "cpp" || definition.type !== "function_definition")
+        return false;
+    if (hasStaticStorageClass(definition))
+        return false;
+    const ownerPath = cppOutOfLineOwnerPath(definition, source, sup);
+    if (!ownerPath) {
+        for (let current = definition.parent; current; current = current.parent) {
+            if (CPP_MEMBER_CONTAINER_TYPES.has(current.type))
+                return true;
+        }
+        return false;
+    }
+    const owner = await resolveCppQualifiedMemberContainer(index, sourceModule, ownerPath, loadParsedFile);
+    if (!owner)
+        return false;
+    const parsed = loadParsedFile
+        ? await loadParsedFile(owner.file)
+        : await ensureParsedContext(owner.file, undefined, index.languageExtensions);
+    const body = parsed ? cppMemberContainerForDefinition(parsed.tree, owner)?.childForFieldName("body") : null;
+    const memberName = cppDeclaredMemberName(definition, source);
+    if (!body || !parsed || !memberName)
+        return false;
+    const declarations = body.namedChildren.filter((child) => cppDeclaredMemberName(child, parsed.source) === memberName);
+    return declarations.length > 0 && declarations.every((declaration) => !hasStaticStorageClass(declaration));
+}
+//# sourceMappingURL=navigation-cpp.js.map