Functional extension loading & lint passes

Jakefile.js

@@ -157,7 +157,8 @@ var harnessSources = harnessCoreSources.concat([
  "convertCompilerOptionsFromJson.ts",
  "convertTypingOptionsFromJson.ts",
  "tsserverProjectSystem.ts",
- "matchFiles.ts"
+ "matchFiles.ts",
+ "extensionAPI.ts",
 ].map(function (f) {
  return path.join(unittestsDirectory, f);
 })).concat([
@@ -527,7 +528,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

@@ -17258,6 +17258,10 @@ namespace ts {
  return getTypeForVariableLikeDeclaration(<VariableLikeDeclaration>node.parent, /*includeOptionality*/ true);
  }
 
+ if (node.kind === SyntaxKind.SourceFile) {
+ return unknownType;
+ }
+
  if (isInRightSideOfImportOrExportAssignment(<Identifier>node)) {
  const symbol = getSymbolAtLocation(node);
  const declaredType = symbol && getDeclaredTypeOfSymbol(symbol);

src/compiler/commandLineParser.ts

@@ -268,6 +268,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: {

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 (let i = 0, len = array.length; i < len; i++) {
+ const result = classifier(array[i]);
+ if (!ret[result]) {
+ ret[result] = [];
+ }
+ ret[result].push(array[i]);
+ }
+ return ret;
+ }
+
  export function deduplicate<T>(array: T[], areEqual?: (a: T, b: T) => boolean): T[] {
  let result: T[];
  if (array) {

src/compiler/diagnosticMessages.json

@@ -2656,7 +2656,7 @@
  "category": "Message",
  "code": 6099
  },
- "'package.json' does not have 'types' field.": {
+ "'package.json' does not have '{0}' field.": {
  "category": "Message",
  "code": 6100
  },
@@ -2789,6 +2789,19 @@
  "code": 6132
  },
 
+ "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
+ },
+
  "Variable '{0}' implicitly has an '{1}' type.": {
  "category": "Error",
  "code": 7005

src/compiler/sys.ts

@@ -32,6 +32,7 @@ namespace ts {
  getMemoryUsage?(): number;
  exit(exitCode?: number): void;
  realpath?(path: string): string;
+ loadExtension?(name: string): any;
  }
 
  export interface FileWatcher {
@@ -547,6 +548,9 @@ namespace ts {
  },
  realpath(path: string): string {
  return _fs.realpathSync(path);
+ },
+ loadExtension(name) {
+ return require(name);
  }
  };
  }

src/compiler/tsc.ts

@@ -115,7 +115,12 @@ namespace ts {
  }
 
  const category = DiagnosticCategory[diagnostic.category].toLowerCase();
- output += `${ category } TS${ diagnostic.code }: ${ flattenDiagnosticMessageText(diagnostic.messageText, sys.newLine) }${ sys.newLine }`;
+ if (diagnostic.category === DiagnosticCategory.Extension) {
+ output += `${ category } ${ diagnostic.code }: ${ flattenDiagnosticMessageText(diagnostic.messageText, sys.newLine) }${ sys.newLine }`;
+ }
+ else {
+ output += `${ category } TS${ diagnostic.code }: ${ flattenDiagnosticMessageText(diagnostic.messageText, sys.newLine) }${ sys.newLine }`;
+ }
 
  sys.write(output);
  }
@@ -604,13 +609,16 @@ namespace ts {
  // First get and report any syntactic errors.
  diagnostics = program.getSyntacticDiagnostics();
 
+ // Count extension diagnostics and ignore them for determining continued error reporting
+ const extensionDiagnostics = filter(diagnostics, d => d.category === DiagnosticCategory.Extension).length;
+
  // If we didn't have any syntactic errors, then also try getting the global and
  // semantic errors.
- if (diagnostics.length === 0) {
- diagnostics = program.getOptionsDiagnostics().concat(program.getGlobalDiagnostics());
+ if (diagnostics.length === extensionDiagnostics) {
+ diagnostics = diagnostics.concat(program.getOptionsDiagnostics().concat(program.getGlobalDiagnostics()));
 
- if (diagnostics.length === 0) {
- diagnostics = program.getSemanticDiagnostics();
+ if (diagnostics.length === extensionDiagnostics) {
+ diagnostics = diagnostics.concat(program.getSemanticDiagnostics());
  }
  }
 

src/compiler/types.ts

@@ -1736,6 +1736,11 @@ namespace ts {
  */
  getTypeChecker(): TypeChecker;
 
+ /**
+ * Gets a map of loaded compiler extensions
+ */
+ getCompilerExtensions(): ExtensionCollectionMap;
+
  /* @internal */ getCommonSourceDirectory(): string;
 
  // For testing purposes only. Should not be used by any other consumers (including the
@@ -1812,6 +1817,7 @@ namespace ts {
  getSourceFiles(): SourceFile[];
  getSourceFile(fileName: string): SourceFile;
  getResolvedTypeReferenceDirectives(): Map<ResolvedTypeReferenceDirective>;
+ getCompilerExtensions(): ExtensionCollectionMap;
  }
 
  export interface TypeChecker {
@@ -2496,13 +2502,14 @@ namespace ts {
  length: number;
  messageText: string | DiagnosticMessageChain;
  category: DiagnosticCategory;
- code: number;
+ code: number | string;
  }
 
  export enum DiagnosticCategory {
  Warning,
  Error,
  Message,
+ Extension,
  }
 
  export enum ModuleResolutionKind {
@@ -2586,6 +2593,7 @@ namespace ts {
  typesSearchPaths?: string[];
  /*@internal*/ version?: boolean;
  /*@internal*/ watch?: boolean;
+ extensions?: string[] | Map<any>;
 
  [option: string]: CompilerOptionsValue | undefined;
  }
@@ -2893,6 +2901,57 @@ namespace ts {
  failedLookupLocations: string[];
  }
 
+ export type LintErrorMethod = (err: string, span: Node) => void;
+ export type LintAcceptMethod = () => void;
+
+ /*
+ * Walkers call accept to decend into the node's children
+ * Walkers call error to add errors to the output.
+ */
+ export interface LintWalker {
+ visit(node: Node, accept: LintAcceptMethod, error: LintErrorMethod): void;
+ }
+
+ export interface SyntacticLintProviderStatic {
+ new (typescript: typeof ts, args: any): LintWalker;
+ }
+
+ export interface SemanticLintProviderStatic {
+ new (typescript: typeof ts, checker: TypeChecker, args: any): LintWalker;
+ }
+
+ export namespace ExtensionKind {
+ export const SemanticLint: "semantic-lint" = "semantic-lint";
+ export type SemanticLint = "semantic-lint";
+ export const SyntacticLint: "syntactic-lint" = "syntactic-lint";
+ export type SyntacticLint = "syntactic-lint";
+ }
+ export type ExtensionKind = ExtensionKind.SemanticLint | ExtensionKind.SyntacticLint;
+
+ export interface ExtensionCollectionMap {
+ "syntactic-lint"?: SyntacticLintExtension[];
+ "semantic-lint"?: SemanticLintExtension[];
+ [index: string]: Extension[] | undefined;
+ }
+
+ export interface ExtensionBase {
+ name: string;
+ args: any;
+ kind: ExtensionKind;
+ }
+
+ // @kind(ExtensionKind.SyntacticLint)
+ export interface SyntacticLintExtension extends ExtensionBase {
+ ctor: SyntacticLintProviderStatic;
+ }
+
+ // @kind(ExtensionKind.SemanticLint)
+ export interface SemanticLintExtension extends ExtensionBase {
+ ctor: SemanticLintProviderStatic;
+ }
+
+ export type Extension = SyntacticLintExtension | SemanticLintExtension;
+
  export interface CompilerHost extends ModuleResolutionHost {
  getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile;
  getSourceFileByPath?(fileName: string, path: Path, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile;
@@ -2919,6 +2978,14 @@ namespace ts {
  * This method is a companion for 'resolveModuleNames' and is used to resolve 'types' references to actual type declaration files
  */
  resolveTypeReferenceDirectives?(typeReferenceDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[];
+
+ /**
+ * Delegates the loading of compiler extensions to the compiler host.
+ * The function should return the result of executing the code of an extension
+ * - its exported members. These members will be searched for objects who have been decorated with
+ * specific flags.
+ */
+ loadExtension?(extension: string): any;
  }
 
  export interface TextSpan {

src/compiler/utilities.ts

@@ -453,6 +453,19 @@ namespace ts {
  return createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2);
  }
 
+ export function createExtensionDiagnosticForNode(node: Node, extension: string, message: string): Diagnostic {
+ const sourceFile = getSourceFileOfNode(node);
+ const span = getErrorSpanForNode(sourceFile, node);
+ return {
+ file: sourceFile,
+ messageText: message,
+ code: extension,
+ start: span.start,
+ length: span.length,
+ category: DiagnosticCategory.Extension
+ };
+ }
+
  export function createDiagnosticForNodeFromMessageChain(node: Node, messageChain: DiagnosticMessageChain): Diagnostic {
  const sourceFile = getSourceFileOfNode(node);
  const span = getErrorSpanForNode(sourceFile, node);

src/services/shims.ts

@@ -541,11 +541,11 @@ namespace ts {
  }
  }
 
- export function realizeDiagnostics(diagnostics: Diagnostic[], newLine: string): { message: string; start: number; length: number; category: string; code: number; }[] {
+ export function realizeDiagnostics(diagnostics: Diagnostic[], newLine: string): { message: string; start: number; length: number; category: string; code: number | string; }[] {
  return diagnostics.map(d => realizeDiagnostic(d, newLine));
  }
 
- function realizeDiagnostic(diagnostic: Diagnostic, newLine: string): { message: string; start: number; length: number; category: string; code: number; } {
+ function realizeDiagnostic(diagnostic: Diagnostic, newLine: string): { message: string; start: number; length: number; category: string; code: number | string; } {
  return {
  message: flattenDiagnosticMessageText(diagnostic.messageText, newLine),
  start: diagnostic.start,