gitnexus 1.6.5-rc.37 → 1.6.5-rc.38

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

@@ -1,5 +1,5 @@
 /**
- * C++ argument-dependent lookup (ADL / Koenig lookup) — V1.
+ * C++ argument-dependent lookup (ADL / Koenig lookup).
  *
  * When ordinary unqualified lookup fails for a free-call site, ADL also
  * considers candidates declared in the **associated namespaces** of the
@@ -13,17 +13,18 @@
  * `using` anything. With V1 ADL: `audit::record` is discovered via
  * `audit::Event`'s associated namespace.
  *
- * ## V1 boundary
+ * ## Current boundary
  *
- * V1 covers ONE associated-entity rule: an argument that's a directly-named
+ * 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. Anything else — pointer/reference
+ * namespace** to the candidate set. V2 extends that one step to
+ * pointer-typed class args (`audit::Event* p`, `audit::Event** pp`):
+ * they contribute the pointee class's enclosing namespace too. Reference
  * arguments, function-pointer arguments, template specializations,
- * base-class associated namespaces — is V2 closure work and is
- * deliberately excluded. The `cpp-adl-pointer-arg-boundary` fixture
- * locks the exclusion in CI.
+ * base-class associated namespaces, and the rest of the full closure are
+ * still deliberately excluded.
  *
- * V1 also short-circuits to ADL only when ordinary lookup is empty
+ * The current implementation also short-circuits to ADL only when ordinary lookup is empty
  * (`findCallableBindingInScope` returned undefined). ISO C++ would
  * normally merge ADL candidates with ordinary-lookup candidates and
  * run overload resolution over the union; V1 defers that merge to V2.
@@ -54,16 +55,16 @@
 import type { ParsedFile, SymbolDefinition } from '../../../../_shared/index.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
 /**
- * Per-argument shape information collected at capture time. ADL only
- * fires for arguments where `simpleClassName !== ''` AND `!isPointer`
- * AND `!isReference` — i.e., directly-named class-type values.
+ * Per-argument shape information collected at capture time. ADL fires for
+ * arguments where `simpleClassName !== ''` AND `!isReference`, including
+ * class pointers whose declarator chain resolves to a named class type.
  */
 export interface CppAdlArgInfo {
     /** Simple class-like type name (last segment of qualified name); empty
      *  for primitives, literals, function pointers, template specs, etc. */
     readonly simpleClassName: string;
-    /** True when the variable's declarator was a `pointer_declarator`. V1
-     *  excludes pointer-typed args (closure rules deferred to V2). */
+    /** True when the variable's declarator contained one or more
+     *  `pointer_declarator` wrappers. */
     readonly isPointer: boolean;
     /** True when the variable's declarator was a `reference_declarator`. */
     readonly isReference: boolean;
@@ -105,8 +106,8 @@ export declare function populateCppAssociatedNamespaces(parsed: ParsedFile): voi
  *
  * Fires only when:
  *   - the call site is not in `noAdlSites` (parenthesized form), AND
- *   - at least one argument is a directly-named class type (not pointer,
- *     not reference, not literal/primitive).
+ *   - at least one argument resolves to a named class type (value or
+ *     pointer, but not reference, function pointer, literal, or primitive).
  */
 export declare function pickCppAdlCandidates(site: {
     readonly name: string;

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

@@ -1,5 +1,5 @@
 /**
- * C++ argument-dependent lookup (ADL / Koenig lookup) — V1.
+ * C++ argument-dependent lookup (ADL / Koenig lookup).
  *
  * When ordinary unqualified lookup fails for a free-call site, ADL also
  * considers candidates declared in the **associated namespaces** of the
@@ -13,17 +13,18 @@
  * `using` anything. With V1 ADL: `audit::record` is discovered via
  * `audit::Event`'s associated namespace.
  *
- * ## V1 boundary
+ * ## Current boundary
  *
- * V1 covers ONE associated-entity rule: an argument that's a directly-named
+ * 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. Anything else — pointer/reference
+ * namespace** to the candidate set. V2 extends that one step to
+ * pointer-typed class args (`audit::Event* p`, `audit::Event** pp`):
+ * they contribute the pointee class's enclosing namespace too. Reference
  * arguments, function-pointer arguments, template specializations,
- * base-class associated namespaces — is V2 closure work and is
- * deliberately excluded. The `cpp-adl-pointer-arg-boundary` fixture
- * locks the exclusion in CI.
+ * base-class associated namespaces, and the rest of the full closure are
+ * still deliberately excluded.
  *
- * V1 also short-circuits to ADL only when ordinary lookup is empty
+ * The current implementation also short-circuits to ADL only when ordinary lookup is empty
  * (`findCallableBindingInScope` returned undefined). ISO C++ would
  * normally merge ADL candidates with ordinary-lookup candidates and
  * run overload resolution over the union; V1 defers that merge to V2.
@@ -118,8 +119,8 @@ export function populateCppAssociatedNamespaces(parsed) {
  *
  * Fires only when:
  *   - the call site is not in `noAdlSites` (parenthesized form), AND
- *   - at least one argument is a directly-named class type (not pointer,
- *     not reference, not literal/primitive).
+ *   - at least one argument resolves to a named class type (value or
+ *     pointer, but not reference, function pointer, literal, or primitive).
  */
 export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
     const key = siteKey(callerParsed.filePath, site.atRange.startLine, site.atRange.startCol);
@@ -128,12 +129,12 @@ 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 value-class-typed arg.
+    // Collect associated namespace QNames from every participating class-typed arg.
     const associatedNamespaces = new Set();
     for (const arg of args) {
         if (arg.simpleClassName === '')
             continue;
-        if (arg.isPointer || arg.isReference)
+        if (arg.isReference)
             continue;
         const classDef = findCppClassDefBySimpleName(arg.simpleClassName, scopes);
         if (classDef === undefined)

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

@@ -657,14 +657,15 @@ function isParenthesizedFunctionCall(callNode) {
 }
 /**
  * Per-argument ADL classification: walk each argument of a free call and
- * decide whether it's a directly-named class type (V1 ADL fires) or
- * something V1 excludes (pointer, reference, primitive, literal, function
- * pointer, template specialization).
+ * 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.
  *
- * V1 only fires for value class-typed args: `void f(N::S); N::S s; f(s);`.
- * Pointer args (`N::S* p; f(p);`) intentionally return `simpleClassName=''`
- * to lock the V1 boundary — the `cpp-adl-pointer-arg-boundary` fixture
- * regression-tests this.
+ * Class-typed values and class pointers (`N::S`, `N::S*`, `N::S**`) all
+ * preserve the pointee 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.
  */
 function inferCppCallAdlArgs(callNode) {
     const argList = callNode.childForFieldName('arguments');
@@ -727,15 +728,23 @@ function lookupAdlIdentifierType(identNode) {
             continue;
         // Unwrap declarator chain to find pointer/reference markers and the
         // variable name. `init_declarator > pointer_declarator > identifier`
-        // means pointer-typed; `init_declarator > reference_declarator > ...`
-        // means reference-typed; bare `init_declarator > identifier` is value.
+        // means pointer-typed; repeated pointer wrappers still count as pointer
+        // typed; `init_declarator > reference_declarator > ...` means
+        // reference-typed; bare `init_declarator > identifier` is value.
+        // Function-pointer wrappers (`pointer_declarator > function_declarator`)
+        // must not contribute ADL associated namespaces.
         let isPointer = false;
         let isReference = false;
+        let isFunctionPointer = false;
         let inner = declarator;
         let nameText = null;
         let safety = 16; // bound walk depth defensively
         while (safety-- > 0) {
             if (inner.type === 'pointer_declarator') {
+                if (findFirstDescendantOfType(inner, 'function_declarator') !== null) {
+                    isFunctionPointer = true;
+                    break;
+                }
                 isPointer = true;
                 const next = inner.childForFieldName('declarator');
                 if (next === null)
@@ -766,11 +775,15 @@ function lookupAdlIdentifierType(identNode) {
                 inner = next;
                 continue;
             }
+            if (inner.type === 'function_declarator') {
+                isFunctionPointer = true;
+                break;
+            }
             // Reached the leaf — usually `identifier`. Take its text.
             nameText = inner.text;
             break;
         }
-        if (nameText !== varName)
+        if (isFunctionPointer || nameText !== varName)
             continue;
         const simpleClassName = extractAdlSimpleTypeName(typeNode);
         return { simpleClassName, isPointer, isReference };
@@ -778,9 +791,9 @@ function lookupAdlIdentifierType(identNode) {
     return EMPTY_ADL_ARG;
 }
 /** Extract the simple class-like type name from a `type:` field node.
- *  Returns '' for primitives, template specializations, function pointers,
- *  and any other shape V1 ADL doesn't support — those args are excluded
- *  from associated-namespace closure. */
+ *  Returns '' for primitives, template specializations, and any other
+ *  unsupported type-only shape. Function pointers are filtered at the
+ *  declarator level in `lookupAdlIdentifierType`. */
 function extractAdlSimpleTypeName(typeNode) {
     if (typeNode.type === 'primitive_type')
         return '';

package/package.json

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