If we are writing dts file and have used file text as version, we can update the signature when doing actual emit

Author: sheetalkamat

src/compiler/builder.ts

@@ -161,6 +161,8 @@ namespace ts {
          * true if program has been emitted
          */
         programEmitComplete?: true;
+        /** Stores list of files that change signature during emit - test only */
+        filesChangingSignature?: Set<Path>;
     }
 
     function hasSameKeys(map1: ReadonlyCollection<string> | undefined, map2: ReadonlyCollection<string> | undefined): boolean {
@@ -1083,7 +1085,9 @@ namespace ts {
                 // Otherwise just affected file
                 Debug.checkDefined(state.program).emit(
                     affected === state.program ? undefined : affected as SourceFile,
-                    writeFile || maybeBind(host, host.writeFile),
+                    affected !== state.program && getEmitDeclarations(state.compilerOptions) && !customTransformers ?
+                    writeFileUpdatingSignature :
+                        writeFile || maybeBind(host, host.writeFile),
                     cancellationToken,
                     emitOnlyDtsFiles || emitKind === BuilderFileEmit.DtsOnly,
                     customTransformers
@@ -1092,6 +1096,39 @@ namespace ts {
                 emitKind,
                 isPendingEmitFile,
             );
+
+            function writeFileUpdatingSignature(
+                fileName: string,
+                data: string,
+                writeByteOrderMark: boolean,
+                onError?: (message: string) => void,
+                sourceFiles?: readonly SourceFile[],
+                sourceMapUrlPos?: number
+            ) {
+                Debug.assert(sourceFiles?.length === 1);
+                if (isDeclarationFileName(fileName)) {
+                    const file = sourceFiles[0];
+                    const info = state.fileInfos.get(file.resolvedPath)!;
+                    const signature = state.currentAffectedFilesSignatures?.get(file.resolvedPath) || info.signature;
+                    if (signature === file.version) {
+                        const newSignature = (computeHash || generateDjb2Hash)(sourceMapUrlPos !== undefined ? data.substring(0, sourceMapUrlPos) : data);
+                        if (newSignature !== file.version) { // Update it
+                            if (host.storeFilesChangingSignatureDuringEmit) (state.filesChangingSignature ||= new Set()).add(file.resolvedPath);
+                            if (state.exportedModulesMap) BuilderState.updateExportedModules(file, file.exportedModulesFromDeclarationEmit, state.currentAffectedFilesExportedModulesMap ||= BuilderState.createManyToManyPathMap());
+                            if (state.affectedFiles && state.affectedFilesIndex! < state.affectedFiles.length) {
+                                state.currentAffectedFilesSignatures!.set(file.resolvedPath, newSignature);
+                            }
+                            else {
+                                info.signature = newSignature;
+                                if (state.exportedModulesMap) BuilderState.updateExportedFilesMapFromCache(state, state.currentAffectedFilesExportedModulesMap);
+                            }
+                        }
+                    }
+                }
+                if (writeFile) writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles, sourceMapUrlPos);
+                else if (host.writeFile) host.writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles, sourceMapUrlPos);
+                else state.program!.writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles, sourceMapUrlPos);
+            }
         }
 
         /**

src/compiler/builderPublic.ts

@@ -20,6 +20,11 @@ namespace ts {
          */
         /*@internal*/
         disableUseFileVersionAsSignature?: boolean;
+        /**
+         * Store the list of files that update signature during the emit
+         */
+        /*@internal*/
+        storeFilesChangingSignatureDuringEmit?: boolean;
     }
 
     /**

src/compiler/builderState.ts

@@ -434,7 +434,7 @@ namespace ts {
                 );
                 const firstDts = firstOrUndefined(emitOutput.outputFiles);
                 if (firstDts) {
-                    Debug.assert(fileExtensionIsOneOf(firstDts.name, [Extension.Dts, Extension.Dmts, Extension.Dcts]), "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))}`);
+                    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);
                     if (exportedModulesMapCache && latestSignature !== prevSignature) {
                         updateExportedModules(sourceFile, emitOutput.exportedModulesFromDeclarationEmit, exportedModulesMapCache);
@@ -462,7 +462,7 @@ namespace ts {
         /**
          * Coverts the declaration emit result into exported modules map
          */
-        function updateExportedModules(sourceFile: SourceFile, exportedModulesFromDeclarationEmit: ExportedModulesFromDeclarationEmit | undefined, exportedModulesMapCache: ManyToManyPathMap) {
+        export function updateExportedModules(sourceFile: SourceFile, exportedModulesFromDeclarationEmit: ExportedModulesFromDeclarationEmit | undefined, exportedModulesMapCache: ManyToManyPathMap) {
             if (!exportedModulesFromDeclarationEmit) {
                 exportedModulesMapCache.deleteKey(sourceFile.resolvedPath);
                 return;

src/compiler/emitter.ts

@@ -531,6 +531,7 @@ namespace ts {
                 printer.writeFile(sourceFile!, writer, sourceMapGenerator);
             }
 
+            let sourceMapUrlPos;
             if (sourceMapGenerator) {
                 if (sourceMapDataList) {
                     sourceMapDataList.push({
@@ -548,6 +549,7 @@ namespace ts {
 
                 if (sourceMappingURL) {
                     if (!writer.isAtStartOfLine()) writer.rawWrite(newLine);
+                    sourceMapUrlPos = writer.getTextPos();
                     writer.writeComment(`//# ${"sourceMappingURL"}=${sourceMappingURL}`); // Tools can sometimes see this line as a source mapping url comment
                 }
 
@@ -562,7 +564,7 @@ namespace ts {
             }
 
             // Write the output file
-            writeFile(host, emitterDiagnostics, jsFilePath, writer.getText(), !!compilerOptions.emitBOM, sourceFiles);
+            writeFile(host, emitterDiagnostics, jsFilePath, writer.getText(), !!compilerOptions.emitBOM, sourceFiles, sourceMapUrlPos);
 
             // Reset state
             writer.clear();

src/compiler/moduleNameResolver.ts

@@ -1498,7 +1498,7 @@ namespace ts {
     }
 
     function loadJSOrExactTSFileName(extensions: Extensions, candidate: string, onlyRecordFailures: boolean, state: ModuleResolutionState): PathAndExtension | undefined {
-        if ((extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) && fileExtensionIsOneOf(candidate, [Extension.Dts, Extension.Dcts, Extension.Dmts])) {
+        if ((extensions === Extensions.TypeScript || extensions === Extensions.DtsOnly) && isDeclarationFileName(candidate)) {
             const result = tryFile(candidate, onlyRecordFailures, state);
             return result !== undefined ? { path: candidate, ext: forEach([Extension.Dts, Extension.Dcts, Extension.Dmts], e => fileExtensionIs(candidate, e) ? e : undefined)! } : undefined;
         }

src/compiler/parser.ts

@@ -9411,9 +9411,10 @@ namespace ts {
         }
     }
 
+    const dtsExtensions = [Extension.Dts, Extension.Dmts, Extension.Dcts];
     /** @internal */
     export function isDeclarationFileName(fileName: string): boolean {
-        return fileExtensionIsOneOf(fileName, [Extension.Dts, Extension.Dmts, Extension.Dcts]);
+        return fileExtensionIsOneOf(fileName, dtsExtensions);
     }
 
     /*@internal*/

src/compiler/program.ts

@@ -262,7 +262,7 @@ namespace ts {
             return newValue;
         };
         if (originalWriteFile) {
-            host.writeFile = (fileName, data, writeByteOrderMark, onError, sourceFiles) => {
+            host.writeFile = (fileName, data, ...rest) => {
                 const key = toPath(fileName);
                 fileExistsCache.delete(key);
 
@@ -277,7 +277,7 @@ namespace ts {
                         sourceFileCache.delete(key);
                     }
                 }
-                originalWriteFile.call(host, fileName, data, writeByteOrderMark, onError, sourceFiles);
+                originalWriteFile.call(host, fileName, data, ...rest);
             };
         }
 
@@ -1340,6 +1340,7 @@ namespace ts {
             useCaseSensitiveFileNames: () => host.useCaseSensitiveFileNames(),
             getFileIncludeReasons: () => fileReasons,
             structureIsReused,
+            writeFile,
         };
 
         onProgramCreateComplete();
@@ -1393,7 +1394,7 @@ namespace ts {
 
         function getRedirectReferenceForResolution(file: SourceFile) {
             const redirect = getResolvedProjectReferenceToRedirect(file.originalFileName);
-            if (redirect || !fileExtensionIsOneOf(file.originalFileName, [Extension.Dts, Extension.Dcts, Extension.Dmts])) return redirect;
+            if (redirect || !isDeclarationFileName(file.originalFileName)) return redirect;
 
             // The originalFileName could not be actual source file name if file found was d.ts from referecned project
             // So in this case try to look up if this is output from referenced project, if it is use the redirected project in that case
@@ -1894,8 +1895,7 @@ namespace ts {
                 getProjectReferenceRedirect,
                 isSourceOfProjectReferenceRedirect,
                 getSymlinkCache,
-                writeFile: writeFileCallback || (
-                    (fileName, data, writeByteOrderMark, onError, sourceFiles) => host.writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles)),
+                writeFile: writeFileCallback || writeFile,
                 isEmitBlocked,
                 readFile: f => host.readFile(f),
                 fileExists: f => {
@@ -1914,6 +1914,17 @@ namespace ts {
             };
         }
 
+        function writeFile(
+            fileName: string,
+            data: string,
+            writeByteOrderMark: boolean,
+            onError?: (message: string) => void,
+            sourceFiles?: readonly SourceFile[],
+            sourceMapUrlPos?: number,
+        ) {
+            host.writeFile(fileName, data, writeByteOrderMark, onError, sourceFiles, sourceMapUrlPos);
+        }
+
         function emitBuildInfo(writeFileCallback?: WriteFileCallback): EmitResult {
             Debug.assert(!outFile(options));
             tracing?.push(tracing.Phase.Emit, "emitBuildInfo", {}, /*separateBeginAndEnd*/ true);

src/compiler/sys.ts

@@ -1210,11 +1210,13 @@ namespace ts {
         base64decode?(input: string): string;
         base64encode?(input: string): string;
         /*@internal*/ bufferFrom?(input: string, encoding?: string): Buffer;
+        /*@internal*/ require?(baseDir: string, moduleName: string): RequireResult;
+        /*@internal*/ defaultWatchFileKind?(): WatchFileKind | undefined;
+
         // For testing
         /*@internal*/ now?(): Date;
         /*@internal*/ disableUseFileVersionAsSignature?: boolean;
-        /*@internal*/ require?(baseDir: string, moduleName: string): RequireResult;
-        /*@internal*/ defaultWatchFileKind?(): WatchFileKind | undefined;
+        /*@internal*/ storeFilesChangingSignatureDuringEmit?: boolean;
     }
 
     export interface FileWatcher {

src/compiler/types.ts

@@ -3862,6 +3862,7 @@ namespace ts {
         writeByteOrderMark: boolean,
         onError?: (message: string) => void,
         sourceFiles?: readonly SourceFile[],
+        sourceMapUrlPos?: number,
     ) => void;
 
     export class OperationCanceledException { }
@@ -4067,6 +4068,8 @@ namespace ts {
          * This implementation handles file exists to be true if file is source of project reference redirect when program is created using useSourceOfProjectReferenceRedirect
          */
         /*@internal*/ fileExists(fileName: string): boolean;
+        /** Call compilerHost.writeFile on host program was created with */
+        /*@internal*/ writeFile: WriteFileCallback;
     }
 
     /*@internal*/
@@ -6779,6 +6782,7 @@ namespace ts {
 
         // For testing:
         /*@internal*/ disableUseFileVersionAsSignature?: boolean;
+        /*@internal*/ storeFilesChangingSignatureDuringEmit?: boolean;
     }
 
     /** true if --out otherwise source file name */

src/compiler/utilities.ts

@@ -4446,10 +4446,10 @@ namespace ts {
         return combinePaths(newDirPath, sourceFilePath);
     }
 
-    export function writeFile(host: { writeFile: WriteFileCallback; }, diagnostics: DiagnosticCollection, fileName: string, data: string, writeByteOrderMark: boolean, sourceFiles?: readonly SourceFile[]) {
+    export function writeFile(host: { writeFile: WriteFileCallback; }, diagnostics: DiagnosticCollection, fileName: string, data: string, writeByteOrderMark: boolean, sourceFiles?: readonly SourceFile[], sourceMapUrlPos?: number) {
         host.writeFile(fileName, data, writeByteOrderMark, hostErrorMessage => {
             diagnostics.add(createCompilerDiagnostic(Diagnostics.Could_not_write_file_0_Colon_1, fileName, hostErrorMessage));
-        }, sourceFiles);
+        }, sourceFiles, sourceMapUrlPos);
     }
 
     function ensureDirectoriesExist(