[Experiment] Cache Dts Emit result / transform

src/compiler/builder.ts

@@ -1038,10 +1038,6 @@ namespace ts {
         return { host, newProgram, oldProgram, configFileParsingDiagnostics: configFileParsingDiagnostics || emptyArray };
     }
 
-    export function computeSignature(text: string, data: WriteFileCallbackData | undefined, computeHash: BuilderState.ComputeHash | undefined) {
-        return BuilderState.computeSignature(data?.sourceMapUrlPos !== undefined ? text.substring(0, data.sourceMapUrlPos) : text, computeHash);
-    }
-
     export function createBuilderProgram(kind: BuilderProgramKind.SemanticDiagnosticsBuilderProgram, builderCreationParameters: BuilderCreationParameters): SemanticDiagnosticsBuilderProgram;
     export function createBuilderProgram(kind: BuilderProgramKind.EmitAndSemanticDiagnosticsBuilderProgram, builderCreationParameters: BuilderCreationParameters): EmitAndSemanticDiagnosticsBuilderProgram;
     export function createBuilderProgram(kind: BuilderProgramKind, { newProgram, host, oldProgram, configFileParsingDiagnostics }: BuilderCreationParameters) {
@@ -1170,7 +1166,7 @@ namespace ts {
                             const file = sourceFiles[0];
                             const info = state.fileInfos.get(file.resolvedPath)!;
                             if (info.signature === file.version) {
-                                newSignature = computeSignature(text, data, computeHash);
+                                newSignature = BuilderState.computeSignature(text, computeHash, data);
                                 if (newSignature !== file.version) { // Update it
                                     if (host.storeFilesChangingSignatureDuringEmit) (state.filesChangingSignature ||= new Set()).add(file.resolvedPath);
                                     if (state.exportedModulesMap) BuilderState.updateExportedModules(state, file, file.exportedModulesFromDeclarationEmit);
@@ -1195,15 +1191,15 @@ namespace ts {
                         if (state.compilerOptions.composite) {
                             const filePath = sourceFiles[0].resolvedPath;
                             const oldSignature = state.emitSignatures?.get(filePath);
-                            newSignature ||= computeSignature(text, data, computeHash);
+                            newSignature ||= BuilderState.computeSignature(text, computeHash, data);
                             if (newSignature !== oldSignature) {
                                 (state.emitSignatures ||= new Map()).set(filePath, newSignature);
                                 state.hasChangedEmitSignature = true;
                             }
                         }
                     }
                     else if (state.compilerOptions.composite) {
-                        const newSignature = computeSignature(text, data, computeHash);
+                        const newSignature = BuilderState.computeSignature(text, computeHash, data);
                         if (newSignature !== state.outSignature) {
                             state.outSignature = newSignature;
                             state.hasChangedEmitSignature = true;

src/compiler/builderState.ts

@@ -3,8 +3,8 @@ namespace ts {
     export function getFileEmitOutput(program: Program, sourceFile: SourceFile, emitOnlyDtsFiles: boolean,
         cancellationToken?: CancellationToken, customTransformers?: CustomTransformers, forceDtsEmit?: boolean): EmitOutput {
         const outputFiles: OutputFile[] = [];
-        const { emitSkipped, diagnostics, exportedModulesFromDeclarationEmit } = program.emit(sourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers, forceDtsEmit);
-        return { outputFiles, emitSkipped, diagnostics, exportedModulesFromDeclarationEmit };
+        const { emitSkipped, diagnostics } = program.emit(sourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers, forceDtsEmit);
+        return { outputFiles, emitSkipped, diagnostics };
 
         function writeFile(fileName: string, text: string, writeByteOrderMark: boolean) {
             outputFiles.push({ name: fileName, writeByteOrderMark, text });
@@ -346,6 +346,10 @@ namespace ts {
             (state.hasCalledUpdateShapeSignature ||= new Set()).add(path);
         }
 
+        export function computeSignature(text: string, computeHash: ComputeHash | undefined, data?: WriteFileCallbackData) {
+            return (computeHash || generateDjb2Hash)(data?.sourceMapUrlPos !== undefined ? text.substring(0, data.sourceMapUrlPos) : text);
+        }
+
         /**
          * Returns if the shape of the signature has changed since last emit
          */
@@ -357,22 +361,21 @@ namespace ts {
             const prevSignature = info.signature;
             let latestSignature: string | undefined;
             if (!sourceFile.isDeclarationFile && !useFileVersionAsSignature) {
-                const emitOutput = getFileEmitOutput(
-                    programOfThisState,
+                programOfThisState.emit(
                     sourceFile,
-                    /*emitOnlyDtsFiles*/ true,
+                    (fileName, text, _writeByteOrderMark, _onError, _sourceFiles, data) => {
+                        Debug.assert(isDeclarationFileName(fileName), "File extension for signature expected to be dts");
+                        Debug.assert(latestSignature === undefined, "Only one file should be set");
+                        latestSignature = computeSignature(text, computeHash, data);
+                        if (latestSignature !== prevSignature) {
+                            updateExportedModules(state, sourceFile, data?.exportedModulesFromDeclarationEmit);
+                        }
+                    },
                     cancellationToken,
+                    /*emitOnlyDtsFiles*/ true,
                     /*customTransformers*/ undefined,
                     /*forceDtsEmit*/ true
                 );
-                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 = computeSignature(firstDts.text, computeHash);
-                    if (latestSignature !== prevSignature) {
-                        updateExportedModules(state, sourceFile, emitOutput.exportedModulesFromDeclarationEmit);
-                    }
-                }
             }
             // Default is to use file version as signature
             if (latestSignature === undefined) {
@@ -395,10 +398,6 @@ 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/builderStatePublic.ts

@@ -3,7 +3,6 @@ namespace ts {
         outputFiles: OutputFile[];
         emitSkipped: boolean;
         /* @internal */ diagnostics: readonly Diagnostic[];
-        /* @internal */ exportedModulesFromDeclarationEmit?: ExportedModulesFromDeclarationEmit;
     }
 
     export interface OutputFile {