Add incremental compilation.

.travis.yml

@@ -8,7 +8,7 @@ install:
  - yarn add $WEBPACK $TSLOADER $VUELOADER -D
  - yarn lint
 env:
- - WEBPACK=webpack@^5.0.0-alpha.0 TSLOADER=ts-loader@^5.0.0 VUELOADER=vue-loader@^15.2.4
+ - WEBPACK=webpack@^5.0.0-alpha.5 TSLOADER=ts-loader@^5.0.0 VUELOADER=vue-loader@^15.2.4
  - WEBPACK=webpack@^4.0.0 TSLOADER=ts-loader@^5.0.0 VUELOADER=vue-loader@^15.2.4
  - WEBPACK=webpack@^3.10.0 TSLOADER=ts-loader@^3.4.0 VUELOADER=vue-loader@^13.5.0
  - WEBPACK=webpack@^2.7.0 TSLOADER=ts-loader@^3.4.0 VUELOADER=vue-loader@^13.5.0

CHANGELOG.md

@@ -1,3 +1,7 @@
+## v1.0.0-alpha.2
+
+* [Add `useTypescriptIncrementalApi`](https://github.com/Realytics/fork-ts-checker-webpack-plugin/pull/198) (#196)
+
 ## v1.0.0-alpha.1
 
 * [Use object-spread instead of `Object.assign`](https://github.com/Realytics/fork-ts-checker-webpack-plugin/pull/194) (#194)

README.md

@@ -107,7 +107,7 @@ Options passed to formatters (currently only `codeframe` - see [available option
 If `true`, logger will not be used. Default: `false`.
 
 * **checkSyntacticErrors** `boolean`: 
-This option is useful if you're using ts-loader in `happyPackMode` with [HappyPack](https://github.com/amireh/happypack) or [thread-loader](https://github.com/webpack-contrib/thread-loader) to parallelise your builds.  It will ensure that the plugin checks for both syntactic errors (eg `const array = [{} {}];`) and semantic errors (eg `const x: number = '1';`).  By default the plugin only checks for semantic errors.  This is because when ts-loader is used in `transpileOnly` mode, ts-loader will still report syntactic errors. When used in `happyPackMode` it does not. Default: `false`.
+This option is useful if you're using ts-loader in `happyPackMode` with [HappyPack](https://github.com/amireh/happypack) or [thread-loader](https://github.com/webpack-contrib/thread-loader) to parallelise your builds.  If `true` it will ensure that the plugin checks for *both* syntactic errors (eg `const array = [{} {}];`) and semantic errors (eg `const x: number = '1';`).  By default the plugin only checks for semantic errors.  This is because when ts-loader is used in `transpileOnly` mode, ts-loader will still report syntactic errors. When used in `happyPackMode` it does not. Default: `false`.
 
 * **memoryLimit** `number`: 
 Memory limit for service process in MB. If service exits with allocation failed error, increase this number. Default: `2048`.
@@ -122,6 +122,15 @@ number **can increase checking time**. Default: `ForkTsCheckerWebpackPlugin.ONE_
 If `true`, the linter and compiler will process VueJs single-file-component (.vue) files. See the 
 [Vue section](https://github.com/Realytics/fork-ts-checker-webpack-plugin#vue) further down for information on how to correctly setup your project.
 
+* **useTypescriptIncrementalApi** `boolean`:
+If true, the plugin will use incremental compilation API introduced in typescript 2.7. In this mode you can only have 1 
+worker, but if the changes in your code are small (like you normally have when you work in 'watch' mode), the compilation 
+may be much faster, even compared to multi-threaded compilation. 
+
+* **measureCompilationTime** `boolean`:
+If true, the plugin will measure the time spent inside the compilation code. This may be useful to compare modes,
+especially if there are other loaders/plugins involved in the compilation.
+
 ### Pre-computed consts:      
   * `ForkTsCheckerWebpackPlugin.ONE_CPU` - always use one CPU
   * `ForkTsCheckerWebpackPlugin.ALL_CPUS` - always use all CPUs (will increase build time)

package.json

@@ -1,6 +1,6 @@
 {
   "name": "fork-ts-checker-webpack-plugin",
-  "version": "1.0.0-alpha.1",
+  "version": "1.0.0-alpha.2",
   "description": "Runs typescript type checker and linter on separate process.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -15,7 +15,8 @@
     "test:watch": "mocha -R spec --watch ./test/unit",
     "test:coverage": "rimraf coverage && istanbul cover -root lib --include-all-sources mocha -- -R spec ./test/unit ./test/integration",
     "lint": "tslint --project src/tsconfig.json && eslint ./test",
-    "lint:fix": "tslint --project src/tsconfig.json --fix && eslint ./test --fix"
+    "lint:fix": "tslint --project src/tsconfig.json --fix && eslint ./test --fix",
+    "watch": "tsc --version && tsc --project \"./src\" --watch"
   },
   "repository": {
     "url": "https://github.com/Realytics/fork-ts-checker-webpack-plugin.git",

src/ApiIncrementalChecker.ts

@@ -0,0 +1,150 @@
+import * as ts from 'typescript';
+import * as minimatch from 'minimatch';
+import * as path from 'path';
+import { IncrementalCheckerInterface } from './IncrementalCheckerInterface';
+import { CancellationToken } from './CancellationToken';
+import { NormalizedMessage } from './NormalizedMessage';
+import { Configuration, Linter, LintResult } from 'tslint';
+import { CompilerHost } from './CompilerHost';
+import { FsHelper } from './FsHelper';
+
+// Need some augmentation here - linterOptions.exclude is not (yet) part of the official
+// types for tslint.
+interface ConfigurationFile extends Configuration.IConfigurationFile {
+  linterOptions?: {
+    typeCheck?: boolean;
+    exclude?: string[];
+  };
+}
+
+export class ApiIncrementalChecker implements IncrementalCheckerInterface {
+  private linterConfig?: ConfigurationFile;
+
+  private readonly tsIncrementalCompiler: CompilerHost;
+  private linterExclusions: minimatch.IMinimatch[] = [];
+
+  private currentLintErrors = new Map<string, LintResult>();
+  private lastUpdatedFiles: string[] = [];
+  private lastRemovedFiles: string[] = [];
+
+  constructor(
+    programConfigFile: string,
+    compilerOptions: ts.CompilerOptions,
+    private linterConfigFile: string | false,
+    private linterAutoFix: boolean,
+    checkSyntacticErrors: boolean
+  ) {
+    this.initLinterConfig();
+
+    this.tsIncrementalCompiler = new CompilerHost(
+      programConfigFile,
+      compilerOptions,
+      checkSyntacticErrors
+    );
+  }
+
+  private initLinterConfig() {
+    if (!this.linterConfig && this.linterConfigFile) {
+      this.linterConfig = ApiIncrementalChecker.loadLinterConfig(
+        this.linterConfigFile
+      );
+
+      if (
+        this.linterConfig.linterOptions &&
+        this.linterConfig.linterOptions.exclude
+      ) {
+        // Pre-build minimatch patterns to avoid additional overhead later on.
+        // Note: Resolving the path is required to properly match against the full file paths,
+        // and also deals with potential cross-platform problems regarding path separators.
+        this.linterExclusions = this.linterConfig.linterOptions.exclude.map(
+          pattern => new minimatch.Minimatch(path.resolve(pattern))
+        );
+      }
+    }
+  }
+
+  private static loadLinterConfig(configFile: string): ConfigurationFile {
+    const tslint = require('tslint');
+
+    return tslint.Configuration.loadConfigurationFromPath(
+      configFile
+    ) as ConfigurationFile;
+  }
+
+  private createLinter(program: ts.Program): Linter {
+    const tslint = require('tslint');
+
+    return new tslint.Linter({ fix: this.linterAutoFix }, program);
+  }
+
+  public hasLinter(): boolean {
+    return !!this.linterConfig;
+  }
+
+  public isFileExcluded(filePath: string): boolean {
+    return (
+      filePath.endsWith('.d.ts') ||
+      this.linterExclusions.some(matcher => matcher.match(filePath))
+    );
+  }
+
+  public nextIteration() {
+    // do nothing
+  }
+
+  public async getDiagnostics(_cancellationToken: CancellationToken) {
+    const diagnostics = await this.tsIncrementalCompiler.processChanges();
+    this.lastUpdatedFiles = diagnostics.updatedFiles;
+    this.lastRemovedFiles = diagnostics.removedFiles;
+
+    return NormalizedMessage.deduplicate(
+      diagnostics.results.map(NormalizedMessage.createFromDiagnostic)
+    );
+  }
+
+  public getLints(_cancellationToken: CancellationToken) {
+    if (!this.linterConfig) {
+      return [];
+    }
+
+    for (const updatedFile of this.lastUpdatedFiles) {
+      if (this.isFileExcluded(updatedFile)) {
+        continue;
+      }
+
+      try {
+        const linter = this.createLinter(
+          this.tsIncrementalCompiler.getProgram()
+        );
+        // const source = fs.readFileSync(updatedFile, 'utf-8');
+        linter.lint(updatedFile, undefined!, this.linterConfig);
+        const lints = linter.getResult();
+        this.currentLintErrors.set(updatedFile, lints);
+      } catch (e) {
+        if (
+          FsHelper.existsSync(updatedFile) &&
+          // check the error type due to file system lag
+          !(e instanceof Error) &&
+          !(e.constructor.name === 'FatalError') &&
+          !(e.message && e.message.trim().startsWith('Invalid source file'))
+        ) {
+          // it's not because file doesn't exist - throw error
+          throw e;
+        }
+      }
+
+      for (const removedFile of this.lastRemovedFiles) {
+        this.currentLintErrors.delete(removedFile);
+      }
+    }
+
+    const allLints = [];
+    for (const [, value] of this.currentLintErrors) {
+      allLints.push(...value.failures);
+    }
+
+    return NormalizedMessage.deduplicate(
+      allLints.map(NormalizedMessage.createFromLint)
+    );
+  }
+}