gitnexus 1.6.8-rc.8 → 1.6.8

package/dist/core/ingestion/scope-resolution/graph-bridge/references-to-edges.js

@@ -19,7 +19,11 @@
  */
 import { resolveCallerGraphId, resolveDefGraphId } from '../graph-bridge/ids.js';
 import { mapReferenceKindToEdgeType } from '../graph-bridge/edges.js';
-export function emitReferencesViaLookup(graph, scopes, referenceIndex, nodeLookup, skipSites) {
+export function emitReferencesViaLookup(graph, scopes, referenceIndex, nodeLookup, skipSites, 
+/** Resolved-callee-id capture sink (#2227 U2). Threaded in only under
+ *  `--pdg`; `undefined` ⇒ zero overhead, byte-identity (R4). Captured at the
+ *  CALLS emit below BEFORE this loop's `seen` dedup (KTD6/R8). */
+calleeIdSink) {
     let emitted = 0;
     let skipped = 0;
     const seen = new Set();
@@ -54,6 +58,14 @@ export function emitReferencesViaLookup(graph, scopes, referenceIndex, nodeLooku
                 skipped++;
                 continue;
             }
+            // Resolved-callee-id capture (#2227 U2/KTD6/R8): record this CALLS site's
+            // resolved target BEFORE the `seen` dedup, keyed on `ref.atRange`
+            // (byte-equal to U1's SiteRecord.at: 1-based line / 0-based col). Only
+            // CALLS feeds the bridge; ACCESSES/USES/EXTENDS are skipped. `fromFilePath`
+            // is the call-site (caller) file — the same file U1 stamps the site on.
+            if (calleeIdSink !== undefined && edgeType === 'CALLS' && fromFilePath !== undefined) {
+                calleeIdSink.add(fromFilePath, ref.atRange.startLine, ref.atRange.startCol, targetGraphId);
+            }
             const dedupKey = `${edgeType}:${callerGraphId}->${targetGraphId}:${ref.atRange.startLine}:${ref.atRange.startCol}`;
             if (seen.has(dedupKey))
                 continue;

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.d.ts

@@ -24,6 +24,7 @@ import type { WorkspaceResolutionIndex } from '../workspace-index.js';
 import type { GraphNodeLookup } from '../graph-bridge/node-lookup.js';
 import type { ScopeResolver } from '../contract/scope-resolver.js';
 import type { ResolutionOutcomeRecorder } from '../resolution-outcome.js';
+import type { CalleeIdSink } from '../graph-bridge/callee-id-sink.js';
 import { type ConversionRankFn } from './overload-narrowing.js';
 export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, _referenceIndex: {
     readonly bySourceScope: ReadonlyMap<ScopeId, readonly Reference[]>;
@@ -49,6 +50,7 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
         };
     }, callerParsed: ParsedFile, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[]) => readonly SymbolDefinition[] | undefined;
     readonly conversionRankFn?: ConversionRankFn;
+    readonly conversionOnlyArgTypePrefixes?: readonly string[];
     /** Optional per-language constraint hook threaded into
      *  `narrowOverloadCandidates`. Drops candidates whose template
      *  constraints (e.g. C++ `enable_if_t`, C++20 `requires`) provably
@@ -56,6 +58,11 @@ export declare function emitFreeCallFallback(graph: KnowledgeGraph, scopes: Scop
      *  candidate (monotonicity). */
     readonly constraintCompatibility?: ScopeResolver['constraintCompatibility'];
     readonly recordResolutionOutcome?: ResolutionOutcomeRecorder;
+    /** Resolved-callee-id capture sink (#2227 U2). Threaded in only under
+     *  `--pdg`; `undefined` ⇒ zero overhead, byte-identity (R4). Captured at
+     *  the CALLS emit below BEFORE the collapsed `seen` dedup (KTD6) so
+     *  same-target multi-line calls are still recorded per site. */
+    readonly calleeIdSink?: CalleeIdSink;
 }): number;
 /**
  * Build a `simpleName -> callable defs` index from `scopes.defs` once per
@@ -99,7 +106,7 @@ export declare function buildGlobalClassIndex(scopes: ScopeResolutionIndexes): R
  * order. Exported for unit testing — the `scopeDefsCache` equivalence is
  * exercised via synthetic stubs in `pick-unique-global-callable.test.ts`.
  */
-export declare function pickUniqueGlobalCallable(name: string, model: SemanticModel, globalCallablesBySimpleName: ReadonlyMap<string, readonly SymbolDefinition[]>, callerFilePath: string, isFileLocalDef?: (def: SymbolDefinition) => boolean, callArity?: number, isCallerVisible?: (candidate: SymbolDefinition) => boolean, callArgTypes?: readonly string[], callArgTypeClasses?: readonly ParameterTypeClass[], conversionRankFn?: ConversionRankFn, scopeDefsCache?: Map<string, readonly SymbolDefinition[]>): SymbolDefinition | undefined;
+export declare function pickUniqueGlobalCallable(name: string, model: SemanticModel, globalCallablesBySimpleName: ReadonlyMap<string, readonly SymbolDefinition[]>, callerFilePath: string, isFileLocalDef?: (def: SymbolDefinition) => boolean, callArity?: number, isCallerVisible?: (candidate: SymbolDefinition) => boolean, callArgTypes?: readonly string[], callArgTypeClasses?: readonly ParameterTypeClass[], conversionRankFn?: ConversionRankFn, scopeDefsCache?: Map<string, readonly SymbolDefinition[]>, conversionOnlyArgTypePrefixes?: readonly string[]): SymbolDefinition | undefined;
 /** Find a unique workspace-wide class-like def by simple name, for a
  *  constructor-form call `Type(...)` whose type lives outside the call
  *  site's lexical bindings (a sibling/imported file). Returns the def
@@ -142,5 +149,6 @@ export declare function pickImplicitThisOverload(site: {
     readonly argumentTypeClasses?: readonly import('../../../../_shared/index.js').ParameterTypeClass[];
 }, scopes: ScopeResolutionIndexes, workspaceIndex: WorkspaceResolutionIndex, model: SemanticModel, hookCtx?: {
     readonly conversionRankFn?: ConversionRankFn;
+    readonly conversionOnlyArgTypePrefixes?: readonly string[];
     readonly constraintCompatibility?: ScopeResolver['constraintCompatibility'];
 }): SymbolDefinition | undefined;

package/dist/core/ingestion/scope-resolution/passes/free-call-fallback.js

@@ -89,6 +89,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             if (fnDef === undefined) {
                 fnDef = pickImplicitThisOverload(site, scopes, workspaceIndex, model, {
                     conversionRankFn: options.conversionRankFn,
+                    conversionOnlyArgTypePrefixes: options.conversionOnlyArgTypePrefixes,
                     constraintCompatibility: options.constraintCompatibility,
                 });
                 fnDefFromImplicitThis = fnDef !== undefined;
@@ -112,6 +113,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                             const narrowed = narrowOverloadCandidates(allCallables, site.arity, site.argumentTypes, {
                                 argumentTypeClasses: site.argumentTypeClasses,
                                 conversionRankFn: options.conversionRankFn,
+                                conversionOnlyArgTypePrefixes: options.conversionOnlyArgTypePrefixes,
                                 constraintCompatibility: options.constraintCompatibility,
                             });
                             if (narrowed.length === 1) {
@@ -190,6 +192,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                             const narrowed = narrowOverloadCandidates(ordinary, site.arity, site.argumentTypes, {
                                 argumentTypeClasses: site.argumentTypeClasses,
                                 conversionRankFn: options.conversionRankFn,
+                                conversionOnlyArgTypePrefixes: options.conversionOnlyArgTypePrefixes,
                                 constraintCompatibility: options.constraintCompatibility,
                             });
                             if (narrowed.length === 1) {
@@ -240,6 +243,7 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         const narrowed = narrowOverloadCandidates(merged, site.arity, site.argumentTypes, {
                             argumentTypeClasses: site.argumentTypeClasses,
                             conversionRankFn: options.conversionRankFn,
+                            conversionOnlyArgTypePrefixes: options.conversionOnlyArgTypePrefixes,
                             constraintCompatibility: options.constraintCompatibility,
                         });
                         if (narrowed.length === 1) {
@@ -285,10 +289,22 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
                         callerScope: site.inScope,
                         scopes,
                     })
-                    : undefined, site.argumentTypes, site.argumentTypeClasses, options.conversionRankFn, scopeDefsCache);
+                    : undefined, site.argumentTypes, site.argumentTypeClasses, options.conversionRankFn, scopeDefsCache, options.conversionOnlyArgTypePrefixes);
             }
             if (fnDef === undefined)
                 continue;
+            if (fnDef.isDeleted === true) {
+                recordSuppressedOutcome(options.recordResolutionOutcome, {
+                    phase: 'free-call-fallback',
+                    filePath: parsed.filePath,
+                    name: site.name,
+                    range: site.atRange,
+                    reason: 'selected-callable-deleted',
+                    candidates: [fnDef],
+                });
+                handledSites.add(siteKey(parsed.filePath, site));
+                continue;
+            }
             if ((fnDefFromImplicitThis || fnDef.type === 'Method' || fnDef.type === 'Constructor') &&
                 options.isCallableVisibleFromCaller !== undefined &&
                 !options.isCallableVisibleFromCaller({
@@ -310,6 +326,13 @@ export function emitFreeCallFallback(graph, scopes, parsedFiles, nodeLookup, _re
             // means we don't add a new edge — so `emit-references` skips its
             // potentially-wrong fallback for the same site.
             handledSites.add(siteKey(parsed.filePath, site));
+            // Resolved-callee-id capture (#2227 U2/KTD6/R8): record this CALLS site's
+            // resolved target BEFORE the collapsed `seen` dedup. The free-call dedup
+            // key drops the line (one edge per caller→target), so capturing after
+            // `seen.has` would lose every same-target call past the first — capture
+            // here, per site, keyed on `site.atRange` (byte-equal to U1's
+            // SiteRecord.at: 1-based line / 0-based col).
+            options.calleeIdSink?.add(parsed.filePath, site.atRange.startLine, site.atRange.startCol, tgtGraphId);
             const relId = `rel:CALLS:${callerGraphId}->${tgtGraphId}`;
             if (seen.has(relId))
                 continue;
@@ -430,7 +453,7 @@ export function buildGlobalClassIndex(scopes) {
  * order. Exported for unit testing — the `scopeDefsCache` equivalence is
  * exercised via synthetic stubs in `pick-unique-global-callable.test.ts`.
  */
-export function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleName, callerFilePath, isFileLocalDef, callArity, isCallerVisible, callArgTypes, callArgTypeClasses, conversionRankFn, scopeDefsCache) {
+export function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleName, callerFilePath, isFileLocalDef, callArity, isCallerVisible, callArgTypes, callArgTypeClasses, conversionRankFn, scopeDefsCache, conversionOnlyArgTypePrefixes) {
     // The scope-index candidate list is a pure function of (name, callerFilePath):
     // the same-name bucket is fixed for the pass, the file-local filter depends
     // only on the candidate + callerFilePath, and the logical-key dedup is
@@ -492,6 +515,7 @@ export function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleNam
         const narrowed = narrowOverloadCandidates(scopeDefs, callArity, callArgTypes, {
             argumentTypeClasses: callArgTypeClasses,
             conversionRankFn,
+            conversionOnlyArgTypePrefixes,
         });
         if (narrowed.length === 1)
             return narrowed[0];
@@ -533,6 +557,7 @@ export function pickUniqueGlobalCallable(name, model, globalCallablesBySimpleNam
         const narrowed = narrowOverloadCandidates(defs, callArity, callArgTypes, {
             argumentTypeClasses: callArgTypeClasses,
             conversionRankFn,
+            conversionOnlyArgTypePrefixes,
         });
         if (narrowed.length === 1)
             return narrowed[0];
@@ -675,6 +700,7 @@ export function pickImplicitThisOverload(site, scopes, workspaceIndex, model, ho
     const candidates = narrowOverloadCandidates(overloads, site.arity, site.argumentTypes, {
         argumentTypeClasses: site.argumentTypeClasses,
         conversionRankFn: hookCtx?.conversionRankFn,
+        conversionOnlyArgTypePrefixes: hookCtx?.conversionOnlyArgTypePrefixes,
         constraintCompatibility: hookCtx?.constraintCompatibility,
     });
     if (candidates.length !== 1)

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.d.ts

@@ -69,6 +69,10 @@ export interface OverloadNarrowingHookCtx {
     /** Conversion-rank scoring fallback (step 4b). Engages when the
      *  exact-type filter rejects every candidate. */
     readonly conversionRankFn?: ConversionRankFn;
+    /** Per-language argument-type prefixes whose conversion-rank failures
+     *  should suppress genuinely ambiguous multi-overload sets instead of
+     *  falling back to arity-only candidates. */
+    readonly conversionOnlyArgTypePrefixes?: readonly string[];
     /** Constraint filter (step 4c). Drops candidates whose template
      *  guards (SFINAE `enable_if_t`, C++20 `requires`, future Rust
      *  trait bounds, etc.) provably fail at the call site. Three-valued

package/dist/core/ingestion/scope-resolution/passes/overload-narrowing.js

@@ -106,6 +106,10 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx)
             const ranked = rankByConversion(candidates, argTypes, hookCtx.conversionRankFn, hookCtx.argumentTypeClasses);
             if (ranked.length > 0)
                 result = ranked;
+            else if (candidates.length > 1 &&
+                hasConversionOnlyArgType(argTypes, hookCtx.conversionOnlyArgTypePrefixes)) {
+                result = [];
+            }
         }
     }
     // Constraint filter (step 4c; Tier-A — SFINAE / `requires` clauses).
@@ -145,6 +149,11 @@ export function narrowOverloadCandidates(overloads, argCount, argTypes, hookCtx)
     }
     return result;
 }
+function hasConversionOnlyArgType(argTypes, prefixes) {
+    if (prefixes === undefined || prefixes.length === 0)
+        return false;
+    return argTypes.some((type) => prefixes.some((prefix) => type.startsWith(prefix)));
+}
 function exactTypeSlotMatches(argType, paramType, argTypeClass, paramTypeClass) {
     if (argType !== paramType)
         return false;

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

@@ -43,13 +43,18 @@ import type { SemanticModel } from '../../model/semantic-model.js';
 import type { ScopeResolver } from '../contract/scope-resolver.js';
 import type { GraphNodeLookup } from '../graph-bridge/node-lookup.js';
 import type { WorkspaceResolutionIndex } from '../workspace-index.js';
+import type { CalleeIdSink } from '../graph-bridge/callee-id-sink.js';
 import type { ResolutionOutcomeRecorder } from '../resolution-outcome.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' | 'resolveReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'constraintCompatibility' | 'isStaticOnly'>;
+type ReceiverBoundProviderSubset = Pick<ScopeResolver, 'isSuperReceiver' | 'isSuperReceiverInContext' | 'fieldFallbackOnMethodLookup' | 'collapseMemberCallsByCallerTarget' | 'unwrapCollectionAccessor' | 'hoistTypeBindingsToModule' | 'resolveQualifiedReceiverMember' | 'resolveReceiverMember' | 'resolveThisViaEnclosingClass' | 'conversionRankFn' | 'conversionOnlyArgTypePrefixes' | 'constraintCompatibility' | 'isStaticOnly'>;
 export declare function emitReceiverBoundCalls(graph: KnowledgeGraph, scopes: ScopeResolutionIndexes, parsedFiles: readonly ParsedFile[], nodeLookup: GraphNodeLookup, handledSites: Set<string>, provider: ReceiverBoundProviderSubset, index: WorkspaceResolutionIndex, model: SemanticModel, options?: {
     readonly recordResolutionOutcome?: ResolutionOutcomeRecorder;
+    /** Resolved-callee-id capture sink (#2227 U2). Threaded in only under
+     *  `--pdg`; `undefined` ⇒ zero overhead, byte-identity (R4). Per-file
+     *  capture contexts are built from this + `parsed.filePath` in the loop. */
+    readonly calleeIdSink?: CalleeIdSink;
 }): number;
 /**
  * Sentinel returned by `pickOverload` when narrowing leaves >1 candidate