config::RustfmtConfig,
diagnostics::DiagnosticTask,
from_json, from_proto,
+ global_state::GlobalStateSnapshot,
lsp_ext::{self, InlayHint, InlayHintsParams},
- to_proto,
- world::WorldSnapshot,
- LspError, Result,
+ to_proto, LspError, Result,
};
-pub fn handle_analyzer_status(world: WorldSnapshot, _: ()) -> Result<String> {
+pub fn handle_analyzer_status(snap: GlobalStateSnapshot, _: ()) -> Result<String> {
let _p = profile("handle_analyzer_status");
- let mut buf = world.status();
+ let mut buf = snap.status();
format_to!(buf, "\n\nrequests:\n");
- let requests = world.latest_requests.read();
+ let requests = snap.latest_requests.read();
for (is_last, r) in requests.iter() {
let mark = if is_last { "*" } else { " " };
format_to!(buf, "{}{:4} {:<36}{}ms\n", mark, r.id, r.method, r.duration.as_millis());
}
pub fn handle_syntax_tree(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_ext::SyntaxTreeParams,
) -> Result<String> {
let _p = profile("handle_syntax_tree");
- let id = from_proto::file_id(&world, ¶ms.text_document.uri)?;
- let line_index = world.analysis().file_line_index(id)?;
+ let id = from_proto::file_id(&snap, ¶ms.text_document.uri)?;
+ let line_index = snap.analysis().file_line_index(id)?;
let text_range = params.range.map(|r| from_proto::text_range(&line_index, r));
- let res = world.analysis().syntax_tree(id, text_range)?;
+ let res = snap.analysis().syntax_tree(id, text_range)?;
Ok(res)
}
pub fn handle_expand_macro(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_ext::ExpandMacroParams,
) -> Result<Option<lsp_ext::ExpandedMacro>> {
let _p = profile("handle_expand_macro");
- let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?;
- let line_index = world.analysis().file_line_index(file_id)?;
+ let file_id = from_proto::file_id(&snap, ¶ms.text_document.uri)?;
+ let line_index = snap.analysis().file_line_index(file_id)?;
let offset = from_proto::offset(&line_index, params.position);
- let res = world.analysis().expand_macro(FilePosition { file_id, offset })?;
+ let res = snap.analysis().expand_macro(FilePosition { file_id, offset })?;
Ok(res.map(|it| lsp_ext::ExpandedMacro { name: it.name, expansion: it.expansion }))
}
pub fn handle_selection_range(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::SelectionRangeParams,
) -> Result<Option<Vec<lsp_types::SelectionRange>>> {
let _p = profile("handle_selection_range");
- let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?;
- let line_index = world.analysis().file_line_index(file_id)?;
+ let file_id = from_proto::file_id(&snap, ¶ms.text_document.uri)?;
+ let line_index = snap.analysis().file_line_index(file_id)?;
let res: Result<Vec<lsp_types::SelectionRange>> = params
.positions
.into_iter()
loop {
ranges.push(range);
let frange = FileRange { file_id, range };
- let next = world.analysis().extend_selection(frange)?;
+ let next = snap.analysis().extend_selection(frange)?;
if next == range {
break;
} else {
}
pub fn handle_matching_brace(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_ext::MatchingBraceParams,
) -> Result<Vec<Position>> {
let _p = profile("handle_matching_brace");
- let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?;
- let line_index = world.analysis().file_line_index(file_id)?;
+ let file_id = from_proto::file_id(&snap, ¶ms.text_document.uri)?;
+ let line_index = snap.analysis().file_line_index(file_id)?;
let res = params
.positions
.into_iter()
.map(|position| {
let offset = from_proto::offset(&line_index, position);
- let offset = match world.analysis().matching_brace(FilePosition { file_id, offset }) {
+ let offset = match snap.analysis().matching_brace(FilePosition { file_id, offset }) {
Ok(Some(matching_brace_offset)) => matching_brace_offset,
Err(_) | Ok(None) => offset,
};
}
pub fn handle_join_lines(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_ext::JoinLinesParams,
) -> Result<Vec<lsp_types::TextEdit>> {
let _p = profile("handle_join_lines");
- let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?;
- let line_index = world.analysis().file_line_index(file_id)?;
- let line_endings = world.file_line_endings(file_id);
+ let file_id = from_proto::file_id(&snap, ¶ms.text_document.uri)?;
+ let line_index = snap.analysis().file_line_index(file_id)?;
+ let line_endings = snap.file_line_endings(file_id);
let mut res = TextEdit::default();
for range in params.ranges {
let range = from_proto::text_range(&line_index, range);
- let edit = world.analysis().join_lines(FileRange { file_id, range })?;
+ let edit = snap.analysis().join_lines(FileRange { file_id, range })?;
match res.union(edit) {
Ok(()) => (),
Err(_edit) => {
}
pub fn handle_on_enter(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::TextDocumentPositionParams,
) -> Result<Option<Vec<lsp_ext::SnippetTextEdit>>> {
let _p = profile("handle_on_enter");
- let position = from_proto::file_position(&world, params)?;
- let edit = match world.analysis().on_enter(position)? {
+ let position = from_proto::file_position(&snap, params)?;
+ let edit = match snap.analysis().on_enter(position)? {
None => return Ok(None),
Some(it) => it,
};
- let line_index = world.analysis().file_line_index(position.file_id)?;
- let line_endings = world.file_line_endings(position.file_id);
+ let line_index = snap.analysis().file_line_index(position.file_id)?;
+ let line_endings = snap.file_line_endings(position.file_id);
let edit = to_proto::snippet_text_edit_vec(&line_index, line_endings, true, edit);
Ok(Some(edit))
}
// Don't forget to add new trigger characters to `ServerCapabilities` in `caps.rs`.
pub fn handle_on_type_formatting(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::DocumentOnTypeFormattingParams,
) -> Result<Option<Vec<lsp_types::TextEdit>>> {
let _p = profile("handle_on_type_formatting");
- let mut position = from_proto::file_position(&world, params.text_document_position)?;
- let line_index = world.analysis().file_line_index(position.file_id)?;
- let line_endings = world.file_line_endings(position.file_id);
+ let mut position = from_proto::file_position(&snap, params.text_document_position)?;
+ let line_index = snap.analysis().file_line_index(position.file_id)?;
+ let line_endings = snap.file_line_endings(position.file_id);
// in `ra_ide`, the `on_type` invariant is that
// `text.char_at(position) == typed_char`.
position.offset -= TextSize::of('.');
let char_typed = params.ch.chars().next().unwrap_or('\0');
assert!({
- let text = world.analysis().file_text(position.file_id)?;
+ let text = snap.analysis().file_text(position.file_id)?;
text[usize::from(position.offset)..].starts_with(char_typed)
});
return Ok(None);
}
- let edit = world.analysis().on_char_typed(position, char_typed)?;
+ let edit = snap.analysis().on_char_typed(position, char_typed)?;
let mut edit = match edit {
Some(it) => it,
None => return Ok(None),
}
pub fn handle_document_symbol(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::DocumentSymbolParams,
) -> Result<Option<lsp_types::DocumentSymbolResponse>> {
let _p = profile("handle_document_symbol");
- let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?;
- let line_index = world.analysis().file_line_index(file_id)?;
+ let file_id = from_proto::file_id(&snap, ¶ms.text_document.uri)?;
+ let line_index = snap.analysis().file_line_index(file_id)?;
let mut parents: Vec<(DocumentSymbol, Option<usize>)> = Vec::new();
- for symbol in world.analysis().file_structure(file_id)? {
+ for symbol in snap.analysis().file_structure(file_id)? {
let doc_symbol = DocumentSymbol {
name: symbol.label,
detail: symbol.detail,
}
}
- let res = if world.config.client_caps.hierarchical_symbols {
+ let res = if snap.config.client_caps.hierarchical_symbols {
document_symbols.into()
} else {
- let url = to_proto::url(&world, file_id)?;
+ let url = to_proto::url(&snap, file_id)?;
let mut symbol_information = Vec::<SymbolInformation>::new();
for symbol in document_symbols {
flatten_document_symbol(&symbol, None, &url, &mut symbol_information);
}
pub fn handle_workspace_symbol(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::WorkspaceSymbolParams,
) -> Result<Option<Vec<SymbolInformation>>> {
let _p = profile("handle_workspace_symbol");
q.limit(128);
q
};
- let mut res = exec_query(&world, query)?;
+ let mut res = exec_query(&snap, query)?;
if res.is_empty() && !all_symbols {
let mut query = Query::new(params.query);
query.limit(128);
- res = exec_query(&world, query)?;
+ res = exec_query(&snap, query)?;
}
return Ok(Some(res));
- fn exec_query(world: &WorldSnapshot, query: Query) -> Result<Vec<SymbolInformation>> {
+ fn exec_query(snap: &GlobalStateSnapshot, query: Query) -> Result<Vec<SymbolInformation>> {
let mut res = Vec::new();
- for nav in world.analysis().symbol_search(query)? {
+ for nav in snap.analysis().symbol_search(query)? {
let info = SymbolInformation {
name: nav.name().to_string(),
kind: to_proto::symbol_kind(nav.kind()),
- location: to_proto::location(world, nav.file_range())?,
+ location: to_proto::location(snap, nav.file_range())?,
container_name: nav.container_name().map(|v| v.to_string()),
deprecated: None,
};
}
pub fn handle_goto_definition(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::GotoDefinitionParams,
) -> Result<Option<lsp_types::GotoDefinitionResponse>> {
let _p = profile("handle_goto_definition");
- let position = from_proto::file_position(&world, params.text_document_position_params)?;
- let nav_info = match world.analysis().goto_definition(position)? {
+ let position = from_proto::file_position(&snap, params.text_document_position_params)?;
+ let nav_info = match snap.analysis().goto_definition(position)? {
None => return Ok(None),
Some(it) => it,
};
let src = FileRange { file_id: position.file_id, range: nav_info.range };
- let res = to_proto::goto_definition_response(&world, Some(src), nav_info.info)?;
+ let res = to_proto::goto_definition_response(&snap, Some(src), nav_info.info)?;
Ok(Some(res))
}
pub fn handle_goto_implementation(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::request::GotoImplementationParams,
) -> Result<Option<lsp_types::request::GotoImplementationResponse>> {
let _p = profile("handle_goto_implementation");
- let position = from_proto::file_position(&world, params.text_document_position_params)?;
- let nav_info = match world.analysis().goto_implementation(position)? {
+ let position = from_proto::file_position(&snap, params.text_document_position_params)?;
+ let nav_info = match snap.analysis().goto_implementation(position)? {
None => return Ok(None),
Some(it) => it,
};
let src = FileRange { file_id: position.file_id, range: nav_info.range };
- let res = to_proto::goto_definition_response(&world, Some(src), nav_info.info)?;
+ let res = to_proto::goto_definition_response(&snap, Some(src), nav_info.info)?;
Ok(Some(res))
}
pub fn handle_goto_type_definition(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::request::GotoTypeDefinitionParams,
) -> Result<Option<lsp_types::request::GotoTypeDefinitionResponse>> {
let _p = profile("handle_goto_type_definition");
- let position = from_proto::file_position(&world, params.text_document_position_params)?;
- let nav_info = match world.analysis().goto_type_definition(position)? {
+ let position = from_proto::file_position(&snap, params.text_document_position_params)?;
+ let nav_info = match snap.analysis().goto_type_definition(position)? {
None => return Ok(None),
Some(it) => it,
};
let src = FileRange { file_id: position.file_id, range: nav_info.range };
- let res = to_proto::goto_definition_response(&world, Some(src), nav_info.info)?;
+ let res = to_proto::goto_definition_response(&snap, Some(src), nav_info.info)?;
Ok(Some(res))
}
pub fn handle_parent_module(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::TextDocumentPositionParams,
) -> Result<Option<lsp_types::GotoDefinitionResponse>> {
let _p = profile("handle_parent_module");
- let position = from_proto::file_position(&world, params)?;
- let navs = world.analysis().parent_module(position)?;
- let res = to_proto::goto_definition_response(&world, None, navs)?;
+ let position = from_proto::file_position(&snap, params)?;
+ let navs = snap.analysis().parent_module(position)?;
+ let res = to_proto::goto_definition_response(&snap, None, navs)?;
Ok(Some(res))
}
pub fn handle_runnables(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_ext::RunnablesParams,
) -> Result<Vec<lsp_ext::Runnable>> {
let _p = profile("handle_runnables");
- let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?;
- let line_index = world.analysis().file_line_index(file_id)?;
+ let file_id = from_proto::file_id(&snap, ¶ms.text_document.uri)?;
+ let line_index = snap.analysis().file_line_index(file_id)?;
let offset = params.position.map(|it| from_proto::offset(&line_index, it));
let mut res = Vec::new();
- let workspace_root = world.workspace_root_for(file_id);
- let cargo_spec = CargoTargetSpec::for_file(&world, file_id)?;
- for runnable in world.analysis().runnables(file_id)? {
+ let workspace_root = snap.workspace_root_for(file_id);
+ let cargo_spec = CargoTargetSpec::for_file(&snap, file_id)?;
+ for runnable in snap.analysis().runnables(file_id)? {
if let Some(offset) = offset {
if !runnable.nav.full_range().contains_inclusive(offset) {
continue;
}
}
}
- res.push(to_proto::runnable(&world, file_id, runnable)?);
+ res.push(to_proto::runnable(&snap, file_id, runnable)?);
}
// Add `cargo check` and `cargo test` for the whole package
}
pub fn handle_completion(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::CompletionParams,
) -> Result<Option<lsp_types::CompletionResponse>> {
let _p = profile("handle_completion");
- let position = from_proto::file_position(&world, params.text_document_position)?;
+ let position = from_proto::file_position(&snap, params.text_document_position)?;
let completion_triggered_after_single_colon = {
let mut res = false;
if let Some(ctx) = params.context {
if ctx.trigger_character.unwrap_or_default() == ":" {
- let source_file = world.analysis().parse(position.file_id)?;
+ let source_file = snap.analysis().parse(position.file_id)?;
let syntax = source_file.syntax();
let text = syntax.text();
if let Some(next_char) = text.char_at(position.offset) {
return Ok(None);
}
- let items = match world.analysis().completions(&world.config.completion, position)? {
+ let items = match snap.analysis().completions(&snap.config.completion, position)? {
None => return Ok(None),
Some(items) => items,
};
- let line_index = world.analysis().file_line_index(position.file_id)?;
- let line_endings = world.file_line_endings(position.file_id);
+ let line_index = snap.analysis().file_line_index(position.file_id)?;
+ let line_endings = snap.file_line_endings(position.file_id);
let items: Vec<CompletionItem> = items
.into_iter()
.map(|item| to_proto::completion_item(&line_index, line_endings, item))
}
pub fn handle_folding_range(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: FoldingRangeParams,
) -> Result<Option<Vec<FoldingRange>>> {
let _p = profile("handle_folding_range");
- let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?;
- let folds = world.analysis().folding_ranges(file_id)?;
- let text = world.analysis().file_text(file_id)?;
- let line_index = world.analysis().file_line_index(file_id)?;
- let line_folding_only = world.config.client_caps.line_folding_only;
+ let file_id = from_proto::file_id(&snap, ¶ms.text_document.uri)?;
+ let folds = snap.analysis().folding_ranges(file_id)?;
+ let text = snap.analysis().file_text(file_id)?;
+ let line_index = snap.analysis().file_line_index(file_id)?;
+ let line_folding_only = snap.config.client_caps.line_folding_only;
let res = folds
.into_iter()
.map(|it| to_proto::folding_range(&*text, &line_index, line_folding_only, it))
}
pub fn handle_signature_help(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::SignatureHelpParams,
) -> Result<Option<lsp_types::SignatureHelp>> {
let _p = profile("handle_signature_help");
- let position = from_proto::file_position(&world, params.text_document_position_params)?;
- let call_info = match world.analysis().call_info(position)? {
+ let position = from_proto::file_position(&snap, params.text_document_position_params)?;
+ let call_info = match snap.analysis().call_info(position)? {
None => return Ok(None),
Some(it) => it,
};
- let concise = !world.config.call_info_full;
+ let concise = !snap.config.call_info_full;
let mut active_parameter = call_info.active_parameter.map(|it| it as i64);
if concise && call_info.signature.has_self_param {
active_parameter = active_parameter.map(|it| it.saturating_sub(1));
}))
}
-pub fn handle_hover(world: WorldSnapshot, params: lsp_types::HoverParams) -> Result<Option<Hover>> {
+pub fn handle_hover(
+ snap: GlobalStateSnapshot,
+ params: lsp_types::HoverParams,
+) -> Result<Option<Hover>> {
let _p = profile("handle_hover");
- let position = from_proto::file_position(&world, params.text_document_position_params)?;
- let info = match world.analysis().hover(position)? {
+ let position = from_proto::file_position(&snap, params.text_document_position_params)?;
+ let info = match snap.analysis().hover(position)? {
None => return Ok(None),
Some(info) => info,
};
- let line_index = world.analysis.file_line_index(position.file_id)?;
+ let line_index = snap.analysis.file_line_index(position.file_id)?;
let range = to_proto::range(&line_index, info.range);
let res = Hover {
contents: HoverContents::Markup(MarkupContent {
}
pub fn handle_prepare_rename(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::TextDocumentPositionParams,
) -> Result<Option<PrepareRenameResponse>> {
let _p = profile("handle_prepare_rename");
- let position = from_proto::file_position(&world, params)?;
+ let position = from_proto::file_position(&snap, params)?;
- let optional_change = world.analysis().rename(position, "dummy")?;
+ let optional_change = snap.analysis().rename(position, "dummy")?;
let range = match optional_change {
None => return Ok(None),
Some(it) => it.range,
};
- let line_index = world.analysis().file_line_index(position.file_id)?;
+ let line_index = snap.analysis().file_line_index(position.file_id)?;
let range = to_proto::range(&line_index, range);
Ok(Some(PrepareRenameResponse::Range(range)))
}
-pub fn handle_rename(world: WorldSnapshot, params: RenameParams) -> Result<Option<WorkspaceEdit>> {
+pub fn handle_rename(
+ snap: GlobalStateSnapshot,
+ params: RenameParams,
+) -> Result<Option<WorkspaceEdit>> {
let _p = profile("handle_rename");
- let position = from_proto::file_position(&world, params.text_document_position)?;
+ let position = from_proto::file_position(&snap, params.text_document_position)?;
if params.new_name.is_empty() {
return Err(LspError::new(
.into());
}
- let optional_change = world.analysis().rename(position, &*params.new_name)?;
+ let optional_change = snap.analysis().rename(position, &*params.new_name)?;
let source_change = match optional_change {
None => return Ok(None),
Some(it) => it.info,
};
- let workspace_edit = to_proto::workspace_edit(&world, source_change)?;
+ let workspace_edit = to_proto::workspace_edit(&snap, source_change)?;
Ok(Some(workspace_edit))
}
pub fn handle_references(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::ReferenceParams,
) -> Result<Option<Vec<Location>>> {
let _p = profile("handle_references");
- let position = from_proto::file_position(&world, params.text_document_position)?;
+ let position = from_proto::file_position(&snap, params.text_document_position)?;
- let refs = match world.analysis().find_all_refs(position, None)? {
+ let refs = match snap.analysis().find_all_refs(position, None)? {
None => return Ok(None),
Some(refs) => refs,
};
let locations = if params.context.include_declaration {
refs.into_iter()
- .filter_map(|reference| to_proto::location(&world, reference.file_range).ok())
+ .filter_map(|reference| to_proto::location(&snap, reference.file_range).ok())
.collect()
} else {
// Only iterate over the references if include_declaration was false
refs.references()
.iter()
- .filter_map(|reference| to_proto::location(&world, reference.file_range).ok())
+ .filter_map(|reference| to_proto::location(&snap, reference.file_range).ok())
.collect()
};
}
pub fn handle_formatting(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: DocumentFormattingParams,
) -> Result<Option<Vec<lsp_types::TextEdit>>> {
let _p = profile("handle_formatting");
- let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?;
- let file = world.analysis().file_text(file_id)?;
- let crate_ids = world.analysis().crate_for(file_id)?;
+ let file_id = from_proto::file_id(&snap, ¶ms.text_document.uri)?;
+ let file = snap.analysis().file_text(file_id)?;
+ let crate_ids = snap.analysis().crate_for(file_id)?;
- let file_line_index = world.analysis().file_line_index(file_id)?;
+ let file_line_index = snap.analysis().file_line_index(file_id)?;
let end_position = to_proto::position(&file_line_index, TextSize::of(file.as_str()));
- let mut rustfmt = match &world.config.rustfmt {
+ let mut rustfmt = match &snap.config.rustfmt {
RustfmtConfig::Rustfmt { extra_args } => {
let mut cmd = process::Command::new("rustfmt");
cmd.args(extra_args);
if let Some(&crate_id) = crate_ids.first() {
// Assume all crates are in the same edition
- let edition = world.analysis().crate_edition(crate_id)?;
+ let edition = snap.analysis().crate_edition(crate_id)?;
cmd.arg("--edition");
cmd.arg(edition.to_string());
}
}
fn handle_fixes(
- world: &WorldSnapshot,
+ snap: &GlobalStateSnapshot,
params: &lsp_types::CodeActionParams,
res: &mut Vec<lsp_ext::CodeAction>,
) -> Result<()> {
- let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?;
- let line_index = world.analysis().file_line_index(file_id)?;
+ let file_id = from_proto::file_id(&snap, ¶ms.text_document.uri)?;
+ let line_index = snap.analysis().file_line_index(file_id)?;
let range = from_proto::text_range(&line_index, params.range);
-
- let diagnostics = world.analysis().diagnostics(file_id)?;
+ let diagnostics = snap.analysis().diagnostics(file_id)?;
let fixes_from_diagnostics = diagnostics
.into_iter()
.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 edit = to_proto::snippet_workspace_edit(&snap, fix.source_change)?;
let action = lsp_ext::CodeAction {
title,
id: None,
group: None,
- kind: None,
+ kind: Some(lsp_types::code_action_kind::QUICKFIX.into()),
edit: Some(edit),
command: None,
};
res.push(action);
}
- for fix in world.check_fixes.get(&file_id).into_iter().flatten() {
+
+ for fix in snap.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;
}
pub fn handle_code_action(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::CodeActionParams,
) -> Result<Option<Vec<lsp_ext::CodeAction>>> {
let _p = profile("handle_code_action");
// We intentionally don't support command-based actions, as those either
// requires custom client-code anyway, or requires server-initiated edits.
// Server initiated edits break causality, so we avoid those as well.
- if !world.config.client_caps.code_action_literals {
+ if !snap.config.client_caps.code_action_literals {
return Ok(None);
}
- let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?;
- let line_index = world.analysis().file_line_index(file_id)?;
+ let file_id = from_proto::file_id(&snap, ¶ms.text_document.uri)?;
+ let line_index = snap.analysis().file_line_index(file_id)?;
let range = from_proto::text_range(&line_index, params.range);
let frange = FileRange { file_id, range };
let mut res: Vec<lsp_ext::CodeAction> = Vec::new();
- handle_fixes(&world, ¶ms, &mut res)?;
+ handle_fixes(&snap, ¶ms, &mut res)?;
- if world.config.client_caps.resolve_code_action {
- for (index, assist) in world
- .analysis()
- .unresolved_assists(&world.config.assist, frange)?
- .into_iter()
- .enumerate()
+ if snap.config.client_caps.resolve_code_action {
+ for (index, assist) in
+ snap.analysis().unresolved_assists(&snap.config.assist, frange)?.into_iter().enumerate()
{
- res.push(to_proto::unresolved_code_action(&world, assist, index)?);
+ res.push(to_proto::unresolved_code_action(&snap, assist, index)?);
}
} else {
- for assist in world.analysis().resolved_assists(&world.config.assist, frange)?.into_iter() {
- res.push(to_proto::resolved_code_action(&world, assist)?);
+ for assist in snap.analysis().resolved_assists(&snap.config.assist, frange)?.into_iter() {
+ res.push(to_proto::resolved_code_action(&snap, assist)?);
}
}
}
pub fn handle_resolve_code_action(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_ext::ResolveCodeActionParams,
) -> Result<Option<lsp_ext::SnippetWorkspaceEdit>> {
let _p = profile("handle_resolve_code_action");
- let file_id = from_proto::file_id(&world, ¶ms.code_action_params.text_document.uri)?;
- let line_index = world.analysis().file_line_index(file_id)?;
+ let file_id = from_proto::file_id(&snap, ¶ms.code_action_params.text_document.uri)?;
+ let line_index = snap.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 assists = world.analysis().resolved_assists(&world.config.assist, frange)?;
+ let assists = snap.analysis().resolved_assists(&snap.config.assist, frange)?;
let id_components = params.id.split(":").collect::<Vec<&str>>();
let index = id_components.last().unwrap().parse::<usize>().unwrap();
let id_string = id_components.first().unwrap();
let assist = &assists[index];
assert!(assist.assist.id.0 == *id_string);
- Ok(to_proto::resolved_code_action(&world, assist.clone())?.edit)
+ Ok(to_proto::resolved_code_action(&snap, assist.clone())?.edit)
}
pub fn handle_code_lens(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::CodeLensParams,
) -> Result<Option<Vec<CodeLens>>> {
let _p = profile("handle_code_lens");
let mut lenses: Vec<CodeLens> = Default::default();
- if world.config.lens.none() {
+ if snap.config.lens.none() {
// early return before any db query!
return Ok(Some(lenses));
}
- let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?;
- let line_index = world.analysis().file_line_index(file_id)?;
- let cargo_spec = CargoTargetSpec::for_file(&world, file_id)?;
+ let file_id = from_proto::file_id(&snap, ¶ms.text_document.uri)?;
+ let line_index = snap.analysis().file_line_index(file_id)?;
+ let cargo_spec = CargoTargetSpec::for_file(&snap, file_id)?;
- if world.config.lens.runnable() {
+ if snap.config.lens.runnable() {
// Gather runnables
- for runnable in world.analysis().runnables(file_id)? {
+ for runnable in snap.analysis().runnables(file_id)? {
let (run_title, debugee) = match &runnable.kind {
RunnableKind::Test { .. } | RunnableKind::TestMod { .. } => {
("▶\u{fe0e} Run Test", true)
};
let range = to_proto::range(&line_index, runnable.nav.range());
- let r = to_proto::runnable(&world, file_id, runnable)?;
- if world.config.lens.run {
+ let r = to_proto::runnable(&snap, file_id, runnable)?;
+ if snap.config.lens.run {
let lens = CodeLens {
range,
command: Some(Command {
lenses.push(lens);
}
- if debugee && world.config.lens.debug {
+ if debugee && snap.config.lens.debug {
let debug_lens = CodeLens {
range,
command: Some(Command {
}
}
- if world.config.lens.impementations {
+ if snap.config.lens.impementations {
// Handle impls
lenses.extend(
- world
- .analysis()
+ snap.analysis()
.file_structure(file_id)?
.into_iter()
.filter(|it| match it.kind {
Impls(lsp_types::request::GotoImplementationParams),
}
-pub fn handle_code_lens_resolve(world: WorldSnapshot, code_lens: CodeLens) -> Result<CodeLens> {
+pub fn handle_code_lens_resolve(
+ snap: GlobalStateSnapshot,
+ code_lens: CodeLens,
+) -> Result<CodeLens> {
let _p = profile("handle_code_lens_resolve");
let data = code_lens.data.unwrap();
let resolve = from_json::<Option<CodeLensResolveData>>("CodeLensResolveData", data)?;
match resolve {
Some(CodeLensResolveData::Impls(lens_params)) => {
let locations: Vec<Location> =
- match handle_goto_implementation(world, lens_params.clone())? {
+ match handle_goto_implementation(snap, lens_params.clone())? {
Some(lsp_types::GotoDefinitionResponse::Scalar(loc)) => vec![loc],
Some(lsp_types::GotoDefinitionResponse::Array(locs)) => locs,
Some(lsp_types::GotoDefinitionResponse::Link(links)) => links
}
pub fn handle_document_highlight(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_types::DocumentHighlightParams,
) -> Result<Option<Vec<DocumentHighlight>>> {
let _p = profile("handle_document_highlight");
- let position = from_proto::file_position(&world, params.text_document_position_params)?;
- let line_index = world.analysis().file_line_index(position.file_id)?;
+ let position = from_proto::file_position(&snap, params.text_document_position_params)?;
+ let line_index = snap.analysis().file_line_index(position.file_id)?;
- let refs = match world
+ let refs = match snap
.analysis()
.find_all_refs(position, Some(SearchScope::single_file(position.file_id)))?
{
}
pub fn handle_ssr(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: lsp_ext::SsrParams,
) -> Result<lsp_types::WorkspaceEdit> {
let _p = profile("handle_ssr");
let source_change =
- world.analysis().structural_search_replace(¶ms.query, params.parse_only)??;
- to_proto::workspace_edit(&world, source_change)
+ snap.analysis().structural_search_replace(¶ms.query, params.parse_only)??;
+ to_proto::workspace_edit(&snap, source_change)
}
-pub fn publish_diagnostics(world: &WorldSnapshot, file_id: FileId) -> Result<DiagnosticTask> {
+pub fn publish_diagnostics(snap: &GlobalStateSnapshot, file_id: FileId) -> Result<DiagnosticTask> {
let _p = profile("publish_diagnostics");
- let line_index = world.analysis().file_line_index(file_id)?;
- let diagnostics: Vec<Diagnostic> = world
+ let line_index = snap.analysis().file_line_index(file_id)?;
+ let diagnostics: Vec<Diagnostic> = snap
.analysis()
.diagnostics(file_id)?
.into_iter()
}
pub fn handle_inlay_hints(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: InlayHintsParams,
) -> Result<Vec<InlayHint>> {
let _p = profile("handle_inlay_hints");
- let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?;
- let analysis = world.analysis();
+ let file_id = from_proto::file_id(&snap, ¶ms.text_document.uri)?;
+ let analysis = snap.analysis();
let line_index = analysis.file_line_index(file_id)?;
Ok(analysis
- .inlay_hints(file_id, &world.config.inlay_hints)?
+ .inlay_hints(file_id, &snap.config.inlay_hints)?
.into_iter()
.map(|it| to_proto::inlay_int(&line_index, it))
.collect())
}
pub fn handle_call_hierarchy_prepare(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: CallHierarchyPrepareParams,
) -> Result<Option<Vec<CallHierarchyItem>>> {
let _p = profile("handle_call_hierarchy_prepare");
- let position = from_proto::file_position(&world, params.text_document_position_params)?;
+ let position = from_proto::file_position(&snap, params.text_document_position_params)?;
- let nav_info = match world.analysis().call_hierarchy(position)? {
+ let nav_info = match snap.analysis().call_hierarchy(position)? {
None => return Ok(None),
Some(it) => it,
};
let res = navs
.into_iter()
.filter(|it| it.kind() == SyntaxKind::FN_DEF)
- .map(|it| to_proto::call_hierarchy_item(&world, it))
+ .map(|it| to_proto::call_hierarchy_item(&snap, it))
.collect::<Result<Vec<_>>>()?;
Ok(Some(res))
}
pub fn handle_call_hierarchy_incoming(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: CallHierarchyIncomingCallsParams,
) -> Result<Option<Vec<CallHierarchyIncomingCall>>> {
let _p = profile("handle_call_hierarchy_incoming");
let item = params.item;
let doc = TextDocumentIdentifier::new(item.uri);
- let frange = from_proto::file_range(&world, doc, item.range)?;
+ let frange = from_proto::file_range(&snap, doc, item.range)?;
let fpos = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
- let call_items = match world.analysis().incoming_calls(fpos)? {
+ let call_items = match snap.analysis().incoming_calls(fpos)? {
None => return Ok(None),
Some(it) => it,
};
for call_item in call_items.into_iter() {
let file_id = call_item.target.file_id();
- let line_index = world.analysis().file_line_index(file_id)?;
- let item = to_proto::call_hierarchy_item(&world, call_item.target)?;
+ let line_index = snap.analysis().file_line_index(file_id)?;
+ let item = to_proto::call_hierarchy_item(&snap, call_item.target)?;
res.push(CallHierarchyIncomingCall {
from: item,
from_ranges: call_item
}
pub fn handle_call_hierarchy_outgoing(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: CallHierarchyOutgoingCallsParams,
) -> Result<Option<Vec<CallHierarchyOutgoingCall>>> {
let _p = profile("handle_call_hierarchy_outgoing");
let item = params.item;
let doc = TextDocumentIdentifier::new(item.uri);
- let frange = from_proto::file_range(&world, doc, item.range)?;
+ let frange = from_proto::file_range(&snap, doc, item.range)?;
let fpos = FilePosition { file_id: frange.file_id, offset: frange.range.start() };
- let call_items = match world.analysis().outgoing_calls(fpos)? {
+ let call_items = match snap.analysis().outgoing_calls(fpos)? {
None => return Ok(None),
Some(it) => it,
};
for call_item in call_items.into_iter() {
let file_id = call_item.target.file_id();
- let line_index = world.analysis().file_line_index(file_id)?;
- let item = to_proto::call_hierarchy_item(&world, call_item.target)?;
+ let line_index = snap.analysis().file_line_index(file_id)?;
+ let item = to_proto::call_hierarchy_item(&snap, call_item.target)?;
res.push(CallHierarchyOutgoingCall {
to: item,
from_ranges: call_item
}
pub fn handle_semantic_tokens(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: SemanticTokensParams,
) -> Result<Option<SemanticTokensResult>> {
let _p = profile("handle_semantic_tokens");
- let file_id = from_proto::file_id(&world, ¶ms.text_document.uri)?;
- let text = world.analysis().file_text(file_id)?;
- let line_index = world.analysis().file_line_index(file_id)?;
+ let file_id = from_proto::file_id(&snap, ¶ms.text_document.uri)?;
+ let text = snap.analysis().file_text(file_id)?;
+ let line_index = snap.analysis().file_line_index(file_id)?;
- let highlights = world.analysis().highlight(file_id)?;
+ let highlights = snap.analysis().highlight(file_id)?;
let semantic_tokens = to_proto::semantic_tokens(&text, &line_index, highlights);
Ok(Some(semantic_tokens.into()))
}
pub fn handle_semantic_tokens_range(
- world: WorldSnapshot,
+ snap: GlobalStateSnapshot,
params: SemanticTokensRangeParams,
) -> Result<Option<SemanticTokensRangeResult>> {
let _p = profile("handle_semantic_tokens_range");
- let frange = from_proto::file_range(&world, params.text_document, params.range)?;
- let text = world.analysis().file_text(frange.file_id)?;
- let line_index = world.analysis().file_line_index(frange.file_id)?;
+ let frange = from_proto::file_range(&snap, params.text_document, params.range)?;
+ let text = snap.analysis().file_text(frange.file_id)?;
+ let line_index = snap.analysis().file_line_index(frange.file_id)?;
- let highlights = world.analysis().highlight_range(frange)?;
+ let highlights = snap.analysis().highlight_range(frange)?;
let semantic_tokens = to_proto::semantic_tokens(&text, &line_index, highlights);
Ok(Some(semantic_tokens.into()))
}
projects / rust.git / blobdiff