Implement fix all using Source.fixAll instead of onWillSave

Follow up on #43

package.json

@@ -144,12 +144,6 @@
                 "tslint.suppressWhileTypeErrorsPresent": {
                     "type": "boolean",
                     "description": "Always show rule failures as warnings, independent of the tslint configuration."
-                },
-                "tslint.autoFixOnSave": {
-                    "type": "boolean",
-                    "default": false,
-                    "description": "Turns auto fix on save on or off.",
-                    "scope": "resource"
                 }
             }
         }

src/fixAll.ts

@@ -0,0 +1,64 @@
+
+import * as vscode from 'vscode';
+import { isTypeScriptDocument, isEnabledForJavaScriptDocument } from './utils';
+
+function executeCodeActionProvider(uri: vscode.Uri, range: vscode.Range) {
+    return vscode.commands.executeCommand<vscode.CodeAction[]>('vscode.executeCodeActionProvider', uri, range);
+}
+
+
+async function getTsLintFixAllCodeAction(document: vscode.TextDocument): Promise<vscode.CodeAction | undefined> {
+    const diagnostics = vscode.languages
+        .getDiagnostics(document.uri)
+        .filter(diagnostic => diagnostic.source === 'tslint');
+
+    for (const diagnostic of diagnostics) {
+        const codeActions = await executeCodeActionProvider(document.uri, diagnostic.range);
+        if (codeActions) {
+            const fixAll = codeActions.filter(action => action.title === 'Fix all auto-fixable tslint failures');
+            if (fixAll.length > 0) {
+                return fixAll[0];
+            }
+        }
+    }
+    return undefined;
+}
+
+
+const fixAllCodeActionKind = vscode.CodeActionKind.Source.append('fixAll').append('tslint');
+
+export class FixAllProvider implements vscode.CodeActionProvider {
+    public static metadata: vscode.CodeActionProviderMetadata = {
+        providedCodeActionKinds: [fixAllCodeActionKind],
+    };
+
+    async provideCodeActions(
+        document: vscode.TextDocument,
+        _range: vscode.Range | vscode.Selection,
+        context: vscode.CodeActionContext,
+        _token: vscode.CancellationToken
+    ): Promise<vscode.CodeAction[]> {
+        if (!context.only) {
+            return [];
+        }
+
+        if (!context.only.contains(fixAllCodeActionKind) && !fixAllCodeActionKind.contains(context.only)) {
+            return [];
+        }
+
+        if (!isTypeScriptDocument(document) && !isEnabledForJavaScriptDocument(document)) {
+            return [];
+        }
+
+        const fixAllAction = await getTsLintFixAllCodeAction(document);
+        if (!fixAllAction) {
+            return [];
+        }
+
+        return [{
+            ...fixAllAction,
+            title: 'Fix All TSLint',
+            kind: fixAllCodeActionKind,
+        }];
+    }
+}

src/index.ts

@@ -1,5 +1,5 @@
 import * as vscode from 'vscode';
-import { isTypeScriptDocument, isEnabledForJavaScriptDocument, fixAll } from './utils';
+import { FixAllProvider } from './fixAll';
 
 const typeScriptExtensionId = 'vscode.typescript-language-features';
 const pluginId = 'typescript-tslint-plugin';
@@ -29,14 +29,20 @@ export async function activate(context: vscode.ExtensionContext) {
         return;
     }
 
+    vscode.workspace.onDidChangeConfiguration(e => {
+        if (e.affectsConfiguration(configurationSection)) {
+            synchronizeConfiguration(api);
+        }
+    }, undefined, context.subscriptions);
+
+    const selector: vscode.DocumentFilter[] = [];
+    for (const language of ['javascript', 'javascriptreact', 'typescript', 'typescriptreact']) {
+        selector.push({ language, scheme: 'file' });
+        selector.push({ language, scheme: 'untitled' });
+    }
+
     context.subscriptions.push(
-        vscode.workspace.onDidChangeConfiguration(e => {
-            if (e.affectsConfiguration(configurationSection)) {
-                synchronizeConfiguration(api);
-            }
-        }, undefined, context.subscriptions),
-        vscode.workspace.onWillSaveTextDocument(willSaveTextDocument)
-    );
+        vscode.languages.registerCodeActionsProvider(selector, new FixAllProvider(), FixAllProvider.metadata));
 
     synchronizeConfiguration(api);
 }
@@ -80,21 +86,3 @@ function withConfigValue<C, K extends Extract<keyof C, string>>(
         outConfig[key] = value;
     }
 }
-
-async function willSaveTextDocument(e: vscode.TextDocumentWillSaveEvent) {
-    const config = vscode.workspace.getConfiguration('tslint', e.document.uri);
-    const autoFix = config.get('autoFixOnSave', false);
-    if (autoFix) {
-        const document = e.document;
-
-        // only auto fix when the document was manually saved by the user
-        if (!(isTypeScriptDocument(document) || isEnabledForJavaScriptDocument(document))
-            || e.reason !== vscode.TextDocumentSaveReason.Manual) {
-            return;
-        }
-
-        const promise = fixAll(document);
-        e.waitUntil(promise);
-        await promise;
-    }
-}

src/utils.ts

@@ -1,4 +1,4 @@
-import { CodeAction, Command, commands, languages, Range, TextDocument, TextEdit, Uri, window, workspace } from 'vscode';
+import { TextDocument, workspace } from 'vscode';
 
 export function isTypeScriptDocument(document: TextDocument) {
     return document.languageId === 'typescript' || document.languageId === 'typescriptreact';
@@ -15,39 +15,3 @@ export function isEnabledForJavaScriptDocument(document: TextDocument) {
     }
     return false;
 }
-
-function executeCodeActionProvider(uri: Uri, range: Range) {
-    return commands.executeCommand<(CodeAction | Command)[]>('vscode.executeCodeActionProvider', uri, range);
-}
-
-export async function fixAll(document: TextDocument) {
-    const diagnostics = languages
-        .getDiagnostics(document.uri)
-        .filter(diagnostic => diagnostic.source === 'tslint');
-
-    for (let diagnostic of diagnostics) {
-        const codeActions = await executeCodeActionProvider(
-            document.uri,
-            diagnostic.range
-        );
-        if (codeActions) {
-            const fixAll = codeActions.filter(
-                ({ title }) => title === 'Fix all auto-fixable tslint failures'
-            );
-            if (fixAll.length) {
-                const codeActionOrCommand = fixAll[0];
-                if (codeActionOrCommand instanceof CodeAction) {
-                    if (codeActionOrCommand.edit) {
-                        await workspace.applyEdit(codeActionOrCommand.edit);
-                    }
-                }
-                const command = codeActionOrCommand instanceof CodeAction ? codeActionOrCommand.command : codeActionOrCommand;
-                if (command) {
-                    const args = ('arguments' in command) ? command.arguments || [] : [];
-                    await commands.executeCommand(command.command, ...args);
-                }
-                break;
-            }
-        }
-    }
-}

tsconfig.json

@@ -4,6 +4,7 @@
         "target": "es2016",
         "jsx": "preserve",
         "strict": true,
+        "noUnusedLocals": true,
         "outDir": "./out",
         "sourceMap": true
     },