Keep buildinfos for lifetime of the solution builder and project

Author: sheetalkamat

src/compiler/tsbuildPublic.ts

@@ -210,7 +210,6 @@ namespace ts {
         originalWriteFile: CompilerHost["writeFile"] | undefined;
         originalReadFileWithCache: CompilerHost["readFile"];
         originalGetSourceFile: CompilerHost["getSourceFile"];
-        buildInfoCache: ESMap<Path, BuildInfo | false>;
     }
 
     interface FileWatcherWithModifiedTime {
@@ -219,6 +218,11 @@ namespace ts {
         modifiedTime: Date | undefined;
     }
 
+    interface BuildInfoCacheEntry {
+        path: Path;
+        buildInfo: BuildInfo | false | string;
+    }
+
     interface SolutionBuilderState<T extends BuilderProgram = BuilderProgram> extends WatchFactory<WatchType, ResolvedConfigFileName> {
         readonly host: SolutionBuilderHost<T>;
         readonly hostWithWatch: SolutionBuilderWithWatchHost<T>;
@@ -239,6 +243,7 @@ namespace ts {
         readonly projectStatus: ESMap<ResolvedConfigFilePath, UpToDateStatus>;
         readonly buildInfoChecked: ESMap<ResolvedConfigFilePath, true>;
         readonly extendedConfigCache: ESMap<string, ExtendedConfigCacheEntry>;
+        readonly buildInfoCache: ESMap<ResolvedConfigFilePath, BuildInfoCacheEntry>;
 
         readonly builderPrograms: ESMap<ResolvedConfigFilePath, T>;
         readonly diagnostics: ESMap<ResolvedConfigFilePath, readonly Diagnostic[]>;
@@ -301,7 +306,7 @@ namespace ts {
             compilerHost.resolveTypeReferenceDirectives = (typeReferenceDirectiveNames, containingFile, redirectedReference, _options, containingFileMode) =>
                 loadWithTypeDirectiveCache<ResolvedTypeReferenceDirective>(Debug.checkEachDefined(typeReferenceDirectiveNames), containingFile, redirectedReference, containingFileMode, loader);
         }
-        compilerHost.getBuildInfo = fileName => getBuildInfo(state, fileName);
+        compilerHost.getBuildInfo = (fileName, configFilePath) => getBuildInfo(state, fileName, toResolvedConfigFilePath(state, configFilePath as ResolvedConfigFileName));
 
         const { watchFile, watchDirectory, writeLog } = createWatchFactory<ResolvedConfigFileName>(hostWithWatch, options);
 
@@ -324,6 +329,7 @@ namespace ts {
             projectStatus: new Map(),
             buildInfoChecked: new Map(),
             extendedConfigCache: new Map(),
+            buildInfoCache: new Map(),
 
             builderPrograms: new Map(),
             diagnostics: new Map(),
@@ -487,6 +493,7 @@ namespace ts {
         mutateMapSkippingNewValues(state.diagnostics, currentProjects, noopOnDelete);
         mutateMapSkippingNewValues(state.projectPendingBuild, currentProjects, noopOnDelete);
         mutateMapSkippingNewValues(state.projectErrorsReported, currentProjects, noopOnDelete);
+        mutateMapSkippingNewValues(state.buildInfoCache, currentProjects, noopOnDelete);
 
         // Remove watches for the program no longer in the solution
         if (state.watch) {
@@ -575,7 +582,6 @@ namespace ts {
             originalWriteFile,
             originalReadFileWithCache,
             originalGetSourceFile,
-            buildInfoCache: new Map(),
         };
     }
 
@@ -978,6 +984,7 @@ namespace ts {
             let newestDeclarationFileContentChangedTime: Date | undefined;
             const emitterDiagnostics = createDiagnosticCollection();
             const emittedOutputs = new Map<Path, string>();
+            const buildInfo = state.buildInfoCache.get(projectPath);
             outputFiles.forEach(({ name, text, writeByteOrderMark }) => {
                 if (resultFlags === BuildResultFlags.DeclarationOutputUnchanged && isDeclarationFileName(name)) {
                     // Check for unchanged .d.ts files
@@ -991,7 +998,7 @@ namespace ts {
 
                 const path = toPath(state, name);
                 emittedOutputs.set(path, name);
-                state.cache?.buildInfoCache.delete(path);
+                if (buildInfo?.path === path) buildInfo.buildInfo = text;
                 writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
             });
 
@@ -1010,7 +1017,8 @@ namespace ts {
             Debug.assert(step === BuildStep.EmitBuildInfo);
             const emitResult = program.emitBuildInfo((name, data, writeByteOrderMark, onError, sourceFiles) => {
                 const path = toPath(state, name);
-                state.cache?.buildInfoCache.delete(path);
+                const buildInfo = state.buildInfoCache.get(projectPath);
+                if (buildInfo?.path === path) buildInfo.buildInfo = data;
                 if (writeFileCallback) writeFileCallback(name, data, writeByteOrderMark, onError, sourceFiles);
                 else state.compilerHost.writeFile(name, data, writeByteOrderMark, onError, sourceFiles);
             }, cancellationToken);
@@ -1110,10 +1118,11 @@ namespace ts {
             Debug.assert(!!outputFiles.length);
             const emitterDiagnostics = createDiagnosticCollection();
             const emittedOutputs = new Map<Path, string>();
+            const buildInfo = state.buildInfoCache.get(projectPath);
             outputFiles.forEach(({ name, text, writeByteOrderMark }) => {
                 const path = toPath(state, name);
                 emittedOutputs.set(path, name);
-                state.cache?.buildInfoCache.delete(path);
+                if (buildInfo?.path === path) buildInfo.buildInfo = text;
                 writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
             });
 
@@ -1402,13 +1411,17 @@ namespace ts {
         };
     }
 
-    function getBuildInfo(state: SolutionBuilderState, buildInfoPath: string): BuildInfo | undefined {
+    function getBuildInfo(state: SolutionBuilderState, buildInfoPath: string, resolvedConfigPath: ResolvedConfigFilePath): BuildInfo | undefined {
         const path = toPath(state, buildInfoPath);
-        const existing = state.cache?.buildInfoCache.get(path);
-        if (existing !== undefined) return existing || undefined;
+        const existing = state.buildInfoCache.get(resolvedConfigPath);
+        if (existing !== undefined && existing.path === path) {
+            return isString(existing.buildInfo) ?
+                existing.buildInfo = ts.getBuildInfo(existing.buildInfo) :
+                existing.buildInfo || undefined;
+        }
         const value = state.readFileWithCache(buildInfoPath);
         const buildInfo = value ? ts.getBuildInfo(value) : undefined;
-        state.cache?.buildInfoCache.set(path, buildInfo || false);
+        state.buildInfoCache.set(resolvedConfigPath, { path, buildInfo: buildInfo || false });
         return buildInfo;
     }
 
@@ -1487,7 +1500,7 @@ namespace ts {
                 };
             }
 
-            const buildInfo = Debug.checkDefined(getBuildInfo(state, buildInfoPath));
+            const buildInfo = Debug.checkDefined(getBuildInfo(state, buildInfoPath, resolvedPath));
             if (!state.buildInfoChecked.has(resolvedPath)) {
                 state.buildInfoChecked.set(resolvedPath, true);
                 if (buildInfo && (buildInfo.bundle || buildInfo.program) && buildInfo.version !== version) {

src/compiler/watchPublic.ts

@@ -4,15 +4,15 @@ namespace ts {
         getCurrentDirectory(): string;
         readFile(fileName: string): string | undefined;
         /*@internal*/
-        getBuildInfo?(fileName: string): BuildInfo | undefined;
+        getBuildInfo?(fileName: string, configFilePath: string | undefined): BuildInfo | undefined;
     }
     export function readBuilderProgram(compilerOptions: CompilerOptions, host: ReadBuildProgramHost) {
         if (outFile(compilerOptions)) return undefined;
         const buildInfoPath = getTsBuildInfoEmitOutputFilePath(compilerOptions);
         if (!buildInfoPath) return undefined;
         let buildInfo;
         if (host.getBuildInfo) {
-            buildInfo = host.getBuildInfo(buildInfoPath);
+            buildInfo = host.getBuildInfo(buildInfoPath, compilerOptions.configFilePath);
             if (!buildInfo) return undefined;
         }
         else {