Instead of storing time in buildinfo store filename which was last updated to get modified time stamp from

Author: sheetalkamat

src/compiler/builder.ts

@@ -61,10 +61,6 @@ namespace ts {
          * Hash of d.ts emit with --out
          */
         outSignature?: string;
-        /**
-         * Time when d.ts was modified
-         */
-        dtsChangeTime: number | undefined;
         /**
          * Name of the file whose dts was the latest to change
          */
@@ -145,7 +141,6 @@ namespace ts {
         "programEmitComplete" |
         "emitSignatures" |
         "outSignature" |
-        "dtsChangeTime" |
         "dtsChangeFile" |
         "hasChangedEmitSignature"
     > & { changedFilesSet: BuilderProgramState["changedFilesSet"] | undefined };
@@ -172,7 +167,6 @@ namespace ts {
             state.outSignature = oldState?.outSignature;
         }
         state.changedFilesSet = new Set();
-        state.dtsChangeTime = compilerOptions.composite ? oldState?.dtsChangeTime : undefined;
         state.dtsChangeFile = compilerOptions.composite ? oldState?.dtsChangeFile : undefined;
 
         const useOldState = BuilderState.canReuseOldState(state.referencedMap, oldState);
@@ -307,7 +301,6 @@ namespace ts {
             programEmitComplete: state.programEmitComplete,
             emitSignatures: state.emitSignatures && new Map(state.emitSignatures),
             outSignature: state.outSignature,
-            dtsChangeTime: state.dtsChangeTime,
             dtsChangeFile: state.dtsChangeFile,
             hasChangedEmitSignature: state.hasChangedEmitSignature,
             changedFilesSet: outFilePath ? new Set(state.changedFilesSet) : undefined,
@@ -322,7 +315,6 @@ namespace ts {
         state.programEmitComplete = savedEmitState.programEmitComplete;
         state.emitSignatures = savedEmitState.emitSignatures;
         state.outSignature = savedEmitState.outSignature;
-        state.dtsChangeTime = savedEmitState.dtsChangeTime;
         state.dtsChangeFile = savedEmitState.dtsChangeFile;
         state.hasChangedEmitSignature = savedEmitState.hasChangedEmitSignature;
         if (savedEmitState.changedFilesSet) state.changedFilesSet = savedEmitState.changedFilesSet;
@@ -803,7 +795,6 @@ namespace ts {
         affectedFilesPendingEmit?: ProgramBuilderInfoFilePendingEmit[];
         changeFileSet?: readonly ProgramBuildInfoFileId[];
         emitSignatures?: readonly ProgramBuildInfoEmitSignature[];
-        dtsChangeTime?: number;
         // Because this is only output file in the program, we dont need fileId to deduplicate name
         dtsChangeFile?: string;
     }
@@ -813,7 +804,6 @@ namespace ts {
         fileInfos: readonly string[];
         options: CompilerOptions | undefined;
         outSignature?: string;
-        dtsChangeTime?: number;
         dtsChangeFile?: string;
     }
 
@@ -826,13 +816,11 @@ namespace ts {
     /**
      * Gets the program information to be emitted in buildInfo so that we can use it to create new program
      */
-    function getProgramBuildInfo(state: BuilderProgramState, getCanonicalFileName: GetCanonicalFileName, host: BuilderProgramHost): ProgramBuildInfo | undefined {
+    function getProgramBuildInfo(state: BuilderProgramState, getCanonicalFileName: GetCanonicalFileName): ProgramBuildInfo | undefined {
         const outFilePath = outFile(state.compilerOptions);
         if (outFilePath && !state.compilerOptions.composite) return;
         const currentDirectory = Debug.checkDefined(state.program).getCurrentDirectory();
         const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(state.compilerOptions)!, currentDirectory));
-        // Update the dtsChange time in buildInfo
-        state.dtsChangeTime = state.hasChangedEmitSignature ? getCurrentTime(host).getTime() : state.dtsChangeTime;
         // Convert the file name to Path here if we set the fileName instead to optimize multiple d.ts file emits and having to compute Canonical path
         const dtsChangeFile = state.dtsChangeFile ? relativeToBuildInfoEnsuringAbsolutePath(state.dtsChangeFile) : undefined;
         if (outFilePath) {
@@ -849,7 +837,6 @@ namespace ts {
                 fileInfos,
                 options: convertToProgramBuildInfoCompilerOptions(state.compilerOptions, "affectsBundleEmitBuildInfo"),
                 outSignature: state.outSignature,
-                dtsChangeTime: state.dtsChangeTime,
                 dtsChangeFile,
             };
             return result;
@@ -953,7 +940,6 @@ namespace ts {
             affectedFilesPendingEmit,
             changeFileSet,
             emitSignatures,
-            dtsChangeTime: state.dtsChangeTime,
             dtsChangeFile,
         };
         return result;
@@ -1152,7 +1138,7 @@ namespace ts {
          */
         const computeHash = maybeBind(host, host.createHash);
         const state = createBuilderProgramState(newProgram, getCanonicalFileName, oldState, host.disableUseFileVersionAsSignature);
-        newProgram.getProgramBuildInfo = () => getProgramBuildInfo(state, getCanonicalFileName, host);
+        newProgram.getProgramBuildInfo = () => getProgramBuildInfo(state, getCanonicalFileName);
 
         // To ensure that we arent storing any references to old program or new program without state
         newProgram = undefined!; // TODO: GH#18217
@@ -1495,7 +1481,6 @@ namespace ts {
             state = {
                 fileInfos: new Map(),
                 compilerOptions: program.options ? convertToOptionsWithAbsolutePaths(program.options, toAbsolutePath) : {},
-                dtsChangeTime: program.dtsChangeTime,
                 dtsChangeFile,
                 outSignature: program.outSignature,
             };
@@ -1526,7 +1511,6 @@ namespace ts {
                 affectedFilesPendingEmitKind: program.affectedFilesPendingEmit && arrayToMap(program.affectedFilesPendingEmit, value => toFilePath(value[0]), value => value[1]),
                 affectedFilesPendingEmitIndex: program.affectedFilesPendingEmit && 0,
                 changedFilesSet: new Set(map(program.changeFileSet, toFilePath)),
-                dtsChangeTime: program.dtsChangeTime,
                 dtsChangeFile,
                 emitSignatures: emitSignatures?.size ? emitSignatures : undefined,
             };

src/compiler/emitter.ts

@@ -712,7 +712,6 @@ namespace ts {
         useCaseSensitiveFileNames(): boolean;
         getNewLine(): string;
         createHash?(data: string): string;
-        now?(): Date;
         getBuildInfo?(fileName: string, configFilePath: string | undefined): BuildInfo | undefined;
     }
 
@@ -832,7 +831,6 @@ namespace ts {
                         if (newBuildInfo.program && changedDtsText !== undefined && config.options.composite) {
                             // Update the output signature
                             (newBuildInfo.program as ProgramBundleEmitBuildInfo).outSignature = computeSignature(changedDtsText, createHash, changedDtsData);
-                            newBuildInfo.program.dtsChangeTime = getCurrentTime(host).getTime();
                         }
                         // Update sourceFileInfo
                         const { js, dts, sourceFiles } = buildInfo.bundle!;

src/compiler/tsbuildPublic.ts

@@ -224,6 +224,7 @@ namespace ts {
         path: Path;
         buildInfo: BuildInfo | false;
         modifiedTime: Date;
+        dtsChangeTime?: Date | false;
     }
 
     interface SolutionBuilderState<T extends BuilderProgram = BuilderProgram> extends WatchFactory<WatchType, ResolvedConfigFileName> {
@@ -980,21 +981,17 @@ namespace ts {
 
             // Actual Emit
             const { host, compilerHost } = state;
-            const hasChangedEmitSignature = program.hasChangedEmitSignature?.();
-            let resultFlags = hasChangedEmitSignature ? BuildResultFlags.None : BuildResultFlags.DeclarationOutputUnchanged;
+            const resultFlags = program.hasChangedEmitSignature?.() ? BuildResultFlags.None : BuildResultFlags.DeclarationOutputUnchanged;
             const emitterDiagnostics = createDiagnosticCollection();
             const emittedOutputs = new Map<Path, string>();
             const options = program.getCompilerOptions();
             const isIncremental = isIncrementalCompilation(options);
             let outputTimeStampMap: ESMap<Path, Date> | undefined;
             let now: Date | undefined;
-            // Check dts write only if hasChangedEmitSignature is not implemented
-            const checkDtsChange = options.composite && hasChangedEmitSignature === undefined;
             outputFiles.forEach(({ name, text, writeByteOrderMark, buildInfo }) => {
                 const path = toPath(state, name);
                 emittedOutputs.set(toPath(state, name), name);
-                if (checkDtsChange && isDeclarationFileName(name)) resultFlags &= ~BuildResultFlags.DeclarationOutputUnchanged;
-                if (buildInfo) setBuildInfo(state, buildInfo, projectPath, options);
+                if (buildInfo) setBuildInfo(state, buildInfo, projectPath, options, resultFlags);
                 writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
                 if (!isIncremental && state.watch) {
                     (outputTimeStampMap ||= getOutputTimeStampMap(state, projectPath)!).set(path, now ||= getCurrentTime(state.host));
@@ -1014,7 +1011,7 @@ namespace ts {
             Debug.assertIsDefined(program);
             Debug.assert(step === BuildStep.EmitBuildInfo);
             const emitResult = program.emitBuildInfo((name, text, writeByteOrderMark, onError, sourceFiles, data) => {
-                if (data?.buildInfo) setBuildInfo(state, data.buildInfo, projectPath, program!.getCompilerOptions());
+                if (data?.buildInfo) setBuildInfo(state, data.buildInfo, projectPath, program!.getCompilerOptions(), BuildResultFlags.DeclarationOutputUnchanged);
                 if (writeFileCallback) writeFileCallback(name, text, writeByteOrderMark, onError, sourceFiles, data);
                 else state.compilerHost.writeFile(name, text, writeByteOrderMark, onError, sourceFiles, data);
             }, cancellationToken);
@@ -1113,10 +1110,15 @@ namespace ts {
             const emitterDiagnostics = createDiagnosticCollection();
             const emittedOutputs = new Map<Path, string>();
             let resultFlags = BuildResultFlags.DeclarationOutputUnchanged;
+            const existingBuildInfo = state.buildInfoCache.get(projectPath)!.buildInfo as BuildInfo;
             outputFiles.forEach(({ name, text, writeByteOrderMark, buildInfo }) => {
                 emittedOutputs.set(toPath(state, name), name);
-                if (isDeclarationFileName(name)) resultFlags &= ~BuildResultFlags.DeclarationOutputUnchanged;
-                if (buildInfo) setBuildInfo(state, buildInfo, projectPath, config.options);
+                if (buildInfo) {
+                    if ((buildInfo.program as ProgramBundleEmitBuildInfo)?.outSignature !== (existingBuildInfo.program as ProgramBundleEmitBuildInfo)?.outSignature) {
+                        resultFlags &= ~BuildResultFlags.DeclarationOutputUnchanged;
+                    }
+                    setBuildInfo(state, buildInfo, projectPath, config.options, resultFlags);
+                }
                 writeFile(writeFileCallback ? { writeFile: writeFileCallback } : compilerHost, emitterDiagnostics, name, text, writeByteOrderMark);
             });
 
@@ -1456,15 +1458,28 @@ namespace ts {
         return result;
     }
 
-    function setBuildInfo(state: SolutionBuilderState, buildInfo: BuildInfo, resolvedConfigPath: ResolvedConfigFilePath, options: CompilerOptions) {
+    function setBuildInfo(
+        state: SolutionBuilderState,
+        buildInfo: BuildInfo,
+        resolvedConfigPath: ResolvedConfigFilePath,
+        options: CompilerOptions,
+        resultFlags: BuildResultFlags,
+    ) {
         const buildInfoPath = getTsBuildInfoEmitOutputFilePath(options)!;
         const existing = getBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath);
+        const modifiedTime = getCurrentTime(state.host);
         if (existing) {
             existing.buildInfo = buildInfo;
-            existing.modifiedTime = getCurrentTime(state.host);
+            existing.modifiedTime = modifiedTime;
+            if (!(resultFlags & BuildResultFlags.DeclarationOutputUnchanged)) existing.dtsChangeTime = modifiedTime;
         }
         else {
-            state.buildInfoCache.set(resolvedConfigPath, { path: toPath(state, buildInfoPath), buildInfo, modifiedTime: getCurrentTime(state.host) });
+            state.buildInfoCache.set(resolvedConfigPath, {
+                path: toPath(state, buildInfoPath),
+                buildInfo,
+                modifiedTime,
+                dtsChangeTime: resultFlags & BuildResultFlags.DeclarationOutputUnchanged ? undefined : modifiedTime,
+            });
         }
     }
 
@@ -1474,17 +1489,19 @@ namespace ts {
         return existing?.path === path ? existing : undefined;
     }
 
-    function getBuildInfo(state: SolutionBuilderState, buildInfoPath: string, resolvedConfigPath: ResolvedConfigFilePath, modifiedTime: Date | undefined): BuildInfo | undefined {
+    function getOrCreateBuildInfoCacheEntry(state: SolutionBuilderState, buildInfoPath: string, resolvedConfigPath: ResolvedConfigFilePath, modifiedTime: Date | undefined) {
         const path = toPath(state, buildInfoPath);
-        const existing = state.buildInfoCache.get(resolvedConfigPath);
-        if (existing !== undefined && existing.path === path) {
-            return existing.buildInfo || undefined;
-        }
+        let result = state.buildInfoCache.get(resolvedConfigPath);
+        if (result && result.path === path) return result;
         const value = state.readFileWithCache(buildInfoPath);
         const buildInfo = value ? ts.getBuildInfo(value) : undefined;
         Debug.assert(modifiedTime || !buildInfo);
-        state.buildInfoCache.set(resolvedConfigPath, { path, buildInfo: buildInfo || false, modifiedTime: modifiedTime || missingFileModifiedTime });
-        return buildInfo;
+        state.buildInfoCache.set(resolvedConfigPath, result = { path, buildInfo: buildInfo || false, modifiedTime: modifiedTime || missingFileModifiedTime });
+        return result;
+    }
+
+    function getBuildInfo(state: SolutionBuilderState, buildInfoPath: string, resolvedConfigPath: ResolvedConfigFilePath, modifiedTime: Date | undefined): BuildInfo | undefined {
+        return getOrCreateBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath, modifiedTime).buildInfo || undefined;
     }
 
     function checkConfigFileUpToDateStatus(state: SolutionBuilderState, configFile: string, oldestOutputFileTime: Date, oldestOutputFileName: string): Status.OutOfDateWithSelf | undefined {
@@ -1555,7 +1572,6 @@ namespace ts {
         let buildInfoTime: Date | undefined;
         let buildInfoProgram: ProgramBuildInfo | undefined;
         let buildInfoVersionMap: ESMap<Path, string> | undefined;
-        let newestDeclarationFileContentChangedTime;
         if (buildInfoPath) {
             const buildInfoCacheEntry = getBuildInfoCacheEntry(state, buildInfoPath, resolvedPath);
             buildInfoTime = buildInfoCacheEntry?.modifiedTime || ts.getModifiedTime(host, buildInfoPath);
@@ -1595,8 +1611,6 @@ namespace ts {
 
             oldestOutputFileTime = buildInfoTime;
             oldestOutputFileName = buildInfoPath;
-            // Get the last dtsChange time from build info
-            newestDeclarationFileContentChangedTime = buildInfo.program?.dtsChangeTime ? new Date(buildInfo.program.dtsChangeTime) : undefined;
         }
 
         // Check input files
@@ -1756,7 +1770,7 @@ namespace ts {
                 pseudoInputUpToDate ?
                     UpToDateStatusType.UpToDateWithInputFileText :
                     UpToDateStatusType.UpToDate,
-            newestDeclarationFileContentChangedTime,
+            newestDeclarationFileContentChangedTime: getDtsChangeTime(state, project.options, resolvedPath),
             newestInputFileTime,
             newestInputFileName,
             oldestOutputFileName: oldestOutputFileName!
@@ -1849,8 +1863,13 @@ namespace ts {
     function getDtsChangeTime(state: SolutionBuilderState, options: CompilerOptions, resolvedConfigPath: ResolvedConfigFilePath) {
         if (!options.composite) return undefined;
         const buildInfoPath = getTsBuildInfoEmitOutputFilePath(options)!;
-        const buildInfo = getBuildInfo(state, buildInfoPath, resolvedConfigPath, /*modifiedTime*/ undefined);
-        return buildInfo?.program?.dtsChangeTime ? new Date(buildInfo.program.dtsChangeTime) : undefined;
+        const entry = getOrCreateBuildInfoCacheEntry(state, buildInfoPath, resolvedConfigPath, /*modifiedTime*/ undefined);
+        if (entry.dtsChangeTime !== undefined) return entry.dtsChangeTime || undefined;
+        const dtsChangeTime = entry.buildInfo && entry.buildInfo.program && entry.buildInfo.program.dtsChangeFile ?
+            state.host.getModifiedTime(getNormalizedAbsolutePath(entry.buildInfo.program.dtsChangeFile, getDirectoryPath(entry.path))) :
+            undefined;
+        entry.dtsChangeTime = dtsChangeTime || false;
+        return dtsChangeTime;
     }
 
     function updateOutputTimestamps(state: SolutionBuilderState, proj: ParsedCommandLine, resolvedPath: ResolvedConfigFilePath) {

src/compiler/types.ts

@@ -6981,7 +6981,6 @@ namespace ts {
         // For testing:
         /*@internal*/ disableUseFileVersionAsSignature?: boolean;
         /*@internal*/ storeFilesChangingSignatureDuringEmit?: boolean;
-        /*@internal*/ now?(): Date;
     }
 
     /** true if --out otherwise source file name */

src/compiler/watch.ts

@@ -596,7 +596,6 @@ namespace ts {
             readDirectory: maybeBind(host, host.readDirectory),
             disableUseFileVersionAsSignature: host.disableUseFileVersionAsSignature,
             storeFilesChangingSignatureDuringEmit: host.storeFilesChangingSignatureDuringEmit,
-            now: maybeBind(host, host.now),
         };
 
         function writeFile(fileName: string, text: string, writeByteOrderMark: boolean, onError: (message: string) => void) {

src/compiler/watchPublic.ts

@@ -30,7 +30,6 @@ namespace ts {
         host.createHash = maybeBind(system, system.createHash);
         host.disableUseFileVersionAsSignature = system.disableUseFileVersionAsSignature;
         host.storeFilesChangingSignatureDuringEmit = system.storeFilesChangingSignatureDuringEmit;
-        host.now = maybeBind(system, system.now);
         setGetSourceFileAsHashVersioned(host, system);
         changeCompilerHostLikeToUseCache(host, fileName => toPath(fileName, host.getCurrentDirectory(), host.getCanonicalFileName));
         return host;

src/testRunner/unittests/tsbuild/helpers.ts

@@ -263,7 +263,6 @@ interface Symbol {
                         toFileName(s) :
                         [toFileName(s[0]), s[1]]
                 ),
-                dtsChangeTime: buildInfo.program.dtsChangeTime,
                 dtsChangeFile: buildInfo.program.dtsChangeFile,
             };
         }
@@ -545,7 +544,6 @@ interface Symbol {
                     options: { ...readableBuildInfo.program.options, noEmit: undefined },
                     exportedModulesMap: undefined,
                     affectedFilesPendingEmit: undefined,
-                    dtsChangeTime: readableBuildInfo.program.dtsChangeTime ? "FakeTime" : undefined,
                     dtsChangeFile: readableBuildInfo.program.dtsChangeFile ? "FakeFileName" : undefined,
                 },
                 size: undefined, // Size doesnt need to be equal