gitnexus 1.6.10-rc.21 → 1.6.10-rc.211

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

@@ -19,11 +19,41 @@
  */
 import { resolveCallerGraphId, resolveDefGraphId } from '../graph-bridge/ids.js';
 import { mapReferenceKindToEdgeType } from '../graph-bridge/edges.js';
+import { isValueDefinitionLabel } from '../../utils/ast-helpers.js';
+/**
+ * Value labels whose defs MAY be function-local. A reference to one of these is
+ * dropped only when the def is positively identified as living inside a function
+ * body — see `functionLocalValueDefIds`. Everything else, including a class
+ * member in a language that keeps no values at module scope, is emitted.
+ */
 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) {
+calleeIdSink, 
+/**
+ * Def ids of value symbols bound inside a FUNCTION body. When supplied, a
+ * read/write whose target is a `Const`/`Variable`/`Static` in this set emits
+ * no edge.
+ *
+ * Bare-identifier reads (A2) made module-scope constants answerable, but the
+ * same capture also matches a read of a BLOCK-LOCAL `const`. An edge to one
+ * of those keeps alive precisely the inert local symbols `pruneLocalSymbols`
+ * exists to drop — turning a pruned node into a retained node plus an edge,
+ * in every function of every indexed repo. "Who uses this constant?" is a
+ * question about a module's surface; a local's uses are the three lines
+ * around it.
+ *
+ * A BLOCKLIST, not an allowlist, and the direction is the point. Asking
+ * "is this def module-level?" silently excludes class members — Java/C#
+ * fields, Python class attributes — which are neither module-level nor local.
+ * Asking "is this def function-local?" excludes only what it can positively
+ * identify, so an unrecognised or uninspected def is emitted. A stray inert
+ * local is recoverable; a deleted edge class reads as "nothing uses this".
+ *
+ * Optional so callers that never capture bare identifiers are unchanged.
+ */
+functionLocalValueDefIds) {
     let emitted = 0;
     let skipped = 0;
     const seen = new Set();
@@ -58,12 +88,25 @@ calleeIdSink) {
                 skipped++;
                 continue;
             }
+            // Function-local value reference — see `functionLocalValueDefIds`.
+            if (functionLocalValueDefIds !== undefined &&
+                edgeType === 'ACCESSES' &&
+                isValueDefinitionLabel(targetDef.type) &&
+                functionLocalValueDefIds.has(targetDef.nodeId)) {
+                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`
+            // CALLS from real call sites feeds the bridge; ACCESSES/USES/EXTENDS are
+            // skipped, and so are value-ref CALLS (#2437) — a property-value
+            // reference is not a call site U1 could have stamped. `fromFilePath`
             // is the call-site (caller) file — the same file U1 stamps the site on.
-            if (calleeIdSink !== undefined && edgeType === 'CALLS' && fromFilePath !== undefined) {
+            if (calleeIdSink !== undefined &&
+                edgeType === 'CALLS' &&
+                ref.kind === 'call' &&
+                fromFilePath !== undefined) {
                 calleeIdSink.add(fromFilePath, ref.atRange.startLine, ref.atRange.startCol, targetGraphId);
             }
             const dedupKey = `${edgeType}:${callerGraphId}->${targetGraphId}:${ref.atRange.startLine}:${ref.atRange.startCol}`;

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

@@ -0,0 +1,64 @@
+/**
+ * Flow-insensitive, inclusion-based resolution for calls through callable
+ * values. Providers own syntax recognition; this pass consumes only the
+ * JSON-safe facts carried by ParsedFile.
+ */
+import type { ParsedFile, SymbolDefinition } from '../../../../_shared/index.js';
+import type { KnowledgeGraph } from '../../../graph/types.js';
+import type { ScopeResolutionIndexes } from '../../model/scope-resolution-indexes.js';
+import type { GraphNodeLookup } from '../graph-bridge/node-lookup.js';
+import type { CalleeIdAccumulator } from '../graph-bridge/callee-id-sink.js';
+/**
+ * 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 declare const MAX_CALLABLE_VALUE_TARGETS: number;
+interface Target {
+    readonly id: string;
+    readonly def: SymbolDefinition;
+}
+export interface CallableValueFlowWarning {
+    readonly language: string;
+    readonly context: string;
+    readonly candidateCount: number;
+    readonly cap: number;
+}
+export interface CallableValueFlowResult {
+    readonly emitted: number;
+    readonly resolvedInvokes: number;
+    readonly ambiguousInvokes: number;
+    readonly unmatchedInvokes: number;
+    readonly iterations: number;
+}
+export interface EmitCallableValueFlowInput {
+    readonly graph: KnowledgeGraph;
+    readonly scopes: ScopeResolutionIndexes;
+    readonly parsedFiles: readonly ParsedFile[];
+    readonly nodeLookup: GraphNodeLookup;
+    readonly calleeIds: CalleeIdAccumulator;
+    readonly language: string;
+    readonly collapseByCallerTarget?: boolean;
+    readonly isCallableValueTarget?: (def: SymbolDefinition) => boolean;
+    readonly hasFileLocalCallableLinkage?: (def: SymbolDefinition) => boolean;
+    readonly onWarn?: (warning: CallableValueFlowWarning) => void;
+}
+/** Position key shared with the existing free/reference skip-set contract. */
+export declare function callableFlowSiteKey(filePath: string, range: {
+    readonly startLine: number;
+    readonly startCol: number;
+}): string;
+/**
+ * Return only invoke sites that join to a canonical call ReferenceSite.
+ * Malformed/stale facts never suppress ordinary resolution.
+ */
+export declare function collectDeferredIndirectSites(parsedFiles: readonly ParsedFile[], scopes?: ScopeResolutionIndexes): ReadonlySet<string>;
+export declare function emitCallableValueFlow(input: EmitCallableValueFlowInput): CallableValueFlowResult;
+/**
+ * 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 declare function buildGraphTargetIndex(scopes: ScopeResolutionIndexes, nodeLookup: GraphNodeLookup, providerTarget: ((def: SymbolDefinition) => boolean) | undefined, graph: KnowledgeGraph): ReadonlyMap<string, Target>;
+export {};