cache parsed tsconfig files (#607)

Author: ajafff

packages/wotan/src/project-host.ts

@@ -25,6 +25,16 @@ export class ProjectHost implements ts.CompilerHost {
     private processedFiles = new Map<string, ProcessedFileInfo>();
     private sourceFileCache = new Map<string, ts.SourceFile | undefined>();
     private fileContent = new Map<string, string>();
+    private tsconfigCache = new Map<string, ts.ExtendedConfigCacheEntry>();
+    private commandLineCache = new Map<string, ts.ParsedCommandLine>();
+
+    private parseConfigHost: ts.ParseConfigHost = {
+        useCaseSensitiveFileNames: this.useCaseSensitiveFileNames(),
+        readDirectory:
+            (rootDir, extensions, excludes, includes, depth) => this.readDirectory(rootDir, extensions, excludes, includes, depth),
+        fileExists: (f) => this.fileExists(f),
+        readFile: (f) => this.readFile(f),
+    };
 
     public getCanonicalFileName = ts.sys.useCaseSensitiveFileNames ? (f: string) => f : (f: string) => f.toLowerCase();
     private moduleResolutionCache = ts.createModuleResolutionCache(this.cwd, this.getCanonicalFileName);
@@ -208,6 +218,8 @@ export class ProjectHost implements ts.CompilerHost {
             (entry) => entry.kind === FileKind.Directory ? path.join(dir, entry.name) : undefined,
         );
     }
+    public getSourceFile(fileName: string, languageVersion: ts.ScriptTarget.JSON): ts.JsonSourceFile | undefined;
+    public getSourceFile(fileName: string, languageVersion: ts.ScriptTarget): ts.SourceFile | undefined;
     public getSourceFile(fileName: string, languageVersion: ts.ScriptTarget) {
         return resolveCachedResult(
             this.sourceFileCache,
@@ -225,6 +237,7 @@ export class ProjectHost implements ts.CompilerHost {
         oldProgram: ts.Program | undefined,
         projectReferences: ReadonlyArray<ts.ProjectReference> | undefined,
     ) {
+        options = {...options, suppressOutputPathCheck: true};
         this.compilerOptions = options;
         this.moduleResolutionCache = ts.createModuleResolutionCache(this.cwd, this.getCanonicalFileName, options);
         return ts.createProgram({rootNames, options, oldProgram, projectReferences, host: this});
@@ -255,6 +268,29 @@ export class ProjectHost implements ts.CompilerHost {
         this.processedFiles.delete(fileName);
     }
 
+    public getParsedCommandLine(fileName: string) {
+        return resolveCachedResult(this.commandLineCache, fileName, this.parseConfigFile);
+    }
+
+    @bind
+    private parseConfigFile(fileName: string) {
+        // Note to future self: it's highly unlikely that a tsconfig of a project reference is used as base config for another tsconfig.
+        // Therefore it doesn't make such sense to read or write the tsconfigCache here.
+        const sourceFile = this.getSourceFile(fileName, ts.ScriptTarget.JSON);
+        if (sourceFile === undefined)
+            return;
+        return ts.parseJsonSourceFileConfigFileContent(
+            sourceFile,
+            this.parseConfigHost,
+            path.dirname(fileName),
+            undefined,
+            fileName,
+            undefined,
+            undefined,
+            <ts.Map<ts.ExtendedConfigCacheEntry>>this.tsconfigCache,
+        );
+    }
+
     public resolveModuleNames(names: string[], file: string, _?: unknown, reference?: ts.ResolvedProjectReference) {
         const seen = new Map<string, ts.ResolvedModuleFull | undefined>();
         const resolve = (name: string) =>

packages/wotan/src/runner.ts

@@ -13,7 +13,7 @@ import {
 import * as path from 'path';
 import * as ts from 'typescript';
 import * as glob from 'glob';
-import { unixifyPath, hasSupportedExtension, addUnique, flatMap, createParseConfigHost, hasParseErrors, invertChangeRange } from './utils';
+import { unixifyPath, hasSupportedExtension, addUnique, flatMap, hasParseErrors, invertChangeRange } from './utils';
 import { Minimatch, IMinimatch } from 'minimatch';
 import { ProcessorLoader } from './services/processor-loader';
 import { injectable } from 'inversify';
@@ -327,20 +327,13 @@ export class Runner {
             if (!addUnique(seen, configFilePath))
                 continue;
 
-            let commandLine: ts.ParsedCommandLine;
+            let commandLine;
             if (typeof configFile !== 'string') {
                 ({commandLine} = configFile);
             } else {
-                const sourceFile = host.getSourceFile(configFile, ts.ScriptTarget.JSON);
-                if (sourceFile === undefined)
+                commandLine = host.getParsedCommandLine(configFile);
+                if (commandLine === undefined)
                     continue;
-                commandLine = ts.parseJsonSourceFileConfigFileContent(
-                    <ts.TsConfigSourceFile>sourceFile,
-                    createParseConfigHost(host),
-                    path.dirname(configFile),
-                    {noEmit: true},
-                    configFile,
-                );
             }
             if (commandLine.errors.length !== 0)
                 this.logger.warn(ts.formatDiagnostics(commandLine.errors, host));

packages/wotan/src/utils.ts

@@ -141,23 +141,6 @@ export function addUnique<T>(arr: T[], item: T & {[K in keyof T]: T[K]}) {
     return true;
 }
 
-export function createParseConfigHost(
-    host: Required<Pick<ts.CompilerHost, 'readDirectory' | 'readFile' | 'useCaseSensitiveFileNames' | 'fileExists'>>,
-): ts.ParseConfigHost {
-    return {
-        useCaseSensitiveFileNames: host.useCaseSensitiveFileNames(),
-        readDirectory(rootDir, extensions, excludes, includes, depth) {
-            return host.readDirectory(rootDir, extensions, excludes, includes, depth);
-        },
-        fileExists(f) {
-            return host.fileExists(f);
-        },
-        readFile(f) {
-            return host.readFile(f);
-        },
-    };
-}
-
 export function hasParseErrors(sourceFile: ts.SourceFile) {
     return (<{parseDiagnostics: ts.Diagnostic[]}><{}>sourceFile).parseDiagnostics.length !== 0;
 }