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

package/dist/core/ingestion/scope-resolution/pipeline/phase.js

@@ -34,6 +34,7 @@ import { isDev, isSemanticModelValidatorEnabled } from '../../utils/env.js';
 import { logHeapProbe } from '../../utils/heap-probe.js';
 import { clearParsedFileStore, loadParsedFilesForPaths, forceGc, } from '../../../../storage/parsedfile-store.js';
 import { buildFunctionNodeIndex } from '../../taint/summary-harvest-driver.js';
+import { buildPropertyNameIndex } from '../passes/unique-name-properties.js';
 import { PdgEmitSink } from '../../../lbug/pdg-emit-sink.js';
 import { resolveNativeSafeStorageDir } from '../../../lbug/lbug-config.js';
 import { logger } from '../../../logger.js';
@@ -43,10 +44,23 @@ const NOOP_OUTPUT = Object.freeze({
     importsEmitted: 0,
     referenceEdgesEmitted: 0,
     resolutionOutcomes: [],
+    // Deliberately absent, not `[]`: nothing ran, so nothing was decided either.
     perLanguage: new Map(),
     functionSummaries: [],
     callSummaries: [],
+    propertyInference: { ambiguous: 0, ambiguousNames: [], crossLanguage: 0, crossLanguageNames: [] },
 });
+/** Select source files that must be materialized for one resolver pass. */
+export function selectScopeSourcePathsToRead(provider, primaryFilePaths, preExtractedByPath) {
+    const hasPostExtractHooks = provider.populateWorkspaceOwners !== undefined ||
+        provider.populateNamespaceSiblings !== undefined ||
+        provider.populateRangeBindings !== undefined ||
+        provider.emitPostResolutionEdges !== undefined;
+    const needsAllSourceText = hasPostExtractHooks && provider.postExtractSourceTextPolicy !== 'uncached-files';
+    return needsAllSourceText
+        ? [...primaryFilePaths]
+        : primaryFilePaths.filter((filePath) => !preExtractedByPath.has(filePath));
+}
 export const scopeResolutionPhase = {
     name: 'scopeResolution',
     // Depends on `parse` because emit-references attaches edges to
@@ -89,11 +103,10 @@ export const scopeResolutionPhase = {
         // runs use the in-heap `workerParsedFiles` above or fall back to a fresh
         // extract per file inside runScopeResolution.
         const parsedFileStorePath = ctx.options?.parseCache?.storagePath;
-        // Drop pre-extracted entries for standalone providers — these
-        // languages are skipped by the canonical guard below (line 164)
-        // and never consume preExtractedByPath, so holding onto their
-        // entries leaks memory until the cleanup loop at 262-264 which
-        // also never runs for skipped providers.
+        // Standalone providers are re-extracted from source on the main thread;
+        // workers intentionally do not serialize ParsedFile artifacts for them.
+        // Drop any stale/cache-sourced entry defensively so provider-owned regex
+        // capture logic is always the source of truth for the current content.
         for (const [path] of preExtractedByPath) {
             const lang = getLanguageFromFilename(path);
             if (lang === null)
@@ -108,6 +121,7 @@ export const scopeResolutionPhase = {
         let totalRefs = 0;
         let anyRan = false;
         const resolutionOutcomes = [];
+        const undecidedSatisfaction = [];
         // M4 (#2084 U1): per-function taint summaries accumulated across every
         // language pass; the cross-function fixpoint phase reads this output.
         const functionSummaries = [];
@@ -132,16 +146,13 @@ export const scopeResolutionPhase = {
             const fileLang = getLanguageFromFilename(f.path);
             if (fileLang === null)
                 continue;
-            // Skip files whose grammar isn't available (optional grammars like
-            // swift/dart/kotlin on an install where the binding is absent or the
-            // user set GITNEXUS_SKIP_OPTIONAL_GRAMMARS). The parse phase already
-            // excluded and warned about these (parse-impl.ts); without this guard the
-            // file would fall through to the main-thread re-extract in run.ts and
-            // throw "Unsupported language" (caught, but noisy, and it needlessly
-            // loads the grammar on the main thread). `isLanguageAvailable` is
-            // memoized, so this stays O(1) per language. (#2091, #2093)
-            if (!isLanguageAvailable(fileLang))
+            // Tree-sitter providers require an available grammar. Standalone regex
+            // providers deliberately have none and re-extract on the main thread.
+            const resolver = SCOPE_RESOLVERS.get(fileLang);
+            if (resolver?.languageProvider.parseStrategy !== 'standalone' &&
+                !isLanguageAvailable(fileLang)) {
                 continue;
+            }
             let bucket = filesByLang.get(fileLang);
             if (bucket === undefined) {
                 bucket = [];
@@ -185,6 +196,13 @@ export const scopeResolutionPhase = {
         const sharedFnNodeIndex = ctx.options?.pdg === true && totalScopeFiles > 0
             ? buildFunctionNodeIndex(ctx.graph)
             : undefined;
+        // Same treatment for the `Property`-by-name index the unique-name pass
+        // consults: a whole-graph node scan, language-agnostic, and previously
+        // rebuilt inside every qualifying language pass. Language filtering happens
+        // at LOOKUP time against that language's own file set, so one shared index
+        // serves all of them without widening what any single language can resolve
+        // to.
+        const sharedPropertyNameIndex = totalScopeFiles > 0 ? buildPropertyNameIndex(ctx.graph) : undefined;
         // Streaming/chunked PDG emit (#2202): when enabled (the caller has already
         // gated this to full-rebuild + `--pdg`), route the BasicBlock + intra-file
         // PDG-edge layer to CSV-on-disk through one sink shared across every
@@ -216,18 +234,15 @@ export const scopeResolutionPhase = {
         // finalize/propagate/a provider hook) must still release the sink's file
         // descriptors. finalize() runs on the success path; the finally closes the
         // sink only when finalize did not (idempotent via the sink's `finalized`).
+        // R3-1 accumulators — see the warning after the language loop.
+        let crossLanguagePropertyReads = 0;
+        const crossLanguageAnchorsByName = new Map();
+        let ambiguousPropertyReads = 0;
+        const ambiguousPropertyNames = new Set();
         let pdgEmitManifest;
         let pdgSinkSettled = false;
         try {
             for (const [lang, provider] of SCOPE_RESOLVERS) {
-                // Standalone providers (COBOL, JCL) don't emit graph edges yet
-                // through the scope-resolution path. This is the canonical guard:
-                // runScopeResolution is never called for standalone providers, which
-                // keeps cobolPhase as the sole IMPORTS edge producer. Keep this guard
-                // in sync with any additional standalone providers added to
-                // SCOPE_RESOLVERS.
-                if (provider.languageProvider.parseStrategy === 'standalone')
-                    continue;
                 const primaryLangFiles = filesByLang.get(lang) ?? [];
                 if (primaryLangFiles.length === 0)
                     continue;
@@ -262,16 +277,6 @@ export const scopeResolutionPhase = {
                     for (const [fp, pf] of fromDisk)
                         preExtractedByPath.set(fp, pf);
                 };
-                // A provider that feeds source text into a post-extract hook
-                // (populateWorkspaceOwners / populateNamespaceSiblings /
-                // populateRangeBindings / emitPostResolutionEdges) needs content for ALL
-                // its files; one without those hooks only needs content for files the
-                // store does NOT cover (fresh-extract fallback). Keep this in sync with
-                // the getFileContents() call-sites in run.ts.
-                const providerNeedsAllContent = provider.populateWorkspaceOwners !== undefined ||
-                    provider.populateNamespaceSiblings !== undefined ||
-                    provider.populateRangeBindings !== undefined ||
-                    provider.emitPostResolutionEdges !== undefined;
                 let scopeFilePaths;
                 let contents;
                 if (provider.collectScopeContextPaths !== undefined) {
@@ -294,9 +299,7 @@ export const scopeResolutionPhase = {
                 else {
                     scopeFilePaths = new Set(primaryFilePaths);
                     await loadStoreFor(scopeFilePaths);
-                    const pathsToRead = providerNeedsAllContent
-                        ? primaryFilePaths
-                        : primaryFilePaths.filter((p) => !preExtractedByPath.has(p));
+                    const pathsToRead = selectScopeSourcePathsToRead(provider, primaryFilePaths, preExtractedByPath);
                     contents = await readFileContents(ctx.repoPath, pathsToRead);
                 }
                 const filePaths = [...scopeFilePaths];
@@ -308,9 +311,9 @@ export const scopeResolutionPhase = {
                     }
                     else if (preExtractedByPath.has(fp)) {
                         // Store covers extraction for this file and we deliberately skipped
-                        // reading its source; the empty string is never consumed (the
-                        // extract loop uses the pre-extracted ParsedFile and this provider
-                        // has no content hook).
+                        // reading its source; extraction uses the pre-extracted ParsedFile,
+                        // and the provider's source-text policy guarantees its hooks can
+                        // tolerate empty content for cached files.
                         files.push({ path: fp, content: '' });
                     }
                     // else: uncovered AND unreadable → skip (unchanged from prior behavior).
@@ -335,6 +338,7 @@ export const scopeResolutionPhase = {
                     files,
                     resolutionConfig,
                     prebuiltNodeLookup: sharedNodeLookup,
+                    prebuiltPropertyNameIndex: sharedPropertyNameIndex,
                     prebuiltFunctionNodeIndex: sharedFnNodeIndex,
                     preExtractedParsedFiles: preExtractedByPath,
                     scopeIndexStorePath: parsedFileStorePath,
@@ -419,6 +423,7 @@ export const scopeResolutionPhase = {
                 processedScopeFiles += langFileCount;
                 anyRan = true;
                 functionSummaries.push(...stats.functionSummaries);
+                undecidedSatisfaction.push(...stats.undecidedSatisfaction);
                 callSummaries.push(...stats.callSummaries);
                 totalFiles += stats.filesProcessed;
                 totalImports += stats.importsEmitted;
@@ -431,6 +436,35 @@ export const scopeResolutionPhase = {
                 if (isDev) {
                     logger.info(`[scope-resolution:${lang}] ${stats.filesProcessed} files → ${stats.importsEmitted} IMPORTS + ${stats.referenceEdgesEmitted} reference edges (${stats.resolve.unresolved} unresolved sites, ${stats.referenceSkipped} skipped)`);
                 }
+                // R3-1. Accumulated across languages and reported once below, NOT gated
+                // on isDev: a field whose only definition lives in another language
+                // answers an empty ACCESSES query that is byte-identical to "unused",
+                // and that is the confident-empty failure this whole series removes.
+                ambiguousPropertyReads += stats.uniqueNamePropertyAmbiguous;
+                for (const n of stats.uniqueNamePropertyAmbiguousNames)
+                    ambiguousPropertyNames.add(n);
+                crossLanguagePropertyReads += stats.uniqueNamePropertyCrossLanguage;
+                for (const entry of stats.uniqueNamePropertyCrossLanguageNames) {
+                    const existing = crossLanguageAnchorsByName.get(entry.name);
+                    if (existing === undefined) {
+                        crossLanguageAnchorsByName.set(entry.name, new Set(entry.languages));
+                    }
+                    else {
+                        for (const l of entry.languages)
+                            existing.add(l);
+                    }
+                }
+            }
+            if (crossLanguagePropertyReads > 0) {
+                const sample = Array.from(crossLanguageAnchorsByName)
+                    .slice(0, 10)
+                    .map(([name, langs]) => `${name} (${Array.from(langs).sort().join('/')})`)
+                    .join(', ');
+                logger.warn(`[scope-resolution] ${crossLanguagePropertyReads} property read/write site(s) name a field ` +
+                    `that IS defined in this workspace, but only in another language, so per-language inference ` +
+                    `declined to link them. Queries for these fields return an empty result that does NOT mean ` +
+                    `"unused" — it means the definition anchor is in a different language. ` +
+                    `Affected: ${sample}${crossLanguageAnchorsByName.size > 10 ? ', …' : ''}`);
             }
             // Finalize the streaming PDG sink (#2202) once after the last language:
             // flush + close its CSV writers and capture the COPY manifest. forceGc at
@@ -477,10 +511,20 @@ export const scopeResolutionPhase = {
             importsEmitted: totalImports,
             referenceEdgesEmitted: totalRefs,
             resolutionOutcomes,
+            undecidedSatisfaction,
             perLanguage,
             functionSummaries,
             callSummaries,
             pdgEmitManifest,
+            propertyInference: {
+                ambiguous: ambiguousPropertyReads,
+                ambiguousNames: Array.from(ambiguousPropertyNames).sort().slice(0, 25),
+                crossLanguage: crossLanguagePropertyReads,
+                crossLanguageNames: Array.from(crossLanguageAnchorsByName)
+                    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+                    .slice(0, 25)
+                    .map(([name, languages]) => ({ name, languages: Array.from(languages).sort() })),
+            },
         };
     },
 };

package/dist/core/ingestion/scope-resolution/pipeline/run.d.ts

@@ -30,7 +30,8 @@ import { buildGraphNodeLookup } from '../graph-bridge/node-lookup.js';
 import { type FunctionNodeIndex } from '../../taint/summary-harvest-driver.js';
 import type { FunctionSummary } from '../../taint/summary-model.js';
 import type { CallSummary } from '../../taint/call-summary-model.js';
-import type { ScopeResolver } from '../contract/scope-resolver.js';
+import { type PropertyNameIndex } from '../passes/unique-name-properties.js';
+import type { ScopeResolver, UndecidedSatisfaction } from '../contract/scope-resolver.js';
 import type { ResolutionOutcome, ResolutionOutcomeRecorder } from '../resolution-outcome.js';
 export type ScopeResolutionSubPhase = 'extracting' | 'analyzing types' | 'resolving references' | 'linking symbols';
 interface RunScopeResolutionInput {
@@ -129,6 +130,14 @@ interface RunScopeResolutionInput {
      * (tests / isolated calls) it is built locally for the pdg-enabled language.
      */
     readonly prebuiltFunctionNodeIndex?: FunctionNodeIndex;
+    /**
+     * `Property`-by-name index built ONCE by the caller and shared across every
+     * language pass. Like the two above it is a whole-graph scan and is
+     * language-agnostic; the per-language restriction is applied at lookup time
+     * against that language's own file set, so sharing the index does not widen
+     * what any single language can resolve to. Built locally when omitted.
+     */
+    readonly prebuiltPropertyNameIndex?: PropertyNameIndex;
     /**
      * Opaque per-language import-resolution config (e.g. tsconfig path
      * aliases for TypeScript). Loaded once by the caller via
@@ -185,7 +194,58 @@ interface RunScopeResolutionStats {
     readonly resolve: ResolveStats;
     readonly referenceEdgesEmitted: number;
     readonly referenceSkipped: number;
+    /**
+     * Property-dispatch keys dropped for exceeding the fan-out cap. Non-zero
+     * means member calls through those keys got NO synthesized CALLS — the
+     * #2437 false-safe gap for exactly those keys (names are in the warn log).
+     */
+    readonly propertyDispatchSkippedKeys: number;
+    /** Cross-file value references resolved through finalized import bindings. */
+    readonly importedValueRefEdges: number;
+    /**
+     * ACCESSES edges recovered by property NAME (A1/A5) — the last-resort pass
+     * for receivers no precise pass could type.
+     */
+    readonly uniqueNamePropertyEdges: number;
+    /**
+     * Read/write sites left unresolved because two or more `Property` defs share
+     * the name, so a unique-name match would have been a coin flip. This is the
+     * population a receiver-typing improvement would convert into precise edges.
+     */
+    readonly uniqueNamePropertyAmbiguous: number;
+    /**
+     * Of `uniqueNamePropertyEdges`, how many the name carried several definitions
+     * for and same-file or direct-import evidence narrowed to one. Strict
+     * workspace uniqueness refused every one of these (R2).
+     */
+    readonly uniqueNamePropertyNarrowed: number;
+    /**
+     * The distinct field names behind `uniqueNamePropertyAmbiguous`, capped. A
+     * count says a coverage gap exists; the names say WHICH fields are
+     * unanswerable, so the gap is actionable rather than merely measured.
+     */
+    readonly uniqueNamePropertyAmbiguousNames: readonly string[];
+    /**
+     * Read/write sites whose name IS defined in the workspace but only in another
+     * LANGUAGE, so per-language inference declined. Separate from
+     * `uniqueNamePropertyAmbiguous` because the remedy differs: ambiguity wants
+     * better receiver typing, this wants an anchor in the reading language (R3-1).
+     */
+    readonly uniqueNamePropertyCrossLanguage: number;
+    /** Those names with the languages their definitions actually live in. */
+    readonly uniqueNamePropertyCrossLanguageNames: readonly {
+        readonly name: string;
+        readonly languages: string[];
+    }[];
     readonly resolutionOutcomes: readonly ResolutionOutcome[];
+    /**
+     * Interfaces whose structural-satisfaction check could not be completed for
+     * at least one candidate type (#2873). NOT the same as "no implementors" —
+     * these are questions the analyzer could not answer, and they are reported so
+     * `impact` can hedge a zero instead of asserting one. Empty for every
+     * language whose resolver has no `detectInterfaceImplementations` hook.
+     */
+    readonly undecidedSatisfaction: readonly UndecidedSatisfaction[];
     /**
      * Per-function taint summaries harvested in the pdg window (#2084 M4 U1).
      * Empty unless `input.pdg === true` and the language has a registered taint