mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Preliminary implementation of lazy CodeAssits

Browse Source
This commit is contained in:
Mikhail Rakhmanov 2020-06-02 22:21:48 +02:00
parent 61e8f39219
commit 57cd936c52
13 changed files with 218 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
crates/ra_ide/src/lib.rs
View File

@ -77,7 +77,7 @@ macro_rules! eprintln {
};
pub use hir::Documentation;
pub use ra_assists::{AssistConfig, AssistId};
pub use ra_assists::{Assist, AssistConfig, AssistId, ResolvedAssist};
pub use ra_db::{
Canceled, CrateGraph, CrateId, Edition, FileId, FilePosition, FileRange, SourceRootId,
};
@ -142,14 +142,6 @@ pub struct AnalysisHost {
db: RootDatabase,
}
#[derive(Debug)]
pub struct Assist {
pub id: AssistId,
pub label: String,
pub group_label: Option<String>,
pub source_change: SourceChange,
}
impl AnalysisHost {
pub fn new(lru_capacity: Option<usize>) -> AnalysisHost {
AnalysisHost { db: RootDatabase::new(lru_capacity) }
@ -470,20 +462,23 @@ pub fn completions(
self.with_db(|db| completion::completions(db, config, position).map(Into::into))
}
/// Computes assists (aka code actions aka intentions) for the given
/// Computes resolved assists with source changes for the given position.
pub fn resolved_assists(
&self,
config: &AssistConfig,
frange: FileRange,
) -> Cancelable<Vec<ResolvedAssist>> {
self.with_db(|db| ra_assists::Assist::resolved(db, config, frange))
}
/// Computes unresolved assists (aka code actions aka intentions) for the given
/// position.
pub fn assists(&self, config: &AssistConfig, frange: FileRange) -> Cancelable<Vec<Assist>> {
self.with_db(|db| {
ra_assists::Assist::resolved(db, config, frange)
.into_iter()
.map(|assist| Assist {
id: assist.assist.id,
label: assist.assist.label,
group_label: assist.assist.group.map(|it| it.0),
source_change: assist.source_change,
})
.collect()
})
pub fn unresolved_assists(
&self,
config: &AssistConfig,
frange: FileRange,
) -> Cancelable<Vec<Assist>> {
self.with_db(|db| Assist::unresolved(db, config, frange))
}
/// Computes the set of diagnostics for the given file.

7
crates/rust-analyzer/src/config.rs
View File

@ -103,6 +103,7 @@ pub struct ClientCapsConfig {
pub code_action_literals: bool,
pub work_done_progress: bool,
pub code_action_group: bool,
pub resolve_code_action: bool,
}
impl Default for Config {
@ -299,7 +300,11 @@ pub fn update_caps(&mut self, caps: &ClientCapabilities) {
let code_action_group =
experimental.get("codeActionGroup").and_then(|it| it.as_bool()) == Some(true);
self.client_caps.code_action_group = code_action_group
self.client_caps.code_action_group = code_action_group;
let resolve_code_action =
experimental.get("resolveCodeAction").and_then(|it| it.as_bool()) == Some(true);
self.client_caps.resolve_code_action = resolve_code_action;
}
}
}

1
crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_multi_line_fix.snap
View File

@ -65,6 +65,7 @@ expression: diag
fixes: [
CodeAction {
title: "return the expression directly",
id: None,
group: None,
kind: Some(
"quickfix",

1
crates/rust-analyzer/src/diagnostics/snapshots/rust_analyzer__diagnostics__to_proto__tests__snap_rustc_unused_variable.snap
View File

@ -50,6 +50,7 @@ expression: diag
fixes: [
CodeAction {
title: "consider prefixing with an underscore",
id: None,
group: None,
kind: Some(
"quickfix",

1
crates/rust-analyzer/src/diagnostics/to_proto.rs
View File

@ -145,6 +145,7 @@ fn map_rust_child_diagnostic(
} else {
MappedRustChildDiagnostic::SuggestedFix(lsp_ext::CodeAction {
title: rd.message.clone(),
id: None,
group: None,
kind: Some("quickfix".to_string()),
edit: Some(lsp_ext::SnippetWorkspaceEdit {

19
crates/rust-analyzer/src/lsp_ext.rs
View File

@ -98,6 +98,23 @@ pub struct JoinLinesParams {
pub ranges: Vec<Range>,
}
pub enum ResolveCodeActionRequest {}
impl Request for ResolveCodeActionRequest {
type Params = ResolveCodeActionParams;
type Result = Option<SnippetWorkspaceEdit>;
const METHOD: &'static str = "experimental/resolveCodeAction";
}
/// Params for the ResolveCodeActionRequest
#[derive(Debug, Eq, PartialEq, Clone, Deserialize, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct ResolveCodeActionParams {
pub code_action_params: lsp_types::CodeActionParams,
pub id: String,
pub label: String,
}
pub enum OnEnter {}
impl Request for OnEnter {
@ -197,6 +214,8 @@ impl Request for CodeActionRequest {
pub struct CodeAction {
pub title: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub group: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub kind: Option<String>,

1
crates/rust-analyzer/src/main_loop.rs
View File

@ -517,6 +517,7 @@ fn on_request(
.on::<lsp_ext::Runnables>(handlers::handle_runnables)?
.on::<lsp_ext::InlayHints>(handlers::handle_inlay_hints)?
.on::<lsp_ext::CodeActionRequest>(handlers::handle_code_action)?
.on::<lsp_ext::ResolveCodeActionRequest>(handlers::handle_resolve_code_action)?
.on::<lsp_types::request::OnTypeFormatting>(handlers::handle_on_type_formatting)?
.on::<lsp_types::request::DocumentSymbolRequest>(handlers::handle_document_symbol)?
.on::<lsp_types::request::WorkspaceSymbol>(handlers::handle_workspace_symbol)?

95
crates/rust-analyzer/src/main_loop/handlers.rs
View File

@ -693,6 +693,45 @@ pub fn handle_formatting(
}]))
}
fn handle_fixes(
world: &WorldSnapshot,
params: &lsp_types::CodeActionParams,
res: &mut Vec<lsp_ext::CodeAction>,
) -> Result<()> {
let file_id = from_proto::file_id(&world, &params.text_document.uri)?;
let line_index = world.analysis().file_line_index(file_id)?;
let range = from_proto::text_range(&line_index, params.range);
let diagnostics = world.analysis().diagnostics(file_id)?;
let fixes_from_diagnostics = diagnostics
.into_iter()
.filter_map(|d| Some((d.range, d.fix?)))
.filter(|(diag_range, _fix)| diag_range.intersect(range).is_some())
.map(|(_range, fix)| fix);
for fix in fixes_from_diagnostics {
let title = fix.label;
let edit = to_proto::snippet_workspace_edit(&world, fix.source_change)?;
let action = lsp_ext::CodeAction {
title,
id: None,
group: None,
kind: None,
edit: Some(edit),
command: None,
};
res.push(action);
}
for fix in world.check_fixes.get(&file_id).into_iter().flatten() {
let fix_range = from_proto::text_range(&line_index, fix.range);
if fix_range.intersect(range).is_none() {
continue;
}
res.push(fix.action.clone());
}
Ok(())
}
pub fn handle_code_action(
world: WorldSnapshot,
params: lsp_types::CodeActionParams,
@ -709,38 +748,48 @@ pub fn handle_code_action(
let line_index = world.analysis().file_line_index(file_id)?;
let range = from_proto::text_range(&line_index, params.range);
let frange = FileRange { file_id, range };
let diagnostics = world.analysis().diagnostics(file_id)?;
let mut res: Vec<lsp_ext::CodeAction> = Vec::new();
let fixes_from_diagnostics = diagnostics
.into_iter()
.filter_map(|d| Some((d.range, d.fix?)))
.filter(|(diag_range, _fix)| diag_range.intersect(range).is_some())
.map(|(_range, fix)| fix);
handle_fixes(&world, &params, &mut res)?;
for fix in fixes_from_diagnostics {
let title = fix.label;
let edit = to_proto::snippet_workspace_edit(&world, fix.source_change)?;
let action =
lsp_ext::CodeAction { title, group: None, kind: None, edit: Some(edit), command: None };
res.push(action);
}
for fix in world.check_fixes.get(&file_id).into_iter().flatten() {
let fix_range = from_proto::text_range(&line_index, fix.range);
if fix_range.intersect(range).is_none() {
continue;
if world.config.client_caps.resolve_code_action {
for assist in world.analysis().unresolved_assists(&world.config.assist, frange)?.into_iter()
{
res.push(to_proto::unresolved_code_action(&world, assist)?.into());
}
} else {
for assist in world.analysis().resolved_assists(&world.config.assist, frange)?.into_iter() {
res.push(to_proto::resolved_code_action(&world, assist)?.into());
}
res.push(fix.action.clone());
}
for assist in world.analysis().assists(&world.config.assist, frange)?.into_iter() {
res.push(to_proto::code_action(&world, assist)?.into());
}
Ok(Some(res))
}
pub fn handle_resolve_code_action(
world: WorldSnapshot,
params: lsp_ext::ResolveCodeActionParams,
) -> Result<Option<lsp_ext::SnippetWorkspaceEdit>> {
if !world.config.client_caps.resolve_code_action {
return Ok(None);
}
let _p = profile("handle_resolve_code_action");
let file_id = from_proto::file_id(&world, &params.code_action_params.text_document.uri)?;
let line_index = world.analysis().file_line_index(file_id)?;
let range = from_proto::text_range(&line_index, params.code_action_params.range);
let frange = FileRange { file_id, range };
let mut res: Vec<lsp_ext::CodeAction> = Vec::new();
for assist in world.analysis().resolved_assists(&world.config.assist, frange)?.into_iter() {
res.push(to_proto::resolved_code_action(&world, assist)?.into());
}
Ok(res
.into_iter()
.find(|action| action.id.clone().unwrap() == params.id && action.title == params.label)
.and_then(|action| action.edit))
}
pub fn handle_code_lens(
world: WorldSnapshot,
params: lsp_types::CodeLensParams,

39
crates/rust-analyzer/src/to_proto.rs
View File

@ -3,8 +3,8 @@
use ra_ide::{
Assist, CompletionItem, CompletionItemKind, Documentation, FileSystemEdit, Fold, FoldKind,
FunctionSignature, Highlight, HighlightModifier, HighlightTag, HighlightedRange, Indel,
InlayHint, InlayKind, InsertTextFormat, LineIndex, NavigationTarget, ReferenceAccess, Severity,
SourceChange, SourceFileEdit, TextEdit,
InlayHint, InlayKind, InsertTextFormat, LineIndex, NavigationTarget, ReferenceAccess,
ResolvedAssist, Severity, SourceChange, SourceFileEdit, TextEdit,
};
use ra_syntax::{SyntaxKind, TextRange, TextSize};
use ra_vfs::LineEndings;
@ -617,10 +617,41 @@ fn main() <fold>{
}
}
pub(crate) fn code_action(world: &WorldSnapshot, assist: Assist) -> Result<lsp_ext::CodeAction> {
pub(crate) fn unresolved_code_action(
world: &WorldSnapshot,
assist: Assist,
) -> Result<lsp_ext::CodeAction> {
let res = lsp_ext::CodeAction {
title: assist.label,
group: if world.config.client_caps.code_action_group { assist.group_label } else { None },
id: Some(assist.id.0.to_owned()),
group: assist.group.and_then(|it| {
if world.config.client_caps.code_action_group {
None
} else {
Some(it.0)
}
}),
kind: Some(String::new()),
edit: None,
command: None,
};
Ok(res)
}
pub(crate) fn resolved_code_action(
world: &WorldSnapshot,
assist: ResolvedAssist,
) -> Result<lsp_ext::CodeAction> {
let res = lsp_ext::CodeAction {
title: assist.assist.label,
id: Some(assist.assist.id.0.to_owned()),
group: assist.assist.group.and_then(|it| {
if world.config.client_caps.code_action_group {
None
} else {
Some(it.0)
}
}),
kind: Some(String::new()),
edit: Some(snippet_workspace_edit(world, assist.source_change)?),
command: None,

76
editors/code/src/client.ts
View File

@ -1,8 +1,11 @@
import * as lc from 'vscode-languageclient';
import * as vscode from 'vscode';
import * as ra from '../src/lsp_ext';
import * as Is from 'vscode-languageclient/lib/utils/is';
import { CallHierarchyFeature } from 'vscode-languageclient/lib/callHierarchy.proposed';
import { SemanticTokensFeature, DocumentSemanticsTokensSignature } from 'vscode-languageclient/lib/semanticTokens.proposed';
import { assert } from './util';
export function createClient(serverPath: string, cwd: string): lc.LanguageClient {
// '.' Is the fallback if no folder is open
@ -32,6 +35,8 @@ export function createClient(serverPath: string, cwd: string): lc.LanguageClient
if (res === undefined) throw new Error('busy');
return res;
},
// Using custom handling of CodeActions where each code action is resloved lazily
// That's why we are not waiting for any command or edits
async provideCodeActions(document: vscode.TextDocument, range: vscode.Range, context: vscode.CodeActionContext, token: vscode.CancellationToken, _next: lc.ProvideCodeActionsSignature) {
const params: lc.CodeActionParams = {
textDocument: client.code2ProtocolConverter.asTextDocumentIdentifier(document),
@ -43,32 +48,38 @@ export function createClient(serverPath: string, cwd: string): lc.LanguageClient
const result: (vscode.CodeAction | vscode.Command)[] = [];
const groups = new Map<string, { index: number; items: vscode.CodeAction[] }>();
for (const item of values) {
// In our case we expect to get code edits only from diagnostics
if (lc.CodeAction.is(item)) {
assert(!item.command, "We don't expect to receive commands in CodeActions");
const action = client.protocol2CodeConverter.asCodeAction(item);
const group = actionGroup(item);
if (isSnippetEdit(item) || group) {
action.command = {
command: "rust-analyzer.applySnippetWorkspaceEdit",
title: "",
arguments: [action.edit],
};
action.edit = undefined;
}
if (group) {
let entry = groups.get(group);
if (!entry) {
entry = { index: result.length, items: [] };
groups.set(group, entry);
result.push(action);
}
entry.items.push(action);
} else {
result.push(action);
continue;
}
assert(isCodeActionWithoutEditsAndCommands(item), "We don't expect edits or commands here");
const action = new vscode.CodeAction(item.title);
const group = (item as any).group;
const id = (item as any).id;
const resolveParams: ra.ResolveCodeActionParams = {
id: id,
// TODO: delete after discussions if needed
label: item.title,
codeActionParams: params
};
action.command = {
command: "rust-analyzer.resolveCodeAction",
title: item.title,
arguments: [resolveParams],
};
if (group) {
let entry = groups.get(group);
if (!entry) {
entry = { index: result.length, items: [] };
groups.set(group, entry);
result.push(action);
}
entry.items.push(action);
} else {
const command = client.protocol2CodeConverter.asCommand(item);
result.push(command);
result.push(action);
}
}
for (const [group, { index, items }] of groups) {
@ -80,7 +91,7 @@ export function createClient(serverPath: string, cwd: string): lc.LanguageClient
command: "rust-analyzer.applyActionGroup",
title: "",
arguments: [items.map((item) => {
return { label: item.title, edit: item.command!!.arguments!![0] };
return { label: item.title, arguments: item.command!!.arguments!![0] };
})],
};
result[index] = action;
@ -119,24 +130,17 @@ class ExperimentalFeatures implements lc.StaticFeature {
const caps: any = capabilities.experimental ?? {};
caps.snippetTextEdit = true;
caps.codeActionGroup = true;
caps.resolveCodeAction = true;
capabilities.experimental = caps;
}
initialize(_capabilities: lc.ServerCapabilities<any>, _documentSelector: lc.DocumentSelector | undefined): void {
}
}
function isSnippetEdit(action: lc.CodeAction): boolean {
const documentChanges = action.edit?.documentChanges ?? [];
for (const edit of documentChanges) {
if (lc.TextDocumentEdit.is(edit)) {
if (edit.edits.some((indel) => (indel as any).insertTextFormat === lc.InsertTextFormat.Snippet)) {
return true;
}
}
}
return false;
}
function actionGroup(action: lc.CodeAction): string | undefined {
return (action as any).group;
function isCodeActionWithoutEditsAndCommands(value: any): boolean {
const candidate: lc.CodeAction = value;
return candidate && Is.string(candidate.title) &&
(candidate.diagnostics === void 0 || Is.typedArray(candidate.diagnostics, lc.Diagnostic.is)) &&
(candidate.kind === void 0 || Is.string(candidate.kind)) &&
(candidate.edit === void 0 && candidate.command === void 0);
}

19
editors/code/src/commands.ts
View File

@ -343,10 +343,25 @@ export function showReferences(ctx: Ctx): Cmd {
}
export function applyActionGroup(_ctx: Ctx): Cmd {
return async (actions: { label: string; edit: vscode.WorkspaceEdit }[]) => {
return async (actions: { label: string; arguments: ra.ResolveCodeActionParams }[]) => {
const selectedAction = await vscode.window.showQuickPick(actions);
if (!selectedAction) return;
await applySnippetWorkspaceEdit(selectedAction.edit);
vscode.commands.executeCommand(
'rust-analyzer.resolveCodeAction',
selectedAction.arguments,
);
};
}
export function resolveCodeAction(ctx: Ctx): Cmd {
const client = ctx.client;
return async (params: ra.ResolveCodeActionParams) => {
const item: lc.WorkspaceEdit = await client.sendRequest(ra.resolveCodeAction, params);
if (!item) {
return;
}
const edit = client.protocol2CodeConverter.asWorkspaceEdit(item);
await applySnippetWorkspaceEdit(edit);
};
}

7
editors/code/src/lsp_ext.ts
View File

@ -33,6 +33,13 @@ export const matchingBrace = new lc.RequestType<MatchingBraceParams, lc.Position
export const parentModule = new lc.RequestType<lc.TextDocumentPositionParams, lc.LocationLink[], void>("experimental/parentModule");
export interface ResolveCodeActionParams {
id: string;
label: string;
codeActionParams: lc.CodeActionParams;
}
export const resolveCodeAction = new lc.RequestType<ResolveCodeActionParams, lc.WorkspaceEdit, unknown>('experimental/resolveCodeAction');
export interface JoinLinesParams {
textDocument: lc.TextDocumentIdentifier;
ranges: lc.Range[];

1
editors/code/src/main.ts
View File

@ -98,6 +98,7 @@ export async function activate(context: vscode.ExtensionContext) {
ctx.registerCommand('debugSingle', commands.debugSingle);
ctx.registerCommand('showReferences', commands.showReferences);
ctx.registerCommand('applySnippetWorkspaceEdit', commands.applySnippetWorkspaceEditCommand);
ctx.registerCommand('resolveCodeAction', commands.resolveCodeAction);
ctx.registerCommand('applyActionGroup', commands.applyActionGroup);
ctx.pushCleanup(activateTaskProvider(workspaceFolder));