Handle Rename and OpenDocument responses from Omnisharp

src/features/codeActionProvider.ts

@@ -13,6 +13,8 @@ import { toRange2 } from '../omnisharp/typeConvertion';
 import * as serverUtils from '../omnisharp/utils';
 import { Options } from '../omnisharp/options';
 import TelemetryReporter from 'vscode-extension-telemetry';
+import { FileModificationType } from '../omnisharp/protocol';
+import { Uri } from 'vscode';
 
 export default class CodeActionProvider extends AbstractProvider implements vscode.CodeActionProvider {
 
@@ -90,7 +92,8 @@ export default class CodeActionProvider extends AbstractProvider implements vsco
                     Column: column,
                     Selection: selection,
                     Identifier: codeAction.Identifier,
-                    WantsTextChanges: true
+                    WantsTextChanges: true,
+                    WantsAllCodeActionOperations: true
                 };
 
                 return {
@@ -112,20 +115,71 @@ export default class CodeActionProvider extends AbstractProvider implements vsco
 
                 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) {
-                    let uri = vscode.Uri.file(change.FileName);
-                    let edits: vscode.TextEdit[] = [];
-                    for (let textChange of change.Changes) {
-                        edits.push(vscode.TextEdit.replace(toRange2(textChange), textChange.NewText));
+                    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);
                     }
 
-                    edit.set(uri, edits);
+                    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);
+                    }
                 }
 
-                return vscode.workspace.applyEdit(edit);
-            }
+                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");
+                        });
+                }
 
-        }, (error) => {
+                return fileToOpen != null
+                 ? next.then(_ => 
+                        {
+                            return vscode.commands.executeCommand("vscode.open", fileToOpen);
+                        })
+                 : next;
+                }
+            }, (error) => {
             return Promise.reject(`Problem invoking 'RunCodeAction' on OmniSharp server: ${error}`);
         });
     }

src/omnisharp/protocol.ts

@@ -373,6 +373,14 @@ export interface ModifiedFileResponse {
     FileName: string;
     Buffer: string;
     Changes: TextChange[];
+    ModificationType: FileModificationType;
+}
+
+export enum FileModificationType
+{
+    Modified,
+    Opened,
+    Renamed,
 }
 
 export interface RenameResponse {
@@ -485,13 +493,13 @@ export namespace V2 {
         Identifier: string;
         Selection?: Range;
         WantsTextChanges: boolean;
+        WantsAllCodeActionOperations: boolean;
     }
 
     export interface RunCodeActionResponse {
         Changes: ModifiedFileResponse[];
     }
 
-
     export interface MSBuildProjectDiagnostics {
         FileName: string;
         Warnings: MSBuildDiagnosticsMessage[];

test/integrationTests/codeActionRename.integration.test.ts

@@ -0,0 +1,38 @@
+/*--------------------------------------------------------------------------------------------- 
+ *  Copyright (c) Microsoft Corporation. All rights reserved. 
+ *  Licensed under the MIT License. See License.txt in the project root for license information. 
+ *--------------------------------------------------------------------------------------------*/
+
+import * as fs from 'async-file';
+import * as vscode from 'vscode';
+
+import poll from './poll';
+import { should, expect } from 'chai';
+import testAssetWorkspace from './testAssets/testAssetWorkspace';
+
+const chai = require('chai'); 
+chai.use(require('chai-arrays')); 
+chai.use(require('chai-fs')); 
+
+suite(`Code Action Rename ${testAssetWorkspace.description}`, function() {
+    suiteSetup(async function() { 
+        should();
+
+        let csharpExtension = vscode.extensions.getExtension("ms-vscode.csharp"); 
+        if (!csharpExtension.isActive) { 
+            await csharpExtension.activate(); 
+        }
+
+        await csharpExtension.exports.initializationFinished;
+
+    });
+
+    test("Code actions can remame and open files", async () => {                
+        let fileUri = await testAssetWorkspace.projects[0].addFileWithContents("test.cs", "class C {}");
+        await vscode.commands.executeCommand("vscode.open", fileUri);
+        let c = await vscode.commands.executeCommand("vscode.executeCodeActionProvider", fileUri, new vscode.Range(0, 7, 0, 7)) as {command: string, arguments: string[]}[];
+        expect(c.length).to.equal(2);
+        await vscode.commands.executeCommand(c[1].command, ...c[1].arguments)
+        expect(vscode.window.activeTextEditor.document.fileName).contains("C.cs");
+    });
+});