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

Don't retry position relient requests and version resolve data

Browse Source
This commit is contained in:
Lukas Wirth 2024-04-28 16:19:55 +02:00
parent efb390bb94
commit 001c387150
8 changed files with 116 additions and 129 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
src/tools/rust-analyzer/crates/rust-analyzer/src/dispatch.rs
View File

@ -95,45 +95,8 @@ impl RequestDispatcher<'_> {
self self
} }
/// Dispatches a non-latency-sensitive request onto the thread pool
/// without retrying it if it panics.
pub(crate) fn on_no_retry<R>(
&mut self,
f: fn(GlobalStateSnapshot, R::Params) -> anyhow::Result<R::Result>,
) -> &mut Self
where
R: lsp_types::request::Request + 'static,
R::Params: DeserializeOwned + panic::UnwindSafe + Send + fmt::Debug,
R::Result: Serialize,
{
let (req, params, panic_context) = match self.parse::<R>() {
Some(it) => it,
None => return self,
};
self.global_state.task_pool.handle.spawn(ThreadIntent::Worker, {
let world = self.global_state.snapshot();
move || {
let result = panic::catch_unwind(move || {
let _pctx = stdx::panic_context::enter(panic_context);
f(world, params)
});
match thread_result_to_response::<R>(req.id.clone(), result) {
Ok(response) => Task::Response(response),
Err(_) => Task::Response(lsp_server::Response::new_err(
req.id,
lsp_server::ErrorCode::ContentModified as i32,
"content modified".to_owned(),
)),
}
}
});
self
}
/// Dispatches a non-latency-sensitive request onto the thread pool. /// Dispatches a non-latency-sensitive request onto the thread pool.
pub(crate) fn on<R>( pub(crate) fn on<const ALLOW_RETRYING: bool, R>(
&mut self, &mut self,
f: fn(GlobalStateSnapshot, R::Params) -> anyhow::Result<R::Result>, f: fn(GlobalStateSnapshot, R::Params) -> anyhow::Result<R::Result>,
) -> &mut Self ) -> &mut Self
@ -142,11 +105,11 @@ impl RequestDispatcher<'_> {
R::Params: DeserializeOwned + panic::UnwindSafe + Send + fmt::Debug, R::Params: DeserializeOwned + panic::UnwindSafe + Send + fmt::Debug,
R::Result: Serialize, R::Result: Serialize,
{ {
self.on_with_thread_intent::<true, R>(ThreadIntent::Worker, f) self.on_with_thread_intent::<true, ALLOW_RETRYING, R>(ThreadIntent::Worker, f)
} }
/// Dispatches a latency-sensitive request onto the thread pool. /// Dispatches a latency-sensitive request onto the thread pool.
pub(crate) fn on_latency_sensitive<R>( pub(crate) fn on_latency_sensitive<const ALLOW_RETRYING: bool, R>(
&mut self, &mut self,
f: fn(GlobalStateSnapshot, R::Params) -> anyhow::Result<R::Result>, f: fn(GlobalStateSnapshot, R::Params) -> anyhow::Result<R::Result>,
) -> &mut Self ) -> &mut Self
@ -155,7 +118,7 @@ impl RequestDispatcher<'_> {
R::Params: DeserializeOwned + panic::UnwindSafe + Send + fmt::Debug, R::Params: DeserializeOwned + panic::UnwindSafe + Send + fmt::Debug,
R::Result: Serialize, R::Result: Serialize,
{ {
self.on_with_thread_intent::<true, R>(ThreadIntent::LatencySensitive, f) self.on_with_thread_intent::<true, ALLOW_RETRYING, R>(ThreadIntent::LatencySensitive, f)
} }
/// Formatting requests should never block on waiting a for task thread to open up, editors will wait /// Formatting requests should never block on waiting a for task thread to open up, editors will wait
@ -170,7 +133,7 @@ impl RequestDispatcher<'_> {
R::Params: DeserializeOwned + panic::UnwindSafe + Send + fmt::Debug, R::Params: DeserializeOwned + panic::UnwindSafe + Send + fmt::Debug,
R::Result: Serialize, R::Result: Serialize,
{ {
self.on_with_thread_intent::<false, R>(ThreadIntent::LatencySensitive, f) self.on_with_thread_intent::<false, false, R>(ThreadIntent::LatencySensitive, f)
} }
pub(crate) fn finish(&mut self) { pub(crate) fn finish(&mut self) {
@ -185,7 +148,7 @@ impl RequestDispatcher<'_> {
} }
} }
fn on_with_thread_intent<const MAIN_POOL: bool, R>( fn on_with_thread_intent<const MAIN_POOL: bool, const ALLOW_RETRYING: bool, R>(
&mut self, &mut self,
intent: ThreadIntent, intent: ThreadIntent,
f: fn(GlobalStateSnapshot, R::Params) -> anyhow::Result<R::Result>, f: fn(GlobalStateSnapshot, R::Params) -> anyhow::Result<R::Result>,
@ -215,7 +178,12 @@ impl RequestDispatcher<'_> {
}); });
match thread_result_to_response::<R>(req.id.clone(), result) { match thread_result_to_response::<R>(req.id.clone(), result) {
Ok(response) => Task::Response(response), Ok(response) => Task::Response(response),
Err(_) => Task::Retry(req), Err(_cancelled) if ALLOW_RETRYING => Task::Retry(req),
Err(_cancelled) => Task::Response(lsp_server::Response::new_err(
req.id,
lsp_server::ErrorCode::ContentModified as i32,
"content modified".to_owned(),
)),
} }
}); });

4
src/tools/rust-analyzer/crates/rust-analyzer/src/global_state.rs
View File

@ -488,6 +488,10 @@ impl GlobalStateSnapshot {
Ok(res) Ok(res)
} }
pub(crate) fn file_version(&self, file_id: FileId) -> Option<i32> {
Some(self.mem_docs.get(self.vfs_read().file_path(file_id))?.version)
}
pub(crate) fn url_file_version(&self, url: &Url) -> Option<i32> { pub(crate) fn url_file_version(&self, url: &Url) -> Option<i32> {
let path = from_proto::vfs_path(url).ok()?; let path = from_proto::vfs_path(url).ok()?;
Some(self.mem_docs.get(&path)?.version) Some(self.mem_docs.get(&path)?.version)

39
src/tools/rust-analyzer/crates/rust-analyzer/src/handlers/request.rs
View File

@ -954,8 +954,13 @@ pub(crate) fn handle_completion(
}; };
let line_index = snap.file_line_index(position.file_id)?; let line_index = snap.file_line_index(position.file_id)?;
let items = let items = to_proto::completion_items(
to_proto::completion_items(&snap.config, &line_index, text_document_position, items); &snap.config,
&line_index,
snap.file_version(position.file_id),
text_document_position,
items,
);
let completion_list = lsp_types::CompletionList { is_incomplete: true, items }; let completion_list = lsp_types::CompletionList { is_incomplete: true, items };
Ok(Some(completion_list.into())) Ok(Some(completion_list.into()))
@ -1240,8 +1245,11 @@ pub(crate) fn handle_code_action(
frange, frange,
)?; )?;
for (index, assist) in assists.into_iter().enumerate() { for (index, assist) in assists.into_iter().enumerate() {
let resolve_data = let resolve_data = if code_action_resolve_cap {
if code_action_resolve_cap { Some((index, params.clone())) } else { None }; Some((index, params.clone(), snap.file_version(file_id)))
} else {
None
};
let code_action = to_proto::code_action(&snap, assist, resolve_data)?; let code_action = to_proto::code_action(&snap, assist, resolve_data)?;
// Check if the client supports the necessary `ResourceOperation`s. // Check if the client supports the necessary `ResourceOperation`s.
@ -1280,12 +1288,14 @@ pub(crate) fn handle_code_action_resolve(
mut code_action: lsp_ext::CodeAction, mut code_action: lsp_ext::CodeAction,
) -> anyhow::Result<lsp_ext::CodeAction> { ) -> anyhow::Result<lsp_ext::CodeAction> {
let _p = tracing::span!(tracing::Level::INFO, "handle_code_action_resolve").entered(); let _p = tracing::span!(tracing::Level::INFO, "handle_code_action_resolve").entered();
let params = match code_action.data.take() { let Some(params) = code_action.data.take() else {
Some(it) => it, return Err(invalid_params_error("code action without data".to_owned()).into());
None => return Err(invalid_params_error("code action without data".to_owned()).into()),
}; };
let file_id = from_proto::file_id(&snap, &params.code_action_params.text_document.uri)?; let file_id = from_proto::file_id(&snap, &params.code_action_params.text_document.uri)?;
if snap.file_version(file_id) != params.version {
return Err(invalid_params_error("stale code action".to_owned()).into());
}
let line_index = snap.file_line_index(file_id)?; let line_index = snap.file_line_index(file_id)?;
let range = from_proto::text_range(&line_index, params.code_action_params.range)?; let range = from_proto::text_range(&line_index, params.code_action_params.range)?;
let frange = FileRange { file_id, range }; let frange = FileRange { file_id, range };
@ -1411,12 +1421,11 @@ pub(crate) fn handle_code_lens(
pub(crate) fn handle_code_lens_resolve( pub(crate) fn handle_code_lens_resolve(
snap: GlobalStateSnapshot, snap: GlobalStateSnapshot,
code_lens: CodeLens, mut code_lens: CodeLens,
) -> anyhow::Result<CodeLens> { ) -> anyhow::Result<CodeLens> {
if code_lens.data.is_none() { let Some(data) = code_lens.data.take() else { return Ok(code_lens) };
return Ok(code_lens); let resolve = serde_json::from_value::<lsp_ext::CodeLensResolveData>(data)?;
} let Some(annotation) = from_proto::annotation(&snap, code_lens.range, resolve)? else {
let Some(annotation) = from_proto::annotation(&snap, code_lens.clone())? else {
return Ok(code_lens); return Ok(code_lens);
}; };
let annotation = snap.analysis.resolve_annotation(annotation)?; let annotation = snap.analysis.resolve_annotation(annotation)?;
@ -1522,8 +1531,12 @@ pub(crate) fn handle_inlay_hints_resolve(
let Some(data) = original_hint.data.take() else { return Ok(original_hint) }; let Some(data) = original_hint.data.take() else { return Ok(original_hint) };
let resolve_data: lsp_ext::InlayHintResolveData = serde_json::from_value(data)?; let resolve_data: lsp_ext::InlayHintResolveData = serde_json::from_value(data)?;
let Some(hash) = resolve_data.hash.parse().ok() else { return Ok(original_hint) };
let file_id = FileId::from_raw(resolve_data.file_id); let file_id = FileId::from_raw(resolve_data.file_id);
if resolve_data.version != snap.file_version(file_id) {
tracing::warn!("Inlay hint resolve data is outdated");
return Ok(original_hint);
}
let Some(hash) = resolve_data.hash.parse().ok() else { return Ok(original_hint) };
anyhow::ensure!(snap.file_exists(file_id), "Invalid LSP resolve data"); anyhow::ensure!(snap.file_exists(file_id), "Invalid LSP resolve data");
let line_index = snap.file_line_index(file_id)?; let line_index = snap.file_line_index(file_id)?;

3
src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/ext.rs
View File

@ -561,6 +561,7 @@ pub struct CodeAction {
pub struct CodeActionData { pub struct CodeActionData {
pub code_action_params: lsp_types::CodeActionParams, pub code_action_params: lsp_types::CodeActionParams,
pub id: String, pub id: String,
pub version: Option<i32>,
} }
#[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)] #[derive(Debug, Eq, PartialEq, Clone, Default, Deserialize, Serialize)]
@ -802,6 +803,7 @@ impl Request for OnTypeFormatting {
pub struct CompletionResolveData { pub struct CompletionResolveData {
pub position: lsp_types::TextDocumentPositionParams, pub position: lsp_types::TextDocumentPositionParams,
pub imports: Vec<CompletionImport>, pub imports: Vec<CompletionImport>,
pub version: Option<i32>,
} }
#[derive(Debug, Serialize, Deserialize)] #[derive(Debug, Serialize, Deserialize)]
@ -809,6 +811,7 @@ pub struct InlayHintResolveData {
pub file_id: u32, pub file_id: u32,
// This is a string instead of a u64 as javascript can't represent u64 fully // This is a string instead of a u64 as javascript can't represent u64 fully
pub hash: String, pub hash: String,
pub version: Option<i32>,
} }
#[derive(Debug, Serialize, Deserialize)] #[derive(Debug, Serialize, Deserialize)]

19
src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/from_proto.rs
View File

@ -9,10 +9,8 @@ use syntax::{TextRange, TextSize};
use vfs::AbsPathBuf; use vfs::AbsPathBuf;
use crate::{ use crate::{
from_json,
global_state::GlobalStateSnapshot, global_state::GlobalStateSnapshot,
line_index::{LineIndex, PositionEncoding}, line_index::{LineIndex, PositionEncoding},
lsp::utils::invalid_params_error,
lsp_ext, lsp_ext,
}; };
@ -105,16 +103,13 @@ pub(crate) fn assist_kind(kind: lsp_types::CodeActionKind) -> Option<AssistKind>
pub(crate) fn annotation( pub(crate) fn annotation(
snap: &GlobalStateSnapshot, snap: &GlobalStateSnapshot,
code_lens: lsp_types::CodeLens, range: lsp_types::Range,
data: lsp_ext::CodeLensResolveData,
) -> anyhow::Result<Option<Annotation>> { ) -> anyhow::Result<Option<Annotation>> {
let data = match data.kind {
code_lens.data.ok_or_else(|| invalid_params_error("code lens without data".to_owned()))?;
let resolve = from_json::<lsp_ext::CodeLensResolveData>("CodeLensResolveData", &data)?;
match resolve.kind {
lsp_ext::CodeLensResolveDataKind::Impls(params) => { lsp_ext::CodeLensResolveDataKind::Impls(params) => {
if snap.url_file_version(&params.text_document_position_params.text_document.uri) if snap.url_file_version(&params.text_document_position_params.text_document.uri)
!= Some(resolve.version) != Some(data.version)
{ {
return Ok(None); return Ok(None);
} }
@ -123,19 +118,19 @@ pub(crate) fn annotation(
let line_index = snap.file_line_index(file_id)?; let line_index = snap.file_line_index(file_id)?;
Ok(Annotation { Ok(Annotation {
range: text_range(&line_index, code_lens.range)?, range: text_range(&line_index, range)?,
kind: AnnotationKind::HasImpls { pos, data: None }, kind: AnnotationKind::HasImpls { pos, data: None },
}) })
} }
lsp_ext::CodeLensResolveDataKind::References(params) => { lsp_ext::CodeLensResolveDataKind::References(params) => {
if snap.url_file_version(&params.text_document.uri) != Some(resolve.version) { if snap.url_file_version(&params.text_document.uri) != Some(data.version) {
return Ok(None); return Ok(None);
} }
let pos @ FilePosition { file_id, .. } = file_position(snap, params)?; let pos @ FilePosition { file_id, .. } = file_position(snap, params)?;
let line_index = snap.file_line_index(file_id)?; let line_index = snap.file_line_index(file_id)?;
Ok(Annotation { Ok(Annotation {
range: text_range(&line_index, code_lens.range)?, range: text_range(&line_index, range)?,
kind: AnnotationKind::HasReferences { pos, data: None }, kind: AnnotationKind::HasReferences { pos, data: None },
}) })
} }

12
src/tools/rust-analyzer/crates/rust-analyzer/src/lsp/to_proto.rs
View File

@ -225,13 +225,14 @@ pub(crate) fn snippet_text_edit_vec(
pub(crate) fn completion_items( pub(crate) fn completion_items(
config: &Config, config: &Config,
line_index: &LineIndex, line_index: &LineIndex,
version: Option<i32>,
tdpp: lsp_types::TextDocumentPositionParams, tdpp: lsp_types::TextDocumentPositionParams,
items: Vec<CompletionItem>, items: Vec<CompletionItem>,
) -> Vec<lsp_types::CompletionItem> { ) -> Vec<lsp_types::CompletionItem> {
let max_relevance = items.iter().map(|it| it.relevance.score()).max().unwrap_or_default(); let max_relevance = items.iter().map(|it| it.relevance.score()).max().unwrap_or_default();
let mut res = Vec::with_capacity(items.len()); let mut res = Vec::with_capacity(items.len());
for item in items { for item in items {
completion_item(&mut res, config, line_index, &tdpp, max_relevance, item); completion_item(&mut res, config, line_index, version, &tdpp, max_relevance, item);
} }
if let Some(limit) = config.completion(None).limit { if let Some(limit) = config.completion(None).limit {
@ -246,6 +247,7 @@ fn completion_item(
acc: &mut Vec<lsp_types::CompletionItem>, acc: &mut Vec<lsp_types::CompletionItem>,
config: &Config, config: &Config,
line_index: &LineIndex, line_index: &LineIndex,
version: Option<i32>,
tdpp: &lsp_types::TextDocumentPositionParams, tdpp: &lsp_types::TextDocumentPositionParams,
max_relevance: u32, max_relevance: u32,
item: CompletionItem, item: CompletionItem,
@ -328,7 +330,7 @@ fn completion_item(
}) })
.collect::<Vec<_>>(); .collect::<Vec<_>>();
if !imports.is_empty() { if !imports.is_empty() {
let data = lsp_ext::CompletionResolveData { position: tdpp.clone(), imports }; let data = lsp_ext::CompletionResolveData { position: tdpp.clone(), imports, version };
lsp_item.data = Some(to_value(data).unwrap()); lsp_item.data = Some(to_value(data).unwrap());
} }
} }
@ -483,6 +485,7 @@ pub(crate) fn inlay_hint(
to_value(lsp_ext::InlayHintResolveData { to_value(lsp_ext::InlayHintResolveData {
file_id: file_id.index(), file_id: file_id.index(),
hash: hash.to_string(), hash: hash.to_string(),
version: snap.file_version(file_id),
}) })
.unwrap(), .unwrap(),
), ),
@ -1318,7 +1321,7 @@ pub(crate) fn code_action_kind(kind: AssistKind) -> lsp_types::CodeActionKind {
pub(crate) fn code_action( pub(crate) fn code_action(
snap: &GlobalStateSnapshot, snap: &GlobalStateSnapshot,
assist: Assist, assist: Assist,
resolve_data: Option<(usize, lsp_types::CodeActionParams)>, resolve_data: Option<(usize, lsp_types::CodeActionParams, Option<i32>)>,
) -> Cancellable<lsp_ext::CodeAction> { ) -> Cancellable<lsp_ext::CodeAction> {
let mut res = lsp_ext::CodeAction { let mut res = lsp_ext::CodeAction {
title: assist.label.to_string(), title: assist.label.to_string(),
@ -1336,10 +1339,11 @@ pub(crate) fn code_action(
match (assist.source_change, resolve_data) { match (assist.source_change, resolve_data) {
(Some(it), _) => res.edit = Some(snippet_workspace_edit(snap, it)?), (Some(it), _) => res.edit = Some(snippet_workspace_edit(snap, it)?),
(None, Some((index, code_action_params))) => { (None, Some((index, code_action_params, version))) => {
res.data = Some(lsp_ext::CodeActionData { res.data = Some(lsp_ext::CodeActionData {
id: format!("{}:{}:{index}", assist.id.0, assist.id.1.name()), id: format!("{}:{}:{index}", assist.id.0, assist.id.1.name()),
code_action_params, code_action_params,
version,
}); });
} }
(None, None) => { (None, None) => {

110
src/tools/rust-analyzer/crates/rust-analyzer/src/main_loop.rs
View File

@ -901,6 +901,10 @@ impl GlobalState {
use crate::handlers::request as handlers; use crate::handlers::request as handlers;
use lsp_types::request as lsp_request; use lsp_types::request as lsp_request;
const RETRY: bool = true;
const NO_RETRY: bool = false;
#[rustfmt::skip]
dispatcher dispatcher
// Request handlers that must run on the main thread // Request handlers that must run on the main thread
// because they mutate GlobalState: // because they mutate GlobalState:
@ -926,62 +930,58 @@ impl GlobalState {
// analysis on the main thread because that would block other // analysis on the main thread because that would block other
// requests. Instead, we run these request handlers on higher priority // requests. Instead, we run these request handlers on higher priority
// threads in the threadpool. // threads in the threadpool.
.on_latency_sensitive::<lsp_request::Completion>(handlers::handle_completion) // FIXME: Retrying can make the result of this stale?
.on_latency_sensitive::<lsp_request::ResolveCompletionItem>( .on_latency_sensitive::<RETRY, lsp_request::Completion>(handlers::handle_completion)
handlers::handle_completion_resolve, // FIXME: Retrying can make the result of this stale
) .on_latency_sensitive::<RETRY, lsp_request::ResolveCompletionItem>(handlers::handle_completion_resolve)
.on_latency_sensitive::<lsp_request::SemanticTokensFullRequest>( .on_latency_sensitive::<RETRY, lsp_request::SemanticTokensFullRequest>(handlers::handle_semantic_tokens_full)
handlers::handle_semantic_tokens_full, .on_latency_sensitive::<RETRY, lsp_request::SemanticTokensFullDeltaRequest>(handlers::handle_semantic_tokens_full_delta)
) .on_latency_sensitive::<NO_RETRY, lsp_request::SemanticTokensRangeRequest>(handlers::handle_semantic_tokens_range)
.on_latency_sensitive::<lsp_request::SemanticTokensFullDeltaRequest>( // FIXME: Some of these NO_RETRY could be retries if the file they are interested didn't change.
handlers::handle_semantic_tokens_full_delta,
)
.on_latency_sensitive::<lsp_request::SemanticTokensRangeRequest>(
handlers::handle_semantic_tokens_range,
)
// All other request handlers // All other request handlers
.on::<lsp_ext::FetchDependencyList>(handlers::fetch_dependency_list) .on::<RETRY, lsp_request::DocumentSymbolRequest>(handlers::handle_document_symbol)
.on::<lsp_ext::AnalyzerStatus>(handlers::handle_analyzer_status) .on::<RETRY, lsp_request::FoldingRangeRequest>(handlers::handle_folding_range)
.on::<lsp_ext::SyntaxTree>(handlers::handle_syntax_tree) .on::<NO_RETRY, lsp_request::SignatureHelpRequest>(handlers::handle_signature_help)
.on::<lsp_ext::ViewHir>(handlers::handle_view_hir) .on::<RETRY, lsp_request::WillRenameFiles>(handlers::handle_will_rename_files)
.on::<lsp_ext::ViewMir>(handlers::handle_view_mir) .on::<NO_RETRY, lsp_request::GotoDefinition>(handlers::handle_goto_definition)
.on::<lsp_ext::InterpretFunction>(handlers::handle_interpret_function) .on::<NO_RETRY, lsp_request::GotoDeclaration>(handlers::handle_goto_declaration)
.on::<lsp_ext::ViewFileText>(handlers::handle_view_file_text) .on::<NO_RETRY, lsp_request::GotoImplementation>(handlers::handle_goto_implementation)
.on::<lsp_ext::ViewCrateGraph>(handlers::handle_view_crate_graph) .on::<NO_RETRY, lsp_request::GotoTypeDefinition>(handlers::handle_goto_type_definition)
.on::<lsp_ext::ViewItemTree>(handlers::handle_view_item_tree) .on::<NO_RETRY, lsp_request::InlayHintRequest>(handlers::handle_inlay_hints)
.on::<lsp_ext::DiscoverTest>(handlers::handle_discover_test) .on::<RETRY, lsp_request::InlayHintResolveRequest>(handlers::handle_inlay_hints_resolve)
.on::<lsp_ext::ExpandMacro>(handlers::handle_expand_macro) .on::<NO_RETRY, lsp_request::CodeLensRequest>(handlers::handle_code_lens)
.on::<lsp_ext::ParentModule>(handlers::handle_parent_module) .on::<RETRY, lsp_request::CodeLensResolve>(handlers::handle_code_lens_resolve)
.on::<lsp_ext::Runnables>(handlers::handle_runnables) .on::<NO_RETRY, lsp_request::PrepareRenameRequest>(handlers::handle_prepare_rename)
.on::<lsp_ext::RelatedTests>(handlers::handle_related_tests) .on::<NO_RETRY, lsp_request::Rename>(handlers::handle_rename)
.on::<lsp_ext::CodeActionRequest>(handlers::handle_code_action) .on::<NO_RETRY, lsp_request::References>(handlers::handle_references)
.on::<lsp_ext::CodeActionResolveRequest>(handlers::handle_code_action_resolve) .on::<NO_RETRY, lsp_request::DocumentHighlightRequest>(handlers::handle_document_highlight)
.on::<lsp_ext::HoverRequest>(handlers::handle_hover) .on::<NO_RETRY, lsp_request::CallHierarchyPrepare>(handlers::handle_call_hierarchy_prepare)
.on::<lsp_ext::ExternalDocs>(handlers::handle_open_docs) .on::<NO_RETRY, lsp_request::CallHierarchyIncomingCalls>(handlers::handle_call_hierarchy_incoming)
.on::<lsp_ext::OpenCargoToml>(handlers::handle_open_cargo_toml) .on::<NO_RETRY, lsp_request::CallHierarchyOutgoingCalls>(handlers::handle_call_hierarchy_outgoing)
.on::<lsp_ext::MoveItem>(handlers::handle_move_item) // All other request handlers (lsp extension)
.on::<lsp_ext::WorkspaceSymbol>(handlers::handle_workspace_symbol) .on::<RETRY, lsp_ext::FetchDependencyList>(handlers::fetch_dependency_list)
.on::<lsp_request::DocumentSymbolRequest>(handlers::handle_document_symbol) .on::<RETRY, lsp_ext::AnalyzerStatus>(handlers::handle_analyzer_status)
.on::<lsp_request::GotoDefinition>(handlers::handle_goto_definition) .on::<RETRY, lsp_ext::ViewFileText>(handlers::handle_view_file_text)
.on::<lsp_request::GotoDeclaration>(handlers::handle_goto_declaration) .on::<RETRY, lsp_ext::ViewCrateGraph>(handlers::handle_view_crate_graph)
.on::<lsp_request::GotoImplementation>(handlers::handle_goto_implementation) .on::<RETRY, lsp_ext::ViewItemTree>(handlers::handle_view_item_tree)
.on::<lsp_request::GotoTypeDefinition>(handlers::handle_goto_type_definition) .on::<RETRY, lsp_ext::DiscoverTest>(handlers::handle_discover_test)
.on_no_retry::<lsp_request::InlayHintRequest>(handlers::handle_inlay_hints) .on::<RETRY, lsp_ext::WorkspaceSymbol>(handlers::handle_workspace_symbol)
.on::<lsp_request::InlayHintResolveRequest>(handlers::handle_inlay_hints_resolve) .on::<NO_RETRY, lsp_ext::Ssr>(handlers::handle_ssr)
.on::<lsp_request::CodeLensRequest>(handlers::handle_code_lens) .on::<NO_RETRY, lsp_ext::ViewRecursiveMemoryLayout>(handlers::handle_view_recursive_memory_layout)
.on::<lsp_request::CodeLensResolve>(handlers::handle_code_lens_resolve) .on::<NO_RETRY, lsp_ext::SyntaxTree>(handlers::handle_syntax_tree)
.on::<lsp_request::FoldingRangeRequest>(handlers::handle_folding_range) .on::<NO_RETRY, lsp_ext::ViewHir>(handlers::handle_view_hir)
.on::<lsp_request::SignatureHelpRequest>(handlers::handle_signature_help) .on::<NO_RETRY, lsp_ext::ViewMir>(handlers::handle_view_mir)
.on::<lsp_request::PrepareRenameRequest>(handlers::handle_prepare_rename) .on::<NO_RETRY, lsp_ext::InterpretFunction>(handlers::handle_interpret_function)
.on::<lsp_request::Rename>(handlers::handle_rename) .on::<NO_RETRY, lsp_ext::ExpandMacro>(handlers::handle_expand_macro)
.on::<lsp_request::References>(handlers::handle_references) .on::<NO_RETRY, lsp_ext::ParentModule>(handlers::handle_parent_module)
.on::<lsp_request::DocumentHighlightRequest>(handlers::handle_document_highlight) .on::<NO_RETRY, lsp_ext::Runnables>(handlers::handle_runnables)
.on::<lsp_request::CallHierarchyPrepare>(handlers::handle_call_hierarchy_prepare) .on::<NO_RETRY, lsp_ext::RelatedTests>(handlers::handle_related_tests)
.on::<lsp_request::CallHierarchyIncomingCalls>(handlers::handle_call_hierarchy_incoming) .on::<NO_RETRY, lsp_ext::CodeActionRequest>(handlers::handle_code_action)
.on::<lsp_request::CallHierarchyOutgoingCalls>(handlers::handle_call_hierarchy_outgoing) .on::<RETRY, lsp_ext::CodeActionResolveRequest>(handlers::handle_code_action_resolve)
.on::<lsp_request::WillRenameFiles>(handlers::handle_will_rename_files) .on::<NO_RETRY, lsp_ext::HoverRequest>(handlers::handle_hover)
.on::<lsp_ext::Ssr>(handlers::handle_ssr) .on::<NO_RETRY, lsp_ext::ExternalDocs>(handlers::handle_open_docs)
.on::<lsp_ext::ViewRecursiveMemoryLayout>(handlers::handle_view_recursive_memory_layout) .on::<NO_RETRY, lsp_ext::OpenCargoToml>(handlers::handle_open_cargo_toml)
.on::<NO_RETRY, lsp_ext::MoveItem>(handlers::handle_move_item)
.finish(); .finish();
} }

2
src/tools/rust-analyzer/docs/dev/lsp-extensions.md
View File

@ -1,5 +1,5 @@
<!--- <!---
lsp/ext.rs hash: d8e2aa65fdb48e48 lsp/ext.rs hash: a39009c351009d16
If you need to change the above hash to make the test pass, please check if you If you need to change the above hash to make the test pass, please check if you
need to adjust this doc as well and ping this issue: need to adjust this doc as well and ping this issue: