From 90a0d7b86c9852a627d0c89cf79b1f4e623b57a8 Mon Sep 17 00:00:00 2001
From: Ricci Adams <git@ricciadams.com>
Date: Sat, 6 May 2023 23:40:41 -0700
Subject: [PATCH] More Typechecker improvements (#173)

---
 README.md                      |  32 ++--
 lib/api.js                     |  15 +-
 src/Compiler.js                | 100 +++++------
 src/Generator.js               |   9 +-
 src/Utils.js                   |  18 --
 src/model/NSFile.js            |  20 +--
 src/typechecker/Typechecker.js | 316 ++++++++++++++++++++++-----------
 7 files changed, 305 insertions(+), 205 deletions(-)

diff --git a/README.md b/README.md
index fdb2cc9..03105b4 100644
--- a/README.md
+++ b/README.md
@@ -728,8 +728,6 @@ foo(1, 2, 3); // Error in TS
 
 ---
 
-For performance reasons, we recommend a separate typechecker pass (in parallel with the main build), with `--check-types` enabled, `--output-language` set to `none`, and TypeScript type definitions (such as those found at [DefinitelyTyped](http://definitelytyped.org)) specified using the `--prepend` option.
-
 NilScript tries to convert TypeScript error messages back into NilScript syntax.  Please report any confusing error messages.
 
 ---
@@ -843,8 +841,7 @@ squeeze | Object  | Map of squeezed identifiers to original identifiers.  See [S
 
 The `before-compile` key specifies a callback which is called prior to the compiler's NilScript->js stage.  This allows you to preprocess files.  The callback must return a Promise. Once the promise is resolved, a file's content must be valid NilScript or JavaScript.
 
-The `after-compile` key specifies a callback which is called each time the compiler generates JavaScript code for a file.  This allows you to run the generated JavaScript through a linter (such as [ESLint](http://eslint.org)), or allows further transformations via [Babel](https://babeljs.io).
-The callback must return a Promise. When this callback is invoked, a file's content will be valid JavaScript.
+The `after-compile` key specifies a callback which is called each time the compiler generates JavaScript code for a file.  This allows you to run the generated JavaScript through a linter (such as [ESLint](http://eslint.org)), or allows further transformations via [Babel](https://babeljs.io). The callback must return a Promise. When this callback is invoked, a file's content will be valid JavaScript.
 
 
 ```javascript
@@ -906,6 +903,24 @@ Note: `options.state` and `result.state` are private objects and the format/cont
 
 NilScript 2.x also adds the `symbolicate` function as API.  This converts an internal NilScript identifier such as `N$_f_stringWithString_` to a human-readable string (`"stringWithString:"`).  See [Squeezing and Symbolication](#squeeze) below.
 
+--
+
+To improve type checker performance, NilScript 3.x adds a `tuneTypecheckerPerformance` API:
+
+`nilscript.tuneTypecheckerPerformance(includeInCompileResults, workerCount)`
+
+Key                       | Type     | Default |
+------------------------- | -------- | ------- |
+includeInCompileResults   | Boolean  | `true`  |
+workerCount               | Number   | `4`     |
+
+When `includeInCompileResults` is `true`, Each call to `Compiler#compile` will wait for its associated type checker to finish. Type checker warnings are then merged with `results.warnings`.
+
+When `includeInCompileResults` is `false`, `Compiler#compile` will start the type checker but not wait for it to finish. Warnings are accessed via the `Promise` returned from `Compiler#collectTypecheckerWarnings`. In complex projects with several `Compiler` objects, this option can result in faster compile times.
+
+`workerCount` sets the number of node `worker_threads` used to run TypeScript compilers.
+
+
 ---
 ## <a name="compiling-projects"></a>Compiling Projects
 
@@ -960,15 +975,6 @@ function doWebAppCompile(callback) {
 5. Both `core.js` and `webapp.js` are included (in that order) in various HTML files via `<script>` elements.
 6. The NilScript runtime (`runtime.js`) is also included in various HTML files.  You can obtain its location via the `getRuntimePath` API.
 
---
-
-We've found it best to run a separate typecheck pass in parallel with the `core.js`/`webapp.js` build (via a separate `node` process).  This allows one CPU to be dedicated to typechecking while the other performs transpiling.  The typecheck pass uses the following options:
-
-* All `.js` and `.ns` files (From steps #1 and #3) are passed as `INPUT_FILES` (or `options.files`).
-* Several `.d.ts` definitions (for jQuery, underscore, etc.) are specified with the `--defs` option (or `options.defs`).
-* `--output-language` is set to `none`.
-* `--check-types` is enabled 
-
 ---
 ## <a name="squeeze"></a>Squeezing and Symbolication
 
diff --git a/lib/api.js b/lib/api.js
index 91bbeb7..30a048e 100644
--- a/lib/api.js
+++ b/lib/api.js
@@ -1,5 +1,6 @@
 
 import { Compiler as CompilerImpl } from "../src/Compiler.js";
+import { tuneTypecheckerPerformance } from "../src/typechecker/Typechecker.js";
 import { symbolicate } from "../src/model/NSSymbolTyper.js";
 import { Utils } from "../src/Utils.js";
 
@@ -23,20 +24,30 @@ async compile(options)
 }
 
 
+async collectTypecheckerWarnings()
+{
+    return this._impl.collectTypecheckerWarnings();
+}
+
+
 }
 
 
 export default {
-    Compiler: Compiler,
+    Compiler,
 
     compile: async function(options) {
         return (new Compiler()).compile(options);
     },
-
+    
     getRuntimePath: function() {
         return Utils.getProjectPath("lib/runtime.js");
     },
 
+    tuneTypecheckerPerformance(includeInCompileResults, workerCount) {
+        return tuneTypecheckerPerformance(includeInCompileResults, workerCount);
+    },
+
     symbolicate: function(symbol) {
         return symbolicate(symbol);
     }
diff --git a/src/Compiler.js b/src/Compiler.js
index e6c8c12..247eef4 100644
--- a/src/Compiler.js
+++ b/src/Compiler.js
@@ -55,7 +55,7 @@ const sPublicOptions = [
     // Typechecker options
     "check-types",               // Boolean, enable type checker
     "defs",                      // String or Object, additional typechecker defs
-    "typescript-lib",            // String, specify alternate lib.d.ts file
+    "typescript-lib",            // String, specify alternate lib.d.ts file(s)
     "no-implicit-any",           // Boolean, disallow implicit any
     "no-implicit-returns",       // Boolean, disallow implicit returns
     "no-unreachable-code",       // Boolean, inverts tsc's "--allowUnreachableCode" option
@@ -70,7 +70,7 @@ const sPublicOptions = [
 
     // Private / Development
     "dev-dump-tmp",              // Boolean, dump debug info to /tmp
-    "dev-print-log",             // Boolean, print log to stdout 
+    "dev-print-log",             // Boolean, print log to stdout
     "allow-private-options",     // Boolean, allow use of sPrivateOptions (see below)
 ];
 let sPublicOptionsMap = null;
@@ -96,6 +96,7 @@ constructor()
     this._model   = null;   
     this._parents = null;
     this._checker = null;
+    this._checkerPromise = null;
 }
 
 
@@ -232,7 +233,6 @@ async _parseFiles(files, options)
                 nsFile.ast = Parser.parse(nsFile.contents, { loc: true, sourceType: sourceType });
 
                 nsFile.needsGenerate();
-                nsFile.needsTypecheck();
 
             } catch (inError) {
                 let message = inError.description || inError.toString();
@@ -332,23 +332,23 @@ async _generateJavaScript(files, model, options)
 
     await Promise.all(_.map(files, async nsFile => {
         try {
-            if (!nsFile.generatorLines) {
+            if (!nsFile.generatedLines) {
                 Log(`Generating ${nsFile.path}`);
 
-                let generator = new Generator(nsFile, model, false, options);
+                let generator = new Generator(nsFile, model, options);
                 let result    = generator.generate();
 
-                nsFile.generatorLines    = result.lines;
-                nsFile.generatorWarnings = result.warnings || [ ];
-            }
+                nsFile.generatedLines    = result.lines;
+                nsFile.generatedWarnings = result.warnings || [ ];
 
-            if (afterCompileCallback) {
-                let callbackFile = new NSCompileCallbackFile(nsFile.path, nsFile.generatorLines, nsFile.generatorWarnings);
+                if (afterCompileCallback) {
+                    let callbackFile = new NSCompileCallbackFile(nsFile.path, nsFile.generatedLines, nsFile.generatedWarnings);
 
-                await afterCompileCallback(callbackFile);
+                    await afterCompileCallback(callbackFile);
 
-                nsFile.generatorLines    = callbackFile._lines;
-                nsFile.generatorWarnings = callbackFile._warnings;
+                    nsFile.generatedLines    = callbackFile._lines;
+                    nsFile.generatedWarnings = callbackFile._warnings;
+                }
             }
 
         } catch (err) {
@@ -363,31 +363,6 @@ async _generateJavaScript(files, model, options)
 }
 
 
-async _runTypechecker(typechecker, defs, files, model, options)
-{
-    let err = null;
-
-    await Promise.all(_.map(files, async nsFile => {
-        if (!nsFile.typecheckerCode) {
-            try {
-                let generator = new Generator(nsFile, model, true, options);
-                let result = generator.generate();
-
-                nsFile.typecheckerCode = result.lines.join("\n");
-
-            } catch (e) {
-                nsFile.needsTypecheck();
-                nsFile.error = e;
-            }
-        }
-    }));
-
-    this._throwErrorInFiles(files);
-
-    return typechecker.check(model, defs, files);
-}
-
-
 async _finish(files, options)
 {
     function getLines(arrayOrString) {
@@ -437,7 +412,7 @@ async _finish(files, options)
 
         linesArray.push(prependLines);
         _.each(files, nsFile => {
-            linesArray.push(nsFile.generatorLines);
+            linesArray.push(nsFile.generatedLines);
         });
         linesArray.push(appendLines);
 
@@ -459,6 +434,12 @@ uses(compiler)
 }
 
 
+async collectTypecheckerWarnings()
+{
+    return this._checker?.collectWarnings();
+}
+
+
 async compile(options)
 {
     let previousFiles   = this._files;
@@ -529,16 +510,32 @@ async compile(options)
         });
 
         this._checker = null;
+        this._checkerPromise = null;
+    }
+
+    if (optionsCheckTypes && !this._checker) {
+        this._checker = new Typechecker(options);
     }
 
     let model = new NSModel();
+
     if (this._parents) {
+        let parentCheckers = [ ];
+
         _.each(this._parents, parent => {
             if (parent._model) {
                 model.loadState(parent._model.saveState());
             }
+
+            if (parent._checker) {
+                parentCheckers.push(parent._checker);
+            }
         });
 
+        if (this._checker) {
+            this._checker.parents = parentCheckers;
+        }
+
     } else if (optionsState) {
         model.loadState(optionsState);
     } 
@@ -554,10 +551,6 @@ async compile(options)
     this._options = options;
     this._defs    = defs;
 
-    if (optionsCheckTypes && !this._checker) {
-        this._checker = new Typechecker(options);
-    }
-
     let outputCode          = null;
     let outputSourceMap     = null;
     let outputFunctionMap   = null;
@@ -591,10 +584,7 @@ async compile(options)
                 Log("Model has global changes, all files need generate");
             }
 
-            _.each(files, nsFile => {
-                nsFile.needsGenerate();
-                nsFile.needsTypecheck();
-            });
+            _.each(files, nsFile => nsFile.needsGenerate());
 
         } else {
             if (options["warn-unknown-selectors"]) {
@@ -616,16 +606,20 @@ async compile(options)
         // If we get here, our current model is valid.  Save it for next time
         this._model = model;
 
+        // Run typechecker
+        if (optionsCheckTypes) {
+            this._checker.check(model, defs, files);
+
+            if (Typechecker.includeInCompileResults) {
+                typecheckerWarnings = await this._checker.collectWarnings();
+            }
+        }
+
         // Run generator
         if (optionsOutputLanguage != "none") {
             await this._generateJavaScript(files, model, options);
         }
 
-        // Run typechecker
-        if (optionsCheckTypes) {
-            typecheckerWarnings = await this._runTypechecker(this._checker, defs, files, model, options);
-        }
-
         // Concatenate and map output
         if (optionsOutputLanguage != "none") {
             let results = await this._finish(files, finishOptions);
@@ -654,7 +648,7 @@ async compile(options)
     });
 
     let warnings = _.map(files, nsFile => [
-        nsFile.generatorWarnings,
+        nsFile.generatedWarnings,
     ]);
 
     warnings.push(typecheckerWarnings);
diff --git a/src/Generator.js b/src/Generator.js
index 1b925db..b2a0845 100644
--- a/src/Generator.js
+++ b/src/Generator.js
@@ -31,7 +31,7 @@ const LanguageNone        = "none";
 export class Generator {
 
 
-constructor(nsFile, model, forTypechecker, options)
+constructor(nsFile, model, options)
 {
     this._file     = nsFile;
     this._model    = model;
@@ -50,16 +50,11 @@ constructor(nsFile, model, forTypechecker, options)
         this._language = LanguageEcmascript5;
     }
 
-    if (forTypechecker || (this._language == LanguageTypechecker)) {
-        this._language = LanguageTypechecker;
-        forTypechecker = true;
-    }
-
     _.each(model.enums, nsEnum => {
         let enumNameSymbol = (nsEnum.name && !nsEnum.anonymous) ? symbolTyper.getSymbolForEnumName(nsEnum.name) : null;
 
         _.each(nsEnum.values, (value, name) => {
-            if (enumNameSymbol && forTypechecker) {
+            if (enumNameSymbol && (this._language == LanguageTypechecker)) {
                 inlines[name] = enumNameSymbol + "." + name;
             } else {
                 inlines[name] = value;
diff --git a/src/Utils.js b/src/Utils.js
index d0edd70..a745bae 100644
--- a/src/Utils.js
+++ b/src/Utils.js
@@ -128,23 +128,6 @@ function log()
 }
 
 
-function rmrf(dir)
-{
-    try {
-        _.each(fs.readdirSync(dir), file => {
-            file = dir + path.sep + file;
-            if (fs.statSync(file).isFile()) {
-                fs.unlinkSync(file)
-            } else {
-                rmrf(file);
-            }
-        });
-
-        fs.rmdirSync(dir);
-    } catch(e) { }
-}
-
-
 function mkdirAndWriteFile(file, contents)
 {
     fs.mkdirSync(path.dirname(file), { recursive: true });
@@ -173,6 +156,5 @@ export const Utils = {
     enableLog,
     log,
 
-    rmrf,
     mkdirAndWriteFile
 };
diff --git a/src/model/NSFile.js b/src/model/NSFile.js
index f6135e8..41f94da 100644
--- a/src/model/NSFile.js
+++ b/src/model/NSFile.js
@@ -18,7 +18,9 @@ constructor(path)
     this.path     = path;
     this.contents = null;
     this.time     = 0;
-    this.version  = 1;
+
+    this.contentsVersion  = 1;
+    this.generatedVersion = 1;
 
     this.needsAll();
 }
@@ -38,9 +40,10 @@ updateWithContentsAndTime(contents, time)
 {
     if (time > this.time) {
         if (this.contents != contents) {
+            this.contentsVersion++;
+
             this.contents = contents;
             this.time  = time;
-            this.version++;
 
             // A change in contents invalidates everything
             this.needsAll();
@@ -70,21 +73,14 @@ needsBuild()
     this.declarations = null;
 
     this.needsGenerate();
-    this.needsTypecheck();
 }
 
 
 needsGenerate()
 {
-    this.generatorLines    = null;
-    this.generatorWarnings = null;
-}
-
-
-needsTypecheck()
-{
-    this.typecheckerCode  = null;
-    this.typecheckerDefs  = null;
+    this.generatedVersion++;
+    this.generatedLines    = null;
+    this.generatedWarnings = null;
 }
 
 
diff --git a/src/typechecker/Typechecker.js b/src/typechecker/Typechecker.js
index bfd7e73..9bccee0 100644
--- a/src/typechecker/Typechecker.js
+++ b/src/typechecker/Typechecker.js
@@ -13,17 +13,40 @@ import path from "node:path";
 import { DefinitionMaker  } from "./DefinitionMaker.js";
 import { DiagnosticParser } from "./DiagnosticParser.js";
 import { TypeWorker       } from "./TypeWorker.js";
+import { Generator        } from "../Generator.js";
 import { Utils            } from "../Utils.js";
 
-let sInstanceMap = { };
 
 let sNextCheckerID = 1;
 let sWorkerCount = 4;
 let sWorkers;
 
+let sRuntimeDefsContents;
+
+let sDidRemoveDebugDirectory = false;
+
+const DefsSuffix     = "defs.d.ts";
+const CodeSuffix     = "code.ts";
+
+const GlobalDefsPrefix = `N$-global`;
+const RuntimeDefsKey   = `N$-runtime${path.sep}${DefsSuffix}`;
+
+
+export function tuneTypecheckerPerformance(includeInCompileResults, workerCount)
+{
+    if (sWorkers) {
+        throw new Error("tuneTypecheckerPerformance() must be called before any call to compile()");
+    }
+    
+    Typechecker.includeInCompileResults = includeInCompileResults;
+    sWorkerCount = (workerCount > 0) ? workerCount : 4;
+}
+
 
 export class Typechecker {
 
+static includeInCompileResults = true;
+
 
 constructor(options)
 {
@@ -35,12 +58,20 @@ constructor(options)
         }
     }
     
+    this.parents = null;
+    
     this._checkerID = sNextCheckerID++;
     this._options = options;
-    this._workerIndexMap = { };
     this._nextWorkerIndex = 0;
+    this._defsMap = { };
+    this._codeMap = { };
+
+    this._generatorOptions = {
+        "output-language": "typechecker",
+        "additional-inlines": options["additional-inlines"]
+    };
 
-    options = {
+    let tsOptions = {
         noImplicitAny:        !!options["no-implicit-any"],
         noImplicitReturns:    !!options["no-implicit-returns"],
         allowUnreachableCode:  !options["no-unreachable-code"],
@@ -48,158 +79,243 @@ constructor(options)
     };
         
     for (let i = 0; i < sWorkerCount; i++) {
-        sWorkers[i].prepare(this._checkerID, options);
+        sWorkers[i].prepare(this._checkerID, tsOptions);
     }
 }
 
 
-_makeWorkerArgsArray(inModel, inDefs, inFiles)
+_writeDebugInformation()
 {
-    let allCode  = [ ];
-    let allDefs  = [ ];
-
-    const defsSuffix = "defs.d.ts";
-    const codeSuffix = "code.ts";
+    let debugTmp = "/tmp/nilscript.typechecker";
+    let usedPaths = { };
 
-    _.each(inFiles, nsFile => {
-        let codeKey = path.normalize(nsFile.path) + path.sep + codeSuffix;
-        let defsKey = path.normalize(nsFile.path) + path.sep + defsSuffix;
+    function formatKey(key) {
+        let result = key.replaceAll(/[ /]/g, "_");
 
-        if (!nsFile.typecheckerDefs) {
-            nsFile.typecheckerDefs = (new DefinitionMaker(inModel)).getFileDefinitions(nsFile);
+        while (usedPaths[result]) {
+            result = "_" + result;
         }
-        
-        let workerIndex = this._workerIndexMap[codeKey];
-        if (workerIndex === undefined) {
-            workerIndex = this._nextWorkerIndex;
-            this._nextWorkerIndex = (workerIndex + 1) % sWorkerCount;
-            this._workerIndexMap[codeKey] = workerIndex;
+
+        usedPaths[result] = true; 
+               
+        return result;
+    }
+
+    if (!sDidRemoveDebugDirectory) {
+        fs.rmSync(debugTmp, { recursive: true, force: true });
+        sDidRemoveDebugDirectory = true;
+    }
+    
+    let basePath = debugTmp + path.sep + this._checkerID;
+    let codePath = basePath + path.sep + "code";
+    let defsPath = basePath + path.sep + "defs";
+    
+    fs.mkdirSync(codePath, { recursive: true });
+    fs.mkdirSync(defsPath, { recursive: true });
+
+    _.each(this._defsMap, (entry, key) => {
+        fs.writeFileSync(defsPath + path.sep + formatKey(key), entry.contents);
+    });
+    
+    _.each(this._codeMap, (entry, key) => {
+        fs.writeFileSync(codePath + path.sep + formatKey(key), entry.contents);
+    });
+}
+
+
+_updateEntry(previous, inVersion, callback)
+{
+    let entry = {
+        file:      previous.file,
+        contents:  previous.contents  ?? null,
+        inVersion: previous.inVersion ?? NaN,
+        version:   previous.version   ?? 1
+    };
+
+    if (entry.inVersion != inVersion) {
+        let contents = callback();
+
+        if (contents != entry.contents) {
+            entry.contents = contents;
+            entry.version++;                
         }
         
-        allCode.push({
-            file: codeKey,
-            contents: nsFile.typecheckerCode,
-            version: nsFile.version,
-            original: nsFile.path,
-            workerIndex
+        entry.inVersion = inVersion;
+    }
+    
+    return entry;
+}
+
+
+_updateDefs(inModel, inDefs, inFiles)
+{
+    let previousDefsMap = this._defsMap;
+    let defsMap = { };
+    
+    _.each(this.parents, parent => {
+        // Our call to getGlobalDefinitions() will include globals inherited
+        // from parent Models - we need to filter out the parent defs file to avoid
+        // duplicates.
+        //
+        _.each(parent._defsMap, (value, key) => {
+            if (!key.startsWith(GlobalDefsPrefix)) {
+                defsMap[key] = value;
+            }
         });
+    });
+    
+    _.each(inFiles, nsFile => {
+        let defsKey = path.normalize(nsFile.path) + path.sep + DefsSuffix;
 
-        allDefs.push({
-            file: defsKey,
-            contents: nsFile.typecheckerDefs,
-            version: nsFile.version,
+        let previous = previousDefsMap[defsKey];
+        if (!previous) previous = { file: defsKey };
+
+        defsMap[defsKey] = this._updateEntry(previous, nsFile.generatedVersion, () => {
+            return (new DefinitionMaker(inModel)).getFileDefinitions(nsFile);
         });
     });
 
     _.each(inDefs, nsFile => {
-        let defsKey = nsFile.path + path.sep + defsSuffix;
+        let defsKey = nsFile.path + path.sep + DefsSuffix;
 
-        allDefs.push({
+        defsMap[defsKey] = {
             file: defsKey,
             contents: nsFile.contents,
-            version: nsFile.version,
+            version: nsFile.generatedVersion,
             original: nsFile.path
-        });
+        };
     });
     
     // Make entry for globals
     {
-        let globalDefs = (new DefinitionMaker(inModel)).getGlobalDefinitions();
+        // Each global definition needs to have a unique name, else the
+        // TypeScript cache may use the wrong one
+        //
+        let defsKey = `${GlobalDefsPrefix}.${this._checkerID}${path.sep}${DefsSuffix}`;
         
-        allDefs.push({
-            file: `N$-global${path.sep}${defsSuffix}`,
-            contents: globalDefs,
-            version: 0
+        let previous = previousDefsMap[defsKey];
+        if (!previous) previous = { file: defsKey };
+        
+        // NaN forces the callback block to always run
+        //
+        defsMap[defsKey] = this._updateEntry(previous, NaN, () => {
+            return (new DefinitionMaker(inModel)).getGlobalDefinitions();
         });
     }
 
     // Make entry for runtime.d.ts
     {
-        if (!this._runtimeDefsContents) {
+        if (!sRuntimeDefsContents) {
             let runtimeDefsFile = Utils.getProjectPath("lib/runtime.d.ts");
-            this._runtimeDefsContents = fs.readFileSync(runtimeDefsFile) + "\n";
+            sRuntimeDefsContents = fs.readFileSync(runtimeDefsFile) + "\n";
         }
         
-        allDefs.push({
-            file: `N$-runtime${path.sep}${defsSuffix}`,
-            contents: this._runtimeDefsContents,
+        defsMap[RuntimeDefsKey] = {
+            file: RuntimeDefsKey,
+            contents: sRuntimeDefsContents,
             version: 0
-        });
+        };
     }
 
-    return _.map(sWorkers, (unused, index) => {
-        return {
-            code: _.filter(allCode, code => (code.workerIndex == index)),
-            defs: allDefs
-        }
-    });
+    this._defsMap = defsMap;
 }
+ 
 
-
-async check(model, defs, files)
+_updateCode(inModel, inFiles)
 {
-    let options         = this._options;
-    let development     = options["dev-dump-tmp"];
-    let originalFileMap = { };
-
-    let workerArgsArray = this._makeWorkerArgsArray(model, defs, files);
-    
-    let diagnostics = _.flatten(
-        await Promise.all(_.map(workerArgsArray, (args, index) => {
-            let worker = sWorkers[index];
-            return worker.work(this._checkerID, args.code, args.defs);
-        }))
-    );
+    let previousCodeMap = this._codeMap;
+    let codeMap = { };
 
+    _.each(inFiles, nsFile => {
+        let codeKey = path.normalize(nsFile.path) + path.sep + CodeSuffix;
 
-    let debugTmp = "/tmp/nilscript.typechecker";
-    let debugFilesToWrite = { };
-
-    let warnings = (new DiagnosticParser(model)).getWarnings(diagnostics, filePath => {
-        if (development) {
-            return debugTmp + path.sep + filePath;
-        } else {
-            if (filePath in originalFileMap) {
-                return originalFileMap[filePath];
-            }
+        let previous = previousCodeMap[codeKey];
+        if (!previous) previous = { file: codeKey };
+        
+        let entry = this._updateEntry(previous, nsFile.generatedVersion, () => {
+            let generator = new Generator(nsFile, inModel, this._generatorOptions);
+            return "export {};" + generator.generate().lines.join("\n");
+        });
 
-            return filePath;
+        let workerIndex = previous.workerIndex;
+        
+        if (workerIndex === undefined) {
+            workerIndex = this._nextWorkerIndex;
+            this._nextWorkerIndex = (workerIndex + 1) % sWorkerCount;
         }
-    });
 
-    if (development) {
-        Utils.rmrf(debugTmp);
+        entry.workerIndex = workerIndex;
+        entry.original = nsFile.path;
 
-        let allContents = [ ];
+        codeMap[codeKey] = entry;
+    });
 
-        _.each(this._contentCache, (value, key) => {
-            Utils.mkdirAndWriteFile(debugTmp + path.sep + key, this._contentCache[key]);
-            allContents.push(this._contentCache[key]);
-        });
- 
-        if (diagnostics.length) {
-            let content = _.map(diagnostics, diagnostic => {
-                let fileName = diagnostic && diagnostic.file && diagnostic.file.fileName;
-                if (!fileName) return "";
+    this._codeMap = codeMap;
+}
 
-                let lineColumn  = diagnostic.file ? diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start) : { line: 0, column: 0 };
 
-                return fileName + ":" + lineColumn.line + ":" + ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-            }).join("\n");
+_makeWorkerArgsArray(inModel)
+{
+    let code = _.values(this._codeMap);
+    let defs = _.values(this._defsMap);
 
-            fs.writeFileSync(debugTmp + "/diagnostics", content);
+    return _.map(sWorkers, (unused, index) => {
+        return {
+            code: _.filter(code, entry => (entry.workerIndex == index)),
+            defs: defs
         }
+    });
+}
 
-        if (allContents.length) {
-
-            allContents.unshift(this._runtimeDefsSourceFile.text);
 
-            fs.writeFileSync(debugTmp + "/all.ts", allContents.join("\n;\n"));
+check(model, defs, files)
+{
+    let options         = this._options;
+    let development     = options["dev-dump-tmp"];
+    let originalFileMap = { };
+    
+    let start = Date.now();
 
-        }
+    this._updateDefs(model, defs, files);
+    this._updateCode(model, files);
+    
+    if (development) {
+        this._writeDebugInformation();
     }
 
-    return warnings;
+    this._warningsPromise = (async () => {
+        await Promise.all(_.map(this.parents, parent => parent.collectWarnings()));
+    
+        let workerArgsArray = this._makeWorkerArgsArray(model, defs, files);
+
+        let diagnostics = _.flatten(
+            await Promise.all(_.map(workerArgsArray, (args, index) => {
+                let worker = sWorkers[index];
+                return worker.work(this._checkerID, args.code, args.defs);
+            }))
+        );
+
+        let warnings = (new DiagnosticParser(model)).getWarnings(diagnostics, filePath => {
+            if (development) {
+                return debugTmp + path.sep + filePath;
+            } else {
+                if (filePath in originalFileMap) {
+                    return originalFileMap[filePath];
+                }
+
+                return filePath;
+            }
+        });
+
+        return warnings;
+    })();
+}
+
+
+async collectWarnings()
+{
+    return this._warningsPromise;
 }
 
+
 }