gitnexus 1.6.5-rc.42 → 1.6.5-rc.43

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

@@ -21,9 +21,25 @@
  *   - `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.
+ * 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
@@ -59,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
@@ -76,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,9 +21,25 @@
  *   - `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.
+ * 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
@@ -130,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;
@@ -319,3 +339,75 @@ function findCppClassDefBySimpleName(simpleName, scopes) {
         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);
+            }
+        }
+    }
+}

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

@@ -717,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;
@@ -735,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')
@@ -764,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');
@@ -796,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);
@@ -814,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
@@ -963,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/package.json

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