Save dts change time in buildinfo itself

Author: sheetalkamat

src/compiler/builder.ts

@@ -25,6 +25,11 @@ namespace ts {
          */
         /*@internal*/
         storeFilesChangingSignatureDuringEmit?: boolean;
+        /**
+         * Gets the current time
+         */
+        /*@internal*/
+        now?(): Date;
     }
 
     /**

src/compiler/builderPublic.ts

@@ -29,7 +29,7 @@ namespace ts {
         readonly exportedModulesMap?: BuilderState.ReadonlyManyToManyPathMap | undefined;
     }
 
-    export interface BuilderState {
+    export interface BuilderState extends ReusableBuilderState {
         /**
          * Information of the file eg. its version, signature etc
          */
@@ -423,7 +423,7 @@ namespace ts {
                 const firstDts = firstOrUndefined(emitOutput.outputFiles);
                 if (firstDts) {
                     Debug.assert(isDeclarationFileName(firstDts.name), "File extension for signature expected to be dts", () => `Found: ${getAnyExtensionFromPath(firstDts.name)} for ${firstDts.name}:: All output files: ${JSON.stringify(emitOutput.outputFiles.map(f => f.name))}`);
-                    latestSignature = (computeHash || generateDjb2Hash)(firstDts.text);
+                    latestSignature = computeSignature(firstDts.text, computeHash);
                     if (exportedModulesMapCache && latestSignature !== prevSignature) {
                         updateExportedModules(sourceFile, emitOutput.exportedModulesFromDeclarationEmit, exportedModulesMapCache);
                     }
@@ -447,6 +447,10 @@ namespace ts {
             return latestSignature !== prevSignature;
         }
 
+        export function computeSignature(text: string, computeHash: ComputeHash | undefined) {
+            return (computeHash || generateDjb2Hash)(text);
+        }
+
         /**
          * Coverts the declaration emit result into exported modules map
          */

src/compiler/builderState.ts

@@ -522,6 +522,7 @@ namespace ts {
             name: "outFile",
             type: "string",
             affectsEmit: true,
+            affectsDeclarationPath: true,
             isFilePath: true,
             paramType: Diagnostics.FILE,
             showInSimplifiedHelpView: true,
@@ -533,6 +534,7 @@ namespace ts {
             name: "outDir",
             type: "string",
             affectsEmit: true,
+            affectsDeclarationPath: true,
             isFilePath: true,
             paramType: Diagnostics.DIRECTORY,
             showInSimplifiedHelpView: true,
@@ -543,6 +545,7 @@ namespace ts {
             name: "rootDir",
             type: "string",
             affectsEmit: true,
+            affectsDeclarationPath: true,
             isFilePath: true,
             paramType: Diagnostics.LOCATION,
             category: Diagnostics.Modules,
@@ -988,6 +991,7 @@ namespace ts {
             name: "out",
             type: "string",
             affectsEmit: true,
+            affectsDeclarationPath: true,
             isFilePath: false, // This is intentionally broken to support compatability with existing tsconfig files
             // for correct behaviour, please use outFile
             category: Diagnostics.Backwards_Compatibility,
@@ -1144,6 +1148,7 @@ namespace ts {
             name: "declarationDir",
             type: "string",
             affectsEmit: true,
+            affectsDeclarationPath: true,
             isFilePath: true,
             paramType: Diagnostics.DIRECTORY,
             category: Diagnostics.Emit,
@@ -1281,6 +1286,10 @@ namespace ts {
     export const affectsEmitOptionDeclarations: readonly CommandLineOption[] =
         optionDeclarations.filter(option => !!option.affectsEmit);
 
+    /* @internal */
+    export const affectsDeclarationPathOptionDeclarations: readonly CommandLineOption[] =
+        optionDeclarations.filter(option => !!option.affectsDeclarationPath);
+
     /* @internal */
     export const moduleResolutionOptionDeclarations: readonly CommandLineOption[] =
         optionDeclarations.filter(option => !!option.affectsModuleResolution);

src/compiler/commandLineParser.ts

@@ -72,6 +72,11 @@ namespace ts {
         return date1 ? date2 > date1 ? date2 : date1 : date2;
     }
 
+    /*@internal*/
+    export function getCurrentTime(host: { now?(): Date; }) {
+        return host.now ? host.now() : new Date();
+    }
+
     export type ReportEmitErrorSummary = (errorCount: number, filesInError: (ReportFileInError | undefined)[]) => void;
 
     export interface ReportFileInError {
@@ -985,12 +990,12 @@ namespace ts {
             let newestDeclarationFileContentChangedTime: Date | undefined;
             const emitterDiagnostics = createDiagnosticCollection();
             const emittedOutputs = new Map<Path, string>();
-            const buildInfoEntry = state.buildInfoCache.get(projectPath);
+            const isOutFile = outFile(config.options);
             outputFiles.forEach(({ name, text, writeByteOrderMark, buildInfo }) => {
                 if (resultFlags === BuildResultFlags.DeclarationOutputUnchanged && isDeclarationFileName(name)) {
                     // Check for unchanged .d.ts files
                     if (state.readFileWithCache(name) === text) {
-                        if (config.options.composite) {
+                        if (config.options.composite && isOutFile) {
                             newestDeclarationFileContentChangedTime = newer(newestDeclarationFileContentChangedTime, ts.getModifiedTime(host, name));
                         }
                     }
@@ -1001,10 +1006,7 @@ namespace ts {
 
                 const path = toPath(state, name);
                 emittedOutputs.set(path, name);
-                if (buildInfoEntry?.path === path) {
-                    buildInfoEntry.buildInfo = buildInfo!;
-                    buildInfoEntry.modifiedTime = getCurrentTime(state);
-                }
+                if (buildInfo) setBuildInfo(state, buildInfo, projectPath, program!.getCompilerOptions());
                 writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
             });
 
@@ -1022,12 +1024,7 @@ namespace ts {
             Debug.assertIsDefined(program);
             Debug.assert(step === BuildStep.EmitBuildInfo);
             const emitResult = program.emitBuildInfo((name, text, writeByteOrderMark, onError, sourceFiles, data) => {
-                const path = toPath(state, name);
-                const buildInfo = state.buildInfoCache.get(projectPath);
-                if (buildInfo?.path === path) {
-                    buildInfo.buildInfo = data!.buildInfo!;
-                    buildInfo.modifiedTime = getCurrentTime(state);
-                }
+                if (data?.buildInfo) setBuildInfo(state, data.buildInfo, projectPath, program!.getCompilerOptions());
                 if (writeFileCallback) writeFileCallback(name, text, writeByteOrderMark, onError, sourceFiles, data);
                 else state.compilerHost.writeFile(name, text, writeByteOrderMark, onError, sourceFiles, data);
             }, cancellationToken);
@@ -1076,7 +1073,7 @@ namespace ts {
             state.diagnostics.delete(projectPath);
             state.projectStatus.set(projectPath, {
                 type: UpToDateStatusType.UpToDate,
-                newestDeclarationFileContentChangedTime: anyDtsChange ? undefined : newestDeclarationFileContentChangedTime,
+                newestDeclarationFileContentChangedTime: newestDeclarationFileContentChangedTime || getDtsChangeTime(state, config.options, projectPath),
                 oldestOutputFileName
             });
             afterProgramDone(state, program, config);
@@ -1127,14 +1124,10 @@ namespace ts {
             Debug.assert(!!outputFiles.length);
             const emitterDiagnostics = createDiagnosticCollection();
             const emittedOutputs = new Map<Path, string>();
-            const buildInfoEntry = state.buildInfoCache.get(projectPath);
             outputFiles.forEach(({ name, text, writeByteOrderMark, buildInfo }) => {
                 const path = toPath(state, name);
                 emittedOutputs.set(path, name);
-                if (buildInfoEntry?.path === path) {
-                    buildInfoEntry.buildInfo = buildInfo!;
-                    buildInfoEntry.modifiedTime = getCurrentTime(state);
-                }
+                if (buildInfo) setBuildInfo(state, buildInfo, projectPath, config.options);
                 writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
             });
 
@@ -1423,6 +1416,18 @@ namespace ts {
         };
     }
 
+    function setBuildInfo(state: SolutionBuilderState, buildInfo: BuildInfo, resolvedConfigPath: ResolvedConfigFilePath, options: CompilerOptions) {
+        const buildInfoPath = getTsBuildInfoEmitOutputFilePath(options)!;
+        const existing = getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath);
+        if (existing) {
+            existing.buildInfo = buildInfo;
+            existing.modifiedTime = getCurrentTime(state.host);
+        }
+        else {
+            state.buildInfoCache.set(resolvedConfigPath, { path: toPath(state, buildInfoPath), buildInfo, modifiedTime: getCurrentTime(state.host) });
+        }
+    }
+
     function getBuildInfoCacheEntry(state: SolutionBuilderState, buildInfoPath: string, resolvedConfigPath: ResolvedConfigFilePath) {
         const path = toPath(state, buildInfoPath);
         const existing = state.buildInfoCache.get(resolvedConfigPath);
@@ -1470,7 +1475,8 @@ namespace ts {
             for (const ref of project.projectReferences) {
                 const resolvedRef = resolveProjectReferencePath(ref);
                 const resolvedRefPath = toResolvedConfigFilePath(state, resolvedRef);
-                const refStatus = getUpToDateStatus(state, parseConfigFile(state, resolvedRef, resolvedRefPath), resolvedRefPath);
+                const resolvedConfig = parseConfigFile(state, resolvedRef, resolvedRefPath)!;
+                const refStatus = getUpToDateStatus(state, resolvedConfig, resolvedRefPath);
 
                 // Its a circular reference ignore the status of this project
                 if (refStatus.type === UpToDateStatusType.ComputingUpstream ||
@@ -1496,7 +1502,7 @@ namespace ts {
                     };
                 }
 
-                if (!force) (referenceStatuses ||= []).push({ ref, refStatus });
+                if (!force) (referenceStatuses ||= []).push({ ref, refStatus, resolvedRefPath, resolvedConfig });
             }
         }
         if (force) return { type: UpToDateStatusType.ForceBuild };
@@ -1507,6 +1513,7 @@ namespace ts {
         let oldestOutputFileName = "(none)";
         let oldestOutputFileTime = maximumDate;
         let buildInfoTime: Date | undefined;
+        let newestDeclarationFileContentChangedTime;
         if (buildInfoPath) {
             const buildInfoCacheEntry = getBuildInfoCacheEntry(state, buildInfoPath, resolvedPath);
             buildInfoTime = buildInfoCacheEntry?.modifiedTime || ts.getModifiedTime(host, buildInfoPath);
@@ -1540,6 +1547,7 @@ namespace ts {
 
             oldestOutputFileTime = buildInfoTime;
             oldestOutputFileName = buildInfoPath;
+            newestDeclarationFileContentChangedTime = buildInfo.program?.dtsChangeTime ? new Date(buildInfo.program.dtsChangeTime) : undefined;
         }
 
         // Check input files
@@ -1601,18 +1609,31 @@ namespace ts {
             }
         }
 
+        const seenRefs = buildInfoPath ? new Set<ResolvedConfigFilePath>() : undefined;
+        const buildInfoCacheEntry = state.buildInfoCache.get(resolvedPath)!;
+        seenRefs?.add(resolvedPath);
+
         let pseudoUpToDate = false;
         let usesPrepend = false;
         let upstreamChangedProject: string | undefined;
         if (referenceStatuses) {
-            for (const { ref, refStatus } of referenceStatuses) {
+            for (const { ref, refStatus, resolvedConfig, resolvedRefPath } of referenceStatuses) {
                 usesPrepend = usesPrepend || !!(ref.prepend);
                 // If the upstream project's newest file is older than our oldest output, we
                 // can't be out of date because of it
                 if (refStatus.newestInputFileTime && refStatus.newestInputFileTime <= oldestOutputFileTime) {
                     continue;
                 }
 
+                // Check if tsbuildinfo path is shared, then we need to rebuild
+                if (buildInfoCacheEntry && hasSameBuildInfo(state, buildInfoCacheEntry, seenRefs!, resolvedConfig, resolvedRefPath)) {
+                    return {
+                        type: UpToDateStatusType.OutOfDateWithUpstream,
+                        outOfDateOutputFileName: buildInfoPath!,
+                        newerProjectName: ref.path
+                    };
+                }
+
                 // If the upstream project has only change .d.ts files, and we've built
                 // *after* those files, then we're "psuedo up to date" and eligible for a fast rebuild
                 if (refStatus.newestDeclarationFileContentChangedTime && refStatus.newestDeclarationFileContentChangedTime <= oldestOutputFileTime) {
@@ -1657,13 +1678,31 @@ namespace ts {
         // Up to date
         return {
             type: pseudoUpToDate ? UpToDateStatusType.UpToDateWithUpstreamTypes : UpToDateStatusType.UpToDate,
-            newestDeclarationFileContentChangedTime: undefined,
+            newestDeclarationFileContentChangedTime,
             newestInputFileTime,
             newestInputFileName,
             oldestOutputFileName
         };
     }
 
+    function hasSameBuildInfo(state: SolutionBuilderState, buildInfoCacheEntry: BuildInfoCacheEntry, seenRefs: Set<ResolvedConfigFilePath>, resolvedConfig: ParsedCommandLine, resolvedRefPath: ResolvedConfigFilePath) {
+        if (seenRefs.has(resolvedRefPath)) return false;
+        seenRefs.add(resolvedRefPath);
+        const refBuildInfo = state.buildInfoCache.get(resolvedRefPath)!;
+        if (refBuildInfo.path === buildInfoCacheEntry.path) return true;
+
+        if (resolvedConfig.projectReferences) {
+            // Check references
+            for (const ref of resolvedConfig.projectReferences) {
+                const resolvedRef = resolveProjectReferencePath(ref);
+                const resolvedRefPath = toResolvedConfigFilePath(state, resolvedRef);
+                const resolvedConfig = parseConfigFile(state, resolvedRef, resolvedRefPath)!;
+                if (hasSameBuildInfo(state, buildInfoCacheEntry, seenRefs, resolvedConfig, resolvedRefPath)) return true;
+            }
+        }
+        return false;
+    }
+
     function getUpToDateStatus(state: SolutionBuilderState, project: ParsedCommandLine | undefined, resolvedPath: ResolvedConfigFilePath): UpToDateStatus {
         if (project === undefined) {
             return { type: UpToDateStatusType.Unbuildable, reason: "File deleted mid-build" };
@@ -1679,16 +1718,13 @@ namespace ts {
         return actual;
     }
 
-    function getCurrentTime(state: SolutionBuilderState) {
-        return state.host.now ? state.host.now() : new Date();
-    }
-
     function updateOutputTimestampsWorker(state: SolutionBuilderState, proj: ParsedCommandLine, anyDtsChange: boolean, verboseMessage: DiagnosticMessage, newestDeclarationFileContentChangedTime?: Date, skipOutputs?: ESMap<Path, string>) {
         if (proj.options.noEmit) return undefined;
 
         const buildInfoPath = getTsBuildInfoEmitOutputFilePath(proj.options);
         const { host } = state;
         const outputs = getAllProjectOutputs(proj, !host.useCaseSensitiveFileNames());
+        const isOutFile = outFile(proj.options);
         if (!skipOutputs || outputs.length !== skipOutputs.size) {
             let reportVerbose = !!state.options.verbose;
             let now: Date | undefined;
@@ -1697,7 +1733,7 @@ namespace ts {
                     continue;
                 }
 
-                if (proj.options.composite && !anyDtsChange && isDeclarationFileName(file)) {
+                if (proj.options.composite && isOutFile && !anyDtsChange && isDeclarationFileName(file)) {
                     newestDeclarationFileContentChangedTime = newer(newestDeclarationFileContentChangedTime, ts.getModifiedTime(host, file));
                 }
 
@@ -1707,22 +1743,29 @@ namespace ts {
                         reportStatus(state, verboseMessage, proj.options.configFilePath!);
                     }
 
-                    host.setModifiedTime(file, now ||= getCurrentTime(state));
+                    host.setModifiedTime(file, now ||= getCurrentTime(state.host));
                 }
             }
         }
 
         return newestDeclarationFileContentChangedTime;
     }
 
+    function getDtsChangeTime(state: SolutionBuilderState, options: CompilerOptions, resolvedConfigPath: ResolvedConfigFilePath) {
+        if (!options.composite || outFile(options)) return undefined;
+        const buildInfoPath = getTsBuildInfoEmitOutputFilePath(options)!;
+        const buildInfo = getBuildInfo(state, buildInfoPath, resolvedConfigPath, /*modifiedTime*/ undefined);
+        return buildInfo?.program?.dtsChangeTime ? new Date(buildInfo.program.dtsChangeTime) : undefined;
+    }
+
     function updateOutputTimestamps(state: SolutionBuilderState, proj: ParsedCommandLine, resolvedPath: ResolvedConfigFilePath) {
         if (state.options.dry) {
             return reportStatus(state, Diagnostics.A_non_dry_build_would_update_timestamps_for_output_of_project_0, proj.options.configFilePath!);
         }
         const priorNewestUpdateTime = updateOutputTimestampsWorker(state, proj, /*anyDtsChange*/ false, Diagnostics.Updating_output_timestamps_of_project_0);
         state.projectStatus.set(resolvedPath, {
             type: UpToDateStatusType.UpToDate,
-            newestDeclarationFileContentChangedTime: priorNewestUpdateTime,
+            newestDeclarationFileContentChangedTime: priorNewestUpdateTime || getDtsChangeTime(state, proj.options, resolvedPath),
             oldestOutputFileName: getFirstProjectOutput(proj, !state.host.useCaseSensitiveFileNames())
         });
     }

src/compiler/tsbuildPublic.ts

@@ -6421,6 +6421,7 @@ namespace ts {
         affectsSemanticDiagnostics?: true;                      // true if option affects semantic diagnostics
         affectsEmit?: true;                                     // true if the options affects emit
         affectsProgramStructure?: true;                         // true if program should be reconstructed from root files if option changes and does not affect module resolution as affectsModuleResolution indirectly means program needs to reconstructed
+        affectsDeclarationPath?: true;                          // true if the options affects declaration file path computed
         transpileOptionValue?: boolean | undefined;             // If set this means that the option should be set to this value when transpiling
         extraValidation?: (value: CompilerOptionsValue) => [DiagnosticMessage, ...string[]] | undefined; // Additional validation to be performed for the value to be valid
     }
@@ -6790,6 +6791,7 @@ namespace ts {
         // For testing:
         /*@internal*/ disableUseFileVersionAsSignature?: boolean;
         /*@internal*/ storeFilesChangingSignatureDuringEmit?: boolean;
+        /*@internal*/ now?(): Date;
     }
 
     /** true if --out otherwise source file name */

src/compiler/types.ts

@@ -6465,6 +6465,10 @@ namespace ts {
         return optionsHaveChanges(oldOptions, newOptions, affectsEmitOptionDeclarations);
     }
 
+    export function compilerOptionsAffectDeclarationPath(newOptions: CompilerOptions, oldOptions: CompilerOptions): boolean {
+        return optionsHaveChanges(oldOptions, newOptions, affectsDeclarationPathOptionDeclarations);
+    }
+
     export function getCompilerOptionValue(options: CompilerOptions, option: CommandLineOption): unknown {
         return option.strictFlag ? getStrictOptionValue(options, option.name as StrictOptionName) : options[option.name];
     }