Cache dts emit results

Fixes #43995

Author: sheetalkamat

src/compiler/builder.ts

@@ -1173,7 +1173,7 @@ namespace ts {
                     const info = state.fileInfos.get(file.resolvedPath)!;
                     const signature = state.currentAffectedFilesSignatures?.get(file.resolvedPath) || info.signature;
                     if (signature === file.version) {
-                        const newSignature = (computeHash || generateDjb2Hash)(data?.sourceMapUrlPos !== undefined ? text.substring(0, data.sourceMapUrlPos) : text);
+                        const newSignature = BuilderState.getSignatureFromWriteFileText(text, data, computeHash);
                         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());

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 });
@@ -394,6 +394,10 @@ namespace ts {
             state.hasCalledUpdateShapeSignature.add(path);
         }
 
+        export function getSignatureFromWriteFileText(text: string, data: WriteFileCallbackData | undefined, computeHash: ComputeHash | undefined) {
+            return (computeHash || generateDjb2Hash)(data?.sourceMapUrlPos !== undefined ? text.substring(0, data.sourceMapUrlPos) : text);
+        }
+
         /**
          * Returns if the shape of the signature has changed since last emit
          */
@@ -412,22 +416,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 = getSignatureFromWriteFileText(text, data, computeHash);
+                        if (exportedModulesMapCache && latestSignature !== prevSignature) {
+                            updateExportedModules(sourceFile, data?.exportedModulesFromDeclarationEmit, exportedModulesMapCache);
+                        }
+                    },
                     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 = (computeHash || generateDjb2Hash)(firstDts.text);
-                    if (exportedModulesMapCache && latestSignature !== prevSignature) {
-                        updateExportedModules(sourceFile, emitOutput.exportedModulesFromDeclarationEmit, exportedModulesMapCache);
-                    }
-                }
             }
             // Default is to use file version as signature
             if (latestSignature === undefined) {

src/compiler/builderStatePublic.ts

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

src/compiler/emitter.ts

@@ -276,6 +276,15 @@ namespace ts {
         return Debug.fail(`project ${configFile.options.configFilePath} expected to have at least one output`);
     }
 
+    /*@internal*/
+    export function getCacheDtsEmitResultKey(sourceFileOrBundle: SourceFile | Bundle, options: CompilerOptions) {
+        return isSourceFile(sourceFileOrBundle) ? sourceFileOrBundle.resolvedPath : outFile(options) as Path;
+    }
+
+    function isForceDtsEmitResult(result: CacheDtsEmitResult | undefined): result is ForceDtsEmitResult {
+        return !!result && !(result as TransformationResult<SourceFile | Bundle>).transformed;
+    }
+
     /*@internal*/
     // targetSourceFile is when users only want one file in entire project to be emitted. This is used in compileOnSave feature
     export function emitFiles(resolver: EmitResolver, host: EmitHost, targetSourceFile: SourceFile | undefined, { scriptTransformers, declarationTransformers }: EmitTransformers, emitOnlyDtsFiles?: boolean, onlyBuildInfo?: boolean, forceDtsEmit?: boolean): EmitResult {
@@ -288,7 +297,6 @@ namespace ts {
         const { enter, exit } = performance.createTimer("printTime", "beforePrint", "afterPrint");
         let bundleBuildInfo: BundleBuildInfo | undefined;
         let emitSkipped = false;
-        let exportedModulesFromDeclarationEmit: ExportedModulesFromDeclarationEmit | undefined;
 
         // Emit each output file
         enter();
@@ -308,7 +316,6 @@ namespace ts {
             diagnostics: emitterDiagnostics.getDiagnostics(),
             emittedFiles: emittedFilesList,
             sourceMaps: sourceMapDataList,
-            exportedModulesFromDeclarationEmit
         };
 
         function emitSourceFileOrBundle({ jsFilePath, sourceMapFilePath, declarationFilePath, declarationMapPath, buildInfoPath }: EmitFileNames, sourceFileOrBundle: SourceFile | Bundle | undefined) {
@@ -411,8 +418,7 @@ namespace ts {
                 substituteNode: transform.substituteNode,
             });
 
-            Debug.assert(transform.transformed.length === 1, "Should only see one output from the transform");
-            printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform.transformed[0], printer, compilerOptions);
+            printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform, printer, compilerOptions);
 
             // Clean up emit nodes on parse tree
             transform.dispose();
@@ -433,12 +439,48 @@ namespace ts {
             const filesForEmit = forceDtsEmit ? sourceFiles : filter(sourceFiles, isSourceFileNotJson);
             // Setup and perform the transformation to retrieve declarations from the input files
             const inputListOrBundle = outFile(compilerOptions) ? [factory.createBundle(filesForEmit, !isSourceFile(sourceFileOrBundle) ? sourceFileOrBundle.prepends : undefined)] : filesForEmit;
-            if (emitOnlyDtsFiles && !getEmitDeclarations(compilerOptions)) {
+            // Use existing result:
+            const key = getCacheDtsEmitResultKey(sourceFileOrBundle, compilerOptions);
+            const cache = host.getDtsEmitResultCache();
+            const existing = declarationTransformers.length === 1 ? cache.get(key) : undefined;
+            if (isForceDtsEmitResult(existing)) {
+                if (existing.diagnostics?.length) {
+                    for (const diagnostic of existing.diagnostics) {
+                        emitterDiagnostics.add(diagnostic);
+                    }
+                }
+                const declBlocked = !!existing.diagnostics?.length || !!host.isEmitBlocked(declarationFilePath) || !!compilerOptions.noEmit;
+                emitSkipped = emitSkipped || declBlocked;
+                if (!declBlocked || forceDtsEmit) {
+                    // Write the output file
+                    if (declarationMapPath && !forceDtsEmit) {
+                        if (sourceMapDataList && existing.sourceMapData) {
+                            sourceMapDataList.push(existing.sourceMapData);
+                        }
+                        writeFile(host, emitterDiagnostics, declarationMapPath, existing.sourceMap!, /*writeByteOrderMark*/ false, sourceFiles);
+                    }
+                    writeFile(
+                        host,
+                        emitterDiagnostics,
+                        declarationFilePath,
+                        existing.text,
+                        !!compilerOptions.emitBOM,
+                        filesForEmit,
+                        {
+                            sourceMapUrlPos: existing.sourceMapUrlPos,
+                            exportedModulesFromDeclarationEmit: existing.exportedModulesFromDeclarationEmit,
+                        }
+                    );
+                }
+                return;
+            }
+
+            if (!existing && emitOnlyDtsFiles && !getEmitDeclarations(compilerOptions)) {
                 // Checker wont collect the linked aliases since thats only done when declaration is enabled.
                 // Do that here when emitting only dts files
                 filesForEmit.forEach(collectLinkedAliases);
             }
-            const declarationTransform = transformNodes(resolver, host, factory, compilerOptions, inputListOrBundle, declarationTransformers, /*allowDtsFiles*/ false);
+            const declarationTransform = existing || transformNodes(resolver, host, factory, compilerOptions, inputListOrBundle, declarationTransformers, /*allowDtsFiles*/ false);
             if (length(declarationTransform.diagnostics)) {
                 for (const diagnostic of declarationTransform.diagnostics!) {
                     emitterDiagnostics.add(diagnostic);
@@ -451,8 +493,8 @@ namespace ts {
                 noEmitHelpers: true,
                 module: compilerOptions.module,
                 target: compilerOptions.target,
-                sourceMap: compilerOptions.sourceMap,
-                inlineSourceMap: compilerOptions.inlineSourceMap,
+                // Emit maps when there is noEmit not set with forceDtsEmit
+                sourceMap: (!forceDtsEmit || !compilerOptions.noEmit) && compilerOptions.declarationMap,
                 extendedDiagnostics: compilerOptions.extendedDiagnostics,
                 onlyPrintJsDocStyle: true,
                 writeBundleFileInfo: !!bundleBuildInfo,
@@ -472,24 +514,19 @@ namespace ts {
             const declBlocked = (!!declarationTransform.diagnostics && !!declarationTransform.diagnostics.length) || !!host.isEmitBlocked(declarationFilePath) || !!compilerOptions.noEmit;
             emitSkipped = emitSkipped || declBlocked;
             if (!declBlocked || forceDtsEmit) {
-                Debug.assert(declarationTransform.transformed.length === 1, "Should only see one output from the decl transform");
                 printSourceFileOrBundle(
                     declarationFilePath,
                     declarationMapPath,
-                    declarationTransform.transformed[0],
+                    declarationTransform,
                     declarationPrinter,
                     {
-                        sourceMap: !forceDtsEmit && compilerOptions.declarationMap,
+                        sourceMap: printerOptions.sourceMap,
                         sourceRoot: compilerOptions.sourceRoot,
                         mapRoot: compilerOptions.mapRoot,
                         extendedDiagnostics: compilerOptions.extendedDiagnostics,
                         // Explicitly do not passthru either `inline` option
                     }
                 );
-                if (forceDtsEmit && declarationTransform.transformed[0].kind === SyntaxKind.SourceFile) {
-                    const sourceFile = declarationTransform.transformed[0];
-                    exportedModulesFromDeclarationEmit = sourceFile.exportedModulesFromDeclarationEmit;
-                }
             }
             declarationTransform.dispose();
             if (bundleBuildInfo) bundleBuildInfo.dts = declarationPrinter.bundleFileInfo;
@@ -509,7 +546,10 @@ namespace ts {
             forEachChild(node, collectLinkedAliases);
         }
 
-        function printSourceFileOrBundle(jsFilePath: string, sourceMapFilePath: string | undefined, sourceFileOrBundle: SourceFile | Bundle, printer: Printer, mapOptions: SourceMapOptions) {
+        function printSourceFileOrBundle(
+            jsFilePath: string, sourceMapFilePath: string | undefined, transform: TransformationResult<SourceFile | Bundle>, printer: Printer, mapOptions: SourceMapOptions) {
+            Debug.assert(transform.transformed.length === 1, "Should only see one output from the transform");
+            const sourceFileOrBundle = transform.transformed[0];
             const bundle = sourceFileOrBundle.kind === SyntaxKind.Bundle ? sourceFileOrBundle : undefined;
             const sourceFile = sourceFileOrBundle.kind === SyntaxKind.SourceFile ? sourceFileOrBundle : undefined;
             const sourceFiles = bundle ? bundle.sourceFiles : [sourceFile!];
@@ -532,9 +572,11 @@ namespace ts {
             }
 
             let sourceMapUrlPos;
+            let sourceMap;
+            let sourceMapData;
             if (sourceMapGenerator) {
                 if (sourceMapDataList) {
-                    sourceMapDataList.push({
+                    sourceMapDataList.push(sourceMapData = {
                         inputSourceFileNames: sourceMapGenerator.getSources(),
                         sourceMap: sourceMapGenerator.toJSON()
                     });
@@ -555,16 +597,39 @@ namespace ts {
 
                 // Write the source map
                 if (sourceMapFilePath) {
-                    const sourceMap = sourceMapGenerator.toString();
-                    writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap, /*writeByteOrderMark*/ false, sourceFiles);
+                    sourceMap = sourceMapGenerator.toString();
+                    if (!forceDtsEmit) writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap, /*writeByteOrderMark*/ false, sourceFiles);
                 }
             }
             else {
                 writer.writeLine();
             }
 
             // Write the output file
-            writeFile(host, emitterDiagnostics, jsFilePath, writer.getText(), !!compilerOptions.emitBOM, sourceFiles, { sourceMapUrlPos });
+            writeFile(
+                host,
+                emitterDiagnostics,
+                jsFilePath,
+                writer.getText(),
+                !!compilerOptions.emitBOM,
+                sourceFiles,
+                {
+                    sourceMapUrlPos,
+                    exportedModulesFromDeclarationEmit: sourceFile?.exportedModulesFromDeclarationEmit,
+                }
+            );
+            if (forceDtsEmit) {
+                // Store the result
+                const key = getCacheDtsEmitResultKey(sourceFileOrBundle, compilerOptions);
+                host.getDtsEmitResultCache().set(key, {
+                    diagnostics: transform.diagnostics,
+                    text: writer.getText(),
+                    sourceMap,
+                    sourceMapData,
+                    sourceMapUrlPos,
+                    exportedModulesFromDeclarationEmit: sourceFile?.exportedModulesFromDeclarationEmit,
+                });
+            }
 
             // Reset state
             writer.clear();
@@ -833,6 +898,7 @@ namespace ts {
             getSourceFileFromReference: returnUndefined,
             redirectTargetsMap: createMultiMap(),
             getFileIncludeReasons: notImplemented,
+            getDtsEmitResultCache: () => new Map(),
         };
         emitFiles(
             notImplementedResolver,

src/compiler/program.ts

@@ -1120,6 +1120,7 @@ namespace ts {
         // Key is a file name. Value is the (non-empty, or undefined) list of files that redirect to it.
         let redirectTargetsMap = createMultiMap<Path, string>();
         let usesUriStyleNodeCoreModules = false;
+        let cacheDtsEmitResult: ESMap<Path, CacheDtsEmitResult> | undefined;
 
         /**
          * map with
@@ -1943,6 +1944,7 @@ namespace ts {
                 getSourceFileFromReference: (file, ref) => program.getSourceFileFromReference(file, ref),
                 redirectTargetsMap,
                 getFileIncludeReasons: program.getFileIncludeReasons,
+                getDtsEmitResultCache: () => cacheDtsEmitResult ||= new Map(),
             };
         }
 
@@ -2484,8 +2486,28 @@ namespace ts {
                 const resolver = getTypeChecker().getEmitResolver(sourceFile, cancellationToken);
                 // Don't actually write any files since we're just getting diagnostics.
                 const emitHost = getEmitHost(noop);
-                const result = transformNodes(resolver, emitHost, factory, options, sourceFile ? [sourceFile] : filter(emitHost.getSourceFiles(), isSourceFileNotJson), [transformDeclarations], /*allowDtsFiles*/ false);
-                return result.diagnostics || emptyArray;
+                if (sourceFile) {
+                    if (!outFile(options)) {
+                        // Check from cache
+                        const existing = cacheDtsEmitResult?.get(sourceFile.resolvedPath);
+                        if (existing) return existing.diagnostics || emptyArray;
+                    }
+                    const result = transformNodes(resolver, emitHost, factory, options, [sourceFile], [transformDeclarations], /*allowDtsFiles*/ false);
+                    if (!outFile(options)) {
+                        (cacheDtsEmitResult ||= new Map()).set(sourceFile.resolvedPath, result);
+                    }
+                    return result.diagnostics || emptyArray;
+                }
+                let diagnostics: DiagnosticWithLocation[] | undefined;
+                forEachEmittedFile(emitHost, (_emitFileNames, sourceFileOrBundle) => {
+                    const key = getCacheDtsEmitResultKey(sourceFileOrBundle!, options);
+                    const existing = cacheDtsEmitResult?.get(key);
+                    if (existing) return existing.diagnostics || emptyArray;
+                    const result = transformNodes(resolver, emitHost, factory, options, [sourceFileOrBundle!], [transformDeclarations], /*allowDtsFiles*/ false);
+                    diagnostics = addRange(diagnostics, result.diagnostics);
+                    (cacheDtsEmitResult ||= new Map()).set(key, result);
+                });
+                return diagnostics || emptyArray;
             });
         }