gitnexus 1.6.10-rc.98 → 1.6.10

package/dist/core/ingestion/scope-resolution/passes/callable-value-flow.js

@@ -4,10 +4,21 @@
  * JSON-safe facts carried by ParsedFile.
  */
 import { tryEmitEdgeWithExplicitTargetId } from '../graph-bridge/edges.js';
-import { resolveCallerGraphId, resolveDefGraphId } from '../graph-bridge/ids.js';
+import { resolveCallerGraphId, resolveDefGraphId, simpleQualifiedName, } from '../graph-bridge/ids.js';
 import { resolveInheritanceBaseInScope } from '../scope/walkers.js';
+import { definitionIdPosition } from '../utils/definition-id.js';
 import { narrowOverloadCandidates } from './overload-narrowing.js';
-export const MAX_CALLABLE_VALUE_TARGETS = 32;
+/**
+ * Per-site dispatch-target cap. Above it the site is treated as overflowed and
+ * its edges are dropped — a cliff, so a repo with a legitimately wide dispatch
+ * table (33+ candidates on one callable site) loses the whole call chain.
+ *
+ * Override via `GITNEXUS_MAX_CALLABLE_VALUE_TARGETS` for such repos.
+ */
+export const MAX_CALLABLE_VALUE_TARGETS = (() => {
+    const env = Number(process.env.GITNEXUS_MAX_CALLABLE_VALUE_TARGETS);
+    return Number.isInteger(env) && env >= 1 ? env : 32;
+})();
 /** Position key shared with the existing free/reference skip-set contract. */
 export function callableFlowSiteKey(filePath, range) {
     return `${filePath}:${range.startLine}:${range.startCol}`;
@@ -547,23 +558,98 @@ export function emitCallableValueFlow(input) {
     }
     return { emitted, resolvedInvokes, ambiguousInvokes, unmatchedInvokes, iterations };
 }
-function buildGraphTargetIndex(scopes, nodeLookup, providerTarget, graph) {
+/**
+ * Pure — exported for `bench/callable-value-flow/measure.mjs`, which guards its
+ * scaling ratio and result fingerprint. Not part of the pass's public contract.
+ */
+export function buildGraphTargetIndex(scopes, nodeLookup, providerTarget, graph) {
     const out = new Map();
-    const byAnchor = buildGraphCallableAnchorIndex(graph);
+    const { byAnchor, callableByPosition } = buildGraphCallableIndexes(graph);
     for (const def of scopes.defs.byId.values()) {
-        if (!isCallable(def) && providerTarget?.(def) !== true)
+        const callableDef = isCallable(def) || providerTarget?.(def) === true;
+        if (!callableDef) {
+            // #2693: a closure bound to a name (`val f = { }`) is a callable the def
+            // type cannot see — the scope layer declares it with its VALUE label
+            // (Kotlin/Swift `Property`, Dart `Variable`) while #2687 makes the graph
+            // emit a single callable node for it. Only the graph knows.
+            //
+            // The join MUST be positional. Resolving such a def through
+            // `resolveDefGraphId` is unsafe: every qualified key it builds embeds
+            // `def.type`, so for a value def they can only ever hit a value-labelled
+            // node — and when the def's own node is absent (Rust `let`) or carries a
+            // DIFFERENT label than the def's type (TypeScript declares `const` as
+            // `Variable` but emits a `Const` node), the chain falls through to the
+            // label-agnostic, first-write-wins `simpleKey(filePath, simpleName)`.
+            // That aliases the binding onto ANY same-named callable in the file —
+            // `const save = cb` next to an unrelated `Svc.save` mints a CALLS edge to
+            // the method, and the result depends on declaration order.
+            //
+            // A closure binding IS its callable node: same file, same line, same
+            // name. An aliasing local is not. So look the node up by position and
+            // admit only an exact hit.
+            const positionalKey = valueBindingPositionKey(def);
+            const positionalId = positionalKey === undefined ? undefined : callableByPosition.get(positionalKey);
+            // `''` marks an ambiguous position (two callables claiming one
+            // file/line/name) — undecidable, so admit neither.
+            if (positionalId === undefined || positionalId === '')
+                continue;
+            out.set(def.nodeId, { id: positionalId, def });
             continue;
+        }
         const anchorKey = definitionAnchorKey(def);
         const anchored = anchorKey === undefined ? undefined : byAnchor.get(anchorKey);
         const id = anchored?.length === 1 ? anchored[0] : resolveDefGraphId(def.filePath, def, nodeLookup);
+        if (id === undefined)
+            continue;
         // Overloads can intentionally share one graph node ID. Index by the
         // definition identity so contextual signature narrowing still sees the
         // complete overload set before a selected target collapses to graph ID.
-        if (id !== undefined)
-            out.set(def.nodeId, { id, def });
+        out.set(def.nodeId, { id, def });
     }
     return out;
 }
+/**
+ * Leading sigils are part of a name in some grammars and stripped in others:
+ * PHP keeps `$` on a variable_name node (deliberately — it is what separates
+ * PHP's variable and function namespaces, so `$save` does not collide with
+ * `save()`), while the scope layer and the callable-flow synthesizer both
+ * normalise it away. The positional join has to see both sides the same way.
+ */
+const withoutSigil = (name) => name.replace(/^[$@]+/, '');
+/**
+ * `file\0line\0name` for a value binding, matching the callable-node key built
+ * in `buildGraphCallableIndexes`. Definition lines come from the def id and are
+ * 1-based; graph `startLine` is 0-based, which is the `+ 1` there.
+ */
+function valueBindingPositionKey(def) {
+    if (!VALUE_BINDING_DEF_TYPES.has(def.type))
+        return undefined;
+    const line = definitionIdPosition(def.nodeId, def.filePath)?.line;
+    const name = simpleQualifiedName(def);
+    if (line === undefined || name === undefined)
+        return undefined;
+    return `${def.filePath}\0${line}\0${withoutSigil(name)}`;
+}
+/**
+ * Value-binding labels whose initializer can be a callable. Admitted ONLY on
+ * positional graph-node evidence (see `buildGraphTargetIndex`), never on the def
+ * type alone.
+ *
+ * Deliberately NOT `isOwnableValueLabel` (scope/walkers.ts), which lists the
+ * same labels for the value-receiver bridge: that predicate is contracted to
+ * `reconcileOwnership`, and coupling the two would let a label added for
+ * ownership silently widen call-target admission. Two lists, two reasons —
+ * changing either means checking the other.
+ *
+ * `Static` is excluded: `normalizeNodeLabel` (scope-extractor.ts) has no
+ * `static` case, so no scope-resolution def can carry that type. Including it
+ * added an entry no fixture could ever exercise.
+ */
+const VALUE_BINDING_DEF_TYPES = new Set([
+    'Const',
+    'Property',
+    'Variable',
+]);
 /**
  * Associate declaration-only callable nodes with their unique out-of-file
  * definition. Function scopes are the body/definition signal; prototypes do
@@ -626,8 +712,10 @@ function canonicalizeCallableDeclarations(rawTargets, rawIndexes, scopes, graph,
     };
 }
 function definitionPosition(def) {
-    const match = def.nodeId.match(/#(\d+):(\d+):/);
-    return match === null ? undefined : `${def.filePath}\0${match[1]}\0${match[2]}`;
+    const position = definitionIdPosition(def.nodeId, def.filePath);
+    return position === undefined
+        ? undefined
+        : `${def.filePath}\0${position.line}\0${position.column}`;
 }
 function declarationSignatureCompatible(declaration, definition, graph) {
     const left = declaration.def;
@@ -649,8 +737,9 @@ function declarationSignatureCompatible(declaration, definition, graph) {
     const definitionConst = graph.getNode(definition.id)?.properties.isConst;
     return typeof declarationConst !== 'boolean' || declarationConst === definitionConst;
 }
-function buildGraphCallableAnchorIndex(graph) {
-    const out = new Map();
+function buildGraphCallableIndexes(graph) {
+    const byAnchor = new Map();
+    const callableByPosition = new Map();
     for (const node of graph.iterNodes()) {
         if (node.label !== 'Function' && node.label !== 'Method' && node.label !== 'Constructor') {
             continue;
@@ -663,17 +752,23 @@ function buildGraphCallableAnchorIndex(graph) {
             typeof zeroBasedLine !== 'number') {
             continue;
         }
-        const key = `${filePath}\0${node.label}\0${zeroBasedLine + 1}\0${name}`;
-        const bucket = out.get(key);
+        const oneBasedLine = zeroBasedLine + 1;
+        const positionKey = `${filePath}\0${oneBasedLine}\0${withoutSigil(name)}`;
+        const existing = callableByPosition.get(positionKey);
+        // First wins would be order-dependent; mark the collision instead so an
+        // ambiguous position admits nothing rather than something arbitrary.
+        callableByPosition.set(positionKey, existing === undefined ? node.id : '');
+        const key = `${filePath}\0${node.label}\0${oneBasedLine}\0${name}`;
+        const bucket = byAnchor.get(key);
         if (bucket === undefined)
-            out.set(key, [node.id]);
+            byAnchor.set(key, [node.id]);
         else
             bucket.push(node.id);
     }
-    return out;
+    return { byAnchor, callableByPosition };
 }
 function definitionAnchorKey(def) {
-    const line = def.nodeId.match(/#(\d+):(\d+):/)?.[1];
+    const line = definitionIdPosition(def.nodeId, def.filePath)?.line;
     const name = simpleName(def.qualifiedName);
     if (line === undefined || name === undefined)
         return undefined;
@@ -987,8 +1082,8 @@ function dedupeDefinitions(defs) {
     return [...new Map(defs.map((def) => [def.nodeId, def])).values()];
 }
 function definitionStartsAt(def, line, column) {
-    const match = def.nodeId.match(/#(\d+):(\d+):/);
-    return match !== null && Number(match[1]) === line && Number(match[2]) === column;
+    const position = definitionIdPosition(def.nodeId, def.filePath);
+    return position !== undefined && position.line === line && position.column === column;
 }
 function expandMemberTargets(invoke, targets, scopes, graphTargets, targetIndexes, graph) {
     if (invoke.site.invocationKind !== 'member-pointer' || invoke.site.receiver === undefined) {

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

@@ -20,30 +20,132 @@
  * either don't trigger the call branch or skip this pass entirely.
  */
 import type { ScopeId, SymbolDefinition } from '../../../../_shared/index.js';
+import type { ElementAccessRoute, ScopeResolver } from '../contract/scope-resolver.js';
 import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
 import type { WorkspaceResolutionIndex } from '../workspace-index.js';
+import type { DecodedReceiverChain } from '../../utils/receiver-chain-codec.js';
+import type { DecorationStripper } from '../scope/walkers.js';
+/**
+ * Notified with the spelling a receiver position was typed from and the class
+ * it resolved to — see {@link noteReceiverType}. Pure side channel: this file
+ * never reads it back, and resolution is identical whether or not it is set.
+ */
+type ReceiverTypeRecorder = (spelling: string, defId: string) => void;
 interface ResolveCompoundReceiverOptions {
+    /**
+     * Optional sink for the DECLARED TYPE SPELLINGS this fold typed receiver
+     * positions from (#2912). The fold returns a class, and a class has lost the
+     * generic arguments that decide which implementations an interface-typed
+     * receiver can dispatch to; the caller keeps the last report whose def id
+     * matches the returned class and reads the arguments off that spelling.
+     */
+    readonly recordReceiverType?: ReceiverTypeRecorder;
     /** When true (default), if method lookup fails on the receiver's
      *  class, walk its fields and try the lookup on each field's class.
      *  Phase-9C "unified fixpoint" — Python-shaped heuristic. */
     readonly fieldFallback?: boolean;
-    /** Language-specific accessor unwrap — `data.Values` on a
-     *  Dictionary<K,V>-typed receiver yields V (C#), etc. Returns the
-     *  element type's simple name, or `undefined` to let the regular
-     *  field-walk handle the access. */
-    readonly unwrapCollectionAccessor?: (receiverType: string, accessor: string) => string | undefined;
+    /** Container -> element, by subscript (`repos[0]`) or accessor (`data.Values`
+     *  on a `Dictionary<K,V>` yields V). Returns the element type's simple name,
+     *  or `undefined`. See the `ScopeResolver` field of the same name for why the
+     *  two routes share one hook, and for why `undefined` on the `index` route
+     *  means "not a container" — a step that gets it DECLINES, so a language must
+     *  answer that route to get index folding at all. */
+    readonly elementTypeOf?: (containerType: string, via: ElementAccessRoute) => string | undefined;
     /** Walk up from the class scope to ancestor (Module) scopes when
      *  looking up a method's return-type typeBinding. Only enable for
      *  languages that hoist return-type bindings to Module scope (C#);
      *  otherwise we risk picking up unrelated module-level bindings. */
     readonly hoistTypeBindingsToModule?: boolean;
+    /** `ScopeResolver.resolveThisViaEnclosingClass` — the language declares that
+     *  `this` IS the enclosing class rather than a per-function-scope binding.
+     *  Read only by the `this` head seed below. */
+    readonly resolveThisViaEnclosingClass?: boolean;
     /** Strip C-style cast expressions from the receiver text before
      *  resolving it (`stripCastWrappers`). Default `false` — the text
      *  reaches the resolver untouched and no cast logic runs. See the
      *  `ScopeResolver` contract toggle of the same name for the
      *  classifier grammar and per-language opt-in rules. */
     readonly stripReceiverCastExpressions?: boolean;
+    /** Surface syntax this language uses to construct a value, so an
+     *  inline constructor receiver can be typed. Derived from the contract
+     *  rather than re-declared, so a future sub-field cannot be added there
+     *  and silently ignored here (#2708). */
+    readonly constructionSyntax?: ScopeResolver['constructionSyntax'];
+    /** Verified namespace handles visible in the current file. */
+    readonly namespaceTargets?: ReadonlyMap<string, readonly string[]>;
+    /** Compact receiver chain for THIS site (`ReferenceSite.receiverChain`), when
+     *  the language's capture emitter produced one. Present ⇒ the structural fold
+     *  is tried before the text cascade; absent ⇒ behaviour is exactly as before.
+     *  Consumed only at `depth === 0`: it describes the site's own receiver, so
+     *  carrying it into a recursive call would re-fold it against an inner
+     *  expression it does not describe. */
+    readonly receiverChain?: string;
+    /** Resolve a BARE identifier the way the dotted-chain head does: when a
+     *  receiver typeBinding exists for the name, that binding decides the type and
+     *  nothing else does. Off by default, so the text cascade keeps its existing
+     *  (more permissive) behaviour; the structural fold turns it ON.
+     *
+     *  Without it, the bare-identifier branch falls through to a plain class-name
+     *  lookup EVEN WHEN a binding existed but named no class — which types a local
+     *  that merely SHADOWS a class as that class. That fabricated a `CALLS` edge
+     *  (`const Config = make(1); Config.db.query()` emitted `entry → Database.query`),
+     *  the exact wrong-edge failure this work exists to avoid. */
+    readonly strictBaseBinding?: boolean;
+    /** Per-language type-preserving decoration stripper, from the `ScopeResolver`
+     *  contract. Passed to the class lookup at the base and step sites so a
+     *  decorated declared type (`*Host`) resolves to its class. Absent for
+     *  languages whose declared types carry no such decoration, and never applied
+     *  by the shared lookup's other callers — see the contract's own note on why
+     *  this is opt-in rather than global. */
+    readonly stripTypePreservingDecoration?: DecorationStripper;
+}
+/**
+ * Type a receiver from its decoded structure instead of from its source text.
+ *
+ * Resolves the base, then folds the steps base-first, each step typed against
+ * the class the previous step produced. Returns `undefined` the moment any step
+ * fails to type, so the caller falls back to the existing text cascade rather
+ * than receiving a partially-folded guess — a missing edge is recoverable, a
+ * confidently wrong one is not.
+ *
+ * The base is resolved by handing it to `resolveCompoundReceiverClass`, which
+ * already owns the bare-identifier path in full: type binding, static
+ * class-name receivers, map-tuple sentinels, member aliases and call-result
+ * aliases. A second implementation of that would drift from it.
+ *
+ * Called from `resolveCompoundReceiverClass` ahead of the text cascade, and only
+ * when the site carries a `receiverChain` (see the `depth === 0` gate below).
+ */
+export declare function foldReceiverChain(chain: DecodedReceiverChain, inScope: ScopeId, scopes: ScopeResolutionIndexes, index: WorkspaceResolutionIndex, options?: ResolveCompoundReceiverOptions): SymbolDefinition | undefined;
+/** A resolved compound receiver, together with the declared spelling that typed
+ *  the position it came from — see {@link resolveCompoundReceiverTyped}. */
+export interface TypedCompoundReceiver {
+    readonly def: SymbolDefinition;
+    /**
+     * The receiver's declared type AS WRITTEN (`IValidator<string>`), or
+     * `undefined` where the route that answered had no declared type to report — a
+     * construction expression, a namespace target, a static class receiver. The
+     * fan-out reads its generic arguments off this and restores the unfiltered
+     * behaviour when it is absent, so declining is always safe (#2912).
+     */
+    readonly declaredSpelling: string | undefined;
 }
+/**
+ * {@link resolveCompoundReceiverClass}, paired with the spelling that typed the
+ * position (#2912).
+ *
+ * The sink is created and read HERE, per call, which is the whole point: a
+ * recorder that outlives one resolution has to be reset by hand before every
+ * call, and the retry shapes in this pass make two calls in a row — a reset
+ * missed at one of them silently attributes the previous receiver's spelling to
+ * this one. A local cannot be forgotten.
+ *
+ * The def-id guard is the second half. Lookups that lost — an MRO walk that
+ * moved on, a fold step later folded past — report too, so a report counts only
+ * when it names the class actually returned. `foldReceiverChain` reports its
+ * final state last for exactly this reason, so the structural route wins.
+ */
+export declare function resolveCompoundReceiverTyped(receiverText: string, inScope: ScopeId, scopes: ScopeResolutionIndexes, index: WorkspaceResolutionIndex, options?: ResolveCompoundReceiverOptions): TypedCompoundReceiver | undefined;
 export declare function resolveCompoundReceiverClass(receiverText: string, inScope: ScopeId, scopes: ScopeResolutionIndexes, index: WorkspaceResolutionIndex, options?: ResolveCompoundReceiverOptions, depth?: number): SymbolDefinition | undefined;
 /**
  * Peel C-style cast layers off a receiver-position expression: