Add incremental compilation.

README.md

@@ -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

@@ -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",
@@ -88,7 +89,8 @@
     "chokidar": "^2.0.4",
     "micromatch": "^3.1.10",
     "minimatch": "^3.0.4",
-    "tapable": "^1.0.0"
+    "tapable": "^1.0.0",
+    "typescript-collections": "^1.3.2"
   },
   "husky": {
     "hooks": {

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)
+    );
+  }
+}