gitnexus 1.6.5-rc.38 → 1.6.5-rc.39

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

@@ -18,11 +18,11 @@
  * 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. 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, and the rest of the full closure are
- * still deliberately excluded.
+ * 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.
  *
  * The current implementation also short-circuits to ADL only when ordinary lookup is empty
  * (`findCallableBindingInScope` returned undefined). ISO C++ would
@@ -56,18 +56,13 @@ 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 fires for
- * arguments where `simpleClassName !== ''` AND `!isReference`, including
- * class pointers whose declarator chain resolves to a named class type.
+ * 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 contained one or more
-     *  `pointer_declarator` wrappers. */
-    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
@@ -106,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 resolves to a named class type (value or
- *     pointer, but not reference, function pointer, literal, or 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

@@ -18,11 +18,11 @@
  * 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. 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, and the rest of the full closure are
- * still deliberately excluded.
+ * 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.
  *
  * The current implementation also short-circuits to ADL only when ordinary lookup is empty
  * (`findCallableBindingInScope` returned undefined). ISO C++ would
@@ -119,8 +119,8 @@ export function populateCppAssociatedNamespaces(parsed) {
  *
  * Fires only when:
  *   - the call site is not in `noAdlSites` (parenthesized form), AND
- *   - at least one argument resolves to a named class type (value or
- *     pointer, but not reference, function pointer, literal, or 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);
@@ -134,8 +134,6 @@ export function pickCppAdlCandidates(site, callerParsed, scopes, parsedFiles) {
     for (const arg of args) {
         if (arg.simpleClassName === '')
             continue;
-        if (arg.isReference)
-            continue;
         const classDef = findCppClassDefBySimpleName(arg.simpleClassName, scopes);
         if (classDef === undefined)
             continue;

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

@@ -682,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' ||
@@ -729,12 +729,11 @@ function lookupAdlIdentifierType(identNode) {
         // Unwrap declarator chain to find pointer/reference markers and the
         // variable name. `init_declarator > pointer_declarator > identifier`
         // means pointer-typed; repeated pointer wrappers still count as pointer
-        // typed; `init_declarator > reference_declarator > ...` means
-        // reference-typed; bare `init_declarator > identifier` is value.
+        // 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 isPointer = false;
-        let isReference = false;
         let isFunctionPointer = false;
         let inner = declarator;
         let nameText = null;
@@ -745,15 +744,13 @@ function lookupAdlIdentifierType(identNode) {
                     isFunctionPointer = true;
                     break;
                 }
-                isPointer = true;
                 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++) {
@@ -786,7 +783,7 @@ function lookupAdlIdentifierType(identNode) {
         if (isFunctionPointer || nameText !== varName)
             continue;
         const simpleClassName = extractAdlSimpleTypeName(typeNode);
-        return { simpleClassName, isPointer, isReference };
+        return { simpleClassName };
     }
     return EMPTY_ADL_ARG;
 }

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