Fix all providers support

package.json

@@ -854,6 +854,21 @@
         "title": "Select Project",
         "category": "OmniSharp"
       },
+      {
+        "command": "o.fixAll.solution",
+        "title": "Fix all code issues in solution",
+        "category": "OmniSharp"
+      },
+      {
+        "command": "o.fixAll.project",
+        "title": "Fix all code issues in project",
+        "category": "OmniSharp"
+      },
+      {
+        "command": "o.fixAll.document",
+        "title": "Fix all code issues in document",
+        "category": "OmniSharp"
+      },
       {
         "command": "o.reanalyze.allProjects",
         "title": "Analyze all projects",

src/features/commands.ts

@@ -29,6 +29,7 @@ export default function registerCommands(context: vscode.ExtensionContext, serve
     disposable.add(vscode.commands.registerCommand('o.restart', async () => restartOmniSharp(context, server, optionProvider)));
     disposable.add(vscode.commands.registerCommand('o.pickProjectAndStart', async () => pickProjectAndStart(server, optionProvider)));
     disposable.add(vscode.commands.registerCommand('o.showOutput', () => eventStream.post(new ShowOmniSharpChannel())));
+
     disposable.add(vscode.commands.registerCommand('dotnet.restore.project', async () => pickProjectAndDotnetRestore(server, eventStream)));
     disposable.add(vscode.commands.registerCommand('dotnet.restore.all', async () => dotnetRestoreAllProjects(server, eventStream)));
 
@@ -43,10 +44,8 @@ export default function registerCommands(context: vscode.ExtensionContext, serve
     let attachItemsProvider = DotNetAttachItemsProviderFactory.Get();
     let attacher = new AttachPicker(attachItemsProvider);
     disposable.add(vscode.commands.registerCommand('csharp.listProcess', async () => attacher.ShowAttachEntries()));
-
     // Register command for generating tasks.json and launch.json assets.
     disposable.add(vscode.commands.registerCommand('dotnet.generateAssets', async (selectedIndex) => generateAssets(server, selectedIndex)));
-
     // Register command for remote process picker for attach
     disposable.add(vscode.commands.registerCommand('csharp.listRemoteProcess', async (args) => RemoteAttachPicker.ShowAttachEntries(args, platformInfo)));
 

src/features/fixAll.ts

@@ -0,0 +1,10 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import AbstractProvider from "./abstractProvider";
+
+export class FixAll extends AbstractProvider
+{
+}

src/features/fixAllProvider.ts

@@ -0,0 +1,144 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import * as vscode from 'vscode';
+import * as serverUtils from '../omnisharp/utils';
+import * as protocol from '../omnisharp/protocol';
+import { OmniSharpServer } from '../omnisharp/server';
+import { FixAllScope, FixAllItem, FileModificationType } from '../omnisharp/protocol';
+import { Uri } from 'vscode';
+import CompositeDisposable from '../CompositeDisposable';
+import AbstractProvider from './abstractProvider';
+import { toRange2 } from '../omnisharp/typeConversion';
+import { LanguageMiddlewareFeature } from '../omnisharp/LanguageMiddlewareFeature';
+
+export class FixAllProvider extends AbstractProvider implements vscode.CodeActionProvider {
+    public constructor(private server: OmniSharpServer, languageMiddlewareFeature: LanguageMiddlewareFeature) {
+        super(server, languageMiddlewareFeature);
+        let disposable = new CompositeDisposable();
+        disposable.add(vscode.commands.registerCommand('o.fixAll.solution', async () => this.fixAllMenu(server, protocol.FixAllScope.Solution)));
+        disposable.add(vscode.commands.registerCommand('o.fixAll.project', async () => this.fixAllMenu(server, protocol.FixAllScope.Project)));
+        disposable.add(vscode.commands.registerCommand('o.fixAll.document', async () => this.fixAllMenu(server, protocol.FixAllScope.Document)));
+        this.addDisposables(disposable);
+    }
+
+    public async provideCodeActions(
+        document: vscode.TextDocument,
+        _range: vscode.Range | vscode.Selection,
+        context: vscode.CodeActionContext,
+        _token: vscode.CancellationToken,
+    ): Promise<vscode.CodeAction[]> {
+        console.log(context);
+        if (!context.only) {
+            return [];
+        }
+
+        if (context.only.value === "source.fixAll.csharp") {
+            await this.applyFixes(document.fileName, FixAllScope.Document, undefined);
+        }
+
+        return [];
+    }
+
+    private async fixAllMenu(server: OmniSharpServer, scope: protocol.FixAllScope): Promise<void> {
+        let availableFixes = await serverUtils.getFixAll(server, { FileName: vscode.window.activeTextEditor.document.fileName, Scope: scope });
+
+        let targets = availableFixes.Items.map(x => `${x.Id}: ${x.Message}`);
+
+        if (scope === protocol.FixAllScope.Document) {
+            targets = ["Fix all issues", ...targets];
+        }
+
+        return vscode.window.showQuickPick(targets, {
+            matchOnDescription: true,
+            placeHolder: `Select fix all action`
+        }).then(async selectedAction => {
+            let filter: FixAllItem[] = undefined;
+
+            if (selectedAction === undefined) {
+                return;
+            }
+
+            if (selectedAction !== "Fix all issues") {
+                let actionTokens = selectedAction.split(":");
+                filter = [{ Id: actionTokens[0], Message: actionTokens[1] }];
+            }
+
+            await this.applyFixes(vscode.window.activeTextEditor.document.fileName, scope, filter);
+        });
+    }
+
+    private async applyFixes(fileName: string, scope: FixAllScope, fixAllFilter: FixAllItem[]): Promise<boolean | string | {}> {
+        let response = await serverUtils.runFixAll(this.server, { FileName: fileName, Scope: scope, FixAllFilter: fixAllFilter, WantsAllCodeActionOperations: true, WantsTextChanges: true });
+
+        if (response && Array.isArray(response.Changes)) {
+            let edit = new vscode.WorkspaceEdit();
+
+            let fileToOpen: Uri = null;
+            let renamedFiles: Uri[] = [];
+
+            for (let change of response.Changes) {
+                if (change.ModificationType == FileModificationType.Renamed)
+                {
+                    // The file was renamed. Omnisharp has already persisted
+                    // the right changes to disk. We don't need to try to
+                    // apply text changes (and will skip this file if we see an edit)
+                    renamedFiles.push(Uri.file(change.FileName));
+                }
+            }
+
+            for (let change of response.Changes) {
+                if (change.ModificationType == FileModificationType.Opened)
+                {
+                    // The CodeAction requested that we open a file.
+                    // Record that file name and keep processing CodeActions.
+                    // If a CodeAction requests that we open multiple files 
+                    // we only open the last one (what would it mean to open multiple files?)
+                    fileToOpen = vscode.Uri.file(change.FileName);
+                }
+
+                if (change.ModificationType == FileModificationType.Modified)
+                {
+                    let uri = vscode.Uri.file(change.FileName);
+                    if (renamedFiles.some(r => r == uri))
+                    {
+                        // This file got renamed. Omnisharp has already
+                        // persisted the new file with any applicable changes.
+                        continue;
+                    }
+
+                    let edits: vscode.TextEdit[] = [];
+                    for (let textChange of change.Changes) {
+                        edits.push(vscode.TextEdit.replace(toRange2(textChange), textChange.NewText));
+                    }
+
+                    edit.set(uri, edits);
+                }
+            }
+
+            let applyEditPromise = vscode.workspace.applyEdit(edit);
+
+            // Unfortunately, the textEditor.Close() API has been deprecated
+            // and replaced with a command that can only close the active editor.
+            // If files were renamed that weren't the active editor, their tabs will
+            // be left open and marked as "deleted" by VS Code
+            let next = applyEditPromise;
+            if (renamedFiles.some(r => r.fsPath == vscode.window.activeTextEditor.document.uri.fsPath))
+            {
+                next = applyEditPromise.then(_ => 
+                    {
+                        return vscode.commands.executeCommand("workbench.action.closeActiveEditor");
+                    });
+            }
+
+            return fileToOpen != null
+             ? next.then(_ =>
+                    {
+                        return vscode.commands.executeCommand("vscode.open", fileToOpen);
+                    })
+             : next;
+        }
+    }
+}

src/omnisharp/extension.ts

@@ -38,6 +38,7 @@ import trackVirtualDocuments from '../features/virtualDocumentTracker';
 import { StructureProvider } from '../features/structureProvider';
 import { OmniSharpMonoResolver } from './OmniSharpMonoResolver';
 import { getMonoVersion } from '../utils/getMonoVersion';
+import { FixAllProvider } from '../features/fixAllProvider';
 import { LanguageMiddlewareFeature } from './LanguageMiddlewareFeature';
 import SemanticTokensProvider from '../features/semanticTokensProvider';
 
@@ -95,6 +96,7 @@ export async function activate(context: vscode.ExtensionContext, packageJSON: an
         const codeActionProvider = new CodeActionProvider(server, optionProvider, languageMiddlewareFeature);
         localDisposables.add(codeActionProvider);
         localDisposables.add(vscode.languages.registerCodeActionsProvider(documentSelector, codeActionProvider));
+        localDisposables.add(vscode.languages.registerCodeActionsProvider(documentSelector, new FixAllProvider(server, languageMiddlewareFeature)));
         localDisposables.add(reportDiagnostics(server, advisor, languageMiddlewareFeature));
         localDisposables.add(forwardChanges(server));
         localDisposables.add(trackVirtualDocuments(server, eventStream));

src/omnisharp/protocol.ts

@@ -28,6 +28,8 @@ export module Requests {
     export const TypeLookup = '/typelookup';
     export const UpdateBuffer = '/updatebuffer';
     export const Metadata = '/metadata';
+    export const RunFixAll = '/runfixall';
+    export const GetFixAll = '/getfixall';
     export const ReAnalyze = '/reanalyze';
     export const QuickInfo = '/quickinfo';
 }
@@ -254,6 +256,20 @@ export interface GetCodeActionsResponse {
     CodeActions: string[];
 }
 
+export interface RunFixAllActionResponse {
+    Text: string;
+    Changes: ModifiedFileResponse[];
+}
+
+export interface FixAllItem {
+    Id: string;
+    Message: string;
+}
+
+export interface GetFixAllResponse {
+    Items: FixAllItem[];
+}
+
 export interface SyntaxFeature {
     Name: string;
     Data: string;
@@ -474,6 +490,24 @@ export enum FileChangeType {
     DirectoryDelete = "DirectoryDelete"
 }
 
+export enum FixAllScope {
+    Document = "Document",
+    Project = "Project",
+    Solution = "Solution"
+}
+
+export interface GetFixAllRequest extends FileBasedRequest {
+    Scope: FixAllScope;
+    FixAllFilter?: FixAllItem[];
+}
+
+export interface RunFixAllRequest extends FileBasedRequest {
+    Scope: FixAllScope;
+    FixAllFilter?: FixAllItem[];
+    WantsTextChanges: boolean;
+    WantsAllCodeActionOperations: boolean;
+}
+
 export interface QuickInfoRequest extends Request {
 }
 

src/omnisharp/utils.ts

@@ -43,6 +43,14 @@ export async function findSymbols(server: OmniSharpServer, request: protocol.Fin
     return server.makeRequest<protocol.FindSymbolsResponse>(protocol.Requests.FindSymbols, request, token);
 }
 
+export async function runFixAll(server: OmniSharpServer, request: protocol.RunFixAllRequest): Promise<protocol.RunFixAllActionResponse> {
+    return server.makeRequest<protocol.RunFixAllActionResponse>(protocol.Requests.RunFixAll, request);
+}
+
+export async function getFixAll(server: OmniSharpServer, request: protocol.GetFixAllRequest): Promise<protocol.GetFixAllResponse> {
+    return server.makeRequest<protocol.GetFixAllResponse>(protocol.Requests.GetFixAll, request);
+}
+
 export async function findUsages(server: OmniSharpServer, request: protocol.FindUsagesRequest, token: vscode.CancellationToken) {
     return server.makeRequest<protocol.QuickFixResponse>(protocol.Requests.FindUsages, request, token);
 }