@lzehrung/codegraph 3.0.1 → 3.1.0

package/dist/indexer/build-index.js

@@ -11,7 +11,11 @@ import { DEFAULT_PROJECT_PATTERNS, createProjectDiscoveryContext, discoverProjec
 import { getGitHead, isGitRepo, getGitBlobHashes, listChangedFiles } from "../util/git.js";
 import { clearResolutionCaches, loadNearestTsconfigFor, resolveSpecifier, } from "../util/resolution.js";
 import { collectCppDeclaredModules, isCppNamedModuleSpecifier } from "../util/resolution/cpp.js";
-import { resolveJvmPackageImportPaths } from "../util/resolution/jvm.js";
+import { collectCsharpNamespaceFacts } from "../util/csharp-tree.js";
+import { collectJvmFileFacts } from "../util/jvm-tree.js";
+import { isJvmLanguage, readsSyntaxTree } from "../util/syntax-tree.js";
+import { primeCsharpNamespaceFacts } from "../util/resolution/csharp.js";
+import { primeJvmFileFacts, resolveJvmPackageImportPaths } from "../util/resolution/jvm.js";
 import { loadTsconfigResolutionInputsFor } from "../util/resolution/tsconfig.js";
 import { resolveModuleSpecifierEdges } from "../graphs/edge-resolution.js";
 import { fileIdentityKey, initializeFileIdentityCaseSensitivity, isFilePathWithinRoot, normalizePath, } from "../util/paths.js";
@@ -30,7 +34,7 @@ import { collectLocalsAndExportsFromSource } from "./locals-and-exports.js";
 import { expandStarImports } from "./expand-star-imports.js";
 import { compareEdges, edgeKey, toRelativeEdge } from "./shared.js";
 import { BloomFilter, buildBloomFilterFromSource } from "../util/bloom-filter.js";
-import { initNativeBackendReport } from "../native/native-backend-report.js";
+import { initNativeBackendReport, recordParserBackendDegradation } from "../native/native-backend-report.js";
 import { closeDuplicateUnitCacheDatabase } from "../duplicates.js";
 import { assertNativeRequiredAvailable, isNativeRequiredUnavailableError } from "../native/tree-sitter-native.js";
 import { isNodeSqliteUnavailableError } from "../sqlite-driver.js";
@@ -39,57 +43,80 @@ import { computeResolverEnvironmentFingerprint } from "./build-cache/resolver-en
 import { cacheRoot } from "./build-cache/location.js";
 import { SymbolKind, } from "./types.js";
 import { isUnsupportedParserInputError } from "../languages/file-prep.js";
+import { isSqlFilePath } from "../sql/classify-sql-file.js";
 import { buildSqlFactCache, buildSqlModuleIndex, sqlCorpusSignature } from "../sql/source-graph.js";
 import { finalizeProjectIndex } from "./finalize.js";
 import { toManifestFileEntry, writeIndexManifestSnapshot } from "./build-manifest.js";
-import { prepareFileContextForBuild, countNativeWorkerEligibleFiles, emptyWorkerPoolSetup, setupWorkerPool, teardownWorkerPool, } from "./build-workers.js";
+import { prepareFileContextForBuild, countNativeWorkerEligibleFiles, emptyWorkerPoolSetup, preparedNativeOutcome, setupWorkerPool, teardownWorkerPool, } from "./build-workers.js";
 import { buildIncrementalGitDiffOptions, canUseIncrementalDiscoveryFastPath, buildTrackedFileReverseDependencies, addedResolutionStems, collectDeletedTrackedFileDependents, collectTrackedFileDependents, collectSpecifierEdgeCandidates, collectPythonPackageImporters, pythonImportersOfPackageInits, externalSpecifierMatchesAddedStem, tsconfigAliasMappedTails, isMissingGitRevisionError, listUntrackedProjectFiles, partitionTrackedManifestFiles, probePathExistence, } from "./incremental-plan.js";
 import { parsedCacheMaxEntries, setParsedCacheEntry } from "./parsed-cache.js";
-function initParserBackendDegradationReport(report) {
-    if (!report)
-        return undefined;
-    initNativeBackendReport(report);
-    report.backend ??= {
-        native: {
-            available: false,
-            enabled: false,
-            supportedLanguageIds: [],
-            filesUsed: 0,
-            filesFellBack: 0,
-            fallbackReasons: {
-                unavailable: 0,
-                unsupportedLanguage: 0,
-                queryFailure: 0,
-                sourceTooLarge: 0,
-            },
-            byLanguage: {},
-            errors: [],
-        },
-    };
-    report.backend.parser ??= {
-        total: 0,
-        byLanguage: {},
-        files: [],
-    };
-    return report.backend.parser;
-}
-function recordParserBackendDegradation(report, entry) {
-    const parserReport = initParserBackendDegradationReport(report);
-    if (!parserReport)
-        return;
-    parserReport.total += 1;
-    parserReport.byLanguage[entry.languageId] = (parserReport.byLanguage[entry.languageId] ?? 0) + 1;
-    if (parserReport.files.length >= 20)
-        return;
-    parserReport.files.push(entry);
-}
 function isConfinedFileReadError(error) {
     return (error instanceof Error &&
         /outside project root|possible path confinement race|changed between verification and open|confined file target/u.test(error.message));
 }
+/** A placeholder module. `parseErrorRanges` stays unset: no parser ran, so its parse state is unknown. */
 function createEmptyModuleIndex(file) {
     return { file, exports: [], imports: [], locals: [] };
 }
+/** A file with no language support: nothing is parsed, so it has no parse errors. */
+function unparsedModuleIndex(file) {
+    return { ...createEmptyModuleIndex(file), parseErrorRanges: [] };
+}
+/**
+ * A file whose processing failed. Its symbols are missing from the index, so it is flagged as parser-degraded: the flag
+ * keeps the analysis summary incomplete, and marks a module that is never written to the module cache, so the project
+ * snapshot embeds it instead of leaving its stale disk row to be restored.
+ */
+function failedModuleIndex(file) {
+    return { ...createEmptyModuleIndex(file), parserDegraded: true };
+}
+function collectParseErrorRanges(tree) {
+    const columns = tree.columns;
+    const isParseErrorNode = (nodeId) => {
+        const kind = columns.kinds[columns.kindIds[nodeId]];
+        return kind === "ERROR" || columns.isMissing[nodeId] !== 0;
+    };
+    const ranges = [];
+    for (let nodeId = 0; nodeId < columns.nodeCount; nodeId += 1) {
+        if (!isParseErrorNode(nodeId))
+            continue;
+        let parentId = columns.parentIds[nodeId];
+        let hasErrorAncestor = false;
+        while (parentId >= 0) {
+            if (isParseErrorNode(parentId)) {
+                hasErrorAncestor = true;
+                break;
+            }
+            parentId = columns.parentIds[parentId];
+        }
+        if (hasErrorAncestor)
+            continue;
+        // MISSING nodes are zero-width; prefer a containing statement/declaration, then the nearest non-empty ancestor.
+        let rangeNodeId = nodeId;
+        if (columns.isMissing[nodeId] !== 0) {
+            let ancestorId = columns.parentIds[nodeId];
+            let nearestNonZeroAncestorId = -1;
+            while (ancestorId >= 0) {
+                if (columns.startIndex[ancestorId] !== columns.endIndex[ancestorId]) {
+                    if (nearestNonZeroAncestorId < 0)
+                        nearestNonZeroAncestorId = ancestorId;
+                    const kind = columns.kinds[columns.kindIds[ancestorId]];
+                    if (kind === "statement" || kind.endsWith("_statement") || kind.endsWith("_declaration")) {
+                        rangeNodeId = ancestorId;
+                        break;
+                    }
+                }
+                ancestorId = columns.parentIds[ancestorId];
+            }
+            if (rangeNodeId === nodeId && nearestNonZeroAncestorId >= 0)
+                rangeNodeId = nearestNonZeroAncestorId;
+        }
+        const startIndex = tree.stringIndexForByte(columns.startIndex[rangeNodeId]);
+        const endIndex = tree.stringIndexForByte(columns.endIndex[rangeNodeId]);
+        ranges.push({ startIndex, endIndex });
+    }
+    return ranges;
+}
 /**
  * Declared-container index (container name to declaring files) rebuilt from already-loaded
  * modules. Because `ModuleIndex.declaredContainers` is cached with the module, this reflects
@@ -216,6 +243,17 @@ function sortedDeclaredContainerIndex(byName) {
 function cachedModuleHasExternalImport(mod) {
     return mod.imports.some((binding) => typeof binding.resolved !== "string");
 }
+/**
+ * Gives the C# namespace scan and the JVM package scan the facts a reused module holds, so they parse nothing for
+ * that file. They come from the file's own tree and depend on no other file, so the module's matching signature
+ * keeps them valid.
+ */
+function primeReusedFileFacts(file, mod, opts) {
+    if (mod.csharpNamespaceFacts)
+        primeCsharpNamespaceFacts(file, mod.csharpNamespaceFacts, opts?.languageExtensions);
+    if (mod.jvmFacts)
+        primeJvmFileFacts(file, mod.jvmFacts);
+}
 /**
  * Declaration-language files that have a cached row, are not in the build, and no longer exist.
  * A deleted file leaves no cache miss, so importers that it satisfied would stay stale.
@@ -288,6 +326,16 @@ async function buildIndexedModuleForFile(args) {
     const prepared = await prepareFileContextForBuild(args.file, args.support, args.opts, args.workerSetup, args.report, args.confinedRoot, args.projectRoot, args.trustedSource, !!args.bloomFilterCache);
     const { source, sup, nativeQueries, embeddedBlocks } = prepared;
     let tree;
+    // Every degradation recorded below also marks the module, including a failed import extraction of the file's source
+    // or of one of its embedded blocks. A later build that reuses the module from a cache has no report of this one, and
+    // still counts the file.
+    let parserDegraded = false;
+    // Set when a lookup over other files, not this file's own extraction, left part of its imports unresolved.
+    let importLookupIncomplete = false;
+    const recordTreeUnavailable = (entry) => {
+        parserDegraded = true;
+        recordParserBackendDegradation(args.report, entry);
+    };
     const graphOnlyLanguage = isGraphOnlyLanguage(sup.id), nativeSourceLimitSkip = prepared.nativeFallbackReason === "sourceTooLarge";
     if (prepared.syntaxTree) {
         const parsedTree = new ProjectedSyntaxTree(source, prepared.syntaxTree);
@@ -308,7 +356,7 @@ async function buildIndexedModuleForFile(args) {
             setParsedCacheEntry(args.parsedMap, args.file, parsed, args.parsedCacheMaxEntries);
         }
         else {
-            recordParserBackendDegradation(args.report, {
+            recordTreeUnavailable({
                 file: args.file,
                 languageId: prepared.sup.id,
                 ...(parseAttempt.nativeFallbackReason ? { nativeFallbackReason: parseAttempt.nativeFallbackReason } : {}),
@@ -325,7 +373,28 @@ async function buildIndexedModuleForFile(args) {
             tree = parsed.tree;
             setParsedCacheEntry(args.parsedMap, args.file, parsed, args.parsedCacheMaxEntries);
         }
+        else {
+            recordTreeUnavailable({
+                file: args.file,
+                languageId: sup.id,
+                ...(parseAttempt.nativeFallbackReason ? { nativeFallbackReason: parseAttempt.nativeFallbackReason } : {}),
+                ...(parseAttempt.nativeError ? { nativeError: parseAttempt.nativeError } : {}),
+            });
+        }
+    }
+    if (sup.id === "sql" && !tree) {
+        recordTreeUnavailable({
+            file: args.file,
+            languageId: sup.id,
+            ...(prepared.nativeFallbackReason ? { nativeFallbackReason: prepared.nativeFallbackReason } : {}),
+            ...(prepared.nativeError ? { nativeError: prepared.nativeError } : {}),
+        });
     }
+    // The package scan reads this file's facts when its own imports resolve, so they are known before then.
+    const jvmLanguageId = isJvmLanguage(sup.id) ? sup.id : undefined;
+    const jvmFacts = jvmLanguageId && tree ? collectJvmFileFacts(tree, jvmLanguageId) : undefined;
+    if (jvmFacts)
+        primeJvmFileFacts(args.file, jvmFacts);
     const lacksParserContext = !graphOnlyLanguage && !nativeQueries;
     if (args.bloomFilterCache && !nativeSourceLimitSkip) {
         const filter = prepared.workerBloomFilter
@@ -333,6 +402,12 @@ async function buildIndexedModuleForFile(args) {
             : buildBloomFilterFromSource(source, sup);
         args.bloomFilterCache.set(args.file, filter);
     }
+    // A failed extraction leaves this file's imports incomplete, so it marks the module like a missing syntax tree.
+    const onDegraded = (cause) => {
+        parserDegraded = true;
+        if (cause === "lookup")
+            importLookupIncomplete = true;
+    };
     // Single builder so an option added here always reaches both the primary source and
     // every embedded (SFC) block, instead of one path silently missing a future option.
     const sharedImportOptions = {
@@ -342,12 +417,15 @@ async function buildIndexedModuleForFile(args) {
         ...(args.opts?.logLevel ? { logLevel: args.opts.logLevel } : {}),
         ...(args.opts?.languageExtensions ? { languageExtensions: args.opts.languageExtensions } : {}),
         ...(args.report ? { report: args.report } : {}),
+        parsedFiles: args.parsedMap,
+        onDegraded,
     };
     const imports = nativeSourceLimitSkip || sup.id === "sql"
         ? []
         : await collectImportsForFile(args.file, args.projectRoot, {
             source,
             sup,
+            ...(readsSyntaxTree(sup.id) && tree ? { tree } : {}),
             ...(nativeQueries !== undefined ? { nativeQueries } : {}),
             ...sharedImportOptions,
         });
@@ -376,11 +454,28 @@ async function buildIndexedModuleForFile(args) {
         });
     }
     mod.imports = imports;
+    if (tree instanceof ProjectedSyntaxTree)
+        mod.parseErrorRanges = collectParseErrorRanges(tree);
+    else if (graphOnlyLanguage)
+        mod.parseErrorRanges = [];
+    else
+        delete mod.parseErrorRanges;
+    const nativeOutcome = preparedNativeOutcome(prepared);
+    if (nativeOutcome)
+        mod.nativeOutcome = nativeOutcome;
+    if (parserDegraded)
+        mod.parserDegraded = true;
+    if (importLookupIncomplete)
+        mod.importLookupIncomplete = true;
     if (sup.id === "cpp") {
         const declaredContainers = collectCppDeclaredModules(source);
         if (declaredContainers.length)
             mod.declaredContainers = declaredContainers;
     }
+    if (sup.id === "csharp" && tree)
+        mod.csharpNamespaceFacts = collectCsharpNamespaceFacts(tree);
+    if (jvmFacts)
+        mod.jvmFacts = jvmFacts;
     await resolveCrossModuleSymbolExports(args.file, mod, sup, args.projectRoot, args.graphOptions, args.workspaceConfig, args.matchPath);
     const sigInfo = args.fileSignatures.get(args.file);
     const cacheable = !prepared.nativeFallbackReason && !lacksParserContext;
@@ -432,6 +527,7 @@ function ensureJsonModule(modules, filePath) {
         file: normalized,
         exports: [{ type: "local", exportedAs: "default", target: symbol }],
         imports: [],
+        parseErrorRanges: [],
         locals: [symbol],
     });
 }
@@ -616,7 +712,7 @@ function emitIndexLifecycleProgress(opts, phase, mode, total, elapsedMs) {
         ...(elapsedMs !== undefined ? { elapsedMs } : {}),
     });
 }
-function emitIndexCheckStart(opts, activity = "Checking project index") {
+export function emitIndexCheckStart(opts, activity = "Checking project index") {
     opts?.onProgress?.({
         type: "progress",
         phase: "start",
@@ -627,7 +723,7 @@ function emitIndexCheckStart(opts, activity = "Checking project index") {
         total: 0,
     });
 }
-function emitIndexCheckActivity(opts, activity, current = 0, total = 0) {
+export function emitIndexCheckActivity(opts, activity, current = 0, total = 0) {
     opts?.onProgress?.({
         type: "progress",
         phase: "update",
@@ -762,7 +858,9 @@ async function buildProjectIndexFromExport(projectRoot, opts, helperOpts) {
  * - it changed;
  * - an import or re-export target no longer exists;
  * - an added file can satisfy one of its specifiers;
- * - it resolves imports through namespace or package declarations, and a file it depends on changed.
+ * - it resolves imports through namespace or package declarations, and a file it depends on changed;
+ * - a lookup of its imports over other files could not read one of them (`importLookupIncomplete`). Nothing records
+ *   that file when no module covers it, so the file reading again changes no signature, manifest edge, or cache row.
  *
  * With a manifest, the manifest gives the previous files and edges.
  * Without one (a memory cache, or a disk cache that no manifest-writing build has seen),
@@ -773,6 +871,10 @@ async function collectStaleCachedModules(args) {
     if (!cachedModules.size)
         return { stale: new Set(), deletedDeclarationFiles: [] };
     const stale = await cachedModulesWithMissingTargets(cachedModules, args.concurrency);
+    for (const [file, { mod }] of cachedModules) {
+        if (mod.importLookupIncomplete)
+            stale.add(file);
+    }
     const resolvesFromDeclarations = (file) => DECLARATION_RESOLVED_IMPORT_LANGUAGES.has(supportForFileWithoutHeaderSample(file, args.opts?.languageExtensions)?.id ?? "");
     const loadTsconfigPaths = (importer) => loadTsconfigResolutionInputsFor(importer, args.projectRoot, args.opts?.logLevel).then((inputs) => inputs?.paths);
     // Deleted declaration files. Only the no-manifest path fills this list.
@@ -1139,11 +1241,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
     const conc = edgeProbeConcurrency;
     const languageExtensions = normalizeLanguageExtensions(opts?.languageExtensions);
     const sqlFiles = normalizedFiles
-        .filter((file) => {
-        if (!languageExtensions)
-            return path.extname(file).toLowerCase() === ".sql";
-        return supportForFileWithoutHeaderSample(file, languageExtensions)?.id === "sql";
-    })
+        .filter((file) => isSqlFilePath(file, languageExtensions))
         .sort((left, right) => left.localeCompare(right));
     const fileSignatures = await prepareFileSignatures({
         projectRoot,
@@ -1161,7 +1259,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
         return sqlFactCachePromise;
     };
     const shouldProvideSqlFactCache = (file, sigInfo, cachedEdgesEntry) => {
-        if (supportForFileWithoutHeaderSample(file, opts?.languageExtensions)?.id !== "sql")
+        if (!isSqlFilePath(file, opts?.languageExtensions))
             return false;
         if (!cachedEdgesEntry || !sqlCorpusSig || cachedEdgesEntry.sqlCorpusSig !== sqlCorpusSig)
             return true;
@@ -1252,6 +1350,10 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
             else
                 cacheMissesByState.added.push(file);
         }
+        // The stale check scans package and namespace declarations, so it reads each reused module's own facts
+        // instead of parsing the file again. A module's facts depend only on its own source, which its signature proves.
+        for (const [file, { mod }] of cachedModules)
+            primeReusedFileFacts(file, mod, opts);
         const { stale: staleCachedModules, deletedDeclarationFiles: retiredDeletions } = await collectStaleCachedModules({
             files: normalizedFiles,
             cachedModules,
@@ -1345,6 +1447,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                         ...(manifest?.projectRoot ? { cachedFileEdgesProjectRoot: manifest.projectRoot } : {}),
                         ...(onFileEdges ? { onFileEdges } : {}),
                         allFiles: normalizedFiles,
+                        parsedFiles: parsedMap,
                         ...(sqlFactCache ? { sqlFactCache } : {}),
                     });
                     if (bloomFilterCache) {
@@ -1364,7 +1467,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                     fileReport.parsed = (fileReport.parsed ?? 0) + 1;
                 const support = supportForFile(file, opts?.languageExtensions);
                 if (!support)
-                    return [file, createEmptyModuleIndex(file), [], undefined];
+                    return [file, unparsedModuleIndex(file), [], undefined];
                 ensureBuildProgressStarted();
                 let graphContext;
                 let cacheWrite;
@@ -1409,6 +1512,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                     ...(manifest?.projectRoot ? { cachedFileEdgesProjectRoot: manifest.projectRoot } : {}),
                     ...(onFileEdges ? { onFileEdges } : {}),
                     allFiles: normalizedFiles,
+                    parsedFiles: parsedMap,
                     ...(sqlFactCache ? { sqlFactCache } : {}),
                 });
                 return [file, mod ?? createEmptyModuleIndex(file), edges, cacheWrite];
@@ -1423,7 +1527,7 @@ async function buildIndexFromFileListShared(projectRoot, rawFiles, opts, helperO
                 }
                 recordFileFailure(report, file, error);
                 logWithLevel(opts?.logLevel, "warn", `Warning: Failed to process file ${file}:`, error);
-                return [file, createEmptyModuleIndex(file), []];
+                return [file, failedModuleIndex(file), []];
             }
             finally {
                 processedFiles += 1;
@@ -2300,6 +2404,8 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
                 }
             }
             const reverseDeps = buildTrackedFileReverseDependencies(trackedEntries);
+            // Dependents rebuilt only because a file they depend on changed: their own source may be unchanged.
+            const dependentsToPrime = new Set();
             const invalidateCachedDependents = () => {
                 const dependentFilesOfChanged = collectTrackedFileDependents(trackedEntries, changedFiles, reverseDeps);
                 for (const file of dependentFilesOfChanged) {
@@ -2310,6 +2416,9 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
                             fileReport.cached = Math.max(0, (fileReport.cached ?? 0) - 1);
                         }
                     }
+                    else if (!changedFiles.has(file)) {
+                        dependentsToPrime.add(file);
+                    }
                     markAsChanged(file);
                 }
             };
@@ -2332,8 +2441,22 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
                 ? await tryLoadPersistedBloomFilters(projectRoot, opts, report)
                 : null;
             for (const file of allFiles) {
-                if (changedFiles.has(file))
+                if (changedFiles.has(file)) {
+                    const dependentLanguage = dependentsToPrime.has(file)
+                        ? supportForFileWithoutHeaderSample(file, opts?.languageExtensions)?.id
+                        : undefined;
+                    if (readsSyntaxTree(dependentLanguage)) {
+                        const key = fileIdentityKey(file);
+                        const sigInfo = fileSignatures.get(file);
+                        const reusable = snapshotModules?.get(key) ??
+                            (cacheEnabled
+                                ? tryLoadFromCache(projectRoot, file, await moduleCacheSignatureForFile(file, sigInfo, opts, resolverEnvironmentFingerprint), opts)
+                                : null);
+                        if (reusable)
+                            primeReusedFileFacts(file, reusable, opts);
+                    }
                     continue;
+                }
                 const sigInfo = fileSignatures.get(file);
                 let cached = null;
                 const snapshotMod = snapshotModules?.get(fileIdentityKey(file));
@@ -2344,10 +2467,17 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
                     const cacheSig = await moduleCacheSignatureForFile(file, sigInfo, opts, resolverEnvironmentFingerprint);
                     cached = tryLoadFromCache(projectRoot, file, cacheSig, opts, report);
                 }
-                if (cached) {
+                if (cached?.importLookupIncomplete) {
+                    // See collectStaleCachedModules: extract this importer again. Its own file facts stay valid, so the
+                    // project scan reads them from the cached module instead of parsing the file.
+                    primeReusedFileFacts(file, cached, opts);
+                    changedFiles.add(file);
+                }
+                else if (cached) {
                     if (fileReport)
                         fileReport.cached = (fileReport.cached ?? 0) + 1;
                     modules.set(fileIdentityKey(file), cached);
+                    primeReusedFileFacts(file, cached, opts);
                     collectJsonDependencies(cached.imports, jsonDependencies);
                     if (bloomFilterCache) {
                         const persistedFilter = persistedBloomFilters?.get(file, sigInfo);
@@ -2433,7 +2563,7 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
                             fileReport.parsed = (fileReport.parsed ?? 0) + 1;
                         const support = supportForFile(file, opts?.languageExtensions);
                         if (!support)
-                            return [file, createEmptyModuleIndex(file)];
+                            return [file, unparsedModuleIndex(file)];
                         const matchPath = support.id === "ts" || support.id === "tsx" ? await loadMatchPathForFile(file) : undefined;
                         const built = await buildIndexedModuleForFile({
                             file,
@@ -2463,7 +2593,7 @@ export async function buildProjectIndexIncremental(projectRoot, rawOpts) {
                         }
                         recordFileFailure(report, file, error);
                         logWithLevel(opts?.logLevel, "warn", `Warning: Failed to process file ${file}:`, error);
-                        return [file, createEmptyModuleIndex(file), undefined];
+                        return [file, failedModuleIndex(file), undefined];
                     }
                     finally {
                         if (opts?.onProgress) {