uptodate status worker to read buildinfo and use it to determine upto…

… date ness
microsoft · sheetalkamat · Jun 8, 2022 · Apr 13, 2022 · Apr 13, 2022 · Apr 14, 2022
commit 7cb0f40f071cb81c362cda46dbf42ec47f32b362
diff --git a/src/compiler/builder.ts b/src/compiler/builder.ts
@@ -800,6 +800,7 @@ namespace ts {
         exportedModulesMap?: ProgramBuildInfoReferencedMap;
         semanticDiagnosticsPerFile?: ProgramBuildInfoDiagnostic[];
         affectedFilesPendingEmit?: ProgramBuilderInfoFilePendingEmit[];
+        hasPendingChange?: boolean;
     }
 
     /**
@@ -898,6 +899,7 @@ namespace ts {
             exportedModulesMap,
             semanticDiagnosticsPerFile,
             affectedFilesPendingEmit,
+            hasPendingChange: state.changedFilesSet?.size ? true : undefined,
         };
 
         function relativeToBuildInfoEnsuringAbsolutePath(path: string) {
@@ -941,7 +943,8 @@ namespace ts {
                 // flags it controls (e.g. `strictNullChecks`) will be retrieved correctly from the buildinfo
                 optionKey === "strict" ||
                 // We need to store these to determine whether `lib` files need to be rechecked.
-                optionKey === "skiplibcheck" || optionKey === "skipdefaultlibcheck") {
+                optionKey === "skiplibcheck" || optionKey === "skipdefaultlibcheck" ||
+                optionKey === "noemit") {
                 (result ||= {})[name] = convertToReusableCompilerOptionValue(
                     optionInfo,
                     options[name] as CompilerOptionsValue,

diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
@@ -5272,6 +5272,10 @@
         "category": "Message",
         "code": 6398
     },
+    "Project '{0}' is out of date because buildinfo file '{1}' indicates that some of the changes are not emitted": {
+        "category": "Message",
+        "code": 6399
+    },
 
     "The expected type comes from property '{0}' which is declared here on type '{1}'": {
         "category": "Message",

diff --git a/src/compiler/tsbuild.ts b/src/compiler/tsbuild.ts
@@ -18,6 +18,7 @@ namespace ts {
         OutputMissing,
         OutOfDateWithSelf,
         OutOfDateWithUpstream,
+        OutOfDateBuildInfo,
         UpstreamOutOfDate,
         UpstreamBlocked,
         ComputingUpstream,
@@ -37,6 +38,7 @@ namespace ts {
         | Status.OutputMissing
         | Status.OutOfDateWithSelf
         | Status.OutOfDateWithUpstream
+        | Status.OutOfDateBuildInfo
         | Status.UpstreamOutOfDate
         | Status.UpstreamBlocked
         | Status.ComputingUpstream
@@ -102,6 +104,14 @@ namespace ts {
             newerInputFileName: string;
         }
 
+        /**
+         * Buildinfo indicates that build is out of date
+         */
+        export interface OutOfDateBuildInfo {
+            type: UpToDateStatusType.OutOfDateBuildInfo,
+            buildInfoFile: string;
+        }
+
         /**
          * This project depends on an out-of-date project, so shouldn't be built yet
          */

diff --git a/src/compiler/tsbuildPublic.ts b/src/compiler/tsbuildPublic.ts
@@ -210,6 +210,7 @@ namespace ts {
         originalWriteFile: CompilerHost["writeFile"] | undefined;
         originalReadFileWithCache: CompilerHost["readFile"];
         originalGetSourceFile: CompilerHost["getSourceFile"];
+        buildInfoCache: ESMap<Path, BuildInfo | false>;
     }
 
     interface FileWatcherWithModifiedTime {
@@ -282,7 +283,7 @@ namespace ts {
 
         // State of the solution
         const baseCompilerOptions = getCompilerOptionsOfBuildOptions(options);
-        const compilerHost = createCompilerHostFromProgramHost(host, () => state.projectCompilerOptions);
+        const compilerHost = createCompilerHostFromProgramHost(host, () => state.projectCompilerOptions) as CompilerHost & ReadBuildProgramHost;
         setGetSourceFileAsHashVersioned(compilerHost, host);
         compilerHost.getParsedCommandLine = fileName => parseConfigFile(state, fileName as ResolvedConfigFileName, toResolvedConfigFilePath(state, fileName as ResolvedConfigFileName));
         compilerHost.resolveModuleNames = maybeBind(host, host.resolveModuleNames);
@@ -300,6 +301,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);
 
         const { watchFile, watchDirectory, writeLog } = createWatchFactory<ResolvedConfigFileName>(hostWithWatch, options);
 
@@ -573,6 +575,7 @@ namespace ts {
             originalWriteFile,
             originalReadFileWithCache,
             originalGetSourceFile,
+            buildInfoCache: new Map(),
         };
     }
 
@@ -986,7 +989,9 @@ namespace ts {
                     }
                 }
 
-                emittedOutputs.set(toPath(state, name), name);
+                const path = toPath(state, name);
+                emittedOutputs.set(path, name);
+                state.cache?.buildInfoCache.delete(path);
                 writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
             });
 
@@ -1003,7 +1008,12 @@ namespace ts {
         function emitBuildInfo(writeFileCallback?: WriteFileCallback, cancellationToken?: CancellationToken): EmitResult {
             Debug.assertIsDefined(program);
             Debug.assert(step === BuildStep.EmitBuildInfo);
-            const emitResult = program.emitBuildInfo(writeFileCallback, cancellationToken);
+            const emitResult = program.emitBuildInfo((name, data, writeByteOrderMark, onError, sourceFiles) => {
+                const path = toPath(state, name);
+                state.cache?.buildInfoCache.delete(path);
+                if (writeFileCallback) writeFileCallback(name, data, writeByteOrderMark, onError, sourceFiles);
+                else state.compilerHost.writeFile(name, data, writeByteOrderMark, onError, sourceFiles);
+            }, cancellationToken);
             if (emitResult.diagnostics.length) {
                 reportErrors(state, emitResult.diagnostics);
                 state.diagnostics.set(projectPath, [...state.diagnostics.get(projectPath)!, ...emitResult.diagnostics]);
@@ -1101,7 +1111,9 @@ namespace ts {
             const emitterDiagnostics = createDiagnosticCollection();
             const emittedOutputs = new Map<Path, string>();
             outputFiles.forEach(({ name, text, writeByteOrderMark }) => {
-                emittedOutputs.set(toPath(state, name), name);
+                const path = toPath(state, name);
+                emittedOutputs.set(path, name);
+                state.cache?.buildInfoCache.delete(path);
                 writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
             });
 
@@ -1390,6 +1402,16 @@ namespace ts {
         };
     }
 
+    function getBuildInfo(state: SolutionBuilderState, buildInfoPath: string): BuildInfo | undefined {
+        const path = toPath(state, buildInfoPath);
+        const existing = state.cache?.buildInfoCache.get(path);
+        if (existing !== undefined) return existing || undefined;
+        const value = state.readFileWithCache(buildInfoPath);
+        const buildInfo = value ? ts.getBuildInfo(value) : undefined;
+        state.cache?.buildInfoCache.set(path, buildInfo || false);
+        return buildInfo;
+    }
+
     function checkConfigFileUpToDateStatus(state: SolutionBuilderState, configFile: string, oldestOutputFileTime: Date, oldestOutputFileName: string): Status.OutOfDateWithSelf | undefined {
         // Check tsconfig time
         const tsconfigTime = getModifiedTime(state, configFile);
@@ -1472,43 +1494,89 @@ namespace ts {
 
         if (force) return { type: UpToDateStatusType.ForceBuild };
 
-        // Collect the expected outputs of this project
-        const outputs = getAllProjectOutputs(project, !host.useCaseSensitiveFileNames());
-
+        const buildInfoPath = getTsBuildInfoEmitOutputFilePath(project.options);
         // Now see if all outputs are newer than the newest input
         let oldestOutputFileName = "(none)";
         let oldestOutputFileTime = maximumDate;
         let newestDeclarationFileContentChangedTime;
-        for (const output of outputs) {
-            // Output is missing; can stop checking
-            const outputTime = ts.getModifiedTime(host, output);
+        if (buildInfoPath) {
+            const outputTime = ts.getModifiedTime(host, buildInfoPath);
             if (outputTime === missingFileModifiedTime) {
                 return {
                     type: UpToDateStatusType.OutputMissing,
-                    missingOutputFileName: output
+                    missingOutputFileName: buildInfoPath
                 };
             }
 
-            if (outputTime < oldestOutputFileTime) {
-                oldestOutputFileTime = outputTime;
-                oldestOutputFileName = output;
+            const buildInfo = Debug.checkDefined(getBuildInfo(state, buildInfoPath));
+            if (!state.buildInfoChecked.has(resolvedPath)) {
+                state.buildInfoChecked.set(resolvedPath, true);
+                if (buildInfo && (buildInfo.bundle || buildInfo.program) && buildInfo.version !== version) {
+                    return {
+                        type: UpToDateStatusType.TsVersionOutputOfDate,
+                        version: buildInfo.version
+                    };
+                }
             }
 
             // If an output is older than the newest input, we can stop checking
             if (outputTime < newestInputFileTime) {
                 return {
                     type: UpToDateStatusType.OutOfDateWithSelf,
-                    outOfDateOutputFileName: oldestOutputFileName,
+                    outOfDateOutputFileName: buildInfoPath,
                     newerInputFileName: newestInputFileName
                 };
             }
 
-            // Keep track of when the most recent time a .d.ts file was changed.
-            // In addition to file timestamps, we also keep track of when a .d.ts file
-            // had its file touched but not had its contents changed - this allows us
-            // to skip a downstream typecheck
-            if (isDeclarationFileName(output)) {
-                newestDeclarationFileContentChangedTime = newer(newestDeclarationFileContentChangedTime, outputTime);
+            if (buildInfo.program) {
+                if (buildInfo.program.hasPendingChange ||
+                    (!buildInfo.program.options?.noEmit && buildInfo.program.affectedFilesPendingEmit?.length)) {
+                    return {
+                        type: UpToDateStatusType.OutOfDateBuildInfo,
+                        buildInfoFile: buildInfoPath
+                    };
+                }
+            }
+
+            oldestOutputFileTime = outputTime;
+            oldestOutputFileName = buildInfoPath;
+        }
+        // Dont check output timestamps if we have buildinfo telling us output is uptodate
+        else {
+            // Collect the expected outputs of this project
+            const outputs = getAllProjectOutputs(project, !host.useCaseSensitiveFileNames());
+            for (const output of outputs) {
+                if (buildInfoPath === output) continue;
+                // Output is missing; can stop checking
+                const outputTime = ts.getModifiedTime(state.host, output);
+                if (outputTime === missingFileModifiedTime) {
+                    return {
+                        type: UpToDateStatusType.OutputMissing,
+                        missingOutputFileName: output
+                    };
+                }
+
+                if (outputTime < oldestOutputFileTime) {
+                    oldestOutputFileTime = outputTime;
+                    oldestOutputFileName = output;
+                }
+
+                // If an output is older than the newest input, we can stop checking
+                if (outputTime < newestInputFileTime) {
+                    return {
+                        type: UpToDateStatusType.OutOfDateWithSelf,
+                        outOfDateOutputFileName: oldestOutputFileName,
+                        newerInputFileName: newestInputFileName
+                    };
+                }
+
+                // Keep track of when the most recent time a .d.ts file was changed.
+                // In addition to file timestamps, we also keep track of when a .d.ts file
+                // had its file touched but not had its contents changed - this allows us
+                // to skip a downstream typecheck
+                if (isDeclarationFileName(output)) {
+                    newestDeclarationFileContentChangedTime = newer(newestDeclarationFileContentChangedTime, outputTime);
+                }
             }
         }
 
@@ -1557,21 +1625,6 @@ namespace ts {
         );
         if (dependentPackageFileStatus) return dependentPackageFileStatus;
 
-        if (!state.buildInfoChecked.has(resolvedPath)) {
-            state.buildInfoChecked.set(resolvedPath, true);
-            const buildInfoPath = getTsBuildInfoEmitOutputFilePath(project.options);
-            if (buildInfoPath) {
-                const value = state.readFileWithCache(buildInfoPath);
-                const buildInfo = value && getBuildInfo(value);
-                if (buildInfo && (buildInfo.bundle || buildInfo.program) && buildInfo.version !== version) {
-                    return {
-                        type: UpToDateStatusType.TsVersionOutputOfDate,
-                        version: buildInfo.version
-                    };
-                }
-            }
-        }
-
         if (usesPrepend && pseudoUpToDate) {
             return {
                 type: UpToDateStatusType.OutOfDateWithPrepend,
@@ -2103,6 +2156,13 @@ namespace ts {
                     relName(state, configFileName),
                     relName(state, status.missingOutputFileName)
                 );
+            case UpToDateStatusType.OutOfDateBuildInfo:
+                return reportStatus(
+                    state,
+                    Diagnostics.Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_some_of_the_changes_are_not_emitted,
+                    relName(state, configFileName),
+                    relName(state, status.buildInfoFile)
+                );
             case UpToDateStatusType.UpToDate:
                 if (status.newestInputFileTime !== undefined) {
                     return reportStatus(

diff --git a/src/compiler/watchPublic.ts b/src/compiler/watchPublic.ts
@@ -3,14 +3,23 @@ namespace ts {
         useCaseSensitiveFileNames(): boolean;
         getCurrentDirectory(): string;
         readFile(fileName: string): string | undefined;
+        /*@internal*/
+        getBuildInfo?(fileName: string): BuildInfo | undefined;
     }
     export function readBuilderProgram(compilerOptions: CompilerOptions, host: ReadBuildProgramHost) {
         if (outFile(compilerOptions)) return undefined;
         const buildInfoPath = getTsBuildInfoEmitOutputFilePath(compilerOptions);
         if (!buildInfoPath) return undefined;
-        const content = host.readFile(buildInfoPath);
-        if (!content) return undefined;
-        const buildInfo = getBuildInfo(content);
+        let buildInfo;
+        if (host.getBuildInfo) {
+            buildInfo = host.getBuildInfo(buildInfoPath);
+            if (!buildInfo) return undefined;
+        }
+        else {
+            const content = host.readFile(buildInfoPath);
+            if (!content) return undefined;
+            buildInfo = getBuildInfo(content);
+        }
         if (buildInfo.version !== version) return undefined;
         if (!buildInfo.program) return undefined;
         return createBuildProgramUsingProgramBuildInfo(buildInfo.program, buildInfoPath, host);

diff --git a/src/testRunner/unittests/tsbuild/helpers.ts b/src/testRunner/unittests/tsbuild/helpers.ts
@@ -207,6 +207,7 @@ interface Symbol {
         exportedModulesMap?: MapLike<string[]>;
         semanticDiagnosticsPerFile?: readonly ReadableProgramBuildInfoDiagnostic[];
         affectedFilesPendingEmit?: readonly ReadableProgramBuilderInfoFilePendingEmit[];
+        hasPendingChange?: boolean
     }
     type ReadableBuildInfo = Omit<BuildInfo, "program"> & { program: ReadableProgramBuildInfo | undefined; size: number; };
     function generateBuildInfoProgramBaseline(sys: System, buildInfoPath: string, buildInfo: BuildInfo) {
@@ -231,6 +232,7 @@ interface Symbol {
                     emitKind === BuilderFileEmit.Full ? "Full" :
                         Debug.assertNever(emitKind)
             ]),
+            hasPendingChange: buildInfo.program.hasPendingChange,
         };
         const version = buildInfo.version === ts.version ? fakes.version : buildInfo.version;
         const result: ReadableBuildInfo = {
@@ -480,8 +482,7 @@ interface Symbol {
                     fileNames: undefined,
                     fileNamesList: undefined,
                     fileInfos: sanitizedFileInfos,
-                    // Ignore noEmit since that shouldnt be reason to emit the tsbuild info and presence of it in the buildinfo file does not matter
-                    options: { ...readableBuildInfo.program.options, noEmit: undefined },
+                    options: sanatizeCompilerOptions(readableBuildInfo.program.options),
                     exportedModulesMap: undefined,
                     affectedFilesPendingEmit: undefined,
                 },
@@ -491,6 +492,16 @@ interface Symbol {
         };
     }
 
+    function sanatizeCompilerOptions(options: CompilerOptions | undefined) {
+        if (!options) return options;
+        let result: CompilerOptions | undefined;
+        for (const name of getOwnKeys(options).sort(compareStringsCaseSensitive)) {
+            // Ignore noEmit since that shouldnt be reason to emit the tsbuild info and presence of it in the buildinfo file does not matter
+            if (name.toLowerCase() !== "noemit") (result ||= {})[name] = options[name];
+        }
+        return result;
+    }
+
     export enum CleanBuildDescrepancy {
         CleanFileTextDifferent,
         CleanFilePresent,

diff --git a/src/testRunner/unittests/tsbuild/sample.ts b/src/testRunner/unittests/tsbuild/sample.ts
@@ -285,12 +285,13 @@ namespace ts {
         });
 
         describe("downstream-blocked compilations", () => {
-            verifyTsc({
+            verifyTscWithEdits({
                 scenario: "sample1",
                 subScenario: "does not build downstream projects if upstream projects have errors",
                 fs: () => projFs,
                 commandLineArgs: ["--b", "/src/tests", "--verbose"],
-                modifyFs: fs => replaceText(fs, "/src/logic/index.ts", "c.multiply(10, 15)", `c.muitply()`)
+                modifyFs: fs => replaceText(fs, "/src/logic/index.ts", "c.multiply(10, 15)", `c.muitply()`),
+                edits: noChangeOnlyRuns
             });
         });