gitnexus 1.6.5-rc.40 → 1.6.5-rc.42

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

@@ -15,14 +15,15 @@
  *
  * ## Current boundary
  *
- * The current implementation covers ONE associated-entity rule: an argument that's a directly-named
- * class type (`audit::Event e`) contributes its **direct enclosing
- * namespace** to the candidate set. V2 extends that one step to
- * pointer-typed and reference-typed class args (`audit::Event* p`,
- * `audit::Event& r`, `audit::Event&& rr`): they contribute the pointee /
- * referred class's enclosing namespace too. Function-pointer arguments,
- * template specializations, base-class associated namespaces, and the
- * rest of the full closure are still deliberately excluded.
+ * The current implementation covers class-typed arguments (value, pointer,
+ * and reference) and template specializations with explicit type arguments:
+ *   - `audit::Event e`, `audit::Event* p`, `audit::Event** pp`
+ *   - `audit::Event& r`, `audit::Event&& rr`
+ *   - `std::vector<audit::Event>` (template namespace + template-arg namespaces)
+ *
+ * Function-pointer arguments 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.
  *
  * The current implementation also short-circuits to ADL only when ordinary lookup is empty
  * (`findCallableBindingInScope` returned undefined). ISO C++ would
@@ -61,8 +62,20 @@ import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexe
  */
 export interface CppAdlArgInfo {
     /** Simple class-like type name (last segment of qualified name); empty
-     *  for primitives, literals, function pointers, template specs, etc. */
+     *  for primitives, literals, function pointers, etc. */
     readonly simpleClassName: string;
+    /** Template's own simple class-like name (e.g. `vector` for
+     *  `std::vector<N::T>`), empty when arg type is not a template spec. */
+    readonly templateSimpleClassName: string;
+    /** Template's own enclosing namespace (dot-qualified, e.g. `std`), empty
+     *  when unavailable / unqualified. */
+    readonly templateNamespace: string;
+    /** Class-like names extracted from explicit type template arguments,
+     *  recursively bounded. */
+    readonly templateArgClassNames: readonly string[];
+    /** Enclosing namespaces extracted from explicit type template arguments,
+     *  recursively bounded. */
+    readonly templateArgNamespaces: readonly 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

@@ -15,14 +15,15 @@
  *
  * ## Current boundary
  *
- * The current implementation covers ONE associated-entity rule: an argument that's a directly-named
- * class type (`audit::Event e`) contributes its **direct enclosing
- * namespace** to the candidate set. V2 extends that one step to
- * pointer-typed and reference-typed class args (`audit::Event* p`,
- * `audit::Event& r`, `audit::Event&& rr`): they contribute the pointee /
- * referred class's enclosing namespace too. Function-pointer arguments,
- * template specializations, base-class associated namespaces, and the
- * rest of the full closure are still deliberately excluded.
+ * The current implementation covers class-typed arguments (value, pointer,
+ * and reference) and template specializations with explicit type arguments:
+ *   - `audit::Event e`, `audit::Event* p`, `audit::Event** pp`
+ *   - `audit::Event& r`, `audit::Event&& rr`
+ *   - `std::vector<audit::Event>` (template namespace + template-arg namespaces)
+ *
+ * Function-pointer arguments 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.
  *
  * The current implementation also short-circuits to ADL only when ordinary lookup is empty
  * (`findCallableBindingInScope` returned undefined). ISO C++ would
@@ -132,14 +133,7 @@ export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
     // Collect associated namespace QNames from every participating class-typed arg.
     const associatedNamespaces = new Set();
     for (const arg of args) {
-        if (arg.simpleClassName === '')
-            continue;
-        const classDef = findCppClassDefBySimpleName(arg.simpleClassName, scopes);
-        if (classDef === undefined)
-            continue;
-        const nsQName = classToNamespaceQualifiedName.get(classDef.nodeId);
-        if (nsQName !== undefined)
-            associatedNamespaces.add(nsQName);
+        collectAssociatedNamespacesForAdlArg(arg, scopes, associatedNamespaces);
     }
     if (associatedNamespaces.size === 0)
         return undefined;
@@ -196,6 +190,45 @@ export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
     // unique-survivor requirement (see `pick-implicit-this-overload.test.ts`).
     return ADL_AMBIGUOUS;
 }
+function collectAssociatedNamespacesForAdlArg(arg, scopes, associatedNamespaces) {
+    // For template args this may be the template name itself (e.g. `vector`);
+    // simple-name lookup can match project classes with the same name (known
+    // V1/V2 simplification).
+    addAssociatedNamespaceForClassName(arg.simpleClassName, scopes, associatedNamespaces);
+    // Includes template-owner namespaces (e.g. `std` in std::vector<T>). If
+    // that surfaces extra candidates, ADL_AMBIGUOUS suppression below prevents
+    // arbitrary edge emission.
+    if (arg.templateNamespace.length > 0)
+        associatedNamespaces.add(arg.templateNamespace);
+    for (const ns of arg.templateArgNamespaces) {
+        if (ns.length > 0)
+            associatedNamespaces.add(ns);
+    }
+    for (const className of arg.templateArgClassNames) {
+        addAssociatedNamespaceForClassName(className, scopes, associatedNamespaces);
+    }
+}
+function addAssociatedNamespaceForClassName(simpleClassName, scopes, associatedNamespaces) {
+    if (simpleClassName.length === 0)
+        return;
+    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-
  *  joined, outermost-first). Returns '' when the class has no enclosing
@@ -264,16 +297,25 @@ 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 };
     }
-    return undefined;
+    if (firstMatch === undefined)
+        return undefined;
+    return { classDef: firstMatch, ambiguous: false };
 }

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 ──────────────────────
@@ -657,12 +670,14 @@ function isParenthesizedFunctionCall(callNode) {
 }
 /**
  * Per-argument ADL classification: walk each argument of a free call and
- * decide whether it resolves to a directly-named class or class-pointer
- * type (ADL fires) or to an excluded shape such as a reference, function
- * pointer, primitive, literal, or template specialization.
+ * classify its declared type for associated-namespace lookup.
+ *
+ * Value/pointer/reference class-typed args and template specializations
+ * with explicit type arguments contribute; function pointers, primitives,
+ * literals, and other unsupported shapes produce an empty result.
  *
- * Class-typed values and class pointers (`N::S`, `N::S*`, `N::S**`) all
- * preserve the pointee class name for associated-namespace lookup.
+ * Class-typed values/pointers/references (`N::S`, `N::S*`, `N::S&`) all
+ * preserve the class name for associated-namespace lookup.
  * Function pointers remain excluded even when their return type names a
  * class, because the associated entity is the pointed-to function type,
  * not the return type.
@@ -682,7 +697,14 @@ function inferCppCallAdlArgs(callNode) {
     }
     return out;
 }
-const EMPTY_ADL_ARG = { simpleClassName: '' };
+const ADL_TEMPLATE_RECURSION_MAX_DEPTH = 8;
+const EMPTY_ADL_ARG = {
+    simpleClassName: '',
+    templateSimpleClassName: '',
+    templateNamespace: '',
+    templateArgClassNames: [],
+    templateArgNamespaces: [],
+};
 function classifyAdlArg(argNode) {
     // Literals and primitive-shaped expressions never have associated namespaces.
     if (argNode.type === 'number_literal' ||
@@ -783,21 +805,51 @@ function lookupAdlIdentifierType(identNode) {
         if (isFunctionPointer || nameText !== varName)
             continue;
         const simpleClassName = extractAdlSimpleTypeName(typeNode);
-        return { simpleClassName };
+        const { templateSimpleClassName, templateNamespace, templateArgClassNames, templateArgNamespaces, } = extractAdlTemplateInfo(typeNode);
+        return {
+            simpleClassName,
+            templateSimpleClassName,
+            templateNamespace,
+            templateArgClassNames,
+            templateArgNamespaces,
+        };
     }
     return EMPTY_ADL_ARG;
 }
 /** Extract the simple class-like type name from a `type:` field node.
- *  Returns '' for primitives, template specializations, and any other
+ *  Returns '' for primitives and any other
  *  unsupported type-only shape. Function pointers are filtered at the
  *  declarator level in `lookupAdlIdentifierType`. */
 function extractAdlSimpleTypeName(typeNode) {
+    if (typeNode.type === 'type_descriptor') {
+        const innerType = typeNode.childForFieldName('type');
+        if (innerType !== null)
+            return extractAdlSimpleTypeName(innerType);
+        for (let i = 0; i < typeNode.childCount; i++) {
+            const child = typeNode.child(i);
+            if (child === null)
+                continue;
+            if (child.type === 'type_identifier' ||
+                child.type === 'qualified_identifier' ||
+                child.type === 'template_type') {
+                return extractAdlSimpleTypeName(child);
+            }
+        }
+        return '';
+    }
     if (typeNode.type === 'primitive_type')
         return '';
     if (typeNode.type === 'sized_type_specifier')
         return '';
     if (typeNode.type === 'type_identifier')
         return typeNode.text;
+    if (typeNode.type === 'template_type') {
+        const nameNode = typeNode.childForFieldName('name');
+        if (nameNode !== null)
+            return extractAdlSimpleTypeName(nameNode);
+        const id = findFirstDescendantOfType(typeNode, 'type_identifier');
+        return id !== null ? id.text : '';
+    }
     if (typeNode.type === 'qualified_identifier') {
         const nameNode = typeNode.childForFieldName('name');
         if (nameNode !== null)
@@ -805,9 +857,112 @@ function extractAdlSimpleTypeName(typeNode) {
         const id = findFirstDescendantOfType(typeNode, 'type_identifier');
         return id !== null ? id.text : '';
     }
-    // template_type (e.g. `vector<int>`), function pointers, decltype — V1 excludes.
+    // Function pointers, decltype, etc — unsupported for ADL participation.
+    return '';
+}
+function extractAdlTypeNamespace(typeNode) {
+    if (typeNode.type === 'type_descriptor') {
+        const innerType = typeNode.childForFieldName('type');
+        if (innerType !== null)
+            return extractAdlTypeNamespace(innerType);
+        for (let i = 0; i < typeNode.childCount; i++) {
+            const child = typeNode.child(i);
+            if (child === null)
+                continue;
+            if (child.type === 'qualified_identifier' ||
+                child.type === 'template_type' ||
+                child.type === 'type_identifier') {
+                return extractAdlTypeNamespace(child);
+            }
+        }
+        return '';
+    }
+    if (typeNode.type === 'template_type') {
+        const nameNode = typeNode.childForFieldName('name');
+        return nameNode !== null ? extractAdlTypeNamespace(nameNode) : '';
+    }
+    if (typeNode.type === 'qualified_identifier') {
+        const scope = typeNode.childForFieldName('scope');
+        if (scope !== null)
+            return normalizeCppNamespaceQName(scope.text);
+        return extractNamespaceFromQualifiedText(typeNode.text);
+    }
     return '';
 }
+function extractAdlTemplateInfo(typeNode) {
+    const templateTypeNode = findTemplateTypeNode(typeNode);
+    if (templateTypeNode === null) {
+        return {
+            templateSimpleClassName: '',
+            templateNamespace: '',
+            templateArgClassNames: [],
+            templateArgNamespaces: [],
+        };
+    }
+    const templateArgClassNames = [];
+    const templateArgNamespaces = [];
+    collectAdlTemplateArgs(templateTypeNode, 0, templateArgClassNames, templateArgNamespaces);
+    return {
+        templateSimpleClassName: extractAdlSimpleTypeName(templateTypeNode),
+        templateNamespace: extractAdlTypeNamespace(typeNode),
+        templateArgClassNames,
+        templateArgNamespaces,
+    };
+}
+function collectAdlTemplateArgs(templateTypeNode, depth, outClassNames, outNamespaces) {
+    if (depth >= ADL_TEMPLATE_RECURSION_MAX_DEPTH)
+        return;
+    if (templateTypeNode.type !== 'template_type')
+        return;
+    const argList = templateTypeNode.childForFieldName('arguments') ??
+        findChildOfType(templateTypeNode, ['template_argument_list']);
+    if (argList === null)
+        return;
+    for (let i = 0; i < argList.namedChildCount; i++) {
+        const arg = argList.namedChild(i);
+        if (arg === null || arg.type !== 'type_descriptor')
+            continue;
+        const simpleClassName = extractAdlSimpleTypeName(arg);
+        if (simpleClassName.length > 0)
+            outClassNames.push(simpleClassName);
+        const ns = extractAdlTypeNamespace(arg);
+        if (ns.length > 0)
+            outNamespaces.push(ns);
+        const nestedType = arg.childForFieldName('type');
+        const nestedTemplate = nestedType !== null ? findTemplateTypeNode(nestedType) : null;
+        if (nestedTemplate !== null) {
+            collectAdlTemplateArgs(nestedTemplate, depth + 1, outClassNames, outNamespaces);
+        }
+    }
+}
+function findTemplateTypeNode(typeNode) {
+    if (typeNode.type === 'template_type')
+        return typeNode;
+    if (typeNode.type === 'type_descriptor') {
+        const innerType = typeNode.childForFieldName('type');
+        if (innerType !== null)
+            return findTemplateTypeNode(innerType);
+        return null;
+    }
+    if (typeNode.type === 'qualified_identifier') {
+        const nameNode = typeNode.childForFieldName('name');
+        if (nameNode !== null)
+            return findTemplateTypeNode(nameNode);
+        return null;
+    }
+    return null;
+}
+function normalizeCppNamespaceQName(text) {
+    const normalized = text.replace(/^::/, '').replace(/::$/, '').replace(/::/g, '.');
+    return normalized;
+}
+function extractNamespaceFromQualifiedText(text) {
+    const cleaned = text.replace(/\s+/g, '');
+    const idx = cleaned.lastIndexOf('::');
+    if (idx <= 0)
+        return '';
+    return normalizeCppNamespaceQName(cleaned.slice(0, idx));
+}
 /**
  * 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.
@@ -188,8 +189,10 @@ export const cppScopeResolver = {
     // C++ argument-dependent / Koenig lookup (U2 of plan 2026-05-13-001).
     // Fires after `findCallableBindingInScope` returns undefined; surfaces
     // candidates from the associated namespaces of class-typed arguments.
-    // V1 limitation: only direct enclosing-namespace closure for value
-    // class-typed args; pointer/reference/template-spec args excluded.
+    // Current boundary: class-typed value/pointer/reference args and template
+    // specializations with explicit type arguments contribute associated
+    // namespaces. Function-pointer args, base-class associated namespaces,
+    // and full ordinary+ADL merge remain excluded.
     resolveAdlCandidates: (site, callerParsed, scopes, parsedFiles) => {
         // `using ns::name;` introduces `name` into ordinary unqualified lookup.
         // For template-class method bodies, lexical scope walks can miss this

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.6.5-rc.40",
+  "version": "1.6.5-rc.42",
   "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",