RFC: Extensibility model

Gulpfile.ts

@@ -412,7 +412,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

@@ -45,6 +45,7 @@ var compilerSources = [
  "declarationEmitter.ts",
  "emitter.ts",
  "program.ts",
+ "extensions.ts",
  "commandLineParser.ts",
  "tsc.ts",
  "diagnosticInformationMap.generated.ts"
@@ -65,6 +66,7 @@ var servicesSources = [
  "declarationEmitter.ts",
  "emitter.ts",
  "program.ts",
+ "extensions.ts",
  "commandLineParser.ts",
  "diagnosticInformationMap.generated.ts"
 ].map(function (f) {
@@ -129,6 +131,7 @@ var harnessCoreSources = [
  "typeWriter.ts",
  "fourslashRunner.ts",
  "projectsRunner.ts",
+ "extensionRunner.ts",
  "loggedIO.ts",
  "rwcRunner.ts",
  "test262Runner.ts",
@@ -156,7 +159,7 @@ var harnessSources = harnessCoreSources.concat([
  "convertCompilerOptionsFromJson.ts",
  "convertTypingOptionsFromJson.ts",
  "tsserverProjectSystem.ts",
- "matchFiles.ts"
+ "matchFiles.ts",
 ].map(function (f) {
  return path.join(unittestsDirectory, f);
 })).concat([
@@ -531,7 +534,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/checker.ts

@@ -17531,9 +17531,9 @@ namespace ts {
  return getTypeOfSymbol(symbol);
  }
 
- if (isDeclarationName(node)) {
+ if (isDeclarationName(node) || node.kind === SyntaxKind.SourceFile) {
  const symbol = getSymbolAtLocation(node);
- return symbol && getTypeOfSymbol(symbol);
+ return symbol && getTypeOfSymbol(symbol) || unknownType;
  }
 
  if (isBindingPattern(node)) {

src/compiler/commandLineParser.ts

@@ -278,6 +278,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: {
@@ -425,6 +431,15 @@ namespace ts {
  name: "strictNullChecks",
  type: "boolean",
  description: Diagnostics.Enable_strict_null_checks
+ },
+ {
+ name: "profileExtensions",
+ type: {
+ "none": ProfileLevel.None,
+ "summary": ProfileLevel.Summary,
+ "full": ProfileLevel.Full,
+ },
+ description: Diagnostics.Set_extension_profiling_level_Colon,
  }
  ];
 

src/compiler/core.ts

@@ -176,6 +176,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) {
@@ -1146,7 +1166,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;
  }
 
@@ -1324,4 +1345,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

@@ -2664,7 +2664,7 @@
  "category": "Message",
  "code": 6099
  },
- "'package.json' does not have 'types' field.": {
+ "'package.json' does not have '{0}' field.": {
  "category": "Message",
  "code": 6100
  },
@@ -2684,7 +2684,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
  },
@@ -2812,10 +2812,32 @@
  "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": 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
+ },
+ "Set extension profiling level:": {
+ "category": "Message",
+ "code": 6153
+ },
+ "PROFILE: Extension '{0}' begin '{1}'": {
  "category": "Message",
- "code": 6137
+ "code": 6154
  },
+ "PROFILE: Extension '{0}' end '{1}' ({2} ms)": {
+ "category": "Message",
+ "code": 6155
+ },
+
  "Variable '{0}' implicitly has an '{1}' type.": {
  "category": "Error",
  "code": 7005