Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

Do not drop other servers' data on semantic token refresh (#61795)

Kirill Bulatov410a8a06ed72
diff --git a/crates/project/src/lsp_store/code_lens.rs b/crates/project/src/lsp_store/code_lens.rs
index 36982102779..52c35e13e68 100644
--- a/crates/project/src/lsp_store/code_lens.rs
+++ b/crates/project/src/lsp_store/code_lens.rs
@@ -71,9 +71,9 @@ impl CodeLensData {
self.lens.clear();
self.fetched_servers.clear();
self.resolving.clear();
+ self.update = None;
}
}
- self.update = None;
}
}
diff --git a/crates/project/src/lsp_store/document_colors.rs b/crates/project/src/lsp_store/document_colors.rs
index 70497361f22..e3465eba447 100644
--- a/crates/project/src/lsp_store/document_colors.rs
+++ b/crates/project/src/lsp_store/document_colors.rs
@@ -56,9 +56,9 @@ impl DocumentColorData {
None => {
self.colors.clear();
self.fetched_servers.clear();
+ self.colors_update = None;
}
}
- self.colors_update = None;
}
}
diff --git a/crates/project/src/lsp_store/document_links.rs b/crates/project/src/lsp_store/document_links.rs
index 22eca9cae0e..323b37604dc 100644
--- a/crates/project/src/lsp_store/document_links.rs
+++ b/crates/project/src/lsp_store/document_links.rs
@@ -66,9 +66,9 @@ impl DocumentLinksData {
self.links.clear();
self.fetched_servers.clear();
self.link_resolves.clear();
+ self.links_update = None;
}
}
- self.links_update = None;
}
}
diff --git a/crates/project/src/lsp_store/document_symbols.rs b/crates/project/src/lsp_store/document_symbols.rs
index 20088da3211..adda847c47e 100644
--- a/crates/project/src/lsp_store/document_symbols.rs
+++ b/crates/project/src/lsp_store/document_symbols.rs
@@ -46,9 +46,9 @@ impl DocumentSymbolsData {
None => {
self.symbols.clear();
self.fetched_servers.clear();
+ self.symbols_update = None;
}
}
- self.symbols_update = None;
}
}
diff --git a/crates/project/src/lsp_store/folding_ranges.rs b/crates/project/src/lsp_store/folding_ranges.rs
index 72e7998e810..e1be0c3d57a 100644
--- a/crates/project/src/lsp_store/folding_ranges.rs
+++ b/crates/project/src/lsp_store/folding_ranges.rs
@@ -51,9 +51,9 @@ impl FoldingRangeData {
None => {
self.ranges.clear();
self.fetched_servers.clear();
+ self.ranges_update = None;
}
}
- self.ranges_update = None;
}
}
diff --git a/crates/project/src/lsp_store/semantic_tokens.rs b/crates/project/src/lsp_store/semantic_tokens.rs
index 6b5c40253ba..675ab29f76d 100644
--- a/crates/project/src/lsp_store/semantic_tokens.rs
+++ b/crates/project/src/lsp_store/semantic_tokens.rs
@@ -91,7 +91,8 @@ impl LspStore {
let current_servers = self.relevant_server_ids_for_capability_check(&buffer, cx);
let latest_lsp_data = self.latest_lsp_data(&buffer, cx);
let semantic_tokens_data = latest_lsp_data.semantic_tokens.get_or_insert_default();
- let refreshed_servers = std::mem::take(&mut semantic_tokens_data.pending_refreshes);
+ let mut refreshed_servers = std::mem::take(&mut semantic_tokens_data.pending_refreshes);
+ refreshed_servers.retain(|server_id| current_servers.contains(server_id));
if !refreshed_servers.is_empty() {
semantic_tokens_data.update = None;
semantic_tokens_data.generation += 1;
@@ -190,17 +191,39 @@ impl LspStore {
.await,
)
} else {
- lsp_store.update(cx, |lsp_store, cx| {
+ let remaining_tokens = lsp_store.update(cx, |lsp_store, cx| {
+ let mut remaining_tokens = None;
if let Some(current_lsp_data) =
lsp_store.current_lsp_data(buffer.read(cx).remote_id())
&& current_lsp_data.buffer_version == version_queried_for
&& let Some(semantic_tokens) = current_lsp_data.semantic_tokens.as_mut()
&& semantic_tokens.generation == query_generation
{
- semantic_tokens.evict_all();
+ if for_server.is_none() || semantic_tokens.raw_tokens.servers.is_empty()
+ {
+ semantic_tokens.evict_all();
+ } else {
+ // A targeted fetch that sent no requests (e.g. the server
+ // lost the capability or does not serve this buffer) must
+ // not drop the other servers' cached tokens.
+ let buffer_snapshot =
+ buffer.read_with(cx, |buffer, _| buffer.snapshot());
+ remaining_tokens =
+ Some((semantic_tokens.raw_tokens.clone(), buffer_snapshot));
+ }
}
+ remaining_tokens
})?;
- None
+ match remaining_tokens {
+ Some((raw_tokens, buffer_snapshot)) => Some(
+ cx.background_spawn(raw_to_buffer_semantic_tokens(
+ raw_tokens,
+ buffer_snapshot.text.clone(),
+ ))
+ .await,
+ ),
+ None => None,
+ }
};
Ok(BufferSemanticTokens { tokens: res })
})
diff --git a/crates/project/tests/integration/dynamic_registration.rs b/crates/project/tests/integration/dynamic_registration.rs
index 0dcfd708d41..9600b2cc4cf 100644
--- a/crates/project/tests/integration/dynamic_registration.rs
+++ b/crates/project/tests/integration/dynamic_registration.rs
@@ -1,6 +1,8 @@
//! Tests for dynamic (un)registration of language server capabilities, handled in
//! `project::lsp_store::dynamic_registration`.
+use std::collections::BTreeMap;
+
use pretty_assertions::assert_eq;
use super::*;
@@ -942,12 +944,225 @@ async fn test_multi_registration_diagnostics(cx: &mut gpui::TestAppContext) {
);
}
+/// One large scenario for all per-server-refreshable LSP data kinds (document colors,
+/// links, folding ranges, symbols, code lens, semantic tokens, inlay hints), asserting
+/// at the data level that per-server refreshes never disturb other servers:
+/// neither the second server on the same buffer, nor a server of an unrelated language.
+#[gpui::test]
+async fn test_per_server_refreshes_keep_other_servers_data(cx: &mut gpui::TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.executor());
+ fs.insert_tree(
+ path!("/the-root"),
+ json!({ "a.rs": "fn main() {\n}\n", "b.md": "# title\ntext\n" }),
+ )
+ .await;
+ let project = Project::test(fs, [path!("/the-root").as_ref()], cx).await;
+ let language_registry = project.read_with(cx, |project, _| project.languages().clone());
+ language_registry.add(rust_lang());
+ language_registry.add(markdown_lang());
+
+ let mut static_servers = language_registry.register_fake_lsp(
+ "Rust",
+ FakeLspAdapter {
+ name: "static-server",
+ capabilities: all_lsp_data_server_capabilities(),
+ ..FakeLspAdapter::default()
+ },
+ );
+ let mut dynamic_servers = language_registry.register_fake_lsp(
+ "Rust",
+ FakeLspAdapter {
+ name: "dynamic-server",
+ ..FakeLspAdapter::default()
+ },
+ );
+ let mut markdown_servers = language_registry.register_fake_lsp(
+ "Markdown",
+ FakeLspAdapter {
+ name: "markdown-server",
+ capabilities: all_lsp_data_server_capabilities(),
+ ..FakeLspAdapter::default()
+ },
+ );
+ cx.executor().run_until_parked();
+
+ let (rust_buffer, _rust_lsp_handle) = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer_with_lsp(path!("/the-root/a.rs"), cx)
+ })
+ .await
+ .unwrap();
+ let (markdown_buffer, _markdown_lsp_handle) = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer_with_lsp(path!("/the-root/b.md"), cx)
+ })
+ .await
+ .unwrap();
+ let static_server = static_servers.next().await.unwrap();
+ let dynamic_server = dynamic_servers.next().await.unwrap();
+ let markdown_server = markdown_servers.next().await.unwrap();
+ let static_server_id = static_server.server.server_id();
+ let dynamic_server_id = dynamic_server.server.server_id();
+ let markdown_server_id = markdown_server.server.server_id();
+ let static_counts = serve_lsp_data(&static_server, 1);
+ let dynamic_counts = serve_lsp_data(&dynamic_server, 2);
+ let markdown_counts = serve_lsp_data(&markdown_server, 3);
+ let (refresh_events, _refresh_events_subscription) = observe_refresh_events(&project, cx);
+ cx.executor().run_until_parked();
+
+ let only_static = lsp_data_labels(&[(static_server_id, 1)]);
+ let both_rust_servers = lsp_data_labels(&[(static_server_id, 1), (dynamic_server_id, 2)]);
+ let only_markdown = lsp_data_labels(&[(markdown_server_id, 3)]);
+ let dynamic_refresh = InvalidationStrategy::RefreshRequested {
+ server_id: dynamic_server_id,
+ };
+ let all_dynamic_refresh_events = vec![
+ format!("code_lens({dynamic_server_id})"),
+ format!("document_colors({dynamic_server_id})"),
+ format!("document_links({dynamic_server_id})"),
+ format!("document_symbols({dynamic_server_id})"),
+ format!("folding_ranges({dynamic_server_id})"),
+ format!("inlay_hints({dynamic_server_id})"),
+ format!("semantic_tokens({dynamic_server_id})"),
+ ];
+
+ assert_eq!(
+ fetch_all_lsp_data(&project, &rust_buffer, InvalidationStrategy::None, cx).await,
+ only_static,
+ "expected only the statically capable server's data after the initial fetch",
+ );
+ assert_eq!(
+ fetch_all_lsp_data(&project, &markdown_buffer, InvalidationStrategy::None, cx).await,
+ only_markdown,
+ "expected the markdown server's data after the initial fetch",
+ );
+ assert_eq!(refresh_events.lock().as_slice(), &[] as &[String]);
+
+ register_all_lsp_data_capabilities(&dynamic_server).await;
+ cx.executor().run_until_parked();
+ assert_eq!(
+ sorted(refresh_events.lock().drain(..)),
+ all_dynamic_refresh_events,
+ "expected every dynamic registration to trigger the corresponding per-server refresh",
+ );
+ assert_eq!(
+ fetch_all_lsp_data(&project, &rust_buffer, dynamic_refresh, cx).await,
+ both_rust_servers,
+ "expected both servers' data after the dynamic registrations",
+ );
+ assert_eq!(
+ fetch_all_lsp_data(&project, &markdown_buffer, InvalidationStrategy::None, cx).await,
+ only_markdown,
+ "expected the registrations of another language's server to not disturb markdown data",
+ );
+
+ dynamic_server
+ .request::<lsp::request::CodeLensRefresh>((), DEFAULT_LSP_REQUEST_TIMEOUT)
+ .await
+ .into_response()
+ .unwrap();
+ dynamic_server
+ .request::<lsp::request::SemanticTokensRefresh>((), DEFAULT_LSP_REQUEST_TIMEOUT)
+ .await
+ .into_response()
+ .unwrap();
+ dynamic_server
+ .request::<lsp::request::InlayHintRefreshRequest>((), DEFAULT_LSP_REQUEST_TIMEOUT)
+ .await
+ .into_response()
+ .unwrap();
+ cx.executor().run_until_parked();
+ assert_eq!(
+ sorted(refresh_events.lock().drain(..)),
+ vec![
+ format!("code_lens({dynamic_server_id})"),
+ format!("inlay_hints({dynamic_server_id})"),
+ format!("semantic_tokens({dynamic_server_id})"),
+ ],
+ "expected the server-sent refresh requests to trigger per-server refreshes",
+ );
+ assert_eq!(
+ fetch_all_lsp_data(&project, &rust_buffer, dynamic_refresh, cx).await,
+ both_rust_servers,
+ "expected the per-server refresh requests to keep the other server's data",
+ );
+ assert_eq!(
+ fetch_all_lsp_data(&project, &markdown_buffer, InvalidationStrategy::None, cx).await,
+ only_markdown,
+ "expected another language server's refresh requests to not disturb markdown data",
+ );
+
+ unregister_all_lsp_data_capabilities(&dynamic_server).await;
+ cx.executor().run_until_parked();
+ assert_eq!(
+ sorted(refresh_events.lock().drain(..)),
+ all_dynamic_refresh_events,
+ "expected every unregistration to trigger the corresponding per-server refresh",
+ );
+ assert_eq!(
+ fetch_all_lsp_data(&project, &rust_buffer, dynamic_refresh, cx).await,
+ only_static,
+ "expected the unregistrations to drop only the dynamic server's data",
+ );
+ assert_eq!(
+ fetch_all_lsp_data(&project, &markdown_buffer, InvalidationStrategy::None, cx).await,
+ only_markdown,
+ "expected the unregistrations of another language's server to not disturb markdown data",
+ );
+
+ assert_eq!(
+ *static_counts.lock(),
+ BTreeMap::from_iter([
+ ("code_lens", 1),
+ ("colors", 1),
+ ("document_symbols", 1),
+ ("folding_ranges", 1),
+ ("inlay_hints", 1),
+ ("links", 1),
+ ("semantic_tokens", 1),
+ ]),
+ "expected the static server to never be re-queried by the other server's changes",
+ );
+ assert_eq!(
+ *dynamic_counts.lock(),
+ BTreeMap::from_iter([
+ ("code_lens", 2),
+ ("colors", 1),
+ ("document_symbols", 1),
+ ("folding_ranges", 1),
+ ("inlay_hints", 2),
+ ("links", 1),
+ ("semantic_tokens", 2),
+ ]),
+ "expected the dynamic server to be re-queried only after registering and for the kinds it requested refreshes for",
+ );
+ assert_eq!(
+ *markdown_counts.lock(),
+ BTreeMap::from_iter([
+ ("code_lens", 1),
+ ("colors", 1),
+ ("document_symbols", 1),
+ ("folding_ranges", 1),
+ ("inlay_hints", 1),
+ ("links", 1),
+ ("semantic_tokens", 1),
+ ]),
+ "expected the markdown server to never be re-queried by the rust servers' changes",
+ );
+}
+
+/// Unlike [`test_per_server_refreshes_keep_other_servers_data`], focuses on the
+/// dynamic capability changes as the refresh trigger: how they combine data from
+/// static and dynamic capabilities (e.g. completion trigger characters), and which
+/// servers get [re-]queried after the capability changes.
#[gpui::test]
async fn test_dynamic_registration_refreshes_lsp_data(cx: &mut gpui::TestAppContext) {
init_test(cx);
let fs = FakeFs::new(cx.executor());
- fs.insert_tree(path!("/the-root"), json!({ "a.rs": "fn main() {}" }))
+ fs.insert_tree(path!("/the-root"), json!({ "a.rs": "fn main() {\n}\n" }))
.await;
let project = Project::test(fs, [path!("/the-root").as_ref()], cx).await;
let language_registry = project.read_with(cx, |project, _| project.languages().clone());
@@ -958,30 +1173,11 @@ async fn test_dynamic_registration_refreshes_lsp_data(cx: &mut gpui::TestAppCont
FakeLspAdapter {
name: "static-server",
capabilities: lsp::ServerCapabilities {
- color_provider: Some(lsp::ColorProviderCapability::Simple(true)),
- document_link_provider: Some(lsp::DocumentLinkOptions {
- resolve_provider: None,
- work_done_progress_options: lsp::WorkDoneProgressOptions::default(),
- }),
- folding_range_provider: Some(lsp::FoldingRangeProviderCapability::Simple(true)),
- document_symbol_provider: Some(lsp::OneOf::Left(true)),
- code_lens_provider: Some(lsp::CodeLensOptions {
- resolve_provider: None,
- }),
- semantic_tokens_provider: Some(
- lsp::SemanticTokensServerCapabilities::SemanticTokensOptions(
- lsp::SemanticTokensOptions {
- full: Some(lsp::SemanticTokensFullOptions::Bool(true)),
- ..lsp::SemanticTokensOptions::default()
- },
- ),
- ),
- inlay_hint_provider: Some(lsp::OneOf::Left(true)),
completion_provider: Some(lsp::CompletionOptions {
trigger_characters: Some(vec![".".to_string()]),
..lsp::CompletionOptions::default()
}),
- ..lsp::ServerCapabilities::default()
+ ..all_lsp_data_server_capabilities()
},
..FakeLspAdapter::default()
},
@@ -1004,96 +1200,48 @@ async fn test_dynamic_registration_refreshes_lsp_data(cx: &mut gpui::TestAppCont
let static_server = static_servers.next().await.unwrap();
let dynamic_server = dynamic_servers.next().await.unwrap();
let dynamic_server_id = dynamic_server.server.server_id();
- cx.executor().run_until_parked();
-
- let static_counters = count_lsp_requests(&static_server);
- let dynamic_counters = count_lsp_requests(&dynamic_server);
+ let static_counts = serve_lsp_data(&static_server, 1);
+ let dynamic_counts = serve_lsp_data(&dynamic_server, 2);
let (refresh_events, _refresh_events_subscription) = observe_refresh_events(&project, cx);
let buffer_triggers = |cx: &mut gpui::TestAppContext| {
buffer.read_with(cx, |buffer, _| buffer.completion_triggers().clone())
};
+ cx.executor().run_until_parked();
- fetch_lsp_data(&project, &buffer, cx).await;
- assert_eq!(
- static_counters.snapshot(),
- LspRequestCounts {
- colors: 1,
- links: 1,
- folding_ranges: 1,
- document_symbols: 1,
- code_lens: 1,
- semantic_tokens: 1,
- },
+ let all_kinds_queried_once = BTreeMap::from_iter([
+ ("code_lens", 1),
+ ("colors", 1),
+ ("document_symbols", 1),
+ ("folding_ranges", 1),
+ ("inlay_hints", 1),
+ ("links", 1),
+ ("semantic_tokens", 1),
+ ]);
+ let all_dynamic_refresh_events = vec![
+ format!("code_lens({dynamic_server_id})"),
+ format!("document_colors({dynamic_server_id})"),
+ format!("document_links({dynamic_server_id})"),
+ format!("document_symbols({dynamic_server_id})"),
+ format!("folding_ranges({dynamic_server_id})"),
+ format!("inlay_hints({dynamic_server_id})"),
+ format!("semantic_tokens({dynamic_server_id})"),
+ ];
+
+ fetch_all_lsp_data(&project, &buffer, InvalidationStrategy::None, cx).await;
+ assert_eq!(
+ *static_counts.lock(),
+ all_kinds_queried_once,
"expected the initial fetch to query the statically capable server",
);
assert_eq!(
- dynamic_counters.snapshot(),
- LspRequestCounts::default(),
+ *dynamic_counts.lock(),
+ BTreeMap::new(),
"expected the initial fetch to skip the server without capabilities",
);
assert_eq!(buffer_triggers(cx), BTreeSet::from([".".to_string()]));
assert_eq!(refresh_events.lock().as_slice(), &[] as &[String]);
- register_capability(
- &dynamic_server,
- "textDocument/documentColor",
- "colors",
- None,
- )
- .await;
- register_capability(
- &dynamic_server,
- "textDocument/documentLink",
- "links",
- serde_json::to_value(lsp::DocumentLinkOptions {
- resolve_provider: None,
- work_done_progress_options: lsp::WorkDoneProgressOptions::default(),
- })
- .ok(),
- )
- .await;
- register_capability(
- &dynamic_server,
- "textDocument/foldingRange",
- "folding",
- None,
- )
- .await;
- register_capability(
- &dynamic_server,
- "textDocument/documentSymbol",
- "symbols",
- None,
- )
- .await;
- register_capability(
- &dynamic_server,
- "textDocument/codeLens",
- "code-lens",
- serde_json::to_value(lsp::CodeLensOptions {
- resolve_provider: None,
- })
- .ok(),
- )
- .await;
- register_capability(
- &dynamic_server,
- "textDocument/semanticTokens",
- "tokens",
- serde_json::to_value(lsp::SemanticTokensRegistrationOptions {
- text_document_registration_options: lsp::TextDocumentRegistrationOptions {
- document_selector: None,
- },
- semantic_tokens_options: lsp::SemanticTokensOptions {
- full: Some(lsp::SemanticTokensFullOptions::Bool(true)),
- ..lsp::SemanticTokensOptions::default()
- },
- static_registration_options: lsp::StaticRegistrationOptions::default(),
- })
- .ok(),
- )
- .await;
- register_capability(&dynamic_server, "textDocument/inlayHint", "hints", None).await;
+ register_all_lsp_data_capabilities(&dynamic_server).await;
register_capability(
&dynamic_server,
"textDocument/completion",
@@ -1109,15 +1257,7 @@ async fn test_dynamic_registration_refreshes_lsp_data(cx: &mut gpui::TestAppCont
assert_eq!(
sorted(refresh_events.lock().drain(..)),
- vec![
- format!("code_lens({dynamic_server_id})"),
- format!("document_colors({dynamic_server_id})"),
- format!("document_links({dynamic_server_id})"),
- format!("document_symbols({dynamic_server_id})"),
- format!("folding_ranges({dynamic_server_id})"),
- format!("inlay_hints({dynamic_server_id})"),
- format!("semantic_tokens({dynamic_server_id})"),
- ],
+ all_dynamic_refresh_events,
"expected every dynamic registration to trigger the corresponding per-server refresh",
);
assert_eq!(
@@ -1126,53 +1266,33 @@ async fn test_dynamic_registration_refreshes_lsp_data(cx: &mut gpui::TestAppCont
"expected trigger characters from both servers to be combined",
);
- fetch_lsp_data(&project, &buffer, cx).await;
- assert_eq!(
- dynamic_counters.snapshot(),
- LspRequestCounts {
- colors: 1,
- links: 1,
- folding_ranges: 1,
- document_symbols: 1,
- code_lens: 1,
- semantic_tokens: 1,
+ fetch_all_lsp_data(
+ &project,
+ &buffer,
+ InvalidationStrategy::RefreshRequested {
+ server_id: dynamic_server_id,
},
+ cx,
+ )
+ .await;
+ assert_eq!(
+ *dynamic_counts.lock(),
+ all_kinds_queried_once,
"expected the newly registered server to be queried after the refreshes",
);
assert_eq!(
- static_counters.snapshot(),
- LspRequestCounts {
- colors: 1,
- links: 1,
- folding_ranges: 1,
- document_symbols: 1,
- code_lens: 1,
- semantic_tokens: 1,
- },
+ *static_counts.lock(),
+ all_kinds_queried_once,
"expected per-server refreshes to leave the static server's cached data untouched",
);
- unregister_capabilities(&dynamic_server, "textDocument/documentColor", &["colors"]).await;
- unregister_capabilities(&dynamic_server, "textDocument/documentLink", &["links"]).await;
- unregister_capabilities(&dynamic_server, "textDocument/foldingRange", &["folding"]).await;
- unregister_capabilities(&dynamic_server, "textDocument/documentSymbol", &["symbols"]).await;
- unregister_capabilities(&dynamic_server, "textDocument/codeLens", &["code-lens"]).await;
- unregister_capabilities(&dynamic_server, "textDocument/semanticTokens", &["tokens"]).await;
- unregister_capabilities(&dynamic_server, "textDocument/inlayHint", &["hints"]).await;
+ unregister_all_lsp_data_capabilities(&dynamic_server).await;
unregister_capabilities(&dynamic_server, "textDocument/completion", &["completions"]).await;
cx.executor().run_until_parked();
assert_eq!(
sorted(refresh_events.lock().drain(..)),
- vec![
- format!("code_lens({dynamic_server_id})"),
- format!("document_colors({dynamic_server_id})"),
- format!("document_links({dynamic_server_id})"),
- format!("document_symbols({dynamic_server_id})"),
- format!("folding_ranges({dynamic_server_id})"),
- format!("inlay_hints({dynamic_server_id})"),
- format!("semantic_tokens({dynamic_server_id})"),
- ],
+ all_dynamic_refresh_events,
"expected every unregistration to trigger the corresponding per-server refresh",
);
assert_eq!(
@@ -1181,29 +1301,23 @@ async fn test_dynamic_registration_refreshes_lsp_data(cx: &mut gpui::TestAppCont
"expected only the static server's trigger characters to remain",
);
- fetch_lsp_data(&project, &buffer, cx).await;
- assert_eq!(
- dynamic_counters.snapshot(),
- LspRequestCounts {
- colors: 1,
- links: 1,
- folding_ranges: 1,
- document_symbols: 1,
- code_lens: 1,
- semantic_tokens: 1,
+ fetch_all_lsp_data(
+ &project,
+ &buffer,
+ InvalidationStrategy::RefreshRequested {
+ server_id: dynamic_server_id,
},
+ cx,
+ )
+ .await;
+ assert_eq!(
+ *dynamic_counts.lock(),
+ all_kinds_queried_once,
"expected the unregistered server to not be queried anymore",
);
assert_eq!(
- static_counters.snapshot(),
- LspRequestCounts {
- colors: 1,
- links: 1,
- folding_ranges: 1,
- document_symbols: 1,
- code_lens: 1,
- semantic_tokens: 1,
- },
+ *static_counts.lock(),
+ all_kinds_queried_once,
"expected the static server to never be re-queried by another server's capability changes",
);
}
@@ -1717,90 +1831,6 @@ fn server_capabilities(
})
}
-#[derive(Default)]
-struct LspRequestCounters {
- colors: Arc<atomic::AtomicUsize>,
- links: Arc<atomic::AtomicUsize>,
- folding_ranges: Arc<atomic::AtomicUsize>,
- document_symbols: Arc<atomic::AtomicUsize>,
- code_lens: Arc<atomic::AtomicUsize>,
- semantic_tokens: Arc<atomic::AtomicUsize>,
-}
-
-#[derive(Debug, Default, PartialEq)]
-struct LspRequestCounts {
- colors: usize,
- links: usize,
- folding_ranges: usize,
- document_symbols: usize,
- code_lens: usize,
- semantic_tokens: usize,
-}
-
-impl LspRequestCounters {
- fn snapshot(&self) -> LspRequestCounts {
- LspRequestCounts {
- colors: self.colors.load(atomic::Ordering::Acquire),
- links: self.links.load(atomic::Ordering::Acquire),
- folding_ranges: self.folding_ranges.load(atomic::Ordering::Acquire),
- document_symbols: self.document_symbols.load(atomic::Ordering::Acquire),
- code_lens: self.code_lens.load(atomic::Ordering::Acquire),
- semantic_tokens: self.semantic_tokens.load(atomic::Ordering::Acquire),
- }
- }
-}
-
-fn count_lsp_requests(fake_server: &lsp::FakeLanguageServer) -> LspRequestCounters {
- let counters = LspRequestCounters::default();
- fake_server.set_request_handler::<lsp::request::DocumentColor, _, _>({
- let count = counters.colors.clone();
- move |_, _| {
- count.fetch_add(1, atomic::Ordering::Release);
- async move { Ok(Vec::new()) }
- }
- });
- fake_server.set_request_handler::<lsp::request::DocumentLinkRequest, _, _>({
- let count = counters.links.clone();
- move |_, _| {
- count.fetch_add(1, atomic::Ordering::Release);
- async move { Ok(None) }
- }
- });
- fake_server.set_request_handler::<lsp::request::FoldingRangeRequest, _, _>({
- let count = counters.folding_ranges.clone();
- move |_, _| {
- count.fetch_add(1, atomic::Ordering::Release);
- async move { Ok(None) }
- }
- });
- fake_server.set_request_handler::<lsp::request::DocumentSymbolRequest, _, _>({
- let count = counters.document_symbols.clone();
- move |_, _| {
- count.fetch_add(1, atomic::Ordering::Release);
- async move { Ok(None) }
- }
- });
- fake_server.set_request_handler::<lsp::request::CodeLensRequest, _, _>({
- let count = counters.code_lens.clone();
- move |_, _| {
- count.fetch_add(1, atomic::Ordering::Release);
- async move { Ok(None) }
- }
- });
- fake_server.set_request_handler::<lsp::request::SemanticTokensFullRequest, _, _>({
- let count = counters.semantic_tokens.clone();
- move |_, _| {
- count.fetch_add(1, atomic::Ordering::Release);
- async move {
- Ok(Some(lsp::SemanticTokensResult::Tokens(
- lsp::SemanticTokens::default(),
- )))
- }
- }
- });
- counters
-}
-
fn observe_refresh_events(
project: &Entity<Project>,
cx: &mut gpui::TestAppContext,
@@ -1841,12 +1871,284 @@ fn observe_refresh_events(
(events, subscription)
}
-async fn fetch_lsp_data(
+fn sorted(events: impl IntoIterator<Item = String>) -> Vec<String> {
+ let mut events = events.into_iter().collect::<Vec<_>>();
+ events.sort();
+ events
+}
+
+fn all_lsp_data_server_capabilities() -> lsp::ServerCapabilities {
+ lsp::ServerCapabilities {
+ color_provider: Some(lsp::ColorProviderCapability::Simple(true)),
+ document_link_provider: Some(lsp::DocumentLinkOptions {
+ resolve_provider: None,
+ work_done_progress_options: lsp::WorkDoneProgressOptions::default(),
+ }),
+ folding_range_provider: Some(lsp::FoldingRangeProviderCapability::Simple(true)),
+ document_symbol_provider: Some(lsp::OneOf::Left(true)),
+ code_lens_provider: Some(lsp::CodeLensOptions {
+ resolve_provider: None,
+ }),
+ semantic_tokens_provider: Some(
+ lsp::SemanticTokensServerCapabilities::SemanticTokensOptions(
+ lsp::SemanticTokensOptions {
+ legend: lsp::SemanticTokensLegend {
+ token_types: vec!["keyword".into()],
+ token_modifiers: Vec::new(),
+ },
+ full: Some(lsp::SemanticTokensFullOptions::Bool(true)),
+ ..lsp::SemanticTokensOptions::default()
+ },
+ ),
+ ),
+ inlay_hint_provider: Some(lsp::OneOf::Left(true)),
+ ..lsp::ServerCapabilities::default()
+ }
+}
+
+async fn register_all_lsp_data_capabilities(fake_server: &lsp::FakeLanguageServer) {
+ register_capability(fake_server, "textDocument/documentColor", "colors", None).await;
+ register_capability(
+ fake_server,
+ "textDocument/documentLink",
+ "links",
+ serde_json::to_value(lsp::DocumentLinkOptions {
+ resolve_provider: None,
+ work_done_progress_options: lsp::WorkDoneProgressOptions::default(),
+ })
+ .ok(),
+ )
+ .await;
+ register_capability(fake_server, "textDocument/foldingRange", "folding", None).await;
+ register_capability(fake_server, "textDocument/documentSymbol", "symbols", None).await;
+ register_capability(
+ fake_server,
+ "textDocument/codeLens",
+ "code-lens",
+ serde_json::to_value(lsp::CodeLensOptions {
+ resolve_provider: None,
+ })
+ .ok(),
+ )
+ .await;
+ register_capability(
+ fake_server,
+ "textDocument/semanticTokens",
+ "tokens",
+ serde_json::to_value(lsp::SemanticTokensRegistrationOptions {
+ text_document_registration_options: lsp::TextDocumentRegistrationOptions {
+ document_selector: None,
+ },
+ semantic_tokens_options: lsp::SemanticTokensOptions {
+ legend: lsp::SemanticTokensLegend {
+ token_types: vec!["keyword".into()],
+ token_modifiers: Vec::new(),
+ },
+ full: Some(lsp::SemanticTokensFullOptions::Bool(true)),
+ ..lsp::SemanticTokensOptions::default()
+ },
+ static_registration_options: lsp::StaticRegistrationOptions::default(),
+ })
+ .ok(),
+ )
+ .await;
+ register_capability(fake_server, "textDocument/inlayHint", "hints", None).await;
+}
+
+async fn unregister_all_lsp_data_capabilities(fake_server: &lsp::FakeLanguageServer) {
+ unregister_capabilities(fake_server, "textDocument/documentColor", &["colors"]).await;
+ unregister_capabilities(fake_server, "textDocument/documentLink", &["links"]).await;
+ unregister_capabilities(fake_server, "textDocument/foldingRange", &["folding"]).await;
+ unregister_capabilities(fake_server, "textDocument/documentSymbol", &["symbols"]).await;
+ unregister_capabilities(fake_server, "textDocument/codeLens", &["code-lens"]).await;
+ unregister_capabilities(fake_server, "textDocument/semanticTokens", &["tokens"]).await;
+ unregister_capabilities(fake_server, "textDocument/inlayHint", &["hints"]).await;
+}
+
+type LspRequestCounts = Arc<Mutex<BTreeMap<&'static str, usize>>>;
+
+/// Serves distinct data, derived from `index`, for every LSP data kind, and counts the
+/// requests served per kind. [`lsp_data_labels`] builds the expected fetch results for
+/// the same `index`.
+fn serve_lsp_data(fake_server: &lsp::FakeLanguageServer, index: u8) -> LspRequestCounts {
+ let counts = LspRequestCounts::default();
+ fake_server.set_request_handler::<lsp::request::DocumentColor, _, _>({
+ let counts = counts.clone();
+ move |_, _| {
+ *counts.lock().entry("colors").or_default() += 1;
+ async move {
+ Ok(vec![lsp::ColorInformation {
+ range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 1)),
+ color: lsp::Color {
+ red: 0.0,
+ green: 0.0,
+ blue: 0.0,
+ alpha: f32::from(index),
+ },
+ }])
+ }
+ }
+ });
+ fake_server.set_request_handler::<lsp::request::DocumentLinkRequest, _, _>({
+ let counts = counts.clone();
+ move |_, _| {
+ *counts.lock().entry("links").or_default() += 1;
+ async move {
+ Ok(Some(vec![lsp::DocumentLink {
+ range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 1)),
+ target: Some(format!("https://server-{index}.example/").parse().unwrap()),
+ tooltip: None,
+ data: None,
+ }]))
+ }
+ }
+ });
+ fake_server.set_request_handler::<lsp::request::FoldingRangeRequest, _, _>({
+ let counts = counts.clone();
+ move |_, _| {
+ *counts.lock().entry("folding_ranges").or_default() += 1;
+ async move {
+ Ok(Some(vec![lsp::FoldingRange {
+ start_line: 0,
+ start_character: None,
+ end_line: 1,
+ end_character: None,
+ kind: None,
+ collapsed_text: Some(format!("fold-{index}")),
+ }]))
+ }
+ }
+ });
+ fake_server.set_request_handler::<lsp::request::DocumentSymbolRequest, _, _>({
+ let counts = counts.clone();
+ move |_, _| {
+ *counts.lock().entry("document_symbols").or_default() += 1;
+ async move {
+ #[allow(deprecated)]
+ Ok(Some(lsp::DocumentSymbolResponse::Nested(vec![
+ lsp::DocumentSymbol {
+ name: format!("symbol-{index}"),
+ detail: None,
+ kind: lsp::SymbolKind::FUNCTION,
+ tags: None,
+ deprecated: None,
+ range: lsp::Range::default(),
+ selection_range: lsp::Range::default(),
+ children: None,
+ },
+ ])))
+ }
+ }
+ });
+ fake_server.set_request_handler::<lsp::request::CodeLensRequest, _, _>({
+ let counts = counts.clone();
+ move |_, _| {
+ *counts.lock().entry("code_lens").or_default() += 1;
+ async move {
+ Ok(Some(vec![lsp::CodeLens {
+ range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 1)),
+ command: Some(lsp::Command {
+ title: format!("lens-{index}"),
+ command: "test.command".to_string(),
+ arguments: None,
+ }),
+ data: None,
+ }]))
+ }
+ }
+ });
+ fake_server.set_request_handler::<lsp::request::SemanticTokensFullRequest, _, _>({
+ let counts = counts.clone();
+ move |_, _| {
+ *counts.lock().entry("semantic_tokens").or_default() += 1;
+ async move {
+ Ok(Some(lsp::SemanticTokensResult::Tokens(
+ lsp::SemanticTokens {
+ result_id: None,
+ data: semantic_token_test_data(index),
+ },
+ )))
+ }
+ }
+ });
+ fake_server.set_request_handler::<lsp::request::InlayHintRequest, _, _>({
+ let counts = counts.clone();
+ move |_, _| {
+ *counts.lock().entry("inlay_hints").or_default() += 1;
+ async move {
+ Ok(Some(vec![lsp::InlayHint {
+ position: lsp::Position::new(0, 0),
+ label: lsp::InlayHintLabel::String(format!("hint-{index}")),
+ kind: None,
+ text_edits: None,
+ tooltip: None,
+ padding_left: None,
+ padding_right: None,
+ data: None,
+ }]))
+ }
+ }
+ });
+ counts
+}
+
+fn semantic_token_test_data(index: u8) -> Vec<u32> {
+ vec![0, u32::from(index - 1) * 4, 1, 0, 0]
+}
+
+#[derive(Debug, Default, PartialEq)]
+struct LspDataLabels {
+ colors: Vec<String>,
+ links: Vec<String>,
+ folding_ranges: Vec<String>,
+ document_symbols: Vec<String>,
+ code_lens: Vec<String>,
+ semantic_tokens: Vec<(LanguageServerId, Vec<u32>)>,
+ inlay_hints: Vec<(LanguageServerId, Vec<String>)>,
+}
+
+impl LspDataLabels {
+ fn sort(&mut self) {
+ self.colors.sort();
+ self.links.sort();
+ self.folding_ranges.sort();
+ self.document_symbols.sort();
+ self.code_lens.sort();
+ self.semantic_tokens.sort();
+ self.inlay_hints.sort();
+ }
+}
+
+/// The expected [`fetch_all_lsp_data`] results for servers set up with [`serve_lsp_data`].
+fn lsp_data_labels(servers: &[(LanguageServerId, u8)]) -> LspDataLabels {
+ let mut labels = LspDataLabels::default();
+ for &(server_id, index) in servers {
+ labels.colors.push(format!("color-{index}"));
+ labels
+ .links
+ .push(format!("https://server-{index}.example/"));
+ labels.folding_ranges.push(format!("fold-{index}"));
+ labels.document_symbols.push(format!("symbol-{index}"));
+ labels.code_lens.push(format!("lens-{index}"));
+ labels
+ .semantic_tokens
+ .push((server_id, semantic_token_test_data(index)));
+ labels
+ .inlay_hints
+ .push((server_id, vec![format!("hint-{index}")]));
+ }
+ labels.sort();
+ labels
+}
+
+async fn fetch_all_lsp_data(
project: &Entity<Project>,
buffer: &Entity<Buffer>,
+ inlay_hints_invalidate: InvalidationStrategy,
cx: &mut gpui::TestAppContext,
-) {
+) -> LspDataLabels {
let lsp_store = project.read_with(cx, |project, _| project.lsp_store());
+ let buffer_id = buffer.read_with(cx, |buffer, _| buffer.remote_id());
let colors = lsp_store.update(cx, |lsp_store, cx| {
lsp_store.document_colors(buffer.clone(), cx)
});
@@ -1863,18 +2165,73 @@ async fn fetch_lsp_data(
let semantic_tokens = lsp_store.update(cx, |lsp_store, cx| {
lsp_store.semantic_tokens(buffer.clone(), cx)
});
+ let inlay_hint_tasks = lsp_store.update(cx, |lsp_store, cx| {
+ let query_range =
+ buffer.read(cx).anchor_before(0)..buffer.read(cx).anchor_after(buffer.read(cx).len());
+ lsp_store.inlay_hints(
+ inlay_hints_invalidate,
+ buffer.clone(),
+ vec![query_range],
+ None,
+ cx,
+ )
+ });
+
+ let mut labels = LspDataLabels::default();
if let Some(colors) = colors {
- colors.await.unwrap();
+ labels.colors.extend(
+ colors
+ .await
+ .unwrap()
+ .colors
+ .into_iter()
+ .map(|color| format!("color-{}", color.color.alpha as u8)),
+ );
}
- links.await;
- folding_ranges.await;
- document_symbols.await;
- code_lens.await.unwrap();
+ labels.links.extend(
+ links
+ .await
+ .unwrap_or_default()
+ .values()
+ .flat_map(|server_links| server_links.values())
+ .filter_map(|link| link.target.clone())
+ .map(|target| target.to_string()),
+ );
+ labels.folding_ranges.extend(
+ folding_ranges
+ .await
+ .into_iter()
+ .filter_map(|folding_range| folding_range.collapsed_text)
+ .map(|collapsed_text| collapsed_text.to_string()),
+ );
+ labels.document_symbols.extend(
+ document_symbols
+ .await
+ .into_iter()
+ .map(|symbol| symbol.text.to_string()),
+ );
+ labels.code_lens.extend(
+ code_lens
+ .await
+ .unwrap()
+ .unwrap_or_default()
+ .values()
+ .map(|action| action.lsp_action.title().to_string()),
+ );
semantic_tokens.await.unwrap();
-}
-
-fn sorted(events: impl IntoIterator<Item = String>) -> Vec<String> {
- let mut events = events.into_iter().collect::<Vec<_>>();
- events.sort();
- events
+ labels.semantic_tokens =
+ lsp_store.read_with(cx, |lsp_store, _| lsp_store.semantic_token_data(buffer_id));
+ for (_, hints_task) in inlay_hint_tasks {
+ for (server_id, server_hints) in hints_task.await.unwrap() {
+ let hint_labels = server_hints
+ .into_iter()
+ .map(|(_, hint)| hint.text().to_string())
+ .collect::<Vec<_>>();
+ if !hint_labels.is_empty() {
+ labels.inlay_hints.push((server_id, hint_labels));
+ }
+ }
+ }
+ labels.sort();
+ labels
}