Merge branch 'extensibility-model' into language-service-extensions

Author: weswigham

src/compiler/program.ts

@@ -1605,13 +1605,12 @@ namespace ts {
             function visitNode(node: Node) {
                 let oneAccepted = false;
                 const oldParent = parent;
-                const needsReset: boolean[] = new Array(initializedLints.length);
+                const needsReset: Map<boolean> = {};
                 for (let i = 0; i < initializedLints.length; i++) {
                     if (initializedLints[i].accepted) {
                         activeLint = initializedLints[i];
-                        activeLint.accepted = false;
                         node.parent = parent;
-                        activeLint.walker.visit(node, accept, error);
+                        activeLint.walker.visit(node, stop, error);
                         if (activeLint.accepted) {
                             oneAccepted = true;
                         }
@@ -1633,12 +1632,23 @@ namespace ts {
                 }
             }
 
-            function accept() {
-                activeLint.accepted = true;
+            function stop() {
+                activeLint.accepted = false;
             }
 
-            function error(err: string, node: Node) {
-                diagnostics.push(createExtensionDiagnosticForNode(node, activeLint.name, err));
+            function error(err: string): void;
+            function error(err: string, node: Node): void;
+            function error(err: string, start: number, length: number): void;
+            function error(err: string, nodeOrStart?: Node | number, length?: number): void {
+                if (typeof nodeOrStart === "undefined") {
+                    diagnostics.push(createExtensionDiagnostic(activeLint.name, err, sourceFile));
+                }
+                else if (typeof nodeOrStart === "number") {
+                    diagnostics.push(createExtensionDiagnostic(activeLint.name, err, sourceFile, nodeOrStart, length));
+                }
+                else {
+                    diagnostics.push(createExtensionDiagnosticForNode(nodeOrStart, activeLint.name, err));
+                }
             }
         }
 

src/compiler/types.ts

@@ -2901,15 +2901,19 @@ namespace ts {
         failedLookupLocations: string[];
     }
 
-    export type LintErrorMethod = (err: string, span: Node) => void;
-    export type LintAcceptMethod = () => void;
+    export type LintErrorMethod = {
+        (err: string): void;
+        (err: string, span: Node): void;
+        (err: string, start: number, length: number): void;
+    };
+    export type LintStopMethod = () => void;
 
     /*
-    * Walkers call accept to decend into the node's children
+    * Walkers call stop to halt recursion 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;
+        visit(node: Node, stop: LintStopMethod, error: LintErrorMethod): void;
     }
 
     export interface SyntacticLintProviderStatic {

src/compiler/utilities.ts

@@ -456,12 +456,16 @@ namespace ts {
     export function createExtensionDiagnosticForNode(node: Node, extension: string, message: string): Diagnostic {
         const sourceFile = getSourceFileOfNode(node);
         const span = getErrorSpanForNode(sourceFile, node);
+        return createExtensionDiagnostic(extension, message, sourceFile, span.start, span.length);
+    }
+
+    export function createExtensionDiagnostic(extension: string, message: string, file?: SourceFile, start?: number, length?: number): Diagnostic {
         return {
-            file: sourceFile,
+            file: file,
             messageText: message,
             code: extension,
-            start: span.start,
-            length: span.length,
+            start: start,
+            length: length,
             category: DiagnosticCategory.Extension
         };
     }

tests/cases/unittests/extensionAPI.ts

@@ -165,13 +165,13 @@ import * as tsi from "typescript";
 export abstract class SyntacticLintWalker implements tsi.LintWalker {
     private static __tsCompilerExtensionKind: tsi.ExtensionKind.SyntacticLint = "syntactic-lint";
     constructor(protected ts: typeof tsi, protected args: any) {}
-    abstract visit(node: tsi.Node, accept: tsi.LintAcceptMethod, error: tsi.LintErrorMethod): void;
+    abstract visit(node: tsi.Node, stop: tsi.LintStopMethod, error: tsi.LintErrorMethod): void;
 }
 
 export abstract class SemanticLintWalker implements tsi.LintWalker {
     private static __tsCompilerExtensionKind: tsi.ExtensionKind.SemanticLint = "semantic-lint";
     constructor(protected ts: typeof tsi, protected checker: tsi.TypeChecker, protected args: any) {}
-    abstract visit(node: tsi.Node, accept: tsi.LintAcceptMethod, error: tsi.LintErrorMethod): void;
+    abstract visit(node: tsi.Node, stop: tsi.LintStopMethod, error: tsi.LintErrorMethod): void;
 }
 
 export abstract class LanguageServiceProvider implements tsi.LanguageServiceProvider {
@@ -244,13 +244,12 @@ import {SyntacticLintWalker} from "typescript-plugin-api";
 
 export default class IsNamedFoo extends SyntacticLintWalker {
     constructor(ts, args) { super(ts, args); }
-    visit(node, accept, error) {
+    visit(node, stop, error) {
         if (node.kind === this.ts.SyntaxKind.Identifier) {
             if (node.text.toLowerCase() === "foo") {
                 error("Identifier 'foo' is forbidden.", node);
             }
         }
-        accept();
     }
 }
 `,
@@ -268,14 +267,13 @@ import {SemanticLintWalker} from "typescript-plugin-api";
 
 export default class IsValueFoo extends SemanticLintWalker {
     constructor(ts, checker, args) { super(ts, checker, args); }
-    visit(node, accept, error) {
+    visit(node, stop, error) {
         const type = this.checker.getTypeAtLocation(node);
         if (type.flags & this.ts.TypeFlags.StringLiteral) {
             if (node.text === "foo") {
                 error("String literal type 'foo' is forbidden.", node);
             }
         }
-        accept();
     }
 }
 `,
@@ -293,15 +291,14 @@ import {SyntacticLintWalker} from "typescript-plugin-api";
 
 export default class IsNamedX extends SyntacticLintWalker {
     constructor(ts, args) { super(ts, args); }
-    visit(node, accept, error) {
+    visit(node, stop, error) {
         if (node.kind === this.ts.SyntaxKind.Identifier) {
             for (let i = 0; i<this.args.length; i++) {
                 if (node.text.toLowerCase() === this.args[i]) {
                     error(\`Identifier \${this.args[i]} is forbidden.\`, node);
                 }
             }
         }
-        accept();
     }
 }
                 `
@@ -319,51 +316,47 @@ import {SyntacticLintWalker, SemanticLintWalker} from "typescript-plugin-api";
 
 export class IsNamedFoo extends SyntacticLintWalker {
     constructor(ts, args) { super(ts, args); }
-    visit(node, accept, error) {
+    visit(node, stop, error) {
         if (node.kind === this.ts.SyntaxKind.Identifier) {
             if (node.text.toLowerCase() === "foo") {
                 error("Identifier 'foo' is forbidden.", node);
             }
         }
-        accept();
     }
 }
 
 export class IsNamedBar extends SyntacticLintWalker {
     constructor(ts, args) { super(ts, args); }
-    visit(node, accept, error) {
+    visit(node, stop, error) {
         if (node.kind === this.ts.SyntaxKind.Identifier) {
             if (node.text.toLowerCase() === "bar") {
                 error("Identifier 'bar' is forbidden.", node);
             }
         }
-        accept();
     }
 }
 
 export class IsValueFoo extends SemanticLintWalker {
     constructor(ts, checker, args) { super(ts, checker, args); }
-    visit(node, accept, error) {
+    visit(node, stop, error) {
         const type = this.checker.getTypeAtLocation(node);
         if (type.flags & this.ts.TypeFlags.StringLiteral) {
             if (node.text === "foo") {
                 error("String literal type 'foo' is forbidden.", node);
             }
         }
-        accept();
     }
 }
 
 export class IsValueBar extends SemanticLintWalker {
     constructor(ts, checker, args) { super(ts, checker, args); }
-    visit(node, accept, error) {
+    visit(node, stop, error) {
         const type = this.checker.getTypeAtLocation(node);
         if (type.flags & this.ts.TypeFlags.StringLiteral) {
             if (node.text === "bar") {
                 error("String literal type 'bar' is forbidden.", node);
             }
         }
-        accept();
     }
 }
 `