gitnexus 1.6.6-rc.80 → 1.6.6-rc.81

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

@@ -24,22 +24,18 @@
  * 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.
+ * Function-reference arguments follow ISO C++ `[basic.lookup.argdep]`:
+ * associated entities come from the parameter types and return type of each
+ * referenced function in the overload set, not from the function's enclosing
+ * namespace. For `void worker()`, the associated set is empty. For
+ * `void worker(api::Token)` or `api::Token make_token()`, `api` is associated
+ * through `Token`.
+ *
+ * For qualified refs (e.g. `utils::worker`) the workspace lookup is restricted
+ * to functions/methods named `worker` in `utils`; for unqualified refs the
+ * workspace is searched for matching functions/methods by simple name. Locally
+ * declared function-pointer variables and function parameters are excluded
+ * from this path.
  *
  * ADL candidates are merged with ordinary unqualified-lookup candidates
  * in the free-call fallback before overload narrowing.
@@ -94,11 +90,8 @@ export interface CppAdlArgInfo {
     /** 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. */
+     *  `"worker"`). Resolution contributes associated namespaces from each
+     *  referenced Function/Method def's parameter and return types. */
     readonly functionRefText?: string;
 }
 /** Record per-call-site argument info. Called once per call site from

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

@@ -24,22 +24,18 @@
  * 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.
+ * Function-reference arguments follow ISO C++ `[basic.lookup.argdep]`:
+ * associated entities come from the parameter types and return type of each
+ * referenced function in the overload set, not from the function's enclosing
+ * namespace. For `void worker()`, the associated set is empty. For
+ * `void worker(api::Token)` or `api::Token make_token()`, `api` is associated
+ * through `Token`.
  *
- * 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.
+ * For qualified refs (e.g. `utils::worker`) the workspace lookup is restricted
+ * to functions/methods named `worker` in `utils`; for unqualified refs the
+ * workspace is searched for matching functions/methods by simple name. Locally
+ * declared function-pointer variables and function parameters are excluded
+ * from this path.
  *
  * ADL candidates are merged with ordinary unqualified-lookup candidates
  * in the free-call fallback before overload narrowing.
@@ -67,6 +63,7 @@
  * but logically share the same namespace. ADL must consider candidates
  * declared in either file.
  */
+import { normalizeCppParamType } from './arity-metadata.js';
 import { isCppInlineNamespaceScope } from './inline-namespaces.js';
 const argInfoBySite = new Map();
 const noAdlSites = new Set();
@@ -157,7 +154,7 @@ export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
     for (const arg of args) {
         collectAssociatedNamespacesForAdlArg(arg, scopes, associatedNamespaces);
         if (arg.functionRefText !== undefined) {
-            collectFunctionRefNamespaces(arg.functionRefText, parsedFiles, associatedNamespaces);
+            collectFunctionTypeAssociatedNamespaces(arg.functionRefText, scopes, parsedFiles, associatedNamespaces);
         }
     }
     if (associatedNamespaces.size === 0)
@@ -405,22 +402,10 @@ function findCppClassDefBySimpleName(simpleName, scopes) {
     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.
+ * Contribute associated namespaces for a function-reference argument by walking
+ * the referenced overload set's parameter and return types.
  */
-function collectFunctionRefNamespaces(refText, parsedFiles, out) {
+function collectFunctionTypeAssociatedNamespaces(refText, scopes, parsedFiles, out) {
     const colonIdx = refText.lastIndexOf('::');
     if (colonIdx !== -1) {
         // Qualified ref: extract namespace prefix and normalise :: → dot notation.
@@ -445,21 +430,18 @@ function collectFunctionRefNamespaces(refText, parsedFiles, out) {
                     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.
-                    }
+                    if (simple === simpleName)
+                        collectAssociatedNamespacesForFunctionDef(def, scopes, out);
                 }
             }
         }
         return;
     }
-    // Unqualified: search all namespace scopes for a Function def with this
-    // simple name and contribute its enclosing namespace.
+    // Unqualified function references are approximated workspace-wide, matching
+    // the previous V1 lookup scope. The stricter part of this PR is what each
+    // overload contributes: only namespaces from parameter/return types, never
+    // the function's own 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;
@@ -469,10 +451,101 @@ function collectFunctionRefNamespaces(refText, parsedFiles, out) {
                 const simple = def.qualifiedName?.split('.').pop() ?? def.qualifiedName ?? '';
                 if (simple !== refText)
                     continue;
-                const nsQName = computeNamespaceQName(scope, scopesById);
-                if (nsQName !== '')
-                    out.add(nsQName);
+                collectAssociatedNamespacesForFunctionDef(def, scopes, out);
             }
         }
     }
 }
+function collectAssociatedNamespacesForFunctionDef(def, scopes, out) {
+    const parameterTypes = def.parameterTypeClasses?.map((typeClass) => typeClass.base);
+    for (const paramType of parameterTypes ?? def.parameterTypes ?? []) {
+        collectAssociatedNamespacesForFunctionTypeText(paramType, scopes, out);
+    }
+    if (def.returnType !== undefined) {
+        collectAssociatedNamespacesForFunctionTypeText(def.returnType, scopes, out);
+    }
+}
+function collectAssociatedNamespacesForFunctionTypeText(typeText, scopes, out) {
+    for (const token of extractCppTypeNameTokens(typeText)) {
+        if (isIgnoredCppAdlNamespace(token.namespaceName))
+            continue;
+        addAssociatedNamespaceForClassName(token.simpleName, scopes, out);
+        if (token.namespaceName !== '')
+            out.add(token.namespaceName);
+    }
+}
+function extractCppTypeNameTokens(typeText) {
+    const cleaned = normalizeCppParamType(typeText);
+    if (cleaned === '' || isPrimitiveCppAdlType(cleaned))
+        return [];
+    const out = [];
+    const seen = new Set();
+    const tokenSource = typeText.includes('<') ? `${cleaned} ${typeText}` : cleaned;
+    for (const rawToken of tokenSource.match(/[A-Za-z_]\w*(?:::[A-Za-z_]\w*)*/g) ?? []) {
+        if (isPrimitiveCppAdlType(rawToken))
+            continue;
+        const segments = rawToken.split('::').filter((part) => part.length > 0);
+        const simpleName = segments.at(-1) ?? '';
+        if (simpleName === '' || isPrimitiveCppAdlType(simpleName))
+            continue;
+        const namespaceName = segments.length > 1 ? segments.slice(0, -1).join('.') : '';
+        const key = `${namespaceName}\0${simpleName}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({
+            simpleName,
+            namespaceName,
+        });
+    }
+    return out;
+}
+const CPP_ADL_PRIMITIVE_OR_KEYWORD_TYPES = new Set([
+    'alignas',
+    'alignof',
+    'auto',
+    'bool',
+    'char',
+    'char8_t',
+    'char16_t',
+    'char32_t',
+    'class',
+    'const',
+    'consteval',
+    'constexpr',
+    'constinit',
+    'decltype',
+    'double',
+    'enum',
+    'explicit',
+    'extern',
+    'float',
+    'inline',
+    'int',
+    'long',
+    'mutable',
+    'noexcept',
+    'null',
+    'register',
+    'short',
+    'signed',
+    'static',
+    'string',
+    'struct',
+    'template',
+    'thread_local',
+    'typename',
+    'union',
+    'unknown',
+    'unsigned',
+    'void',
+    'volatile',
+    'wchar_t',
+    '...',
+]);
+function isPrimitiveCppAdlType(typeText) {
+    return CPP_ADL_PRIMITIVE_OR_KEYWORD_TYPES.has(typeText);
+}
+function isIgnoredCppAdlNamespace(namespaceName) {
+    return namespaceName === 'std' || namespaceName.startsWith('std.');
+}

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

@@ -89,6 +89,10 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
                 if (arity.parameterTypeClasses !== undefined) {
                     grouped['@declaration.parameter-type-classes'] = syntheticCapture('@declaration.parameter-type-classes', fnNode, JSON.stringify(arity.parameterTypeClasses));
                 }
+                const returnType = extractCppDeclarationReturnType(fnNode);
+                if (returnType !== undefined) {
+                    grouped['@declaration.return-type'] = syntheticCapture('@declaration.return-type', fnNode, returnType);
+                }
                 if (hasExplicitSpecifier(fnNode)) {
                     grouped['@declaration.is-explicit'] = syntheticCapture('@declaration.is-explicit', fnNode, 'true');
                 }
@@ -311,6 +315,32 @@ export function emitCppScopeCaptures(sourceText, filePath, cachedTree) {
     detectCppDependentBases(tree.rootNode, filePath);
     return out;
 }
+function extractCppDeclarationReturnType(fnNode) {
+    const typeNode = fnNode.childForFieldName('type');
+    if (typeNode === null)
+        return undefined;
+    const funcDeclarator = findFunctionDeclarator(fnNode);
+    if (funcDeclarator !== null && isCppUnsupportedReturnTypeDeclarator(funcDeclarator)) {
+        return undefined;
+    }
+    const typeText = typeNode.text.trim();
+    if (typeText !== 'auto')
+        return typeText.length > 0 ? typeText : undefined;
+    if (funcDeclarator === null)
+        return typeText;
+    for (let i = 0; i < funcDeclarator.namedChildCount; i++) {
+        const child = funcDeclarator.namedChild(i);
+        if (child?.type !== 'trailing_return_type')
+            continue;
+        const typeDesc = child.firstNamedChild;
+        return typeDesc?.text.trim() || typeText;
+    }
+    return typeText;
+}
+function isCppUnsupportedReturnTypeDeclarator(funcDeclarator) {
+    const text = funcDeclarator.text;
+    return /\boperator\b/.test(text) || /(^|[(:\s])~\s*[A-Za-z_]\w*/.test(text);
+}
 /**
  * Walk every C++ class/struct base clause and emit `@reference.inherits`
  * captures for each base so scope resolution can resolve them into EXTENDS

package/dist/core/ingestion/scope-extractor.js

@@ -853,6 +853,7 @@ const KNOWN_SUB_TAGS = new Set([
     '@declaration.required-parameter-count',
     '@declaration.parameter-types',
     '@declaration.parameter-type-classes',
+    '@declaration.return-type',
     '@declaration.template-constraints',
     '@declaration.is-explicit',
 ]);

package/package.json

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