gitnexus 1.6.5-rc.41 → 1.6.5-rc.42

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

@@ -21,8 +21,9 @@
  *   - `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.
+ * 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

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

@@ -21,8 +21,9 @@
  *   - `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.
+ * 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
@@ -210,12 +211,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 +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 ──────────────────────

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.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",