Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Modernize code action provider #4988

Merged
merged 7 commits into from Jan 10, 2022
Merged

Modernize code action provider #4988

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
7 commits
Select commit Hold shift + click to select a range
6b5d9dc
Return CodeActions instead of Commands
50Wliu Jan 1, 2022
57f1090
Use new Range | Selection argument
50Wliu Jan 2, 2022
db6023f
Reorganize to avoid passing undefined selections
50Wliu Jan 2, 2022
ee50f58
Constify
50Wliu Jan 2, 2022
ffdb9c1
Explicitly specify vscode.CodeAction
50Wliu Jan 2, 2022
1b7d018
Fix integration test
50Wliu Jan 2, 2022
67b1e02
Merge branch 'master' into modernize-code-action-provider
JoeRobich Jan 10, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
84 changes: 30 additions & 54 deletions src/features/codeActionProvider.ts
View file
Open in desktop
Expand Up @@ -13,73 +13,47 @@ import OptionProvider from '../observers/OptionProvider';
import { LanguageMiddlewareFeature } from '../omnisharp/LanguageMiddlewareFeature';
import { buildEditForResponse } from '../omnisharp/fileOperationsResponseEditBuilder';

export default class CodeActionProvider extends AbstractProvider implements vscode.CodeActionProvider {

export default class CodeActionProvider extends AbstractProvider implements vscode.CodeActionProvider<vscode.CodeAction> {
private _commandId: string;

constructor(server: OmniSharpServer, private optionProvider: OptionProvider, languageMiddlewareFeature: LanguageMiddlewareFeature) {
super(server, languageMiddlewareFeature);
this._commandId = 'omnisharp.runCodeAction';
let registerCommandDisposable = vscode.commands.registerCommand(this._commandId, this._runCodeAction, this);
const registerCommandDisposable = vscode.commands.registerCommand(this._commandId, this._runCodeAction, this);
this.addDisposables(new CompositeDisposable(registerCommandDisposable));
}

public async provideCodeActions(document: vscode.TextDocument, range: vscode.Range, context: vscode.CodeActionContext, token: vscode.CancellationToken): Promise<vscode.Command[]> {
let options = this.optionProvider.GetLatestOptions();
public async provideCodeActions(document: vscode.TextDocument, range: vscode.Range | vscode.Selection, context: vscode.CodeActionContext, token: vscode.CancellationToken): Promise<vscode.CodeAction[]> {
const options = this.optionProvider.GetLatestOptions();
if (options.disableCodeActions) {
return;
}

let line: number;
let column: number;
let selection: protocol.V2.Range;

// VS Code will pass the range of the word at the editor caret, even if there isn't a selection.
// To ensure that we don't suggest selection-based refactorings when there isn't a selection, we first
// find the text editor for this document and verify that there is a selection.
let editor = vscode.window.visibleTextEditors.find(e => e.document === document);
if (editor) {
if (editor.selection.isEmpty) {
// The editor does not have a selection. Use the active position of the selection (i.e. the caret).
let active = editor.selection.active;
const line = range.start.line;
const column = range.start.character;

line = active.line;
column = active.character;
}
else {
// The editor has a selection. Use it.
let start = editor.selection.start;
let end = editor.selection.end;
const request: protocol.V2.GetCodeActionsRequest = {
FileName: document.fileName,
Line: line,
Column: column,
};

selection = {
Start: { Line: start.line, Column: start.character },
End: { Line: end.line, Column: end.character }
};
}
}
else {
// We couldn't find the editor, so just use the range we were provided.
selection = {
// Only suggest selection-based refactorings when a selection exists.
// If there is no selection and the editor isn't focused,
// VS Code will pass us an empty Selection rather than a Range,
// hence the extra range.isEmpty check.
if (range instanceof vscode.Selection && !range.isEmpty) {
request.Selection = {
Start: { Line: range.start.line, Column: range.start.character },
End: { Line: range.end.line, Column: range.end.character }
};
}

let request: protocol.V2.GetCodeActionsRequest = {
FileName: document.fileName,
Line: line,
Column: column,
Selection: selection
};

try {
let response = await serverUtils.getCodeActions(this._server, request, token);
const response = await serverUtils.getCodeActions(this._server, request, token);
return response.CodeActions.map(codeAction => {
let runRequest: protocol.V2.RunCodeActionRequest = {
FileName: document.fileName,
Line: line,
Column: column,
Selection: selection,
const runRequest: protocol.V2.RunCodeActionRequest = {
...request,
Identifier: codeAction.Identifier,
WantsTextChanges: true,
WantsAllCodeActionOperations: true,
Expand All @@ -88,24 +62,26 @@ export default class CodeActionProvider extends AbstractProvider implements vsco

return {
title: codeAction.Name,
command: this._commandId,
arguments: [runRequest, token]
command: {
title: codeAction.Name,
command: this._commandId,
arguments: [runRequest, token]
},
};
});
}
catch (error) {
} catch (error) {
return Promise.reject(`Problem invoking 'GetCodeActions' on OmniSharp server: ${error}`);
}
}

private async _runCodeAction(req: protocol.V2.RunCodeActionRequest, token: vscode.CancellationToken): Promise<boolean | string | {}> {

return serverUtils.runCodeAction(this._server, req).then(async response => {
try {
const response = await serverUtils.runCodeAction(this._server, req);
if (response) {
return buildEditForResponse(response.Changes, this._languageMiddlewareFeature, token);
}
}, async (error) => {
} catch (error) {
return Promise.reject(`Problem invoking 'RunCodeAction' on OmniSharp server: ${error}`);
});
}
}
}
10 changes: 4 additions & 6 deletions test/integrationTests/codeActionRename.integration.test.ts
View file
Open in desktop
Expand Up @@ -40,13 +40,11 @@ suite(`Code Action Rename ${testAssetWorkspace.description}`, function () {

test("Code actions can rename and open files", async () => {
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, title: string, arguments: string[] }[];
let command = c.find(
(s) => { return s.title == "Rename file to C.cs"; }
);
expect(command, "Didn't find rename class command");
const codeActions = await vscode.commands.executeCommand<vscode.CodeAction[]>("vscode.executeCodeActionProvider", fileUri, new vscode.Range(0, 7, 0, 7));
const codeAction = codeActions.find(codeAction => codeAction.title == "Rename file to C.cs");
expect(codeAction, "Didn't find rename class code action");

await vscode.commands.executeCommand(command.command, ...command.arguments);
await vscode.commands.executeCommand(codeAction.command.command, ...codeAction.command.arguments);

await assertWithPoll(() => { }, 15 * 1000, 500, _ => expect(vscode.window.activeTextEditor.document.fileName).contains("C.cs"));
});
Expand Down