feat(@ngtools/webpack): use forked type checker

Author: filipesilva

packages/@ngtools/webpack/package.json

@@ -25,6 +25,8 @@
     "npm": ">= 3.0.0"
   },
   "dependencies": {
+    "tree-kill": "^1.0.0",
+    "chalk": "^2.0.1",
     "loader-utils": "^1.0.2",
     "enhanced-resolve": "^3.1.0",
     "magic-string": "^0.22.3",

packages/@ngtools/webpack/src/angular_compiler_plugin.ts

@@ -1,12 +1,13 @@
 // @ignoreDep @angular/compiler-cli
-// @ignoreDep @angular/compiler-cli/ngtools2
 import * as fs from 'fs';
+import { fork, ChildProcess } from 'child_process';
 import * as path from 'path';
 import * as ts from 'typescript';
 
 const { __NGTOOLS_PRIVATE_API_2, VERSION } = require('@angular/compiler-cli');
 const ContextElementDependency = require('webpack/lib/dependencies/ContextElementDependency');
 const NodeWatchFileSystem = require('webpack/lib/node/NodeWatchFileSystem');
+const treeKill = require('tree-kill');
 
 import { WebpackResourceLoader } from './resource_loader';
 import { WebpackCompilerHost } from './compiler_host';
@@ -24,10 +25,10 @@ import {
   replaceResources
 } from './transformers';
 import { time, timeEnd } from './benchmark';
+import { InitMessage, UpdateMessage } from './type_checker';
 
 // These imports do not exist on Angular versions lower than 5, so we cannot use a static ES6
 // import. Instead we copy their types into './ngtools_api2.d.ts'.
-// @ignoreDep @angular/compiler-cli/src/transformers/api
 let compilerCliNgtools: any = {};
 try {
   compilerCliNgtools = require('@angular/compiler-cli/ngtools2');
@@ -41,6 +42,7 @@ import {
   UNKNOWN_ERROR_CODE,
   SOURCE,
   Program,
+  CompilerOptions,
   CompilerHost,
   CreateProgramInterface,
   CreateCompilerHostInterface,
@@ -88,9 +90,9 @@ export class AngularCompilerPlugin implements Tapable {
 
   // TS compilation.
   private _compilerOptions: ts.CompilerOptions;
-  private _angularCompilerOptions: any;
+  private _angularCompilerOptions: CompilerOptions;
   private _tsFilenames: string[];
-  private _program: ts.Program & Program;
+  private _program: ts.Program | Program;
   private _compilerHost: WebpackCompilerHost;
   private _angularCompilerHost: WebpackCompilerHost & CompilerHost;
   // Contains `moduleImportPath#exportName` => `fullModulePath`.
@@ -109,6 +111,10 @@ export class AngularCompilerPlugin implements Tapable {
   private _compilation: any = null;
   private _failedCompilation = false;
 
+  // TypeChecker process.
+  private _forkTypeChecker = true;
+  private _typeCheckerProcess: ChildProcess;
+
   constructor(options: AngularCompilerPluginOptions) {
     this._options = Object.assign({}, options);
     this._setupOptions(this._options);
@@ -244,7 +250,8 @@ export class AngularCompilerPlugin implements Tapable {
       this._angularCompilerOptions.i18nInLocale = options.locale;
     }
     if (options.hasOwnProperty('missingTranslation')) {
-      this._angularCompilerOptions.i18nInMissingTranslations = options.missingTranslation;
+      this._angularCompilerOptions.i18nInMissingTranslations =
+        options.missingTranslation as 'error' | 'warning' | 'ignore';
     }
 
     // Use entryModule if available in options, otherwise resolve it from mainPath after program
@@ -278,10 +285,15 @@ export class AngularCompilerPlugin implements Tapable {
 
     // TODO: consider really using platform names in the plugin options.
     this._platform = options.replaceExport ? PLATFORM.Server : PLATFORM.Browser;
+
+    // Create a new process for the type checker.
+    if (this._forkTypeChecker) {
+      this._createForkedTypeChecker();
+    }
   }
 
   private _getTsProgram() {
-    return this._JitMode ? this._program : this._program.getTsProgram();
+    return this._JitMode ? this._program as ts.Program : (this._program as Program).getTsProgram();
   }
 
   private _getChangedTsFiles() {
@@ -293,19 +305,26 @@ export class AngularCompilerPlugin implements Tapable {
   private _createOrUpdateProgram() {
     this._getChangedTsFiles().forEach((file) => {
       if (!this._tsFilenames.includes(file)) {
+        // TODO: figure out if action is needed for files that were removed from the compilation.
         this._tsFilenames.push(file);
       }
     });
 
+    // Update the forked type checker.
+    if (!this._firstRun && this._forkTypeChecker) {
+      this._updateForkedTypeChecker(this._tsFilenames);
+    }
+
     if (this._JitMode) {
+
       // Create the TypeScript program.
       time('_createOrUpdateProgram.ts.createProgram');
       this._program = ts.createProgram(
         this._tsFilenames,
         this._angularCompilerOptions,
         this._angularCompilerHost,
-        this._program
-      ) as ts.Program & Program;
+        this._program as ts.Program
+      );
       timeEnd('_createOrUpdateProgram.ts.createProgram');
 
       return Promise.resolve();
@@ -316,8 +335,8 @@ export class AngularCompilerPlugin implements Tapable {
         rootNames: this._tsFilenames,
         options: this._angularCompilerOptions,
         host: this._angularCompilerHost,
-        oldProgram: this._program
-      }) as ts.Program & Program;
+        oldProgram: this._program as Program
+      });
       timeEnd('_createOrUpdateProgram.ng.createProgram');
 
       time('_createOrUpdateProgram.ng.loadNgStructureAsync');
@@ -408,6 +427,26 @@ export class AngularCompilerPlugin implements Tapable {
       });
   }
 
+  private _createForkedTypeChecker() {
+    // Bootstrap type checker is using local CLI.
+    const g: any = global;
+    const typeCheckerFile: string = g['angularCliIsLocal']
+      ? './type_checker_bootstrap.js'
+      : './type_checker.js';
+
+    this._typeCheckerProcess = fork(path.resolve(__dirname, typeCheckerFile));
+    this._typeCheckerProcess.send(new InitMessage(
+      this._compilerOptions, this._basePath, this._JitMode));
+
+    process.on('exit', () => {
+      treeKill(process.pid, 'SIGTERM');
+    });
+  }
+
+  private _updateForkedTypeChecker(changedTsFiles: string[]) {
+    this._typeCheckerProcess.send(new UpdateMessage(changedTsFiles));
+  }
+
 
   // Registration hook for webpack plugin.
   apply(compiler: any) {
@@ -596,17 +635,20 @@ export class AngularCompilerPlugin implements Tapable {
         // Build transforms, emit and report errors if there are changes or it's the first run.
         if (changedFiles.length > 0 || this._firstRun) {
 
+          // We now have the final list of changed TS files.
           // Go through each changed file and add transforms as needed.
-          time('_update.transformOps');
           const sourceFiles = this._getChangedTsFiles().map((fileName) => {
+            time('_update.getSourceFile');
             const sourceFile = this._getTsProgram().getSourceFile(fileName);
             if (!sourceFile) {
               throw new Error(`${fileName} is not part of the TypeScript compilation. `
-                + `Please include it in your tsconfig via the 'files' or 'include' property.`);
+              + `Please include it in your tsconfig via the 'files' or 'include' property.`);
             }
+            timeEnd('_update.getSourceFile');
             return sourceFile;
           });
 
+          time('_update.transformOps');
           sourceFiles.forEach((sf) => {
             const fileName = this._compilerHost.resolve(sf.fileName);
             let transformOps = [];
@@ -710,23 +752,26 @@ export class AngularCompilerPlugin implements Tapable {
       let shouldEmit = true;
 
       if (this._JitMode) {
-        const tsProgram: ts.Program = program;
+        const tsProgram = program as ts.Program;
 
-        // Check parameter diagnostics.
-        // TODO: check this only on initial program creation.
-        time('_emit.ts.getOptionsDiagnostics');
-        shouldEmit = shouldEmit && checkDiagnostics(tsProgram.getOptionsDiagnostics());
-        timeEnd('_emit.ts.getOptionsDiagnostics');
+        if (this._firstRun) {
+          // Check parameter diagnostics.
+          time('_emit.ts.getOptionsDiagnostics');
+          shouldEmit = shouldEmit && checkDiagnostics(tsProgram.getOptionsDiagnostics());
+          timeEnd('_emit.ts.getOptionsDiagnostics');
+        }
 
-        // Check syntactic diagnostics.
-        time('_emit.ts.getSyntacticDiagnostics');
-        shouldEmit = shouldEmit && checkDiagnostics(tsProgram.getSyntacticDiagnostics());
-        timeEnd('_emit.ts.getSyntacticDiagnostics');
+        if (this._firstRun || !this._forkTypeChecker) {
+          // Check syntactic diagnostics.
+          time('_emit.ts.getSyntacticDiagnostics');
+          shouldEmit = shouldEmit && checkDiagnostics(tsProgram.getSyntacticDiagnostics());
+          timeEnd('_emit.ts.getSyntacticDiagnostics');
 
-        // Check semantic diagnostics.
-        time('_emit.ts.getSemanticDiagnostics');
-        shouldEmit = shouldEmit && checkDiagnostics(tsProgram.getSemanticDiagnostics());
-        timeEnd('_emit.ts.getSemanticDiagnostics');
+          // Check semantic diagnostics.
+          time('_emit.ts.getSemanticDiagnostics');
+          shouldEmit = shouldEmit && checkDiagnostics(tsProgram.getSemanticDiagnostics());
+          timeEnd('_emit.ts.getSemanticDiagnostics');
+        }
 
         if (shouldEmit) {
           sourceFiles.forEach((sf) => {
@@ -740,31 +785,41 @@ export class AngularCompilerPlugin implements Tapable {
           });
         }
       } else {
-        const angularProgram: Program = program;
-
-        // Check parameter diagnostics.
-        // TODO: check this only on initial program creation.
-        time('_emit.ng.getTsOptionDiagnostics+getNgOptionDiagnostics');
-        shouldEmit = shouldEmit && checkDiagnostics([
-          ...angularProgram.getTsOptionDiagnostics(), ...angularProgram.getNgOptionDiagnostics()
-        ]);
-        timeEnd('_emit.ng.getTsOptionDiagnostics+getNgOptionDiagnostics');
-
-        // Check syntactic diagnostics.
-        time('_emit.ng.getTsSyntacticDiagnostics');
-        shouldEmit = shouldEmit && checkDiagnostics(angularProgram.getTsSyntacticDiagnostics());
-        timeEnd('_emit.ng.getTsSyntacticDiagnostics');
-
-        // Check TypeScript semantic and Angular structure diagnostics.
-        time('_emit.ng.getTsSemanticDiagnostics+getNgStructuralDiagnostics');
-        shouldEmit = shouldEmit && checkDiagnostics(
-          [...angularProgram.getTsSemanticDiagnostics(),
-          ...angularProgram.getNgStructuralDiagnostics()
-          ]);
-        timeEnd('_emit.ng.getTsSemanticDiagnostics+getNgStructuralDiagnostics');
-
-        // Check Angular semantic diagnostics
-        shouldEmit = shouldEmit && checkDiagnostics(angularProgram.getNgSemanticDiagnostics());
+        const angularProgram = program as Program;
+
+        if (this._firstRun) {
+          // Check TypeScript parameter diagnostics.
+          time('_emit.ng.getTsOptionDiagnostics');
+          shouldEmit = shouldEmit && checkDiagnostics(angularProgram.getTsOptionDiagnostics());
+          timeEnd('_emit.ng.getTsOptionDiagnostics');
+
+          // Check Angular parameter diagnostics.
+          time('_emit.ng.getNgOptionDiagnostics');
+          shouldEmit = shouldEmit && checkDiagnostics(angularProgram.getNgOptionDiagnostics());
+          timeEnd('_emit.ng.getNgOptionDiagnostics');
+        }
+
+        if (this._firstRun || !this._forkTypeChecker) {
+          // Check TypeScript syntactic diagnostics.
+          time('_emit.ng.getTsSyntacticDiagnostics');
+          shouldEmit = shouldEmit && checkDiagnostics(angularProgram.getTsSyntacticDiagnostics());
+          timeEnd('_emit.ng.getTsSyntacticDiagnostics');
+
+          // Check TypeScript semantic.
+          time('_emit.ng.getTsSemanticDiagnostics');
+          shouldEmit = shouldEmit && checkDiagnostics(angularProgram.getTsSemanticDiagnostics());
+          timeEnd('_emit.ng.getTsSemanticDiagnostics');
+
+          // Check Angular structural diagnostics.
+          time('_emit.ng.getNgStructuralDiagnostics');
+          shouldEmit = shouldEmit && checkDiagnostics(angularProgram.getNgStructuralDiagnostics());
+          timeEnd('_emit.ng.getNgStructuralDiagnostics');
+
+          // Check Angular semantic diagnostics
+          time('_emit.ng.getNgSemanticDiagnostics');
+          shouldEmit = shouldEmit && checkDiagnostics(angularProgram.getNgSemanticDiagnostics());
+          timeEnd('_emit.ng.getNgSemanticDiagnostics');
+        }
 
         if (shouldEmit) {
           time('_emit.ng.emit');