gitnexus 1.6.5-rc.37 → 1.6.5-rc.39

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
- * 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.
+ * 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.
  *
- * 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,19 +55,14 @@
 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 !== ''`, including class pointers and
+ * references 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). */
-    readonly isPointer: boolean;
-    /** True when the variable's declarator was a `reference_declarator`. */
-    readonly isReference: boolean;
 }
 /** Sentinel returned by `pickCppAdlCandidates` when ADL surfaces multiple
  *  candidates that share normalized parameter types — the caller MUST
@@ -105,8 +101,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,
+ *     pointer, or reference; but not 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
- * 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.
+ * 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.
  *
- * 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,
+ *     pointer, or reference; but not function pointer, literal, or primitive).
  */
 export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
     const key = siteKey(callerParsed.filePath, site.atRange.startLine, site.atRange.startCol);
@@ -128,13 +129,11 @@ 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)
-            continue;
         const classDef = findCppClassDefBySimpleName(arg.simpleClassName, scopes);
         if (classDef === undefined)
             continue;

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');
@@ -681,7 +682,7 @@ function inferCppCallAdlArgs(callNode) {
     }
     return out;
 }
-const EMPTY_ADL_ARG = { simpleClassName: '', isPointer: false, isReference: false };
+const EMPTY_ADL_ARG = { simpleClassName: '' };
 function classifyAdlArg(argNode) {
     // Literals and primitive-shaped expressions never have associated namespaces.
     if (argNode.type === 'number_literal' ||
@@ -727,24 +728,29 @@ 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.
-        let isPointer = false;
-        let isReference = false;
+        // means pointer-typed; repeated pointer wrappers still count as pointer
+        // typed; `init_declarator > reference_declarator > ...` (or
+        // `rvalue_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 isFunctionPointer = false;
         let inner = declarator;
         let nameText = null;
         let safety = 16; // bound walk depth defensively
         while (safety-- > 0) {
             if (inner.type === 'pointer_declarator') {
-                isPointer = true;
+                if (findFirstDescendantOfType(inner, 'function_declarator') !== null) {
+                    isFunctionPointer = true;
+                    break;
+                }
                 const next = inner.childForFieldName('declarator');
                 if (next === null)
                     break;
                 inner = next;
                 continue;
             }
-            if (inner.type === 'reference_declarator') {
-                isReference = true;
+            if (inner.type === 'reference_declarator' || inner.type === 'rvalue_reference_declarator') {
                 // reference_declarator has a single child (the inner declarator).
                 let next = null;
                 for (let j = 0; j < inner.namedChildCount; j++) {
@@ -766,21 +772,25 @@ 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 };
+        return { simpleClassName };
     }
     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/dist/core/ingestion/languages/cpp/scope-resolver.js

@@ -12,6 +12,7 @@ import { populateCppDependentBases, clearCppDependentBases, isCppDependentBaseMe
 import { populateCppAssociatedNamespaces, clearCppAdlState, pickCppAdlCandidates, ADL_AMBIGUOUS, } from './adl.js';
 import { clearCppInlineNamespaces, populateCppInlineNamespaceScopes, resolveCppQualifiedNamespaceMember, } from './inline-namespaces.js';
 import { populateCppRangeBindings } from './range-bindings.js';
+import { isOverloadAmbiguousAfterNormalization, narrowOverloadCandidates, } from '../../scope-resolution/passes/overload-narrowing.js';
 /**
  * C++ `ScopeResolver` registered in `SCOPE_RESOLVERS` and consumed by
  * the generic `runScopeResolution` orchestrator (RFC #909 Ring 3).
@@ -145,6 +146,8 @@ export const cppScopeResolver = {
     // for cross-file propagation and compound-receiver chain resolution.
     // cppBindingScopeFor hoists @type-binding.return to Module scope.
     hoistTypeBindingsToModule: true,
+    // Enable receiver-bound explicit-`this` fallback only for C++.
+    resolveThisViaEnclosingClass: true,
     // The `isFileLocalDef` hook on the global free-call fallback names
     // file-local linkage historically, but semantically gates "logically
     // invisible cross-file" defs. C++ extends this to also reject class-
@@ -188,6 +191,34 @@ export const cppScopeResolver = {
     // V1 limitation: only direct enclosing-namespace closure for value
     // class-typed args; pointer/reference/template-spec args 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
+        // named-using visibility; recover by resolving the imported namespace
+        // member directly when the local call name matches a named using import.
+        const usingNamedHits = [];
+        const seenUsing = new Set();
+        for (const imp of callerParsed.parsedImports) {
+            if (imp.kind !== 'named')
+                continue;
+            if (imp.localName !== site.name)
+                continue;
+            const member = resolveCppQualifiedNamespaceMember(imp.targetRaw, imp.importedName, parsedFiles, scopes);
+            if (member === undefined)
+                continue;
+            if (seenUsing.has(member.nodeId))
+                continue;
+            seenUsing.add(member.nodeId);
+            usingNamedHits.push(member);
+        }
+        if (usingNamedHits.length > 0) {
+            const narrowed = narrowOverloadCandidates(usingNamedHits, site.arity, site.argumentTypes);
+            if (isOverloadAmbiguousAfterNormalization(narrowed, site.arity))
+                return 'ambiguous';
+            if (narrowed.length === 1)
+                return narrowed[0];
+            if (narrowed.length > 1)
+                return 'ambiguous';
+        }
         const result = pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles);
         if (result === ADL_AMBIGUOUS)
             return 'ambiguous';

package/dist/core/ingestion/scope-resolution/contract/scope-resolver.d.ts

@@ -547,6 +547,17 @@ export interface ScopeResolver {
      * remaining cases.
      */
     readonly resolveQualifiedReceiverMember?: (receiverName: string, memberName: string, callerScope: ScopeId, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => SymbolDefinition | undefined;
+    /**
+     * Enable the receiver-bound Case 0.5 fallback for explicit `this`
+     * receivers (`this->m()` / `this.m()`) that resolves against the
+     * enclosing class + MRO even when no explicit `this` typeBinding is
+     * present in scope.
+     *
+     * Keep disabled for languages where the existing type-binding path
+     * (Case 4) already handles `this` correctly and overload ambiguity
+     * suppression must remain unchanged.
+     */
+    readonly resolveThisViaEnclosingClass?: boolean;
     /**
      * Optional post-finalize hook to inject cross-file bindings that
      * aren't modeled via explicit imports. Runs after

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.d.ts

@@ -41,7 +41,7 @@ import type { WorkspaceResolutionIndex } from '../workspace-index.js';
 /** Subset of `ScopeResolver` consumed by this pass. Accepting the
  *  subset rather than the full provider keeps tests and partial
  *  refactors lighter — callers only need to populate what we read. */
-type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'resolveQualifiedReceiverMember'>;
+type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'resolveQualifiedReceiverMember' | 'resolveThisViaEnclosingClass'>;
 export declare function emitReceiverBoundCalls(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, handledSites: Set<string>, provider: ReceiverBoundProviderSubset, index: WorkspaceResolutionIndex, model: SemanticModel): number;
 /**
  * Sentinel returned by `pickOverload` when narrowing leaves >1 candidate

package/dist/core/ingestion/scope-resolution/passes/receiver-bound-calls.js

@@ -232,6 +232,72 @@ export function emitReceiverBoundCalls(graph, scopes, parsedFiles, nodeLookup, h
                     }
                 }
             }
+            // ── Case 0.5: implicit `this` receiver ───────────────────────
+            // C++ `this->member()` (and same-shape receivers in other OO
+            // languages) should resolve against the enclosing class + MRO
+            // even when there is no explicit `this` typeBinding in scope.
+            if (provider.resolveThisViaEnclosingClass === true && receiverName === 'this') {
+                const enclosingClass = findEnclosingClassDef(site.inScope, scopes);
+                if (enclosingClass !== undefined) {
+                    const chain = [
+                        enclosingClass.nodeId,
+                        ...scopes.methodDispatch.mroFor(enclosingClass.nodeId),
+                    ];
+                    let memberDef;
+                    let ambiguous = false;
+                    let hiddenByName = false;
+                    for (const ownerId of chain) {
+                        const methodOverloads = model.methods.lookupAllByOwner(ownerId, memberName);
+                        if (methodOverloads.length > 0) {
+                            const narrowed = narrowOverloadCandidates(methodOverloads, site.arity, site.argumentTypes);
+                            if (isOverloadAmbiguousAfterNormalization(narrowed, site.arity)) {
+                                ambiguous = true;
+                                break;
+                            }
+                            if (narrowed.length === 0) {
+                                // C++ name hiding: if the derived class declares `f`, base-class
+                                // overloads named `f` are hidden for member lookup
+                                // ([basic.lookup.classref]). A non-viable derived overload set
+                                // therefore terminates lookup instead of falling through to base.
+                                hiddenByName = true;
+                                break;
+                            }
+                            memberDef = narrowed[0] ?? methodOverloads[0];
+                            break;
+                        }
+                        // Field/property lookup intentionally runs only after the method
+                        // lookup above: in C++ member-name lookup, functions with this
+                        // name hide same-named base members; we therefore prefer method
+                        // candidates first and only target a field when no methods with
+                        // this name exist on the current owner.
+                        memberDef = model.fields.lookupFieldByOwner(ownerId, memberName);
+                        if (memberDef !== undefined) {
+                            break;
+                        }
+                    }
+                    if (ambiguous) {
+                        handledSites.add(siteKey);
+                        continue;
+                    }
+                    if (hiddenByName) {
+                        handledSites.add(siteKey);
+                        continue;
+                    }
+                    if (memberDef !== undefined) {
+                        const reason = site.kind === 'write' || site.kind === 'read'
+                            ? site.kind
+                            : memberDef.filePath !== parsed.filePath
+                                ? 'import-resolved'
+                                : 'global';
+                        const confidence = site.kind === 'write' || site.kind === 'read' ? 1.0 : 0.85;
+                        const ok = tryEmitEdge(graph, scopes, nodeLookup, site, memberDef, reason, seen, confidence, collapse);
+                        if (ok)
+                            emitted++;
+                        handledSites.add(siteKey);
+                        continue;
+                    }
+                }
+            }
             // ── Case 1: namespace receiver ───────────────────────────────
             const targetFiles = namespaceTargets.get(receiverName);
             if (targetFiles !== undefined) {

package/package.json

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