Framework for discover typings extensions

Gulpfile.ts

@@ -411,7 +411,7 @@ gulp.task(servicesFile, false, ["lib", "generate-diagnostics"], () => {
         completedDts.pipe(clone())
             .pipe(insert.transform((content, file) => {
                 file.path = nodeStandaloneDefinitionsFile;
-                return content.replace(/declare (namespace|module) ts/g, 'declare module "typescript"');
+                return content.replace(/declare (namespace|module) ts {/g, 'declare module "typescript" {\n    import * as ts from "typescript";');
             }))
     ]).pipe(gulp.dest(builtLocalDirectory));
 });

Jakefile.js

@@ -46,6 +46,7 @@ var compilerSources = [
     "declarationEmitter.ts",
     "emitter.ts",
     "program.ts",
+    "extensions.ts",
     "commandLineParser.ts",
     "tsc.ts",
     "diagnosticInformationMap.generated.ts"
@@ -67,6 +68,7 @@ var servicesSources = [
     "declarationEmitter.ts",
     "emitter.ts",
     "program.ts",
+    "extensions.ts",
     "commandLineParser.ts",
     "diagnosticInformationMap.generated.ts"
 ].map(function (f) {
@@ -131,6 +133,7 @@ var harnessCoreSources = [
     "typeWriter.ts",
     "fourslashRunner.ts",
     "projectsRunner.ts",
+    "extensionRunner.ts",
     "loggedIO.ts",
     "rwcRunner.ts",
     "test262Runner.ts",
@@ -158,7 +161,7 @@ var harnessSources = harnessCoreSources.concat([
     "convertCompilerOptionsFromJson.ts",
     "convertTypingOptionsFromJson.ts",
     "tsserverProjectSystem.ts",
-    "matchFiles.ts"
+    "matchFiles.ts",
 ].map(function (f) {
     return path.join(unittestsDirectory, f);
 })).concat([
@@ -524,7 +527,7 @@ compileFile(servicesFile, servicesSources,[builtLocalDirectory, copyright].conca
 
                 // Node package definition file to be distributed without the package. Created by replacing
                 // 'ts' namespace with '"typescript"' as a module.
-                var nodeStandaloneDefinitionsFileContents = definitionFileContents.replace(/declare (namespace|module) ts/g, 'declare module "typescript"');
+                var nodeStandaloneDefinitionsFileContents = definitionFileContents.replace(/declare (namespace|module) ts {/g, 'declare module "typescript" {\n    import * as ts from "typescript";');
                 fs.writeFileSync(nodeStandaloneDefinitionsFile, nodeStandaloneDefinitionsFileContents);
             });
 

src/compiler/commandLineParser.ts

@@ -282,6 +282,12 @@ namespace ts {
             experimental: true,
             description: Diagnostics.Enables_experimental_support_for_emitting_type_metadata_for_decorators
         },
+        {
+            name: "extensions",
+            type: "object",
+            isTSConfigOnly: true,
+            description: Diagnostics.List_of_compiler_extensions_to_require
+        },
         {
             name: "moduleResolution",
             type: {
@@ -429,7 +435,7 @@ namespace ts {
             name: "strictNullChecks",
             type: "boolean",
             description: Diagnostics.Enable_strict_null_checks
-        }
+        },
     ];
 
     /* @internal */

src/compiler/core.ts

@@ -2,6 +2,17 @@
 /// <reference path="performance.ts" />
 
 
+namespace ts {
+    export function startsWith(str: string, prefix: string): boolean {
+        return str.lastIndexOf(prefix, 0) === 0;
+    }
+
+    export function endsWith(str: string, suffix: string): boolean {
+        const expectedPos = str.length - suffix.length;
+        return expectedPos >= 0 && str.indexOf(suffix, expectedPos) === expectedPos;
+    }
+}
+
 /* @internal */
 namespace ts {
     /**
@@ -178,6 +189,26 @@ namespace ts {
         return array1.concat(array2);
     }
 
+    export function flatten<T>(array1: T[][]): T[] {
+        if (!array1 || !array1.length) return <any>array1;
+        return [].concat(...array1);
+    }
+
+    export function groupBy<T>(array: T[], classifier: (item: T) => string): {[index: string]: T[]};
+    export function groupBy<T>(array: T[], classifier: (item: T) => number): {[index: number]: T[]};
+    export function groupBy<T>(array: T[], classifier: (item: T) => (string | number)): {[index: string]: T[], [index: number]: T[]} {
+        if (!array || !array.length) return undefined;
+        const ret: {[index: string]: T[], [index: number]: T[]} = {};
+        for (const elem of array) {
+            const key = classifier(elem);
+            if (!ret[key]) {
+                ret[key] = [];
+            }
+            ret[key].push(elem);
+        }
+        return ret;
+    }
+
     export function deduplicate<T>(array: T[], areEqual?: (a: T, b: T) => boolean): T[] {
         let result: T[];
         if (array) {
@@ -908,17 +939,6 @@ namespace ts {
         return true;
     }
 
-    /* @internal */
-    export function startsWith(str: string, prefix: string): boolean {
-        return str.lastIndexOf(prefix, 0) === 0;
-    }
-
-    /* @internal */
-    export function endsWith(str: string, suffix: string): boolean {
-        const expectedPos = str.length - suffix.length;
-        return expectedPos >= 0 && str.indexOf(suffix, expectedPos) === expectedPos;
-    }
-
     export function fileExtensionIs(path: string, extension: string): boolean {
         return path.length > extension.length && endsWith(path, extension);
     }
@@ -1195,7 +1215,8 @@ namespace ts {
     export const supportedJavascriptExtensions = [".js", ".jsx"];
     const allSupportedExtensions  = supportedTypeScriptExtensions.concat(supportedJavascriptExtensions);
 
-    export function getSupportedExtensions(options?: CompilerOptions): string[] {
+    export function getSupportedExtensions(options?: CompilerOptions, loadJS?: boolean): string[] {
+        if (loadJS) return supportedJavascriptExtensions;
         return options && options.allowJs ? allSupportedExtensions : supportedTypeScriptExtensions;
     }
 
@@ -1373,4 +1394,49 @@ namespace ts {
             : ((fileName) => fileName.toLowerCase());
     }
 
+    /**
+     * This isn't the strictest deep equal, but it's good enough for us
+     *  - +0 === -0 (though who really wants to consider them different?)
+     *  - arguments and arrays can be equal (both typeof === object, both have enumerable keys)
+     *  - doesn't inspect es6 iterables (not that they're used in this code base)
+     *  - doesn't inspect regex toString value (so only references to the same regex are equal)
+     *  - doesn't inspect date primitive number value (so only references to the same date are equal)
+     */
+    export function deepEqual(a: any, b: any, memo?: [any, any][]): boolean {
+        if (a === b) return true;
+        if (typeof a !== typeof b) return false;
+        // Special case NaN
+        if (typeof a === "number" && isNaN(a) && isNaN(b)) return true;
+        // We can't know if function arguments are deep equal, so we say they're equal if they look alike
+        if (typeof a === "object" || typeof a === "function") {
+            if (memo) {
+                for (let i = 0; i < memo.length; i++) {
+                    if (memo[i][0] === a && memo[i][1] === b) return true;
+                    if (memo[i][0] === b && memo[i][1] === a) return true;
+                }
+            }
+            else {
+                memo = [];
+            }
+
+            const aKeys = ts.getKeys(a);
+            const bKeys = ts.getKeys(b);
+            aKeys.sort();
+            bKeys.sort();
+
+            if (aKeys.length !== bKeys.length) return false;
+
+            for (let i = 0; i < aKeys.length; i++) {
+                if (aKeys[i] !== bKeys[i]) return false;
+            }
+
+            memo.push([a, b]);
+
+            for (const key of aKeys) {
+                if (!deepEqual(a[key], b[key], memo)) return false;
+            }
+            return true;
+        }
+        return false;
+    }
 }

src/compiler/diagnosticMessages.json

@@ -2676,7 +2676,7 @@
         "category": "Message",
         "code": 6099
     },
-    "'package.json' does not have 'types' field.": {
+    "'package.json' does not have '{0}' field.": {
         "category": "Message",
         "code": 6100
     },
@@ -2696,7 +2696,7 @@
         "category": "Message",
         "code": 6104
     },
-    "Expected type of '{0}' field in 'package.json' to be 'string', got '{1}'.": {
+    "Expected type of '{0}' field in 'package.json' to be '{1}', got '{2}'.": {
         "category": "Message",
         "code": 6105
     },
@@ -2824,10 +2824,20 @@
         "category": "Message",
         "code": 6136
     },
-    "No types specified in 'package.json' but 'allowJs' is set, so returning 'main' value of '{0}'": {
+
+    "List of compiler extensions to require.": {
         "category": "Message",
-        "code": 6137
+        "code": 6150
+    },
+    "Extension loading failed with error '{0}'.": {
+        "category": "Error",
+        "code": 6151
     },
+    "Extension '{0}' exported member '{1}' has extension kind '{2}', but was type '{3}' when type '{4}' was expected.": {
+        "category": "Error",
+        "code": 6152
+    },
+
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
         "code": 7005