@rushstack/heft-typescript-plugin 0.1.0-rc.5 → 0.2.0-rc.6

package/lib/TypeScriptBuilder.js

@@ -28,25 +28,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TypeScriptBuilder = void 0;
 const crypto = __importStar(require("crypto"));
 const path = __importStar(require("path"));
+const worker_threads_1 = require("worker_threads");
 const semver = __importStar(require("semver"));
 const node_core_library_1 = require("@rushstack/node-core-library");
-const TypeScriptCachedFileSystem_1 = require("./fileSystem/TypeScriptCachedFileSystem");
+const configureProgramForMultiEmit_1 = require("./configureProgramForMultiEmit");
 const OLDEST_SUPPORTED_TS_MAJOR_VERSION = 2;
 const OLDEST_SUPPORTED_TS_MINOR_VERSION = 9;
 const NEWEST_SUPPORTED_TS_MAJOR_VERSION = 5;
 const NEWEST_SUPPORTED_TS_MINOR_VERSION = 0;
-// symbols for attaching hidden metadata to ts.Program instances.
-const INNER_GET_COMPILER_OPTIONS_SYMBOL = Symbol('getCompilerOptions');
-const INNER_EMIT_SYMBOL = Symbol('emit');
 class TypeScriptBuilder {
-    constructor(configuration) {
-        this._suppressedDiagnosticCodes = new Set();
-        this._cachedFileSystem = new TypeScriptCachedFileSystem_1.TypeScriptCachedFileSystem();
-        this._tool = undefined;
-        this._configuration = configuration;
-        this._typescriptLogger = configuration.scopedLogger;
-        this._typescriptTerminal = configuration.scopedLogger.terminal;
-    }
     get _tsCacheFilePath() {
         if (!this.__tsCacheFilePath) {
             // TypeScript internally handles if the tsconfig options have changed from when the tsbuildinfo file was created.
@@ -66,6 +56,14 @@ class TypeScriptBuilder {
         }
         return this.__tsCacheFilePath;
     }
+    constructor(configuration) {
+        this._suppressedDiagnosticCodes = new Set();
+        this._tool = undefined;
+        this._nextRequestId = 0;
+        this._configuration = configuration;
+        this._typescriptLogger = configuration.scopedLogger;
+        this._typescriptTerminal = configuration.scopedLogger.terminal;
+    }
     async invokeAsync(onChangeDetected) {
         var _a, _b;
         if (!this._tool) {
@@ -133,23 +131,12 @@ class TypeScriptBuilder {
                 ts.performance.measure(measurementName, beforeName, afterName);
                 return Object.assign(Object.assign({}, result), { duration: ts.performance.getDuration(measurementName), count: ts.performance.getCount(beforeName) });
             };
-            const measureTsPerformanceAsync = async (measurementName, fn) => {
-                const beforeName = `before${measurementName}`;
-                ts.performance.mark(beforeName);
-                const resultPromise = fn();
-                const result = await resultPromise;
-                const afterName = `after${measurementName}`;
-                ts.performance.mark(afterName);
-                ts.performance.measure(measurementName, beforeName, afterName);
-                return Object.assign(Object.assign({}, result), { duration: ts.performance.getDuration(measurementName) });
-            };
             this._typescriptTerminal.writeLine(`Using TypeScript version ${ts.version}`);
             const rawDiagnostics = [];
             const pendingOperations = new Set();
             this._tool = {
                 ts,
                 measureSync: measureTsPerformance,
-                measureAsync: measureTsPerformanceAsync,
                 sourceFileCache: new Map(),
                 watchProgram: undefined,
                 solutionBuilder: undefined,
@@ -171,7 +158,10 @@ class TypeScriptBuilder {
                         onChangeDetected();
                     }
                     return timeout;
-                }
+                },
+                worker: undefined,
+                pendingTranspilePromises: new Map(),
+                pendingTranspileSignals: new Map()
             };
         }
         const { performance } = this._tool.ts;
@@ -179,88 +169,17 @@ class TypeScriptBuilder {
         performance.disable();
         performance.enable();
         if (onChangeDetected !== undefined) {
-            this._runWatch(this._tool);
+            await this._runWatchAsync(this._tool);
         }
         else if (this._useSolutionBuilder) {
-            this._runSolutionBuild(this._tool);
+            await this._runSolutionBuildAsync(this._tool);
         }
         else {
             await this._runBuildAsync(this._tool);
         }
     }
-    _configureProgramForMultiEmit(innerProgram, ts) {
-        const program = innerProgram;
-        // Check to see if this Program has already been modified.
-        let { [INNER_EMIT_SYMBOL]: innerEmit, [INNER_GET_COMPILER_OPTIONS_SYMBOL]: innerGetCompilerOptions } = program;
-        if (!innerGetCompilerOptions) {
-            program[INNER_GET_COMPILER_OPTIONS_SYMBOL] = innerGetCompilerOptions = program.getCompilerOptions;
-        }
-        if (!innerEmit) {
-            program[INNER_EMIT_SYMBOL] = innerEmit = program.emit;
-        }
-        let foundPrimary = false;
-        let defaultModuleKind;
-        const multiEmitMap = new Map();
-        for (const moduleKindToEmit of this._moduleKindsToEmit) {
-            const kindCompilerOptions = moduleKindToEmit.isPrimary
-                ? Object.assign({}, innerGetCompilerOptions()) : Object.assign(Object.assign({}, innerGetCompilerOptions()), { module: moduleKindToEmit.moduleKind, outDir: moduleKindToEmit.outFolderPath, 
-                // Don't emit declarations for secondary module kinds
-                declaration: false, declarationMap: false });
-            if (!kindCompilerOptions.outDir) {
-                throw new node_core_library_1.InternalError('Expected compilerOptions.outDir to be assigned');
-            }
-            multiEmitMap.set(moduleKindToEmit, kindCompilerOptions);
-            if (moduleKindToEmit.isPrimary) {
-                if (foundPrimary) {
-                    throw new Error('Multiple primary module emit kinds encountered.');
-                }
-                else {
-                    foundPrimary = true;
-                }
-                defaultModuleKind = moduleKindToEmit.moduleKind;
-            }
-        }
-        const changedFiles = new Set();
-        program.emit = (targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) => {
-            if (emitOnlyDtsFiles) {
-                return program[INNER_EMIT_SYMBOL](targetSourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers);
-            }
-            if (targetSourceFile && changedFiles) {
-                changedFiles.add(targetSourceFile);
-            }
-            const originalCompilerOptions = program[INNER_GET_COMPILER_OPTIONS_SYMBOL]();
-            let defaultModuleKindResult;
-            const diagnostics = [];
-            let emitSkipped = false;
-            try {
-                for (const [moduleKindToEmit, kindCompilerOptions] of multiEmitMap) {
-                    program.getCompilerOptions = () => kindCompilerOptions;
-                    // Need to mutate the compiler options for the `module` field specifically, because emitWorker() captures
-                    // options in the closure and passes it to `ts.getTransformers()`
-                    originalCompilerOptions.module = moduleKindToEmit.moduleKind;
-                    const flavorResult = program[INNER_EMIT_SYMBOL](targetSourceFile, writeFile && wrapWriteFile(writeFile, moduleKindToEmit.jsExtensionOverride), cancellationToken, emitOnlyDtsFiles, customTransformers);
-                    emitSkipped = emitSkipped || flavorResult.emitSkipped;
-                    // Need to aggregate diagnostics because some are impacted by the target module type
-                    for (const diagnostic of flavorResult.diagnostics) {
-                        diagnostics.push(diagnostic);
-                    }
-                    if (moduleKindToEmit.moduleKind === defaultModuleKind) {
-                        defaultModuleKindResult = flavorResult;
-                    }
-                }
-                const mergedDiagnostics = ts.sortAndDeduplicateDiagnostics(diagnostics);
-                return Object.assign(Object.assign({}, defaultModuleKindResult), { changedSourceFiles: changedFiles, diagnostics: mergedDiagnostics, emitSkipped });
-            }
-            finally {
-                // Restore the original compiler options and module kind for future calls
-                program.getCompilerOptions = program[INNER_GET_COMPILER_OPTIONS_SYMBOL];
-                originalCompilerOptions.module = defaultModuleKind;
-            }
-        };
-        return { changedFiles };
-    }
-    _runWatch(tool) {
-        const { ts, measureSync: measureTsPerformance, pendingOperations, rawDiagnostics } = tool;
+    async _runWatchAsync(tool) {
+        const { ts, measureSync: measureTsPerformance, pendingOperations, rawDiagnostics, pendingTranspilePromises } = tool;
         if (!tool.solutionBuilder && !tool.watchProgram) {
             //#region CONFIGURE
             const { duration: configureDurationMs, tsconfig } = measureTsPerformance('Configure', () => {
@@ -290,12 +209,21 @@ class TypeScriptBuilder {
                 pendingOperations.delete(operation);
                 operation();
             }
+            if (pendingTranspilePromises.size) {
+                const emitResults = await Promise.all(pendingTranspilePromises.values());
+                for (const { diagnostics } of emitResults) {
+                    for (const diagnostic of diagnostics) {
+                        rawDiagnostics.push(diagnostic);
+                    }
+                }
+            }
+            // eslint-disable-next-line require-atomic-updates
             tool.executing = false;
         }
         this._logDiagnostics(ts, rawDiagnostics);
     }
     async _runBuildAsync(tool) {
-        const { ts, measureSync: measureTsPerformance, measureAsync: measureTsPerformanceAsync } = tool;
+        const { ts, measureSync: measureTsPerformance, pendingTranspilePromises } = tool;
         //#region CONFIGURE
         const { duration: configureDurationMs, tsconfig, compilerHost } = measureTsPerformance('Configure', () => {
             const _tsconfig = this._loadTsconfig(ts);
@@ -312,8 +240,15 @@ class TypeScriptBuilder {
         // There will be only one program here; emit will get a bit abused if we produce multiple outputs
         let builderProgram = undefined;
         let innerProgram;
+        const isolatedModules = !!this._configuration.useTranspilerWorker && !!tsconfig.options.isolatedModules;
+        const mode = isolatedModules ? 'declaration' : 'both';
+        let filesToTranspile;
         if (tsconfig.options.incremental) {
-            builderProgram = this._getCreateBuilderProgram(ts)(tsconfig.fileNames, tsconfig.options, compilerHost, ts.readBuilderProgram(tsconfig.options, compilerHost), ts.getConfigFileParsingDiagnostics(tsconfig), tsconfig.projectReferences);
+            // Use ts.createEmitAndSemanticDiagnositcsBuilderProgram directly because the customizations performed by
+            // _getCreateBuilderProgram duplicate those performed in this function for non-incremental build.
+            const oldProgram = ts.readBuilderProgram(tsconfig.options, compilerHost);
+            builderProgram = ts.createEmitAndSemanticDiagnosticsBuilderProgram(tsconfig.fileNames, tsconfig.options, compilerHost, oldProgram, ts.getConfigFileParsingDiagnostics(tsconfig), tsconfig.projectReferences);
+            filesToTranspile = getFilesToTranspileFromBuilderProgram(builderProgram);
             innerProgram = builderProgram.getProgram();
         }
         else {
@@ -325,11 +260,16 @@ class TypeScriptBuilder {
                 oldProgram: undefined,
                 configFileParsingDiagnostics: ts.getConfigFileParsingDiagnostics(tsconfig)
             });
+            filesToTranspile = getFilesToTranspileFromProgram(innerProgram);
         }
         // Prefer the builder program, since it is what gives us incremental builds
         const genericProgram = builderProgram || innerProgram;
         this._logReadPerformance(ts);
         //#endregion
+        if (isolatedModules) {
+            // Kick the transpilation worker.
+            this._queueTranspileInWorker(tool, genericProgram.getCompilerOptions(), filesToTranspile);
+        }
         //#region ANALYSIS
         const { duration: diagnosticsDurationMs, diagnostics: preDiagnostics } = measureTsPerformance('Analyze', () => {
             const rawDiagnostics = [
@@ -344,34 +284,34 @@ class TypeScriptBuilder {
         this._typescriptTerminal.writeVerboseLine(`Analyze: ${diagnosticsDurationMs}ms`);
         //#endregion
         //#region EMIT
-        const filesToWrite = [];
-        const writeFileCallback = (filePath, data) => {
-            filesToWrite.push({ filePath, data });
-        };
-        const { changedFiles } = this._configureProgramForMultiEmit(innerProgram, ts);
-        const emitResult = genericProgram.emit(undefined, writeFileCallback);
+        const { changedFiles } = (0, configureProgramForMultiEmit_1.configureProgramForMultiEmit)(innerProgram, ts, this._moduleKindsToEmit, mode);
+        const emitResult = genericProgram.emit(undefined, 
+        // The writeFile callback must be provided for the multi-emit redirector
+        ts.sys.writeFile, undefined, undefined, undefined);
+        this._cleanupWorker();
         //#endregion
         this._logEmitPerformance(ts);
         //#region FINAL_ANALYSIS
         // Need to ensure that we include emit diagnostics, since they might not be part of the other sets
         const rawDiagnostics = [...preDiagnostics, ...emitResult.diagnostics];
         //#endregion
-        //#region WRITE
-        // Using async file system I/O for theoretically better peak performance
-        // Also allows to run concurrently with linting
-        const writePromise = measureTsPerformanceAsync('Write', () => node_core_library_1.Async.forEachAsync(filesToWrite, async ({ filePath, data }) => this._cachedFileSystem.writeFile(filePath, data, { ensureFolderExists: true }), { concurrency: this._configuration.maxWriteParallelism }));
-        //#endregion
-        const { duration: writeDuration } = await writePromise;
-        this._typescriptTerminal.writeVerboseLine(`I/O Write: ${writeDuration}ms (${filesToWrite.length} files)`);
+        this._configuration.emitChangedFilesCallback(innerProgram, changedFiles);
+        if (pendingTranspilePromises.size) {
+            const emitResults = await Promise.all(pendingTranspilePromises.values());
+            for (const { diagnostics } of emitResults) {
+                for (const diagnostic of diagnostics) {
+                    rawDiagnostics.push(diagnostic);
+                }
+            }
+        }
         this._logDiagnostics(ts, rawDiagnostics);
         // Reset performance counters in case any are used in the callback
         ts.performance.disable();
         ts.performance.enable();
-        this._configuration.emitChangedFilesCallback(innerProgram, changedFiles);
     }
-    _runSolutionBuild(tool) {
+    async _runSolutionBuildAsync(tool) {
         this._typescriptTerminal.writeVerboseLine(`Using solution mode`);
-        const { ts, measureSync, rawDiagnostics } = tool;
+        const { ts, measureSync, rawDiagnostics, pendingTranspilePromises } = tool;
         rawDiagnostics.length = 0;
         if (!tool.solutionBuilder) {
             //#region CONFIGURE
@@ -396,7 +336,16 @@ class TypeScriptBuilder {
         //#region EMIT
         // Ignoring the exit status because we only care about presence of diagnostics
         tool.solutionBuilder.build();
+        this._cleanupWorker();
         //#endregion
+        if (pendingTranspilePromises.size) {
+            const emitResults = await Promise.all(pendingTranspilePromises.values());
+            for (const { diagnostics } of emitResults) {
+                for (const diagnostic of diagnostics) {
+                    rawDiagnostics.push(diagnostic);
+                }
+            }
+        }
         this._logDiagnostics(ts, rawDiagnostics);
     }
     _logDiagnostics(ts, rawDiagnostics) {
@@ -417,6 +366,7 @@ class TypeScriptBuilder {
         this._typescriptTerminal.writeVerboseLine(`Print: ${ts.performance.getDuration('printTime')}ms ` +
             `(${ts.performance.getCount('beforePrint')} files) (Includes Transform)`);
         this._typescriptTerminal.writeVerboseLine(`Emit: ${ts.performance.getDuration('Emit')}ms (Includes Print)`);
+        this._typescriptTerminal.writeVerboseLine(`I/O Write: ${ts.performance.getDuration('I/O Write')}ms (${ts.performance.getCount('beforeIOWrite')} files)`);
     }
     _logReadPerformance(ts) {
         this._typescriptTerminal.writeVerboseLine(`I/O Read: ${ts.performance.getDuration('I/O Read')}ms (${ts.performance.getCount('beforeIORead')} files)`);
@@ -605,13 +555,12 @@ class TypeScriptBuilder {
         return `${outFolderName}:${jsExtensionOverride || '.js'}`;
     }
     _loadTsconfig(ts) {
-        const parsedConfigFile = ts.readConfigFile(this._configuration.tsconfigPath, this._cachedFileSystem.readFile);
+        const parsedConfigFile = ts.readConfigFile(this._configuration.tsconfigPath, ts.sys.readFile);
         const currentFolder = path.dirname(this._configuration.tsconfigPath);
         const tsconfig = ts.parseJsonConfigFileContent(parsedConfigFile.config, {
-            fileExists: this._cachedFileSystem.exists,
-            readFile: this._cachedFileSystem.readFile,
-            readDirectory: (folderPath, extensions, excludes, includes, depth) => ts.matchFiles(folderPath, extensions, excludes, includes, 
-            /* useCaseSensitiveFileNames */ true, currentFolder, depth, this._cachedFileSystem.readFolderFilesAndDirectories.bind(this._cachedFileSystem), this._cachedFileSystem.getRealPath.bind(this._cachedFileSystem), this._cachedFileSystem.directoryExists.bind(this._cachedFileSystem)),
+            fileExists: ts.sys.fileExists,
+            readFile: ts.sys.readFile,
+            readDirectory: ts.sys.readDirectory,
             useCaseSensitiveFileNames: true
         }, currentFolder, 
         /*existingOptions:*/ undefined, this._configuration.tsconfigPath);
@@ -629,11 +578,18 @@ class TypeScriptBuilder {
             this._typescriptTerminal.writeVerboseLine(`Reading program "${compilerOptions.configFilePath}"`);
             const newProgram = ts.createEmitAndSemanticDiagnosticsBuilderProgram(fileNames, compilerOptions, host, oldProgram, configFileParsingDiagnostics, projectReferences);
             this._logReadPerformance(ts);
+            const isolatedModules = !!this._configuration.useTranspilerWorker && !!compilerOptions.isolatedModules;
+            const mode = isolatedModules ? 'declaration' : 'both';
+            if (isolatedModules) {
+                // Kick the transpilation worker.
+                const filesToTranspile = getFilesToTranspileFromBuilderProgram(newProgram);
+                this._queueTranspileInWorker(this._tool, compilerOptions, filesToTranspile);
+            }
             const { emit: originalEmit } = newProgram;
             const emit = (outerTargetSourceFile, outerWriteFile, outerCancellationToken, outerEmitOnlyDtsFiles, outerCustomTransformers) => {
                 const innerProgram = newProgram.getProgram();
                 const innerCompilerOptions = innerProgram.getCompilerOptions();
-                const { changedFiles } = this._configureProgramForMultiEmit(innerProgram, ts);
+                const { changedFiles } = (0, configureProgramForMultiEmit_1.configureProgramForMultiEmit)(innerProgram, ts, this._moduleKindsToEmit, mode);
                 const result = originalEmit.call(newProgram, outerTargetSourceFile, outerWriteFile, outerCancellationToken, outerEmitOnlyDtsFiles, outerCustomTransformers);
                 result.changedSourceFiles = changedFiles;
                 this._typescriptTerminal.writeVerboseLine(`Emitting program "${innerCompilerOptions.configFilePath}"`);
@@ -679,7 +635,7 @@ class TypeScriptBuilder {
         const reportWatchStatus = (diagnostic) => {
             this._printDiagnosticMessage(ts, diagnostic);
         };
-        const compilerHost = ts.createWatchCompilerHost(tsconfig.fileNames, tsconfig.options, ts.sys, this._getCreateBuilderProgram(ts), tool.reportDiagnostic, reportWatchStatus, tsconfig.projectReferences);
+        const compilerHost = ts.createWatchCompilerHost(tsconfig.fileNames, tsconfig.options, ts.sys, this._getCreateBuilderProgram(ts), tool.reportDiagnostic, reportWatchStatus, tsconfig.projectReferences, tsconfig.watchOptions);
         compilerHost.clearTimeout = tool.clearTimeout;
         compilerHost.setTimeout = tool.setTimeout;
         return compilerHost;
@@ -735,16 +691,100 @@ class TypeScriptBuilder {
                 throw new Error(`"${moduleKindName}" is not a valid module kind name.`);
         }
     }
+    _queueTranspileInWorker(tool, compilerOptions, filesToTranspile) {
+        const { pendingTranspilePromises, pendingTranspileSignals } = tool;
+        let maybeWorker = tool.worker;
+        if (!maybeWorker) {
+            const workerData = {
+                typeScriptToolPath: this._configuration.typeScriptToolPath
+            };
+            tool.worker = maybeWorker = new worker_threads_1.Worker(require.resolve('./TranspilerWorker.js'), {
+                workerData: workerData
+            });
+            maybeWorker.on('message', (response) => {
+                const { requestId: resolvingRequestId, type, result } = response;
+                const signal = pendingTranspileSignals.get(resolvingRequestId);
+                if (type === 'error') {
+                    const error = Object.assign(new Error(result.message), result);
+                    if (signal) {
+                        signal.reject(error);
+                    }
+                    else {
+                        this._typescriptTerminal.writeErrorLine(`Unexpected worker rejection for request with id ${resolvingRequestId}: ${error}`);
+                    }
+                }
+                else if (signal) {
+                    signal.resolve(result);
+                }
+                else {
+                    this._typescriptTerminal.writeErrorLine(`Unexpected worker resolution for request with id ${resolvingRequestId}`);
+                }
+                pendingTranspileSignals.delete(resolvingRequestId);
+                pendingTranspilePromises.delete(resolvingRequestId);
+            });
+            maybeWorker.once('exit', (exitCode) => {
+                if (pendingTranspileSignals.size) {
+                    const error = new Error(`Worker exited unexpectedly with code ${exitCode}.`);
+                    for (const { reject: rejectTranspile } of pendingTranspileSignals.values()) {
+                        rejectTranspile(error);
+                    }
+                    pendingTranspileSignals.clear();
+                }
+            });
+            maybeWorker.once('error', (err) => {
+                for (const { reject: rejectTranspile } of pendingTranspileSignals.values()) {
+                    rejectTranspile(err);
+                }
+                pendingTranspileSignals.clear();
+            });
+        }
+        // make linter happy
+        const worker = maybeWorker;
+        const requestId = ++this._nextRequestId;
+        const transpilePromise = new Promise((resolve, reject) => {
+            pendingTranspileSignals.set(requestId, { resolve, reject });
+            this._typescriptTerminal.writeLine(`Asynchronously transpiling ${compilerOptions.configFilePath}`);
+            const request = {
+                compilerOptions,
+                filesToTranspile,
+                moduleKindsToEmit: this._moduleKindsToEmit,
+                requestId
+            };
+            worker.postMessage(request);
+        });
+        pendingTranspilePromises.set(requestId, transpilePromise);
+    }
+    _cleanupWorker() {
+        const tool = this._tool;
+        if (!tool) {
+            return;
+        }
+        const { worker } = tool;
+        if (worker) {
+            worker.postMessage(false);
+            tool.worker = undefined;
+        }
+    }
 }
 exports.TypeScriptBuilder = TypeScriptBuilder;
-const JS_EXTENSION_REGEX = /\.js(\.map)?$/;
-function wrapWriteFile(baseWriteFile, jsExtensionOverride) {
-    if (!jsExtensionOverride) {
-        return baseWriteFile;
+function getFilesToTranspileFromBuilderProgram(builderProgram) {
+    const changedFilesSet = builderProgram.getState().changedFilesSet;
+    const filesToTranspile = new Map();
+    for (const fileName of changedFilesSet) {
+        const sourceFile = builderProgram.getSourceFile(fileName);
+        if (sourceFile && !sourceFile.isDeclarationFile) {
+            filesToTranspile.set(sourceFile.fileName, sourceFile.text);
+        }
+    }
+    return filesToTranspile;
+}
+function getFilesToTranspileFromProgram(program) {
+    const filesToTranspile = new Map();
+    for (const sourceFile of program.getSourceFiles()) {
+        if (!sourceFile.isDeclarationFile) {
+            filesToTranspile.set(sourceFile.fileName, sourceFile.text);
+        }
     }
-    const replacementExtension = `${jsExtensionOverride}$1`;
-    return (fileName, data, writeBOM, onError, sourceFiles) => {
-        return baseWriteFile(fileName.replace(JS_EXTENSION_REGEX, replacementExtension), data, writeBOM, onError, sourceFiles);
-    };
+    return filesToTranspile;
 }
 //# sourceMappingURL=TypeScriptBuilder.js.map