Pvb/codeaction/api

src/compiler/core.ts

@@ -115,6 +115,15 @@ namespace ts {
         return -1;
     }
 
+    export function firstOrUndefined<T>(array: T[], predicate: (x: T) => boolean): T {
+        for (let i = 0, len = array.length; i < len; i++) {
+            if (predicate(array[i])) {
+                return array[i];
+            }
+        }
+        return undefined;
+    }
+
     export function indexOfAnyCharCode(text: string, charCodes: number[], start?: number): number {
         for (let i = start || 0, len = text.length; i < len; i++) {
             if (contains(charCodes, text.charCodeAt(i))) {

src/compiler/diagnosticMessages.json

@@ -3031,5 +3031,33 @@
     "Unknown typing option '{0}'.": {
         "category": "Error",
         "code": 17010
+    },
+    "Add missing 'super()' call.": {
+        "category": "CodeFix",
+        "code": 90001
+    },
+    "Make 'super()' call the first statement in the constructor.": {
+        "category": "CodeFix",
+        "code": 90002
+    },
+    "Change 'extends' to 'implements'": {
+        "category": "CodeFix",
+        "code": 90003
+    },
+    "Remove unused identifiers": {
+        "category": "CodeFix",
+        "code": 90004
+    },
+    "Implement interface on reference": {
+        "category": "CodeFix",
+        "code": 90005
+    },
+    "Implement interface on class": {
+        "category": "CodeFix",
+        "code": 90006
+    },
+    "Implement inherited abstract class": {
+        "category": "CodeFix",
+        "code": 90007
     }
 }

src/compiler/types.ts

@@ -2547,6 +2547,7 @@ namespace ts {
         Warning,
         Error,
         Message,
+        CodeFix,
     }
 
     export enum ModuleResolutionKind {

src/harness/fourslash.ts

@@ -384,7 +384,7 @@ namespace FourSlash {
 
             if (exists !== negative) {
                 this.printErrorLog(negative, this.getAllDiagnostics());
-                throw new Error("Failure between markers: " + startMarkerName + ", " + endMarkerName);
+                throw new Error(`Failure between markers: '${startMarkerName}', '${endMarkerName}'`);
             }
         }
 
@@ -638,7 +638,6 @@ namespace FourSlash {
             }
         }
 
-
         public verifyCompletionListAllowsNewIdentifier(negative: boolean) {
             const completions = this.getCompletionListAtCaret();
 
@@ -1479,7 +1478,7 @@ namespace FourSlash {
             if (isFormattingEdit) {
                 const newContent = this.getFileContent(fileName);
 
-                if (newContent.replace(/\s/g, "") !== oldContent.replace(/\s/g, "")) {
+                if (this.removeWhitespace(newContent) !== this.removeWhitespace(oldContent)) {
                     this.raiseError("Formatting operation destroyed non-whitespace content");
                 }
             }
@@ -1545,6 +1544,10 @@ namespace FourSlash {
             }
         }
 
+        private removeWhitespace(text: string): string {
+            return text.replace(/\s/g, "");
+        }
+
         public goToBOF() {
             this.goToPosition(0);
         }
@@ -1862,6 +1865,44 @@ namespace FourSlash {
             }
         }
 
+        public verifyCodeFixAtPosition(expectedText: string, errorCode?: number) {
+
+            const ranges = this.getRanges();
+            if (ranges.length == 0) {
+                this.raiseError("At least one range should be specified in the testfile.");
+            }
+
+            const fileName = this.activeFile.fileName;
+            const diagnostics = this.getDiagnostics(fileName);
+
+            if (diagnostics.length === 0) {
+                this.raiseError("Errors expected.");
+            }
+
+            if (diagnostics.length > 1 && !errorCode) {
+                this.raiseError("When there's more than one error, you must specify the errror to fix.");
+            }
+
+            const diagnostic = !errorCode ? diagnostics[0] : ts.firstOrUndefined(diagnostics, d => d.code == errorCode);
+
+            const actual = this.languageService.getCodeFixesAtPosition(fileName, diagnostic.start, diagnostic.length, [`TS${diagnostic.code}`]);
+
+            if (!actual || actual.length == 0) {
+                this.raiseError("No codefixes returned.");
+            }
+
+            if (actual.length > 1) {
+                this.raiseError("More than 1 codefix returned.");
+            }
+
+            this.applyEdits(actual[0].changes[0].fileName, actual[0].changes[0].textChanges, /*isFormattingEdit*/ false);
+            const actualText = this.rangeText(ranges[0]);
+
+            if (this.removeWhitespace(actualText) !== this.removeWhitespace(expectedText)) {
+                this.raiseError(`Actual text doesn't match expected text. Actual: '${actualText}' Expected: '${expectedText}'`);
+            }
+        }
+
         public verifyDocCommentTemplate(expected?: ts.TextInsertion) {
             const name = "verifyDocCommentTemplate";
             const actual = this.languageService.getDocCommentTemplateAtPosition(this.activeFile.fileName, this.currentCaretPosition);
@@ -3066,6 +3107,10 @@ namespace FourSlashInterface {
             this.DocCommentTemplate(/*expectedText*/ undefined, /*expectedOffset*/ undefined, /*empty*/ true);
         }
 
+        public codeFixAtPosition(expectedText: string, errorCode?: number): void {
+            this.state.verifyCodeFixAtPosition(expectedText, errorCode);
+        }
+
         public navigationBar(json: any) {
             this.state.verifyNavigationBar(json);
         }

src/harness/harnessLanguageService.ts

@@ -453,6 +453,9 @@ namespace Harness.LanguageService {
         isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean {
             return unwrapJSONCallResult(this.shim.isValidBraceCompletionAtPosition(fileName, position, openingBrace));
         }
+        getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: string[]): ts.CodeAction[] {
+            return unwrapJSONCallResult(this.shim.getCodeFixesAtPosition(fileName, start, end, JSON.stringify(errorCodes)));
+        }
         getEmitOutput(fileName: string): ts.EmitOutput {
             return unwrapJSONCallResult(this.shim.getEmitOutput(fileName));
         }

src/server/client.ts

@@ -592,6 +592,10 @@ namespace ts.server {
             throw new Error("Not Implemented Yet.");
         }
 
+        getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: string[]): ts.CodeAction[] {
+            throw new Error("Not Implemented Yet.");
+        }
+
         getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[] {
             const lineOffset = this.positionToOneBasedLineOffset(fileName, position);
             const args: protocol.FileLocationRequestArgs = {

src/services/codefixes/codeFixProvider.ts

@@ -0,0 +1,53 @@
+/* @internal */
+namespace ts {
+    export interface CodeFix {
+        name: string;
+        errorCodes: string[];
+        getCodeActions(context: CodeFixContext): CodeAction[];
+    }
+
+    export interface CodeFixContext {
+        errorCode: string;
+        sourceFile: SourceFile;
+        span: TextSpan;
+        checker: TypeChecker;
+        newLineCharacter: string;
+    }
+
+    export namespace codeFix {
+        const codeFixes: Map<CodeFix[]> = {};
+
+        export function registerCodeFix(action: CodeFix) {
+            forEach(action.errorCodes, error => {
+                let fixes = codeFixes[error];
+                if (!fixes) {
+                    fixes = [];
+                    codeFixes[error] = fixes;
+                }
+                fixes.push(action);
+            });
+        }
+
+        export class CodeFixProvider {
+            public static getSupportedErrorCodes() {
+                return getKeys(codeFixes);
+            }
+
+            public getFixes(context: CodeFixContext): CodeAction[] {
+                const fixes = codeFixes[context.errorCode];
+                let allActions: CodeAction[] = [];
+
+                Debug.assert(fixes && fixes.length > 0, "No fixes found for error: '${errorCode}'.");
+
+                forEach(fixes, f => {
+                    const actions = f.getCodeActions(context);
+                    if (actions && actions.length > 0) {
+                        allActions = allActions.concat(actions);
+                    }
+                });
+
+                return allActions;
+            }
+        }
+    }
+}

src/services/codefixes/references.ts

@@ -0,0 +1,6 @@
+///<reference path='..\services.ts' />
+///<reference path='codeFixProvider.ts' />
+///<reference path='superFixes.ts' />
+///<reference path='unusedIdentifierFixes.ts' />
+///<reference path='changeExtendsToImplementsFix.ts' />
+///<reference path='interfaceFixes.ts' />

src/services/codefixes/superFixes.ts

@@ -0,0 +1,65 @@
+/* @internal */
+namespace ts.codeFix {
+    function getOpenBraceEnd(constructor: ConstructorDeclaration, sourceFile: SourceFile) {
+        // First token is the open curly, this is where we want to put the 'super' call.
+        return constructor.body.getFirstToken(sourceFile).getEnd();
+    }
+
+    registerCodeFix({
+        name: "AddMissingSuperCallFix",
+        errorCodes: ["TS2377"],
+        getCodeActions: (context: CodeFixContext) => {
+            const sourceFile = context.sourceFile;
+            const token = getTokenAtPosition(sourceFile, context.span.start);
+            Debug.assert(token.kind === SyntaxKind.ConstructorKeyword, "Failed to find the constructor.");
+
+            const newPosition = getOpenBraceEnd(<ConstructorDeclaration>token.parent, sourceFile);
+            return [{
+                description: getLocaleSpecificMessage(Diagnostics.Add_missing_super_call),
+                changes: [{ fileName: sourceFile.fileName, textChanges: [{ newText: "super();", span: { start: newPosition, length: 0 } }] }]
+            }];
+        }
+    });
+
+    registerCodeFix({
+        name: "MakeSuperCallTheFirstStatementInTheConstructor",
+        errorCodes: ["TS17009"],
+        getCodeActions: (context: CodeFixContext) => {
+            const sourceFile = context.sourceFile;
+
+            const token = getTokenAtPosition(sourceFile, context.span.start);
+            const constructor = getContainingFunction(token);
+            Debug.assert(constructor.kind === SyntaxKind.Constructor, "Failed to find the constructor.");
+
+            const superCall = findSuperCall((<ConstructorDeclaration>constructor).body);
+            Debug.assert(!!superCall, "Failed to find super call.");
+
+            const newPosition = getOpenBraceEnd(<ConstructorDeclaration>constructor, sourceFile);
+            const changes =  [{
+                fileName: sourceFile.fileName, textChanges: [{
+                    newText: superCall.getText(sourceFile),
+                    span: { start: newPosition, length: 0 }
+                },
+                {
+                    newText: "",
+                    span: { start: superCall.getStart(sourceFile), length: superCall.getWidth(sourceFile) }
+                }]
+            }];
+
+            return [{
+                description: getLocaleSpecificMessage(Diagnostics.Make_super_call_the_first_statement_in_the_constructor),
+                changes
+            }];
+
+            function findSuperCall(n: Node): Node {
+                if (n.kind === SyntaxKind.ExpressionStatement && isSuperCallExpression((<ExpressionStatement>n).expression)) {
+                    return n;
+                }
+                if (isFunctionLike(n)) {
+                    return undefined;
+                }
+                return forEachChild(n, findSuperCall);
+            }
+        }
+    });
+}

src/services/services.ts

@@ -11,6 +11,7 @@
 /// <reference path='jsTyping.ts' />
 /// <reference path='formatting\formatting.ts' />
 /// <reference path='formatting\smartIndenter.ts' />
+/// <reference path='codefixes\references.ts' />
 
 namespace ts {
     /** The version of the language service API */
@@ -1237,6 +1238,8 @@ namespace ts {
 
         isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean;
 
+        getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: string[]): CodeAction[];
+
         getEmitOutput(fileName: string): EmitOutput;
 
         getProgram(): Program;
@@ -1283,6 +1286,18 @@ namespace ts {
         newText: string;
     }
 
+    export interface FileTextChanges {
+        fileName: string;
+        textChanges: TextChange[];
+    }
+
+    export interface CodeAction {
+        /** Description of the code action to display in the UI of the editor */
+        description: string;
+        /** Text changes to apply to each file as part of the code action */
+        changes: FileTextChanges[];
+    }
+
     export interface TextInsertion {
         newText: string;
         /** The position in newText the caret should point to after the insertion. */
@@ -1886,9 +1901,13 @@ namespace ts {
         };
     }
 
-    // Cache host information about script should be refreshed
+    export function getSupportedCodeFixes() {
+        return codeFix.CodeFixProvider.getSupportedErrorCodes();
+    }
+
+    // Cache host information about script Should be refreshed
     // at each language service public entry point, since we don't know when
-    // set of scripts handled by the host changes.
+    // the set of scripts handled by the host changes.
     class HostCache {
         private fileNameToEntry: FileMap<HostFileInformation>;
         private _compilationSettings: CompilerOptions;
@@ -3022,6 +3041,7 @@ namespace ts {
         documentRegistry: DocumentRegistry = createDocumentRegistry(host.useCaseSensitiveFileNames && host.useCaseSensitiveFileNames(), host.getCurrentDirectory())): LanguageService {
 
         const syntaxTreeCache: SyntaxTreeCache = new SyntaxTreeCache(host);
+        const codeFixProvider: codeFix.CodeFixProvider = new codeFix.CodeFixProvider();
         let ruleProvider: formatting.RulesProvider;
         let program: Program;
         let lastProjectVersion: string;
@@ -7832,6 +7852,30 @@ namespace ts {
             return [];
         }
 
+        function getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: string[]): CodeAction[] {
+            synchronizeHostData();
+            const sourceFile = getValidSourceFile(fileName);
+            const checker = program.getTypeChecker();
+            let allFixes: CodeAction[] = [];
+
+            forEach(errorCodes, error => {
+                const context = {
+                    errorCode: error,
+                    sourceFile: sourceFile,
+                    span: { start, length: end - start },
+                    checker: checker,
+                    newLineCharacter: getNewLineOrDefaultFromHost(host)
+                };
+
+                const fixes = codeFixProvider.getFixes(context);
+                if (fixes) {
+                    allFixes = allFixes.concat(fixes);
+                }
+            });
+
+            return allFixes;
+        }
+
         /**
          * Checks if position points to a valid position to add JSDoc comments, and if so,
          * returns the appropriate template. Otherwise returns an empty string.
@@ -8302,6 +8346,7 @@ namespace ts {
             getFormattingEditsAfterKeystroke,
             getDocCommentTemplateAtPosition,
             isValidBraceCompletionAtPosition,
+            getCodeFixesAtPosition,
             getEmitOutput,
             getNonBoundSourceFile,
             getProgram