Merge pull request #193 from typed-ember/extract-compiler-state

Pull out incremental-compiler state management

Author: chriskrycho

lib/commands/precompile.js

@@ -6,7 +6,6 @@ const execa = require('execa');
 const fs = require('fs-extra');
 const path = require('path');
 const walkSync = require('walk-sync');
-const mkdirp = require('mkdirp');
 const Command = require('ember-cli/lib/models/command'); // eslint-disable-line node/no-unpublished-require
 
 const PRECOMPILE_MANIFEST = 'tmp/.ts-precompile-manifest';
@@ -37,7 +36,7 @@ module.exports = Command.extend({
     ];
 
     // Ensure the output directory is created even if no files are generated
-    mkdirp.sync(outDir);
+    fs.mkdirsSync(outDir);
 
     return execa('tsc', flags).then(() => {
       let output = [];
@@ -54,7 +53,7 @@ module.exports = Command.extend({
         }
       }
 
-      mkdirp.sync(path.dirname(manifestPath));
+      fs.mkdirsSync(path.dirname(manifestPath));
       fs.writeFileSync(manifestPath, JSON.stringify(output.reverse()));
       fs.remove(outDir);
     });

lib/incremental-typescript-compiler/compiler-state.js

@@ -0,0 +1,65 @@
+'use strict';
+
+const debug = require('debug')('ember-cli-typescript:compiler-state');
+const RSVP = require('rsvp');
+
+/*
+ * This class captures the state of the Broccoli build and the TypeScript
+ * compilation process in terms of our concurrent juggling of the two.
+ * It maintains a `buildDeferred` object for the most recently started
+ * TS compilation, and it accepts notifications about changes in the state
+ * of the world framed as {broccoli,tsc}Did{Start,End} method calls.
+ */
+module.exports = class CompilerState {
+  constructor() {
+    this._buildingBroccoliNodes = 0;
+    this.tscDidStart();
+  }
+
+  broccoliDidStart() {
+    this._buildingBroccoliNodes++;
+    this._emitTransition('broccoliDidStart');
+  }
+
+  broccoliDidEnd() {
+    this._buildingBroccoliNodes--;
+    this._emitTransition('broccoliDidEnd');
+  }
+
+  tscDidStart() {
+    if (this.buildDeferred) {
+      this.buildDeferred.resolve();
+    }
+
+    this.buildDeferred = RSVP.defer();
+    this._tscBuilding = true;
+    this._pendingErrors = [];
+    this._emitTransition('tscDidStart');
+  }
+
+  tscDidEnd() {
+    if (this._pendingErrors.length) {
+      this.buildDeferred.reject(new Error(this._pendingErrors.join('\n')));
+    } else {
+      this.buildDeferred.resolve();
+    }
+
+    this._tscBuilding = false;
+    this._emitTransition('tscDidEnd');
+  }
+
+  didError(error) {
+    this._pendingErrors.push(error);
+    this._emitTransition('didError');
+  }
+
+  _emitTransition(event) {
+    debug(
+      `%s | broccoli: %s active nodes | tsc: %s (%s errors)`,
+      event,
+      this._buildingBroccoliNodes,
+      this._tscBuilding ? 'building' : 'idle',
+      this._pendingErrors.length
+    );
+  }
+};

lib/incremental-typescript-compiler.js renamed to lib/incremental-typescript-compiler/index.js

@@ -1,20 +1,17 @@
 'use strict';
 
-const tmpdir = require('./utilities/tmpdir');
-const mkdirp = require('mkdirp');
+const tmpdir = require('../utilities/tmpdir');
 const Funnel = require('broccoli-funnel');
 const MergeTrees = require('broccoli-merge-trees');
-const symlinkOrCopy = require('symlink-or-copy');
-const Plugin = require('broccoli-plugin');
-const RSVP = require('rsvp');
 const path = require('path');
-const fs = require('fs');
+const fs = require('fs-extra');
 const resolve = require('resolve');
-const compile = require('./utilities/compile');
+const compile = require('../utilities/compile');
 const ts = require('typescript');
+const TypescriptOutput = require('./typescript-output-plugin');
+const CompilerState = require('./compiler-state');
 
-const debugCompiler = require('debug')('ember-cli-typescript:compiler');
-const debugAutoresolve = require('debug')('ember-cli-typescript:autoresolve');
+const debugTsc = require('debug')('ember-cli-typescript:tsc');
 
 module.exports = class IncrementalTypescriptCompiler {
   constructor(app, project) {
@@ -29,21 +26,12 @@ module.exports = class IncrementalTypescriptCompiler {
     this.app = app;
     this.project = project;
     this.addons = this._discoverAddons(project, []);
-    this.maxBuildCount = 1;
-    this.autoresolveThreshold = 250;
-
-    this._buildDeferred = RSVP.defer();
-    this._isSynced = false;
-    this._pendingErrors = [];
-    this._triggerDir = `${this.outDir()}/.rebuild`;
-    this._pendingAutoresolve = null;
-    this._didAutoresolve = false;
+    this.state = new CompilerState();
+
     this._watchProgram = null;
   }
 
   treeForHost() {
-    let triggerTree = new Funnel(this._triggerDir, { destDir: 'app' });
-
     let appTree = new TypescriptOutput(this, {
       [`${this._relativeAppRoot()}/app`]: 'app',
     });
@@ -53,7 +41,7 @@ module.exports = class IncrementalTypescriptCompiler {
       [mirage]: 'app/mirage',
     });
 
-    let tree = new MergeTrees([triggerTree, mirageTree, appTree].filter(Boolean), { overwrite: true });
+    let tree = new MergeTrees([mirageTree, appTree].filter(Boolean), { overwrite: true });
     return new Funnel(tree, { srcDir: 'app' });
   }
 
@@ -85,14 +73,14 @@ module.exports = class IncrementalTypescriptCompiler {
   }
 
   buildPromise() {
-    return this._buildDeferred.promise;
+    return this.state.buildDeferred.promise;
   }
 
   outDir() {
     if (!this._outDir) {
       let outDir = path.join(tmpdir(), `e-c-ts-${process.pid}`);
       this._outDir = outDir;
-      mkdirp.sync(outDir);
+      fs.mkdirsSync(outDir);
     }
 
     return this._outDir;
@@ -104,47 +92,26 @@ module.exports = class IncrementalTypescriptCompiler {
       return;
     }
 
-    mkdirp.sync(this._triggerDir);
-    this._touchRebuildTrigger();
-
     let project = this.project;
     let outDir = this.outDir();
 
     this._watchProgram = compile(project, { outDir, watch: true }, {
+      watchedFileChanged: () => this.state.tscDidStart(),
+
       reportWatchStatus: (diagnostic) => {
         let text = diagnostic.messageText;
-
-        if (text.indexOf('Starting incremental compilation') !== -1) {
-          debugCompiler('tsc detected a file change');
-          this.willRebuild();
-          clearTimeout(this._pendingAutoresolve);
-        }
+        debugTsc(text);
 
         if (text.indexOf('Compilation complete') !== -1) {
-          debugCompiler('rebuild completed');
-
-          this.didSync();
-
-          if (this._didAutoresolve) {
-            this._touchRebuildTrigger();
-            this.maxBuildCount++;
-          }
-
-          clearTimeout(this._pendingAutoresolve);
-          this._didAutoresolve = false;
+          this.state.tscDidEnd();
         }
       },
 
       reportDiagnostic: (diagnostic) => {
         if (diagnostic.category !== 2) {
-          let message = ts.formatDiagnostic(diagnostic, {
-            getCanonicalFileName: path => path,
-            getCurrentDirectory: ts.sys.getCurrentDirectory,
-            getNewLine: () => ts.sys.newLine,
-          });
-
+          let message = this._formatDiagnosticMessage(diagnostic);
           if (this._shouldFailOnTypeError()) {
-            this.didError(message);
+            this.state.didError(message);
           } else {
             this.project.ui.write(message);
           }
@@ -153,42 +120,18 @@ module.exports = class IncrementalTypescriptCompiler {
     });
   }
 
-  willRebuild() {
-    if (this._isSynced) {
-      this._isSynced = false;
-      this._buildDeferred = RSVP.defer();
-
-      // Schedule a timer to automatically resolve if tsc doesn't pick up any file changes in a
-      // short period. This may happen if a non-TS file changed, or if the tsc watcher is
-      // drastically behind watchman. If the latter happens, we'll explicitly touch a file in the
-      // broccoli output in order to ensure the changes are picked up.
-      this._pendingAutoresolve = setTimeout(() => {
-        debugAutoresolve('no tsc rebuild; autoresolving...');
-
-        this.didSync();
-        this._didAutoresolve = true;
-      }, this.autoresolveThreshold);
-    }
-  }
-
-  didError(message) {
-    this._pendingErrors.push(message);
-  }
-
-  didSync() {
-    this._isSynced = true;
-    if (this._pendingErrors.length) {
-      this._buildDeferred.reject(new Error(this._pendingErrors.join('\n')));
-      this._pendingErrors = [];
-    } else {
-      this._buildDeferred.resolve();
-    }
-  }
-
   getProgram() {
     return this._watchProgram.getProgram();
   }
 
+  _formatDiagnosticMessage(diagnostic) {
+    return ts.formatDiagnostic(diagnostic, {
+      getCanonicalFileName: path => path,
+      getCurrentDirectory: ts.sys.getCurrentDirectory,
+      getNewLine: () => ts.sys.newLine,
+    });
+  }
+
   _shouldFailOnTypeError() {
     let options = this.getProgram().getCompilerOptions();
     return !!options.noEmitOnError;
@@ -219,11 +162,6 @@ module.exports = class IncrementalTypescriptCompiler {
     }
   }
 
-  _touchRebuildTrigger() {
-    debugAutoresolve('touching rebuild trigger.');
-    fs.writeFileSync(`${this._triggerDir}/tsc-delayed-rebuild`, '', 'utf-8');
-  }
-
   _discoverAddons(node, addons) {
     for (let addon of node.addons) {
       let devDeps = addon.pkg.devDependencies || {};
@@ -261,43 +199,3 @@ module.exports = class IncrementalTypescriptCompiler {
   }
 };
 
-class TypescriptOutput extends Plugin {
-  constructor(compiler, paths) {
-    super([]);
-    this.compiler = compiler;
-    this.paths = paths;
-    this.buildCount = 0;
-  }
-
-  build() {
-    this.buildCount++;
-
-    // We use this to keep track of the build state between the various
-    // Broccoli trees and tsc; when either tsc or broccoli notices a file
-    // change, we immediately invalidate the previous build output.
-    if (this.buildCount > this.compiler.maxBuildCount) {
-      debugCompiler('broccoli detected a file change');
-      this.compiler.maxBuildCount = this.buildCount;
-      this.compiler.willRebuild();
-    }
-
-    debugCompiler('waiting for tsc output', this.paths);
-    return this.compiler.buildPromise().then(() => {
-      debugCompiler('tsc build complete', this.paths);
-      for (let relativeSrc of Object.keys(this.paths)) {
-        let src = `${this.compiler.outDir()}/${relativeSrc}`;
-        let dest = `${this.outputPath}/${this.paths[relativeSrc]}`;
-        if (fs.existsSync(src)) {
-          let dir = path.dirname(dest);
-          if (dir !== '.') {
-            mkdirp.sync(dir);
-          }
-
-          symlinkOrCopy.sync(src, dest);
-        } else {
-          mkdirp.sync(dest);
-        }
-      }
-    });
-  }
-}

lib/incremental-typescript-compiler/typescript-output-plugin.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const Plugin = require('broccoli-plugin');
+const fs = require('fs-extra');
+const path = require('path');
+const symlinkOrCopy = require('symlink-or-copy');
+
+/*
+ * We don't insert the output of the TypeScript compiler directly into
+ * the broccoli pipeline, as that would cause double rebuilds (once for
+ * the change to the original .ts file, then another for the change to
+ * the resulting .js file). Instead, we use this Broccoli plugin to
+ * essentially provide a lightweight 'view' into the compiler output,
+ * blocking the rebuild triggered by the original .ts file until the
+ * corresponding .js file is ready.
+ */
+module.exports = class TypescriptOutput extends Plugin {
+  constructor(compiler, paths) {
+    super([]);
+    this.compiler = compiler;
+    this.paths = paths;
+  }
+
+  build() {
+    this.compiler.state.broccoliDidStart();
+
+    return this.compiler
+      .buildPromise()
+      .then(() => {
+        for (let relativeSrc of Object.keys(this.paths)) {
+          let src = `${this.compiler.outDir()}/${relativeSrc}`;
+          let dest = `${this.outputPath}/${this.paths[relativeSrc]}`;
+          if (fs.existsSync(src)) {
+            let dir = path.dirname(dest);
+            if (dir !== '.') {
+              fs.mkdirsSync(dir);
+            }
+
+            symlinkOrCopy.sync(src, dest);
+          } else {
+            fs.mkdirsSync(dest);
+          }
+        }
+      })
+      .finally(() => this.compiler.state.broccoliDidEnd());
+  }
+};