gitnexus 1.6.5-rc.41 → 1.6.5-rc.43

package/dist/core/ingestion/languages/cpp/adl.d.ts

@@ -21,8 +21,25 @@
  *   - `audit::Event& r`, `audit::Event&& rr`
  *   - `std::vector<audit::Event>` (template namespace + template-arg namespaces)
  *
- * Function-pointer arguments, base-class associated namespaces, and the rest
- * of the full closure are still deliberately excluded.
+ * V2 additionally walks class ancestors (via MRO), so base-class enclosing
+ * namespaces also contribute associated namespaces.
+ *
+ * **GitNexus approximation (not strict ISO C++ ADL):** passing a qualified
+ * function reference like `utils::worker` contributes `utils` to the associated
+ * set, enabling resolution of unqualified calls like `with_callback(utils::worker)`
+ * to `utils::with_callback`. Under ISO C++ `[basic.lookup.argdep]`, associated
+ * entities for function-type arguments come from the **parameter types and return
+ * type** of each function in the overload set — NOT the function's enclosing
+ * namespace. For `void worker()`, the standard-compliant associated set is empty.
+ * GitNexus instead contributes the enclosing namespace of any Function/Method
+ * def whose simple name matches, because it enables the dominant real-world ADL
+ * pattern at reasonable precision cost.
+ *
+ * For qualified refs (e.g. `utils::worker`) the namespace is confirmed via a
+ * workspace lookup (only contributed when a Function/Method named `worker` exists
+ * in `utils`). For unqualified refs the workspace is searched for any Function
+ * def with that simple name. Locally-declared function-pointer variables
+ * (e.g. `void (*g)()`) and function parameters are excluded from this path.
  *
  * The current implementation also short-circuits to ADL only when ordinary lookup is empty
  * (`findCallableBindingInScope` returned undefined). ISO C++ would
@@ -58,6 +75,7 @@ import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexe
  * Per-argument shape information collected at capture time. ADL fires for
  * arguments where `simpleClassName !== ''`, including class pointers and
  * references whose declarator chain resolves to a named class type.
+ * Free-function reference arguments use `functionRefText`.
  */
 export interface CppAdlArgInfo {
     /** Simple class-like type name (last segment of qualified name); empty
@@ -75,6 +93,15 @@ export interface CppAdlArgInfo {
     /** Enclosing namespaces extracted from explicit type template arguments,
      *  recursively bounded. */
     readonly templateArgNamespaces: readonly string[];
+    /** When set, the arg is a potential free-function reference (not a locally-
+     *  declared function-pointer variable or function parameter). Contains the
+     *  identifier text as written in source (e.g. `"utils::worker"` or
+     *  `"worker"`). GitNexus approximation: the function's enclosing namespace
+     *  is contributed to the ADL associated set. For qualified refs a workspace
+     *  lookup confirms a Function/Method with that simple name exists in the
+     *  namespace before contributing; for unqualified refs every namespace
+     *  containing a matching Function/Method def is contributed. */
+    readonly functionRefText?: string;
 }
 /** Sentinel returned by `pickCppAdlCandidates` when ADL surfaces multiple
  *  candidates that share normalized parameter types — the caller MUST

package/dist/core/ingestion/languages/cpp/adl.js

@@ -21,8 +21,25 @@
  *   - `audit::Event& r`, `audit::Event&& rr`
  *   - `std::vector<audit::Event>` (template namespace + template-arg namespaces)
  *
- * Function-pointer arguments, base-class associated namespaces, and the rest
- * of the full closure are still deliberately excluded.
+ * V2 additionally walks class ancestors (via MRO), so base-class enclosing
+ * namespaces also contribute associated namespaces.
+ *
+ * **GitNexus approximation (not strict ISO C++ ADL):** passing a qualified
+ * function reference like `utils::worker` contributes `utils` to the associated
+ * set, enabling resolution of unqualified calls like `with_callback(utils::worker)`
+ * to `utils::with_callback`. Under ISO C++ `[basic.lookup.argdep]`, associated
+ * entities for function-type arguments come from the **parameter types and return
+ * type** of each function in the overload set — NOT the function's enclosing
+ * namespace. For `void worker()`, the standard-compliant associated set is empty.
+ * GitNexus instead contributes the enclosing namespace of any Function/Method
+ * def whose simple name matches, because it enables the dominant real-world ADL
+ * pattern at reasonable precision cost.
+ *
+ * For qualified refs (e.g. `utils::worker`) the namespace is confirmed via a
+ * workspace lookup (only contributed when a Function/Method named `worker` exists
+ * in `utils`). For unqualified refs the workspace is searched for any Function
+ * def with that simple name. Locally-declared function-pointer variables
+ * (e.g. `void (*g)()`) and function parameters are excluded from this path.
  *
  * The current implementation also short-circuits to ADL only when ordinary lookup is empty
  * (`findCallableBindingInScope` returned undefined). ISO C++ would
@@ -129,10 +146,14 @@ export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
     const args = argInfoBySite.get(key);
     if (args === undefined || args.length === 0)
         return undefined;
-    // Collect associated namespace QNames from every participating class-typed arg.
+    // Collect associated namespace QNames from every participating class-typed arg
+    // and from function-reference args.
     const associatedNamespaces = new Set();
     for (const arg of args) {
         collectAssociatedNamespacesForAdlArg(arg, scopes, associatedNamespaces);
+        if (arg.functionRefText !== undefined) {
+            collectFunctionRefNamespaces(arg.functionRefText, parsedFiles, associatedNamespaces);
+        }
     }
     if (associatedNamespaces.size === 0)
         return undefined;
@@ -210,12 +231,23 @@ function collectAssociatedNamespacesForAdlArg(arg, scopes, associatedNamespaces)
 function addAssociatedNamespaceForClassName(simpleClassName, scopes, associatedNamespaces) {
     if (simpleClassName.length === 0)
         return;
-    const classDef = findCppClassDefBySimpleName(simpleClassName, scopes);
-    if (classDef === undefined)
+    const classLookup = findCppClassDefBySimpleName(simpleClassName, scopes);
+    if (classLookup === undefined)
         return;
+    const { classDef, ambiguous } = classLookup;
     const nsQName = classToNamespaceQualifiedName.get(classDef.nodeId);
     if (nsQName !== undefined)
         associatedNamespaces.add(nsQName);
+    // Preserve V1 collision behavior for the direct class namespace, but avoid
+    // amplifying a same-simple-name collision by walking an arbitrary class's
+    // full MRO chain.
+    if (ambiguous)
+        return;
+    for (const ancestorDefId of scopes.methodDispatch.mroFor(classDef.nodeId)) {
+        const ancestorNsQName = classToNamespaceQualifiedName.get(ancestorDefId);
+        if (ancestorNsQName !== undefined)
+            associatedNamespaces.add(ancestorNsQName);
+    }
 }
 /** Walk upward from a Class scope, finding the innermost enclosing
  *  Namespace scope, and return that namespace's qualified name (dot-
@@ -285,16 +317,97 @@ function findNamespaceDefInScope(scope) {
     return undefined;
 }
 /** Find a class-like def by simple name across the workspace. V1
- *  arbitrary-pick on collisions (multiple classes share the simple name);
- *  C++ ADL strictness would require full type-driven lookup, but V1
- *  trades that for simplicity. */
+ *  still arbitrary-picks the first class on collisions (multiple classes
+ *  share the simple name), but reports the collision so callers can avoid
+ *  amplifying that uncertainty (for example by skipping MRO expansion).
+ *  C++ ADL strictness would require full type-driven lookup. */
 function findCppClassDefBySimpleName(simpleName, scopes) {
+    let firstMatch;
     for (const def of scopes.defs.byId.values()) {
         if (def.type !== 'Class' && def.type !== 'Struct' && def.type !== 'Interface')
             continue;
         const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
-        if (simple === simpleName)
-            return def;
+        if (simple !== simpleName)
+            continue;
+        if (firstMatch === undefined) {
+            firstMatch = def;
+            continue;
+        }
+        return { classDef: firstMatch, ambiguous: true };
+    }
+    if (firstMatch === undefined)
+        return undefined;
+    return { classDef: firstMatch, ambiguous: false };
+}
+/**
+ * Contribute associated namespaces for a function-reference argument.
+ *
+ * - **Qualified refs** (`utils::worker`, `outer::inner::fn`): the namespace
+ *   is extracted from the qualifier text (converting `::` to `.` for dot-joined
+ *   QName matching). A workspace lookup then **verifies** that a Function or
+ *   Method def named `worker` (the simple name after the last `::`) actually
+ *   exists in the extracted namespace. This prevents false positives from
+ *   namespace-qualified variables, enum values, and static data members, which
+ *   also produce `qualified_identifier` AST nodes in tree-sitter-cpp (the
+ *   AST node type alone does not distinguish functions from non-function names).
+ * - **Unqualified refs** (`worker`): the workspace is searched for any
+ *   Function/Method def whose simple name matches. Every distinct enclosing
+ *   namespace found is added — overloads across the same namespace produce
+ *   a single entry; GitNexus does not select a specific overload at this stage.
+ */
+function collectFunctionRefNamespaces(refText, parsedFiles, out) {
+    const colonIdx = refText.lastIndexOf('::');
+    if (colonIdx !== -1) {
+        // Qualified ref: extract namespace prefix and normalise :: → dot notation.
+        const nsText = refText.slice(0, colonIdx).replace(/::/g, '.');
+        if (nsText === '')
+            return;
+        const simpleName = refText.slice(colonIdx + 2);
+        // Verify that a Function/Method named `simpleName` exists in `nsText`.
+        // Without this guard every `a::b` qualified_identifier arg (variable,
+        // enum value, static member, type alias) would blindly contribute `a`
+        // to the associated set and risk a false-positive CALLS edge.
+        for (const parsed of parsedFiles) {
+            const scopesById = new Map();
+            for (const sc of parsed.scopes)
+                scopesById.set(sc.id, sc);
+            for (const scope of parsed.scopes) {
+                if (scope.kind !== 'Namespace')
+                    continue;
+                if (computeNamespaceQName(scope, scopesById) !== nsText)
+                    continue;
+                for (const def of scope.ownedDefs) {
+                    if (def.type !== 'Function' && def.type !== 'Method')
+                        continue;
+                    const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+                    if (simple === simpleName) {
+                        out.add(nsText);
+                        return; // Namespace confirmed; no need to scan further files.
+                    }
+                }
+            }
+        }
+        return;
+    }
+    // Unqualified: search all namespace scopes for a Function def with this
+    // simple name and contribute its enclosing namespace.
+    for (const parsed of parsedFiles) {
+        const scopesById = new Map();
+        for (const sc of parsed.scopes)
+            scopesById.set(sc.id, sc);
+        for (const scope of parsed.scopes) {
+            if (scope.kind !== 'Namespace')
+                continue;
+            for (const def of scope.ownedDefs) {
+                if (def.type !== 'Function' && def.type !== 'Method')
+                    continue;
+                const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
+                if (simple !== refText)
+                    continue;
+                const nsQName = computeNamespaceQName(scope, scopesById);
+                if (nsQName !== '')
+                    out.add(nsQName);
+            }
+        }
     }
-    return undefined;
 }

package/dist/core/ingestion/languages/cpp/captures.js

@@ -4,7 +4,7 @@ import { getTreeSitterBufferSize } from '../../constants.js';
 import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
 import { splitCppInclude, splitCppUsingDecl } from './import-decomposer.js';
 import { computeCppDeclarationArity, computeCppCallArity } from './arity-metadata.js';
-import { markFileLocal } from './file-local-linkage.js';
+import { markCppAnonymousNamespaceRange, markFileLocal } from './file-local-linkage.js';
 import { markCppDependentBase } from './two-phase-lookup.js';
 import { markCppAdlSiteArgs, markCppAdlSiteNoAdl } from './adl.js';
 import { markCppInlineNamespaceRange } from './inline-namespaces.js';
@@ -150,20 +150,33 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
         // namespace's source range so `populateCppInlineNamespaceScopes`
         // (during populateOwners) can match it back to the corresponding
         // Namespace scope.
-        if (grouped['@declaration.namespace'] !== undefined) {
-            const anchor = grouped['@declaration.namespace'];
-            const nsNode = findNodeAtRange(tree.rootNode, anchor.range, 'namespace_definition');
-            if (nsNode !== null && isInlineNamespace(nsNode)) {
+        // `@declaration.namespace` fires only for NAMED namespaces (the query
+        // requires a `name: (namespace_identifier)` child). Use the unconditional
+        // `@scope.namespace` capture so the anonymous-namespace branch also runs.
+        const namespaceScopeAnchor = grouped['@declaration.namespace'] ?? grouped['@scope.namespace'];
+        if (namespaceScopeAnchor !== undefined) {
+            const nsNode = findNodeAtRange(tree.rootNode, namespaceScopeAnchor.range, 'namespace_definition');
+            if (nsNode !== null) {
                 // Range coords stored in the shared Range shape use 1-based
                 // line numbers (see `ast-helpers.ts` rangeForNode where
                 // `startPosition.row + 1` is applied). Match that convention so
-                // `populateCppInlineNamespaceScopes` can join against `Scope.range`.
-                markCppInlineNamespaceRange(filePath, {
+                // the populators can join against `Scope.range`.
+                const nsRange = {
                     startLine: nsNode.startPosition.row + 1,
                     startCol: nsNode.startPosition.column,
                     endLine: nsNode.endPosition.row + 1,
                     endCol: nsNode.endPosition.column,
-                });
+                };
+                if (isInlineNamespace(nsNode)) {
+                    markCppInlineNamespaceRange(filePath, nsRange);
+                }
+                // Anonymous namespace: `namespace_definition` with no `name` field.
+                // Recorded so `expandCppWildcardNames` can propagate its members
+                // to including TUs even though their names are also `markFileLocal`'d
+                // (which blocks the global free-call fallback's cross-file path).
+                if ((nsNode.childForFieldName?.('name') ?? null) === null) {
+                    markCppAnonymousNamespaceRange(filePath, nsRange);
+                }
             }
         }
         // ── ADL (Koenig lookup) per-site recording ──────────────────────
@@ -704,15 +717,93 @@ function classifyAdlArg(argNode) {
         argNode.type === 'nullptr') {
         return EMPTY_ADL_ARG;
     }
+    // Qualified expression (a::b) — may be a function, variable, enum value,
+    // or static member. Record as a potential function reference; resolution
+    // time verifies via workspace lookup that a Function/Method with this simple
+    // name exists in the extracted namespace before contributing to the set.
+    if (argNode.type === 'qualified_identifier') {
+        return {
+            simpleClassName: '',
+            templateSimpleClassName: '',
+            templateNamespace: '',
+            templateArgClassNames: [],
+            templateArgNamespaces: [],
+            functionRefText: argNode.text,
+        };
+    }
     // Variable reference — look up its declared type (preserving pointer /
     // reference / qualified-name shape; the existing arity-narrowing helper
     // strips this info).
     if (argNode.type === 'identifier') {
-        return lookupAdlIdentifierType(argNode);
+        const result = lookupAdlIdentifierType(argNode);
+        if (result === null) {
+            // Not found in the local compound_statement scope — could be a
+            // free-function reference (unqualified name, namespace scope).
+            return {
+                simpleClassName: '',
+                templateSimpleClassName: '',
+                templateNamespace: '',
+                templateArgClassNames: [],
+                templateArgNamespaces: [],
+                functionRefText: argNode.text,
+            };
+        }
+        return result;
     }
     // Other shapes (calls, member access, operators) — V1 unsupported.
     return EMPTY_ADL_ARG;
 }
+/**
+ * Returns `true` when `varName` appears as a parameter name in the nearest
+ * enclosing `function_definition` or `function_declarator` that contains
+ * `identNode`. Parameters live in `parameter_list` (a sibling of the
+ * `compound_statement`), so the `compound_statement`-local declaration scan
+ * in `lookupAdlIdentifierType` would not find them — causing them to be
+ * mistakenly classified as potential free-function references.
+ *
+ * In tree-sitter-cpp a `function_definition` does NOT expose `parameters`
+ * as a direct named field; parameters live inside the nested
+ * `function_declarator`. For `function_declarator` nodes the `parameters`
+ * field IS direct. Both cases are handled below.
+ */
+function isIdentifierAFunctionParameter(identNode, varName) {
+    let node = identNode.parent;
+    let safety = 64;
+    while (node !== null && safety-- > 0) {
+        let params = null;
+        if (node.type === 'function_declarator') {
+            // parameters is a direct field on function_declarator.
+            params = node.childForFieldName('parameters');
+        }
+        else if (node.type === 'function_definition') {
+            // function_definition carries parameters inside its `declarator` field
+            // (which is a function_declarator). Walk through it.
+            const decl = node.childForFieldName('declarator');
+            if (decl !== null && decl.type === 'function_declarator') {
+                params = decl.childForFieldName('parameters');
+            }
+        }
+        if (params !== null) {
+            for (let i = 0; i < params.namedChildCount; i++) {
+                const param = params.namedChild(i);
+                if (param === null)
+                    continue;
+                const declNode = param.childForFieldName('declarator');
+                if (declNode === null)
+                    continue;
+                const leafName = extractDeclaratorLeafName(declNode);
+                if (leafName === varName)
+                    return true;
+            }
+            // Only check the immediately enclosing function — do not climb further.
+            break;
+        }
+        if (node.type === 'translation_unit')
+            break;
+        node = node.parent;
+    }
+    return false;
+}
 function lookupAdlIdentifierType(identNode) {
     const varName = identNode.text;
     let scope = identNode.parent;
@@ -722,7 +813,15 @@ function lookupAdlIdentifierType(identNode) {
         scope = scope.parent;
     }
     if (scope === null)
+        return null;
+    // Function parameters live in the enclosing function's `parameter_list`,
+    // NOT inside the `compound_statement`, so the declaration scan below would
+    // never find them and would return `null` — incorrectly triggering the
+    // free-function-reference path. Check the parameter_list first.
+    if (isIdentifierAFunctionParameter(identNode, varName)) {
         return EMPTY_ADL_ARG;
+    }
+    let foundAsLocalFunctionPointer = false;
     for (let i = 0; i < scope.childCount; i++) {
         const stmt = scope.child(i);
         if (stmt === null || stmt.type !== 'declaration')
@@ -751,6 +850,9 @@ function lookupAdlIdentifierType(identNode) {
             if (inner.type === 'pointer_declarator') {
                 if (findFirstDescendantOfType(inner, 'function_declarator') !== null) {
                     isFunctionPointer = true;
+                    // Extract the name from within the function-pointer declarator chain
+                    // so `foundAsLocalFunctionPointer` can detect a matching declaration.
+                    nameText = extractDeclaratorLeafName(inner);
                     break;
                 }
                 const next = inner.childForFieldName('declarator');
@@ -783,12 +885,22 @@ function lookupAdlIdentifierType(identNode) {
             }
             if (inner.type === 'function_declarator') {
                 isFunctionPointer = true;
+                // Extract the name from the inner declarator (e.g. `(*g)` in `void (*g)()`).
+                const innerDecl = inner.childForFieldName('declarator');
+                if (innerDecl !== null)
+                    nameText = extractDeclaratorLeafName(innerDecl);
                 break;
             }
             // Reached the leaf — usually `identifier`. Take its text.
             nameText = inner.text;
             break;
         }
+        if (nameText === varName && isFunctionPointer) {
+            // Explicitly declared as a function-pointer variable — must not be
+            // treated as a free-function reference by the caller.
+            foundAsLocalFunctionPointer = true;
+            continue;
+        }
         if (isFunctionPointer || nameText !== varName)
             continue;
         const simpleClassName = extractAdlSimpleTypeName(typeNode);
@@ -801,7 +913,22 @@ function lookupAdlIdentifierType(identNode) {
             templateArgNamespaces,
         };
     }
-    return EMPTY_ADL_ARG;
+    // If the identifier was found in local scope as a function-pointer variable,
+    // return EMPTY_ADL_ARG so the caller does NOT treat it as a free-function
+    // reference. Otherwise return null to indicate "not in local scope".
+    //
+    // Known limitation (Finding 4): variables whose type is a typedef/using alias
+    // for a function-pointer type are NOT detected here. For example:
+    //   using Callback = void (*)();
+    //   Callback g;
+    //   foo(g);  // `g`'s declarator is `identifier` with type `Callback`
+    // The declarator has no `pointer_declarator` wrapper, so `isFunctionPointer`
+    // stays false and `extractAdlSimpleTypeName` returns `"Callback"`. ADL then
+    // looks for a class named `Callback`; if none exists, this degrades to
+    // EMPTY_ADL_ARG (class not found → no namespace contributed). If a class
+    // named `Callback` does exist, a spurious namespace contribution could occur.
+    // Risk is low in practice; a future fix should resolve the typedef/alias chain.
+    return foundAsLocalFunctionPointer ? EMPTY_ADL_ARG : null;
 }
 /** Extract the simple class-like type name from a `type:` field node.
  *  Returns '' for primitives and any other
@@ -950,6 +1077,29 @@ function extractNamespaceFromQualifiedText(text) {
         return '';
     return normalizeCppNamespaceQName(cleaned.slice(0, idx));
 }
+/**
+ * Walk a declarator node chain, unwrapping pointer/reference/function/
+ * parenthesized wrappers, and return the text of the innermost identifier.
+ * Returns `null` when no identifier is found within `safety` steps.
+ * Used by `lookupAdlIdentifierType` to extract the variable name from
+ * function-pointer declarator trees such as `(*g)()` in `void (*g)()`.
+ */
+function extractDeclaratorLeafName(node) {
+    let cur = node;
+    let safety = 16;
+    while (safety-- > 0) {
+        if (cur.type === 'identifier' || cur.type === 'type_identifier')
+            return cur.text;
+        // Common wrapper nodes — follow the 'declarator' field when present.
+        const next = cur.childForFieldName('declarator') ??
+            // parenthesized_declarator: single named child
+            (cur.type === 'parenthesized_declarator' ? cur.namedChild(0) : null);
+        if (next === null)
+            return null;
+        cur = next;
+    }
+    return null;
+}
 /**
  * Check if a C++ function_definition or declaration has `static` storage class.
  */

package/dist/core/ingestion/languages/cpp/file-local-linkage.d.ts

@@ -1,10 +1,34 @@
 import type { ParsedFile, ScopeId } from '../../../../_shared/index.js';
+interface RangeKeyShape {
+    readonly startLine: number;
+    readonly startCol: number;
+    readonly endLine: number;
+    readonly endCol: number;
+}
 /** Record a symbol name as file-local (static or anonymous namespace). */
 export declare function markFileLocal(filePath: string, name: string): void;
 /** Check whether a symbol name has file-local linkage in the given file. */
 export declare function isFileLocal(filePath: string, name: string): boolean;
+/** Capture-time: record an anonymous `namespace_definition` source range. */
+export declare function markCppAnonymousNamespaceRange(filePath: string, range: RangeKeyShape): void;
+/** Predicate consumed by `populateCppNonGloballyVisible` and
+ *  `expandCppWildcardNames` to exempt anonymous-namespace scopes from
+ *  the cross-file unqualified-lookup exclusion that applies to ordinary
+ *  named namespaces. */
+export declare function isCppAnonymousNamespaceScope(scopeId: ScopeId): boolean;
 /** Clear tracked file-local names (call at start of each resolution pass). */
 export declare function clearFileLocalNames(): void;
+/** Resolve recorded anonymous-namespace source ranges to `ScopeId`s.
+ *  Must run inside `populateOwners` BEFORE `populateCppNonGloballyVisible`
+ *  consults the resolved set. */
+export declare function populateCppAnonymousNamespaceScopes(parsed: {
+    readonly filePath: string;
+    readonly scopes: readonly {
+        readonly id: ScopeId;
+        readonly kind: string;
+        readonly range: RangeKeyShape;
+    }[];
+}): void;
 /**
  * Populate per-file "not globally visible" nodeIds by walking the parsed
  * file's scopes. Run as part of the `populateOwners` hook so every C++
@@ -91,3 +115,4 @@ export declare function isCppDefGloballyVisible(filePath: string, nodeId: string
  * members never enter `localDefs` unqualified.
  */
 export declare function expandCppWildcardNames(targetModuleScope: ScopeId, parsedFiles: readonly ParsedFile[]): readonly string[];
+export {};

package/dist/core/ingestion/languages/cpp/file-local-linkage.js

@@ -31,6 +31,24 @@ const fileLocalNames = new Map();
  * this set encodes).
  */
 const nonGloballyVisibleNodeIds = new Map();
+/**
+ * Per-file set of source-range keys identifying `namespace { ... }` blocks.
+ * Resolved to `ScopeId`s in `populateCppAnonymousNamespaceScopes` and
+ * consumed via `isCppAnonymousNamespaceScope`.
+ *
+ * Anonymous namespaces have file-local linkage but, unlike `static`, their
+ * members propagate to any TU that `#include`s the declaring file — each
+ * including TU gets its own internal-linkage copy. So for wildcard import
+ * expansion (`expandCppWildcardNames`) we treat anonymous-namespace owned
+ * defs as if declared at the enclosing scope. Cross-file unqualified
+ * lookup that does NOT go through `#include` is still blocked by the
+ * `isFileLocal` mark recorded on the def's name.
+ */
+const anonymousNamespaceRangesByFile = new Map();
+const anonymousNamespaceScopeIds = new Set();
+function rangeKey(r) {
+    return `${r.startLine}:${r.startCol}:${r.endLine}:${r.endCol}`;
+}
 /** Record a symbol name as file-local (static or anonymous namespace). */
 export function markFileLocal(filePath, name) {
     let names = fileLocalNames.get(filePath);
@@ -44,10 +62,43 @@ export function markFileLocal(filePath, name) {
 export function isFileLocal(filePath, name) {
     return fileLocalNames.get(filePath)?.has(name) ?? false;
 }
+/** Capture-time: record an anonymous `namespace_definition` source range. */
+export function markCppAnonymousNamespaceRange(filePath, range) {
+    let set = anonymousNamespaceRangesByFile.get(filePath);
+    if (set === undefined) {
+        set = new Set();
+        anonymousNamespaceRangesByFile.set(filePath, set);
+    }
+    set.add(rangeKey(range));
+}
+/** Predicate consumed by `populateCppNonGloballyVisible` and
+ *  `expandCppWildcardNames` to exempt anonymous-namespace scopes from
+ *  the cross-file unqualified-lookup exclusion that applies to ordinary
+ *  named namespaces. */
+export function isCppAnonymousNamespaceScope(scopeId) {
+    return anonymousNamespaceScopeIds.has(scopeId);
+}
 /** Clear tracked file-local names (call at start of each resolution pass). */
 export function clearFileLocalNames() {
     fileLocalNames.clear();
     nonGloballyVisibleNodeIds.clear();
+    anonymousNamespaceRangesByFile.clear();
+    anonymousNamespaceScopeIds.clear();
+}
+/** Resolve recorded anonymous-namespace source ranges to `ScopeId`s.
+ *  Must run inside `populateOwners` BEFORE `populateCppNonGloballyVisible`
+ *  consults the resolved set. */
+export function populateCppAnonymousNamespaceScopes(parsed) {
+    const ranges = anonymousNamespaceRangesByFile.get(parsed.filePath);
+    if (ranges === undefined || ranges.size === 0)
+        return;
+    for (const scope of parsed.scopes) {
+        if (scope.kind !== 'Namespace')
+            continue;
+        if (ranges.has(rangeKey(scope.range))) {
+            anonymousNamespaceScopeIds.add(scope.id);
+        }
+    }
 }
 /**
  * Populate per-file "not globally visible" nodeIds by walking the parsed
@@ -75,6 +126,14 @@ export function populateCppNonGloballyVisible(parsed) {
         // unqualified lookup can still see their callable defs.
         if (scope.kind === 'Namespace' && isCppInlineNamespaceScope(scope.id))
             continue;
+        // Anonymous namespaces give internal linkage but their contents are
+        // visible at the enclosing scope within the same TU and propagate to
+        // any TU that `#include`s the declaring file. The `isFileLocal` mark
+        // (recorded on the def's name in this file) still blocks cross-file
+        // unqualified lookup that does not go through #include, so dropping
+        // the structural visibility exclusion here is safe.
+        if (scope.kind === 'Namespace' && anonymousNamespaceScopeIds.has(scope.id))
+            continue;
         for (const def of scope.ownedDefs) {
             set.add(def.nodeId);
         }
@@ -173,15 +232,27 @@ export function expandCppWildcardNames(targetModuleScope, parsedFiles) {
         // including TU. When the owning scope is unknown we default to
         // include (preserves prior behavior for any def whose structural
         // ownership wasn't recorded in `Scope.ownedDefs`).
+        //
+        // Anonymous namespaces are exempt: their members propagate to the
+        // enclosing scope of any TU that #includes the declaring file (each
+        // including TU gets its own internal-linkage copy per ISO C++).
         const ownerScope = ownerScopeByNodeId.get(def.nodeId);
+        const ownerIsAnonymousNamespace = ownerScope !== undefined &&
+            ownerScope.kind === 'Namespace' &&
+            anonymousNamespaceScopeIds.has(ownerScope.id);
         if (ownerScope !== undefined &&
+            !ownerIsAnonymousNamespace &&
             (ownerScope.kind === 'Namespace' || ownerScope.kind === 'Class')) {
             continue;
         }
         const name = simpleName(def);
         if (name === '')
             continue;
-        if (isFileLocal(target.filePath, name))
+        // Same exemption for the `isFileLocal` mark — anonymous-namespace
+        // names are recorded as file-local to suppress the global free-call
+        // fallback's cross-file leak, but they MUST still propagate through
+        // wildcard import expansion to including TUs.
+        if (!ownerIsAnonymousNamespace && isFileLocal(target.filePath, name))
             continue;
         if (seen.has(name))
             continue;

package/dist/core/ingestion/languages/cpp/scope-resolver.js

@@ -7,7 +7,7 @@ import { cppArityCompatibility } from './arity.js';
 import { cppMergeBindings } from './merge-bindings.js';
 import { resolveCppImportTarget } from './import-target.js';
 import { scanCppHeaderFiles } from './header-scan.js';
-import { expandCppWildcardNames, isFileLocal, clearFileLocalNames, populateCppNonGloballyVisible, isCppDefGloballyVisible, } from './file-local-linkage.js';
+import { expandCppWildcardNames, isFileLocal, clearFileLocalNames, populateCppAnonymousNamespaceScopes, populateCppNonGloballyVisible, isCppDefGloballyVisible, } from './file-local-linkage.js';
 import { populateCppDependentBases, clearCppDependentBases, isCppDependentBaseMember, } from './two-phase-lookup.js';
 import { populateCppAssociatedNamespaces, clearCppAdlState, pickCppAdlCandidates, ADL_AMBIGUOUS, } from './adl.js';
 import { clearCppInlineNamespaces, populateCppInlineNamespaceScopes, resolveCppQualifiedNamespaceMember, } from './inline-namespaces.js';
@@ -61,10 +61,11 @@ export const cppScopeResolver = {
     buildMro: (graph, parsedFiles, nodeLookup) => buildMro(graph, parsedFiles, nodeLookup, defaultLinearize),
     populateOwners: (parsed) => {
         populateClassOwnedMembers(parsed);
-        // Resolve inline-namespace ranges (recorded at capture time) to
-        // ScopeIds BEFORE `populateCppNonGloballyVisible` runs, so the
-        // inline-namespace exemption sees the populated Set.
+        // Resolve inline- and anonymous-namespace ranges (recorded at capture
+        // time) to ScopeIds BEFORE `populateCppNonGloballyVisible` runs, so
+        // both exemptions see the populated Sets.
         populateCppInlineNamespaceScopes(parsed);
+        populateCppAnonymousNamespaceScopes(parsed);
         // Track namespace-nested and class-nested defs so the global free-call
         // fallback and wildcard expansion can suppress them as unqualified
         // cross-file callables.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.5-rc.41",
+  "version": "1.6.5-rc.43",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",