Codefix for removing Unused Identifiers

src/harness/fourslash.ts

@@ -2049,7 +2049,7 @@ namespace FourSlash {
                 this.raiseError("Errors expected.");
             }
 
-            if (diagnostics.length > 1 && errorCode !== undefined) {
+            if (diagnostics.length > 1 && errorCode === undefined) {
                 this.raiseError("When there's more than one error, you must specify the errror to fix.");
             }
 

src/services/codefixes/fixes.ts

@@ -1 +1,2 @@
 ///<reference path='superFixes.ts' />
+///<reference path='unusedIdentifierFixes.ts' />

src/services/codefixes/unusedIdentifierFixes.ts

@@ -0,0 +1,153 @@
+/* @internal */
+namespace ts.codefix {
+    registerCodeFix({
+        errorCodes: [
+            Diagnostics._0_is_declared_but_never_used.code,
+            Diagnostics.Property_0_is_declared_but_never_used.code
+        ],
+        getCodeActions: (context: CodeFixContext) => {
+            const sourceFile = context.sourceFile;
+            const start = context.span.start;
+            const token = getTokenAtPosition(sourceFile, start);
+
+            if (token.kind === ts.SyntaxKind.Identifier) {
+                if (token.parent.kind === ts.SyntaxKind.VariableDeclaration) {
+                    if (token.parent.parent.parent.kind === SyntaxKind.ForStatement) {
+                        const forStatement = <ForStatement>token.parent.parent.parent;
+                        const initializer = <VariableDeclarationList>forStatement.initializer;
+                        if (initializer.declarations.length === 1) {
+                            return createCodeFix("", initializer.pos, initializer.end - initializer.pos);
+                        }
+                        else {
+                            if (initializer.declarations[0] === token.parent) {
+                                return createCodeFix("", token.parent.pos, token.parent.end - token.parent.pos + 1);
+                            }
+                            else {
+                                return createCodeFix("", token.parent.pos - 1, token.parent.end - token.parent.pos + 1);
+                            }
+                        }
+                    }
+                    else if (token.parent.parent.parent.kind === SyntaxKind.ForInStatement) {
+                        const forInStatement = <ForInStatement>token.parent.parent.parent;
+                        const initializer = <VariableDeclarationList>forInStatement.initializer;
+                        return createCodeFix("{}", initializer.declarations[0].pos, initializer.declarations[0].end - initializer.declarations[0].pos);
+                    }
+                    else if (token.parent.parent.parent.kind === SyntaxKind.ForOfStatement) {
+                        const forOfStatement = <ForOfStatement>token.parent.parent.parent;
+                        const initializer = <VariableDeclarationList>forOfStatement.initializer;
+                        return createCodeFix("{}", initializer.declarations[0].pos, initializer.declarations[0].end - initializer.declarations[0].pos);
+                    }
+                    else if (token.parent.parent.kind === SyntaxKind.CatchClause) {
+                        const catchClause = <CatchClause>token.parent.parent;
+                        const parameter = catchClause.variableDeclaration.getChildren()[0];
+                        return createCodeFix("", parameter.pos, parameter.end - parameter.pos);
+                    }
+                    else {
+                        const variableStatement = <VariableStatement>token.parent.parent.parent;
+                        if (variableStatement.declarationList.declarations.length === 1) {
+                            return createCodeFix("", variableStatement.pos, variableStatement.end - variableStatement.pos);
+                        }
+                        else {
+                            const declarations = variableStatement.declarationList.declarations;
+                            if (declarations[0].name === token) {
+                                return createCodeFix("", token.parent.pos + 1, token.parent.end - token.parent.pos);
+                            }
+                            else {
+                                return createCodeFix("", token.parent.pos - 1, token.parent.end - token.parent.pos + 1);
+                            }
+                        }
+                    }
+                }
+
+                if (token.parent.kind === SyntaxKind.FunctionDeclaration ||
+                    token.parent.kind === SyntaxKind.ClassDeclaration ||
+                    token.parent.kind === SyntaxKind.InterfaceDeclaration ||
+                    token.parent.kind === SyntaxKind.MethodDeclaration ||
+                    token.parent.kind === SyntaxKind.ModuleDeclaration ||
+                    token.parent.kind === SyntaxKind.PropertyDeclaration ||
+                    token.parent.kind === SyntaxKind.ArrowFunction) {
+                    return createCodeFix("", token.parent.pos, token.parent.end - token.parent.pos);
+                }
+
+                if (token.parent.kind === SyntaxKind.TypeParameter) {
+                    const typeParameters = (<ClassDeclaration>token.parent.parent).typeParameters;
+                    if (typeParameters.length === 1) {
+                        return createCodeFix("", token.parent.pos - 1, token.parent.end - token.parent.pos + 2);
+                    }
+                    else {
+                        if (typeParameters[0] === token.parent) {
+                            return createCodeFix("", token.parent.pos, token.parent.end - token.parent.pos + 1);
+                        }
+                        else {
+                            return createCodeFix("", token.parent.pos - 1, token.parent.end - token.parent.pos + 1);
+                        }
+                    }
+                }
+
+                if (token.parent.kind === ts.SyntaxKind.Parameter) {
+                    const functionDeclaration = <FunctionDeclaration>token.parent.parent;
+                    if (functionDeclaration.parameters.length === 1) {
+                        return createCodeFix("", token.parent.pos, token.parent.end - token.parent.pos);
+                    }
+                    else {
+                        if (functionDeclaration.parameters[0] === token.parent) {
+                            return createCodeFix("", token.parent.pos, token.parent.end - token.parent.pos + 1);
+                        }
+                        else {
+                            return createCodeFix("", token.parent.pos - 1, token.parent.end - token.parent.pos + 1);
+                        }
+                    }
+                }
+
+                if (token.parent.kind === SyntaxKind.ImportSpecifier) {
+                    const namedImports = <NamedImports>token.parent.parent;
+                    const elements = namedImports.elements;
+                    if (elements.length === 1) {
+                        // Only 1 import and it is unused. So the entire line could be removed.
+                        return createCodeFix("", token.parent.pos, token.parent.end - token.parent.pos);
+                    }
+                    else {
+                        if (elements[0] === token.parent) {
+                            return createCodeFix("", token.parent.pos, token.parent.end - token.parent.pos + 1);
+                        }
+                        else {
+                            return createCodeFix("", token.parent.pos - 1, token.parent.end - token.parent.pos + 1);
+                        }
+                    }
+                }
+
+                if (token.parent.parent.kind === SyntaxKind.ImportClause || token.parent.parent.kind === SyntaxKind.ImportDeclaration) {
+                    return createCodeFix("{}", token.parent.pos, token.parent.end - token.parent.pos);
+                }
+
+                if (token.parent.kind === SyntaxKind.ImportEqualsDeclaration) {
+                    return createCodeFix("{}", token.pos, token.end - token.pos);
+                }
+
+                if (token.parent.kind === SyntaxKind.EnumDeclaration) {
+                    return createCodeFix("", token.parent.pos, token.parent.end - token.parent.pos);
+                }
+            }
+
+            if (token.kind === SyntaxKind.PrivateKeyword && token.parent.kind === SyntaxKind.PropertyDeclaration) {
+                return createCodeFix("", token.parent.pos, token.parent.end - token.parent.pos);
+            }
+
+            if (token.kind === SyntaxKind.AsteriskToken && token.parent.kind === SyntaxKind.NamespaceImport) {
+                return createCodeFix("{}", token.parent.pos, token.parent.end - token.parent.pos);
+            }
+
+            return undefined;
+
+            function createCodeFix(newText: string, start: number, length: number): CodeAction[] {
+                return [{
+                    description: getLocaleSpecificMessage(Diagnostics.Remove_unused_identifiers),
+                    changes: [{
+                        fileName: sourceFile.fileName,
+                        textChanges: [{ newText, span: { start, length } }]
+                    }]
+                }];
+            }
+        }
+    });
+}

tests/cases/fourslash/unusedClassInNamespace1.ts

@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+//// [| namespace greeter {
+////   class class1 {
+////   }
+//// } |]
+
+verify.codeFixAtPosition(`namespace greeter {
+}`);

tests/cases/fourslash/unusedClassInNamespace2.ts

@@ -0,0 +1,15 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+//// [| namespace greeter {
+////    export class class2 {
+////    }
+////    class class1 {
+////    }
+//// } |]
+
+verify.codeFixAtPosition(`namespace greeter {
+    export class class2 {
+    }
+}`);
+

tests/cases/fourslash/unusedClassInNamespace3.ts

@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+// @noUnusedParameters:true
+//// [| namespace Validation {
+////    class c1 {
+////
+////   }/*1*/
+//// } |]
+
+verify.codeFixAtPosition(`namespace Validation {
+}`);

tests/cases/fourslash/unusedClassInNamespace4.ts

@@ -0,0 +1,19 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+// @noUnusedParameters:true
+
+//// [| namespace Validation {
+////    class c1 {
+////
+////    }
+////
+////    export class c2 {
+////
+////    }
+//// } |]
+
+verify.codeFixAtPosition(`namespace Validation {
+    export class c2 {
+    }
+}`);

tests/cases/fourslash/unusedClassInNamespace5.ts

@@ -0,0 +1,26 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+// @noUnusedParameters:true
+
+//// [| namespace Validation {
+////    class c1 {
+////
+////    }
+////
+////    export class c2 {
+////
+////    }
+////
+////    class c3 extends c1 {
+////
+////    }
+////} |]
+
+verify.codeFixAtPosition(`namespace Validation {
+    class c1 {
+    }
+
+    export class c2 {
+    }
+}`);

tests/cases/fourslash/unusedClassInNamespace6.ts

@@ -0,0 +1,27 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+// @noUnusedParameters:true
+//// [| namespace Validation {
+////    class c1 {
+////
+////    }
+////
+////    export class c2 {
+////
+////    }
+////
+////    class c3 {
+////        public x: c1;
+////    }
+////} |]
+
+verify.codeFixAtPosition(`namespace Validation {
+    class c1 {
+
+    }
+
+    export class c2 {
+
+    }
+}`);

tests/cases/fourslash/unusedConstantInFunction1.ts

@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+//// [| function f1 () {
+////     const x: string = "x";
+//// } |]
+
+verify.codeFixAtPosition(`function f1 () {
+}`);
+

tests/cases/fourslash/unusedEnumInFunction1.ts

@@ -0,0 +1,11 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+//// [| function f1 () {
+////     enum Directions { Up, Down}
+//// } |]
+
+verify.codeFixAtPosition(`function f1 () {
+}
+`);
+

tests/cases/fourslash/unusedFunctionInNamespace1.ts

@@ -0,0 +1,10 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+//// [| namespace greeter {
+////   function function1() {
+////   }/*1*/
+//// } |]
+
+verify.codeFixAtPosition(`namespace greeter {
+}`);

tests/cases/fourslash/unusedFunctionInNamespace2.ts

@@ -0,0 +1,14 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+//// [| namespace greeter {
+////    export function function2() {
+////    }
+////    function function1() {
+////    }
+////} |]
+
+verify.codeFixAtPosition(`namespace greeter {
+    export function function2() {
+    }
+}`);

tests/cases/fourslash/unusedFunctionInNamespace3.ts

@@ -0,0 +1,12 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+// @noUnusedParameters:true
+
+//// [| namespace Validation {
+////    function function1() {
+////    }
+////} |]
+
+verify.codeFixAtPosition(`namespace Validation {
+}`);

tests/cases/fourslash/unusedFunctionInNamespace4.ts

@@ -0,0 +1,11 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+// @noUnusedParameters:true
+//// [| namespace Validation {
+////    var function1 = function() {
+////    }
+////} |]
+
+verify.codeFixAtPosition(`namespace Validation {
+}`);

tests/cases/fourslash/unusedFunctionInNamespace5.ts

@@ -0,0 +1,28 @@
+/// <reference path='fourslash.ts' />
+
+// @noUnusedLocals: true
+// @noUnusedParameters:true
+////namespace Validation {
+////    var function1 = function() {
+////    }
+////
+////    export function function2() {
+////
+////    }
+////
+////    [| function function3() {
+////        function1();
+////    }
+////
+////    function function4() {
+////
+////    }
+////
+////    exp ort let a = function3; |]
+////}
+
+verify.codeFixAtPosition(`function function3() {
+        function1();
+    }
+
+    export let a = function3;`, 6133);