Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
project: Track inlay hint / code lens / document symbol registrations by ID (#55340)
Tautik Agraharib64e5dc8861f
diff --git a/crates/collab/src/rpc.rs b/crates/collab/src/rpc.rsindex 4def99e182f..9bbca16a392 100644--- a/crates/collab/src/rpc.rs+++ b/crates/collab/src/rpc.rs@@ -428,6 +428,14 @@ impl Server {broadcast_project_message_from_host::<proto::RefreshSemanticTokens>,).add_message_handler(broadcast_project_message_from_host::<proto::RefreshCodeLens>)+ .add_message_handler(+ broadcast_project_message_from_host::<proto::RefreshDocumentColors>,+ )+ .add_message_handler(broadcast_project_message_from_host::<proto::RefreshDocumentLinks>)+ .add_message_handler(broadcast_project_message_from_host::<proto::RefreshFoldingRanges>)+ .add_message_handler(+ broadcast_project_message_from_host::<proto::RefreshDocumentSymbols>,+ ).add_message_handler(broadcast_project_message_from_host::<proto::UpdateBufferFile>).add_message_handler(broadcast_project_message_from_host::<proto::BufferReloaded>).add_message_handler(broadcast_project_message_from_host::<proto::BufferSaved>)diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rsindex e1f08e230f3..fbd6ad44d8c 100644--- a/crates/editor/src/editor.rs+++ b/crates/editor/src/editor.rs@@ -220,7 +220,7 @@ use project::{git_store::GitStoreEvent,lsp_store::{BufferSemanticTokens, CacheInlayHints, CompletionDocumentation, FormatTrigger,- LspFormatTarget, OpenLspBufferHandle, RefreshForServer,+ LspFormatTarget, OpenLspBufferHandle,},project_settings::{DiagnosticSeverity, GoToDiagnosticSeverityFilter, ProjectSettings},};@@ -2003,33 +2003,31 @@ impl Editor {project,window,|editor, _, event, window, cx| match event {- project::Event::RefreshCodeLens => {+ project::Event::RefreshCodeLens { .. } => {editor.refresh_code_lenses(None, window, cx);}- project::Event::RefreshInlayHints {- server_id,- request_id,- } => {+ project::Event::RefreshDocumentColors { .. } => {+ editor.refresh_document_colors(None, window, cx);+ }+ project::Event::RefreshDocumentLinks { .. } => {+ editor.refresh_document_links(None, cx);+ }+ project::Event::RefreshFoldingRanges { .. } => {+ editor.refresh_folding_ranges(None, window, cx);+ }+ project::Event::RefreshDocumentSymbols { .. } => {+ editor.refresh_document_symbols(None, cx);+ }+ project::Event::RefreshInlayHints { server_id } => {editor.refresh_inlay_hints(InlayHintRefreshReason::RefreshRequested {server_id: *server_id,- request_id: *request_id,},cx,);}- project::Event::RefreshSemanticTokens {- server_id,- request_id,- } => {- editor.refresh_semantic_tokens(- None,- Some(RefreshForServer {- server_id: *server_id,- request_id: *request_id,- }),- cx,- );+ project::Event::RefreshSemanticTokens { .. } => {+ editor.refresh_semantic_tokens(None, true, cx);}project::Event::LanguageServerRemoved(_) => {editor.registered_buffers.clear();@@ -9936,7 +9934,7 @@ impl Editor {.update_rules(new_semantic_token_rules);if language_settings_changed || semantic_token_rules_changed {self.invalidate_semantic_tokens(None);- self.refresh_semantic_tokens(None, None, cx);+ self.refresh_semantic_tokens(None, false, cx);}}@@ -9955,7 +9953,7 @@ impl Editor {}self.invalidate_semantic_tokens(None);- self.refresh_semantic_tokens(None, None, cx);+ self.refresh_semantic_tokens(None, false, cx);self.refresh_outline_symbols_at_cursor(cx);}@@ -10850,7 +10848,7 @@ impl Editor {if let Some(buffer_id) = for_buffer {self.pull_diagnostics(buffer_id, window, cx);}- self.refresh_semantic_tokens(for_buffer, None, cx);+ self.refresh_semantic_tokens(for_buffer, false, cx);self.refresh_document_colors(for_buffer, window, cx);self.refresh_document_links(for_buffer, cx);self.refresh_folding_ranges(for_buffer, window, cx);@@ -11266,7 +11264,6 @@ pub trait SemanticsProvider {fn semantic_tokens(&self,buffer: Entity<Buffer>,- refresh: Option<RefreshForServer>,cx: &mut App,) -> Option<Shared<Task<std::result::Result<BufferSemanticTokens, Arc<anyhow::Error>>>>>;@@ -11426,13 +11423,11 @@ impl SemanticsProvider for WeakEntity<Project> {fn semantic_tokens(&self,buffer: Entity<Buffer>,- refresh: Option<RefreshForServer>,cx: &mut App,) -> Option<Shared<Task<std::result::Result<BufferSemanticTokens, Arc<anyhow::Error>>>>> {self.update(cx, |this, cx| {- this.lsp_store().update(cx, |lsp_store, cx| {- lsp_store.semantic_tokens(buffer, refresh, cx)- })+ this.lsp_store()+ .update(cx, |lsp_store, cx| lsp_store.semantic_tokens(buffer, cx))}).ok()}diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rsindex ff3e9bb162b..3a6d2436e25 100644--- a/crates/editor/src/editor_tests.rs+++ b/crates/editor/src/editor_tests.rs@@ -35729,7 +35729,6 @@ async fn test_insert_snippet(cx: &mut TestAppContext) {#[gpui::test]async fn test_inlay_hints_request_timeout(cx: &mut TestAppContext) {- use crate::inlays::inlay_hints::InlayHintRefreshReason;use crate::inlays::inlay_hints::tests::{cached_hint_labels, init_test, visible_hint_labels};use settings::InlayHintSettingsContent;use std::sync::atomic::AtomicU32;@@ -35834,16 +35833,10 @@ async fn test_inlay_hints_request_timeout(cx: &mut TestAppContext) {}).unwrap();- editor- .update(cx, |editor, _window, cx| {- editor.refresh_inlay_hints(- InlayHintRefreshReason::RefreshRequested {- server_id: fake_server.server.server_id(),- request_id: Some(1),- },- cx,- );- })+ fake_server+ .request::<lsp::request::InlayHintRefreshRequest>((), lsp::DEFAULT_LSP_REQUEST_TIMEOUT)+ .await+ .into_response().unwrap();cx.executor().advance_clock(Duration::from_secs(BASE_TIMEOUT_SECS) + Duration::from_millis(100));@@ -35870,16 +35863,10 @@ async fn test_inlay_hints_request_timeout(cx: &mut TestAppContext) {});});});- editor- .update(cx, |editor, _window, cx| {- editor.refresh_inlay_hints(- InlayHintRefreshReason::RefreshRequested {- server_id: fake_server.server.server_id(),- request_id: Some(2),- },- cx,- );- })+ fake_server+ .request::<lsp::request::InlayHintRefreshRequest>((), lsp::DEFAULT_LSP_REQUEST_TIMEOUT)+ .await+ .into_response().unwrap();cx.executor().advance_clock(Duration::from_secs(BASE_TIMEOUT_SECS * 4) + Duration::from_millis(100));diff --git a/crates/editor/src/inlays/inlay_hints.rs b/crates/editor/src/inlays/inlay_hints.rsindex 0efc4355a62..de634f467f9 100644--- a/crates/editor/src/inlays/inlay_hints.rs+++ b/crates/editor/src/inlays/inlay_hints.rs@@ -234,10 +234,7 @@ pub enum InlayHintRefreshReason {NewLinesShown,BufferEdited(BufferId),ServerRemoved,- RefreshRequested {- server_id: LanguageServerId,- request_id: Option<usize>,- },+ RefreshRequested { server_id: LanguageServerId },BuffersRemoved(Vec<BufferId>),}@@ -541,13 +538,11 @@ impl Editor {InlayHintRefreshReason::ServerRemoved => InvalidationStrategy::BufferEdited,InlayHintRefreshReason::NewLinesShown => InvalidationStrategy::None,InlayHintRefreshReason::BufferEdited(_) => InvalidationStrategy::BufferEdited,- InlayHintRefreshReason::RefreshRequested {- server_id,- request_id,- } => InvalidationStrategy::RefreshRequested {- server_id: *server_id,- request_id: *request_id,- },+ InlayHintRefreshReason::RefreshRequested { server_id } => {+ InvalidationStrategy::RefreshRequested {+ server_id: *server_id,+ }+ }};match &mut self.inlay_hints {@@ -1196,17 +1191,8 @@ pub mod tests {}).unwrap();cx.executor().advance_clock(Duration::from_millis(5));- editor- .update(cx, |editor, _window, cx| {- editor.refresh_inlay_hints(- InlayHintRefreshReason::RefreshRequested {- server_id: fake_server.server.server_id(),- request_id: Some(1),- },- cx,- );- })- .unwrap();+ let refresh_request = fake_server+ .request::<lsp::request::InlayHintRefreshRequest>((), lsp::DEFAULT_LSP_REQUEST_TIMEOUT);cx.executor().advance_clock(Duration::from_millis(5));editor.update(cx, |editor, _window, cx| {@@ -1215,6 +1201,7 @@ pub mod tests {.unwrap();cx.executor().advance_clock(Duration::from_secs(1));cx.executor().run_until_parked();+ refresh_request.await.into_response().unwrap();editor.update(cx, |editor, _window, cx| {let expected_hints = vec!["2".to_string()];@@ -1332,6 +1319,52 @@ pub mod tests {assert_eq!(expected_hints, visible_hint_labels(editor, cx));}).unwrap();++ run_work_cycle(&fake_server, progress_token + 1, cx).await;++ editor+ .update(cx, |editor, _, cx| {+ let expected_hints = vec!["1".to_string()];+ assert_eq!(+ expected_hints,+ cached_hint_labels(editor, cx),+ "Repeated work cycles without buffer changes should not invalidate hints again"+ );+ assert_eq!(expected_hints, visible_hint_labels(editor, cx));+ })+ .unwrap();++ editor+ .update(cx, |editor, window, cx| {+ editor.handle_input("~", window, cx);+ })+ .unwrap();+ cx.executor().run_until_parked();+ editor+ .update(cx, |editor, _, cx| {+ let expected_hints = vec!["2".to_string()];+ assert_eq!(+ expected_hints,+ cached_hint_labels(editor, cx),+ "A buffer edit should invalidate and re-query the hints"+ );+ assert_eq!(expected_hints, visible_hint_labels(editor, cx));+ })+ .unwrap();++ run_work_cycle(&fake_server, progress_token + 2, cx).await;++ editor+ .update(cx, |editor, _, cx| {+ let expected_hints = vec!["3".to_string()];+ assert_eq!(+ expected_hints,+ cached_hint_labels(editor, cx),+ "A buffer edit should re-allow the work-end hint refresh"+ );+ assert_eq!(expected_hints, visible_hint_labels(editor, cx));+ })+ .unwrap();}#[gpui::test]@@ -4124,17 +4157,8 @@ let c = 3;"#}).unwrap();// Emulate a language server refresh request, coming in the background..- editor- .update(cx, |editor, _, cx| {- editor.refresh_inlay_hints(- InlayHintRefreshReason::RefreshRequested {- server_id: fake_server.server.server_id(),- request_id: Some(1),- },- cx,- );- })- .unwrap();+ let refresh_request = fake_server+ .request::<lsp::request::InlayHintRefreshRequest>((), lsp::DEFAULT_LSP_REQUEST_TIMEOUT);// Edit the 1st buffer while scrolled down and not seeing that.// The edit will auto scroll to the edit (1st buffer).editor@@ -4151,6 +4175,7 @@ let c = 3;"#cx.executor().advance_clock(Duration::from_millis(1000));cx.executor().run_until_parked();+ refresh_request.await.into_response().unwrap();editor.update(cx, |editor, _window, cx| {assert_eq!(@@ -4537,16 +4562,10 @@ let c = 3;"#// Trigger RefreshRequested from server A. This should re-fetch server A's// hints while keeping server B's hints intact.- editor- .update(cx, |editor, _window, cx| {- editor.refresh_inlay_hints(- InlayHintRefreshReason::RefreshRequested {- server_id: fake_server_a.server.server_id(),- request_id: Some(1),- },- cx,- );- })+ fake_server_a+ .request::<lsp::request::InlayHintRefreshRequest>((), lsp::DEFAULT_LSP_REQUEST_TIMEOUT)+ .await+ .into_response().unwrap();cx.executor().advance_clock(Duration::from_millis(100));cx.executor().run_until_parked();@@ -4915,4 +4934,36 @@ let c = 3;"#.allowed_hint_kinds.clone()}++ async fn run_work_cycle(+ fake_server: &FakeLanguageServer,+ progress_token: i32,+ cx: &mut gpui::TestAppContext,+ ) {+ fake_server+ .request::<lsp::request::WorkDoneProgressCreate>(+ lsp::WorkDoneProgressCreateParams {+ token: lsp::ProgressToken::Number(progress_token),+ },+ DEFAULT_LSP_REQUEST_TIMEOUT,+ )+ .await+ .into_response()+ .expect("work done progress create request failed");+ cx.executor().run_until_parked();+ fake_server.notify::<lsp::notification::Progress>(lsp::ProgressParams {+ token: lsp::ProgressToken::Number(progress_token),+ value: lsp::ProgressParamsValue::WorkDone(lsp::WorkDoneProgress::Begin(+ lsp::WorkDoneProgressBegin::default(),+ )),+ });+ cx.executor().run_until_parked();+ fake_server.notify::<lsp::notification::Progress>(lsp::ProgressParams {+ token: lsp::ProgressToken::Number(progress_token),+ value: lsp::ProgressParamsValue::WorkDone(lsp::WorkDoneProgress::End(+ lsp::WorkDoneProgressEnd::default(),+ )),+ });+ cx.executor().run_until_parked();+ }}diff --git a/crates/editor/src/semantic_tokens.rs b/crates/editor/src/semantic_tokens.rsindex d5a2d06f194..0790712f5ed 100644--- a/crates/editor/src/semantic_tokens.rs+++ b/crates/editor/src/semantic_tokens.rs@@ -8,10 +8,7 @@ use gpui::{use itertools::Itertools;use language::language_settings::LanguageSettings;use project::{- lsp_store::{- BufferSemanticToken, BufferSemanticTokens, RefreshForServer, SemanticTokenStylizer,- TokenType,- },+ lsp_store::{BufferSemanticToken, BufferSemanticTokens, SemanticTokenStylizer, TokenType},project_settings::ProjectSettings,};use settings::{@@ -103,7 +100,7 @@ impl Editor {) {self.semantic_token_state.toggle_enabled();self.invalidate_semantic_tokens(None);- self.refresh_semantic_tokens(None, None, cx);+ self.refresh_semantic_tokens(None, false, cx);}pub(super) fn invalidate_semantic_tokens(&mut self, for_buffer: Option<BufferId>) {@@ -116,7 +113,7 @@ impl Editor {pub(super) fn refresh_semantic_tokens(&mut self,buffer_id: Option<BufferId>,- for_server: Option<RefreshForServer>,+ server_refreshed: bool,cx: &mut Context<Self>,) {if !self.lsp_data_enabled() || !self.semantic_token_state.enabled() {@@ -133,7 +130,7 @@ impl Editor {}let mut invalidate_semantic_highlights_for_buffers = HashSet::default();- if for_server.is_some() {+ if server_refreshed {invalidate_semantic_highlights_for_buffers.extend(self.semantic_token_state.fetched_for_buffers@@ -216,9 +213,9 @@ impl Editor {}) {None} else {- sema.semantic_tokens(buffer, for_server, cx).map(- |task| async move { (buffer_id, query_version, task.await) },- )+ sema.semantic_tokens(buffer, cx).map(|task| async move {+ (buffer_id, query_version, task.await)+ })}}).collect::<Vec<_>>()diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rsindex 73cafbbeb6f..00cf28568a5 100644--- a/crates/language/src/buffer.rs+++ b/crates/language/src/buffer.rs@@ -3210,16 +3210,15 @@ impl Buffer {if triggers.is_empty() {self.completion_triggers_per_language_server.remove(&server_id);- self.completion_triggers = self- .completion_triggers_per_language_server- .values()- .flat_map(|triggers| triggers.iter().cloned())- .collect();} else {self.completion_triggers_per_language_server- .insert(server_id, triggers.iter().cloned().collect());- self.completion_triggers.extend(triggers);+ .insert(server_id, triggers.into_iter().collect());}+ self.completion_triggers = self+ .completion_triggers_per_language_server+ .values()+ .flat_map(|triggers| triggers.iter().cloned())+ .collect();self.text.lamport_clock.observe(lamport_timestamp);}Operation::UpdateLineEnding {@@ -3391,16 +3390,15 @@ impl Buffer {if triggers.is_empty() {self.completion_triggers_per_language_server.remove(&server_id);- self.completion_triggers = self- .completion_triggers_per_language_server- .values()- .flat_map(|triggers| triggers.iter().cloned())- .collect();} else {self.completion_triggers_per_language_server.insert(server_id, triggers.clone());- self.completion_triggers.extend(triggers.iter().cloned());}+ self.completion_triggers = self+ .completion_triggers_per_language_server+ .values()+ .flat_map(|triggers| triggers.iter().cloned())+ .collect();self.send_operation(Operation::UpdateCompletionTriggers {triggers: triggers.into_iter().collect(),diff --git a/crates/language/src/buffer_tests.rs b/crates/language/src/buffer_tests.rsindex 256deda2967..5c4bf46a11f 100644--- a/crates/language/src/buffer_tests.rs+++ b/crates/language/src/buffer_tests.rs@@ -4549,6 +4549,100 @@ fn test_autoindent_typescript_braceless_control_flow(cx: &mut App) {});}+#[gpui::test]+fn test_completion_triggers_across_language_servers(cx: &mut TestAppContext) {+ cx.update(|cx| init_settings(cx, |_| {}));++ let buffer = cx.new(|cx| Buffer::local("", cx));+ let replica = cx.new(|cx| {+ Buffer::from_proto(+ ReplicaId::new(1),+ Capability::ReadWrite,+ buffer.read(cx).to_proto(cx),+ None,+ )+ .unwrap()+ });+ replica.update(cx, |_, cx| {+ cx.subscribe(&buffer, |this, _, event, cx| {+ if let BufferEvent::Operation {+ operation,+ is_local: true,+ } = event+ {+ this.apply_ops([operation.clone()], cx);+ }+ })+ .detach();+ });++ let server_a = LanguageServerId(1);+ let server_b = LanguageServerId(2);+ let triggers = |buffer: &Entity<Buffer>, cx: &mut TestAppContext| {+ buffer.read_with(cx, |buffer, _| buffer.completion_triggers().clone())+ };++ buffer.update(cx, |buffer, cx| {+ buffer.set_completion_triggers(server_a, BTreeSet::from_iter([".".to_string()]), cx);+ buffer.set_completion_triggers(server_b, BTreeSet::from_iter([":".to_string()]), cx);+ });+ let expected = BTreeSet::from_iter([".".to_string(), ":".to_string()]);+ assert_eq!(+ triggers(&buffer, cx),+ expected,+ "expected triggers from both servers to be combined",+ );+ assert_eq!(+ triggers(&replica, cx),+ expected,+ "expected the replica to combine triggers from both servers",+ );++ buffer.update(cx, |buffer, cx| {+ buffer.set_completion_triggers(server_a, BTreeSet::from_iter([",".to_string()]), cx);+ });+ let expected = BTreeSet::from_iter([",".to_string(), ":".to_string()]);+ assert_eq!(+ triggers(&buffer, cx),+ expected,+ "expected replaced triggers to not linger in the combined set",+ );+ assert_eq!(+ triggers(&replica, cx),+ expected,+ "expected the replica to not keep replaced triggers in the combined set",+ );++ buffer.update(cx, |buffer, cx| {+ buffer.set_completion_triggers(server_a, BTreeSet::new(), cx);+ });+ let expected = BTreeSet::from_iter([":".to_string()]);+ assert_eq!(+ triggers(&buffer, cx),+ expected,+ "expected the other server's triggers to survive clearing one server's triggers",+ );+ assert_eq!(+ triggers(&replica, cx),+ expected,+ "expected the replica to keep the other server's triggers",+ );++ buffer.update(cx, |buffer, cx| {+ buffer.set_completion_triggers(server_b, BTreeSet::new(), cx);+ });+ assert_eq!(+ triggers(&buffer, cx),+ BTreeSet::new(),+ "expected no triggers after clearing all servers",+ );+ assert_eq!(+ triggers(&replica, cx),+ BTreeSet::new(),+ "expected no triggers on the replica after clearing all servers",+ );+}+// Assert that the enclosing bracket ranges around the selection match the pairs indicated by the marked text in `range_markers`#[track_caller]fn assert_bracket_pairs(diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rsindex 5b911dc3c73..f61ddbf7ad5 100644--- a/crates/project/src/lsp_store.rs+++ b/crates/project/src/lsp_store.rs@@ -14,6 +14,7 @@ pub mod code_lens;mod document_colors;mod document_links;mod document_symbols;+mod dynamic_registration;mod folding_ranges;mod inlay_hints;pub mod json_language_server_ext;@@ -27,6 +28,7 @@ use self::code_lens::CodeLensData;use self::document_colors::DocumentColorData;use self::document_links::DocumentLinksData;use self::document_symbols::DocumentSymbolsData;+use self::dynamic_registration::{DynamicRegistrations, RegistrationSource};use self::inlay_hints::BufferInlayHints;use crate::{CodeAction, Completion, CompletionDisplayOptions, CompletionResponse, CompletionSource,@@ -92,14 +94,14 @@ use language::{row_chunk::RowChunk,};use lsp::{- AdapterServerCapabilities, CodeActionKind, CompletionContext, CompletionOptions,- DEFAULT_LSP_REQUEST_TIMEOUT, DiagnosticServerCapabilities, DiagnosticSeverity, DiagnosticTag,+ AdapterServerCapabilities, CodeActionKind, CompletionContext, DEFAULT_LSP_REQUEST_TIMEOUT,+ DiagnosticServerCapabilities, DiagnosticSeverity, DiagnosticTag,DidChangeWatchedFilesRegistrationOptions, Edit, FileOperationFilter, FileOperationPatternKind,FileOperationRegistrationOptions, FileRename, FileSystemWatcher, LanguageServer,LanguageServerBinary, LanguageServerBinaryOptions, LanguageServerId, LanguageServerName,LanguageServerSelector, LspRequestFuture, MessageActionItem, MessageType, OneOf,- RenameFilesParams, TextDocumentSyncSaveOptions, TextEdit, Uri, WillRenameFiles,- WorkDoneProgressCancelParams, notification::DidRenameFiles,+ RenameFilesParams, TextEdit, Uri, WillRenameFiles, WorkDoneProgressCancelParams,+ notification::DidRenameFiles,};use node_runtime::read_package_installed_version;use parking_lot::Mutex;@@ -160,7 +162,7 @@ pub use prettier::FORMAT_SUFFIX as TEST_PRETTIER_FORMAT_SUFFIX;#[cfg(any(test, feature = "test-support"))]pub use prettier::RANGE_FORMAT_SUFFIX as TEST_PRETTIER_RANGE_FORMAT_SUFFIX;pub use semantic_tokens::{- BufferSemanticToken, BufferSemanticTokens, RefreshForServer, SemanticTokenStylizer, TokenType,+ BufferSemanticToken, BufferSemanticTokens, SemanticTokenStylizer, TokenType,};pub use worktree::{@@ -174,6 +176,14 @@ const WORKSPACE_DIAGNOSTICS_TOKEN_START: &str = "id:";const SERVER_DOWNLOAD_TIMEOUT: Duration = Duration::from_secs(10);static NEXT_PROMPT_REQUEST_ID: AtomicUsize = AtomicUsize::new(0);+/// Refresh messages carry a monotonic id for backwards compatibility only: older peers+/// use it to order refreshes, while current ones re-mark pending refreshes on arrival.+/// The envelope's own message id cannot be used, as old peers compare the payload field.+fn next_wire_refresh_request_id() -> u64 {+ static NEXT_WIRE_REFRESH_REQUEST_ID: AtomicUsize = AtomicUsize::new(1);+ NEXT_WIRE_REFRESH_REQUEST_ID.fetch_add(1, atomic::Ordering::Relaxed) as u64+}+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]pub enum ProgressToken {Number(i32),@@ -286,12 +296,6 @@ pub struct DocumentDiagnostics {version: Option<i32>,}-#[derive(Default, Debug)]-struct DynamicRegistrations {- did_change_watched_files: HashSet<String>,- diagnostics: HashMap<Option<String>, DiagnosticServerCapabilities>,-}-pub struct LocalLspStore {weak: WeakEntity<LspStore>,pub worktree_store: Entity<WorktreeStore>,@@ -1096,32 +1100,13 @@ impl LocalLspStore {language_server.on_request::<lsp::request::InlayHintRefreshRequest, _, _>({let lsp_store = lsp_store.clone();- let request_id = Arc::new(AtomicUsize::new(0));move |(), cx| {let lsp_store = lsp_store.clone();- let request_id = request_id.clone();let mut cx = cx.clone();async move {- lsp_store- .update(&mut cx, |lsp_store, cx| {- let request_id =- Some(request_id.fetch_add(1, atomic::Ordering::AcqRel));- cx.emit(LspStoreEvent::RefreshInlayHints {- server_id,- request_id,- });- lsp_store- .downstream_client- .as_ref()- .map(|(client, project_id)| {- client.send(proto::RefreshInlayHints {- project_id: *project_id,- server_id: server_id.to_proto(),- request_id: request_id.map(|id| id as u64),- })- })- })?- .transpose()?;+ lsp_store.update(&mut cx, |lsp_store, cx| {+ lsp_store.refresh_inlay_hints(server_id, cx);+ })?;Ok(())}}@@ -1133,7 +1118,7 @@ impl LocalLspStore {let lsp_store = lsp_store.clone();move |(), cx| {let result = lsp_store.update(cx, |lsp_store, cx| {- lsp_store.refresh_code_lens(cx);+ lsp_store.refresh_code_lens(Some(server_id), cx);});async move { result }}@@ -1143,16 +1128,12 @@ impl LocalLspStore {language_server.on_request::<lsp::request::SemanticTokensRefresh, _, _>({let lsp_store = lsp_store.clone();- let request_id = Arc::new(AtomicUsize::new(0));move |(), cx| {let lsp_store = lsp_store.clone();- let request_id = request_id.clone();let mut cx = cx.clone();async move {lsp_store.update(&mut cx, |lsp_store, cx| {- let request_id =- Some(request_id.fetch_add(1, atomic::Ordering::AcqRel));- lsp_store.refresh_semantic_tokens(server_id, request_id, cx);+ lsp_store.refresh_semantic_tokens(server_id, cx);})?;Ok(())}@@ -4086,6 +4067,97 @@ impl LocalLspStore {}}+/// Prunes per-server cached LSP data of servers no longer relevant for the buffer, and+/// returns the relevant servers that were not fetched for yet.+/// `None` means the cache covers all relevant servers and can be returned as is.+///+/// `fetched_servers` tracks the servers a completed fetch has queried, not the ones that+/// answered: a server that returned no data (not capable, errored, or not known to the+/// queried remote host) would otherwise be considered perpetually missing and every call+/// would re-fetch.+///+/// An empty `current_servers` set does not prune: on remote clients it may mean the+/// language server statuses have not synced yet, while data of genuinely removed servers+/// is cleaned up via the `remove_server_data` methods.+fn missing_servers_to_query<T>(+ cached: &mut HashMap<LanguageServerId, T>,+ fetched_servers: &mut HashSet<LanguageServerId>,+ current_servers: &HashSet<LanguageServerId>,+) -> Option<HashSet<LanguageServerId>> {+ if current_servers.is_empty() {+ return None;+ }+ cached.retain(|server_id, _| current_servers.contains(server_id));+ fetched_servers.retain(|server_id| current_servers.contains(server_id));+ let missing_servers = current_servers+ .difference(fetched_servers)+ .copied()+ .collect::<HashSet<_>>();+ if missing_servers.is_empty() {+ None+ } else {+ Some(missing_servers)+ }+}++/// The [`proto::LspQuery`] envelope can filter the query by at most one server.+/// Evictions are per-server, so a missing set larger than one is rare: fall back to an+/// unfiltered query then, which is correct as the extra results merely refresh the+/// non-missing servers' cache entries.+fn upstream_lsp_query_server_filter(+ for_servers: Option<&HashSet<LanguageServerId>>,+) -> Option<u64> {+ let servers = for_servers?;+ if servers.len() == 1 {+ servers.iter().next().map(|server_id| server_id.to_proto())+ } else {+ None+ }+}++fn next_lsp_fetch_id() -> u64 {+ static NEXT_LSP_FETCH_ID: AtomicUsize = AtomicUsize::new(1);+ NEXT_LSP_FETCH_ID.fetch_add(1, atomic::Ordering::Relaxed) as u64+}++#[derive(Debug)]+struct RunningFetch<T> {+ id: u64,+ version: Global,+ servers: HashSet<LanguageServerId>,+ task: T,+}++impl<T> RunningFetch<T> {+ /// Unregisters the completed fetch and reports whether its results are still+ /// relevant: an eviction, a buffer version reset, or a superseding fetch (whose+ /// server set covers this one's) all clear or replace the registration, in which+ /// case the results must be discarded.+ fn take_finished(update: &mut Option<Self>, fetch_id: u64) -> bool {+ if update+ .as_ref()+ .is_some_and(|running| running.id == fetch_id)+ {+ *update = None;+ true+ } else {+ false+ }+ }++ /// Unregisters a fetch that has queried the given server, so that, when the server+ /// is removed, a still-running fetch cannot re-insert the removed server's data+ /// after its cache entries were cleaned up.+ fn discard_if_queried(update: &mut Option<Self>, server_id: LanguageServerId) {+ if update+ .as_ref()+ .is_some_and(|running| running.servers.contains(&server_id))+ {+ *update = None;+ }+ }+}+fn notify_server_capabilities_updated(server: &LanguageServer, cx: &mut Context<LspStore>) {if let Some(capabilities) = serde_json::to_string(&server.capabilities()).ok() {cx.emit(LspStoreEvent::LanguageServerUpdate {@@ -4212,7 +4284,7 @@ impl BufferLspData {}if let Some(folding_ranges) = &mut self.folding_ranges {- folding_ranges.ranges.remove(&for_server);+ folding_ranges.remove_server_data(for_server);}if let Some(document_links) = &mut self.document_links {@@ -4224,6 +4296,14 @@ impl BufferLspData {}}+ fn reset_for_newer_buffer_version(&mut self, buffer: &Entity<Buffer>, cx: &mut App) {+ // To send delta requests for semantic tokens, the previous tokens+ // need to be kept between buffer changes.+ let semantic_tokens = self.semantic_tokens.take();+ *self = Self::new(buffer, cx);+ self.semantic_tokens = semantic_tokens;+ }+#[cfg(any(test, feature = "test-support"))]pub fn inlay_hints(&self) -> &BufferInlayHints {&self.inlay_hints@@ -4248,13 +4328,25 @@ pub enum LspStoreEvent {Notification(String),RefreshInlayHints {server_id: LanguageServerId,- request_id: Option<usize>,},RefreshSemanticTokens {server_id: LanguageServerId,- request_id: Option<usize>,},- RefreshCodeLens,+ RefreshCodeLens {+ server_id: Option<LanguageServerId>,+ },+ RefreshDocumentColors {+ server_id: Option<LanguageServerId>,+ },+ RefreshDocumentLinks {+ server_id: Option<LanguageServerId>,+ },+ RefreshFoldingRanges {+ server_id: Option<LanguageServerId>,+ },+ RefreshDocumentSymbols {+ server_id: Option<LanguageServerId>,+ },DiagnosticsUpdated {server_id: LanguageServerId,paths: Vec<ProjectPath>,@@ -4350,6 +4442,10 @@ impl LspStore {client.add_entity_request_handler(Self::handle_refresh_inlay_hints);client.add_entity_request_handler(Self::handle_refresh_semantic_tokens);client.add_entity_request_handler(Self::handle_refresh_code_lens);+ client.add_entity_request_handler(Self::handle_refresh_document_colors);+ client.add_entity_request_handler(Self::handle_refresh_document_links);+ client.add_entity_request_handler(Self::handle_refresh_folding_ranges);+ client.add_entity_request_handler(Self::handle_refresh_document_symbols);client.add_entity_request_handler(Self::handle_on_type_formatting);client.add_entity_request_handler(Self::handle_apply_additional_edits_for_completion);client.add_entity_request_handler(Self::handle_register_buffer_with_language_servers);@@ -5251,7 +5347,7 @@ impl LspStore {&self,buffer: &Entity<Buffer>,cx: &App,- ) -> Vec<LanguageServerId> {+ ) -> HashSet<LanguageServerId> {let buffer_id = buffer.read(cx).remote_id();if let Some(local) = self.as_local() {return local@@ -5264,7 +5360,7 @@ impl LspStore {}let Some(language) = buffer.read(cx).language().cloned() else {- return Vec::default();+ return HashSet::default();};let registered_language_servers = self.languages@@ -7508,7 +7604,13 @@ impl LspStore {.language_server_dynamic_registrations.get(&server_id).into_iter()- .flat_map(|registrations| registrations.diagnostics.clone())+ .flat_map(|registrations| ®istrations.diagnostics)+ .map(|(source, dynamic_caps)| {+ (+ source.registration_id().map(str::to_string),+ dynamic_caps.clone(),+ )+ }).collect::<Vec<_>>();Some(providers_with_identifiers@@ -7593,15 +7695,10 @@ impl LspStore {let lsp_data = self.latest_lsp_data(&buffer, cx);let query_version = lsp_data.buffer_version.clone();let mut lsp_refresh_requested = false;- let for_server = if let InvalidationStrategy::RefreshRequested {- server_id,- request_id,- } = invalidate- {- let invalidated = lsp_data+ let for_server = if let InvalidationStrategy::RefreshRequested { server_id } = invalidate {+ lsp_refresh_requested = lsp_data.inlay_hints- .invalidate_for_server_refresh(server_id, request_id);- lsp_refresh_requested = invalidated;+ .invalidate_for_server_refresh(server_id);Some(server_id)} else {None@@ -7917,8 +8014,9 @@ impl LspStore {else {return false;};- let registration_key = registration_id.as_ref().map(|s| s.to_string());- registrations.diagnostics.contains_key(®istration_key)+ registrations.diagnostics.iter().any(|(source, _)| {+ source.registration_id() == registration_id.as_ref().map(|id| id.as_ref())+ })}pub fn pull_diagnostics_for_buffer(@@ -9395,6 +9493,23 @@ impl LspStore {request: R,cx: &mut Context<Self>,) -> Task<Vec<(LanguageServerId, R::Response)>>+ where+ P: ToOffset,+ R: LspCommand + Clone,+ <R::LspRequest as lsp::request::Request>::Result: Send,+ <R::LspRequest as lsp::request::Request>::Params: Send,+ {+ self.request_filtered_lsp_locally(buffer, position, request, None, cx)+ }++ fn request_filtered_lsp_locally<P, R>(+ &mut self,+ buffer: &Entity<Buffer>,+ position: Option<P>,+ request: R,+ only_servers: Option<&HashSet<LanguageServerId>>,+ cx: &mut Context<Self>,+ ) -> Task<Vec<(LanguageServerId, R::Response)>>whereP: ToOffset,R: LspCommand + Clone,@@ -9418,6 +9533,9 @@ impl LspStore {.unwrap_or(true)}).map(|(_, server)| server.server_id())+ .filter(|server_id| {+ only_servers.is_none_or(|only_servers| only_servers.contains(server_id))+ }).filter(|server_id| {self.as_local().is_none_or(|local| {local@@ -10847,13 +10965,12 @@ impl LspStore {cx: &mut Context<Self>,) {if let Some(status) = self.language_server_statuses.get_mut(&language_server_id) {- if let Some(work) = status.pending_work.remove(&token)- && !work.is_disk_based_diagnostics_progress- {- cx.emit(LspStoreEvent::RefreshInlayHints {- server_id: language_server_id,- request_id: None,- });+ let refresh_inlay_hints = status+ .pending_work+ .remove(&token)+ .is_some_and(|work| !work.is_disk_based_diagnostics_progress);+ if refresh_inlay_hints {+ self.refresh_inlay_hints_on_work_end(language_server_id, cx);}cx.notify();}@@ -11615,6 +11732,12 @@ impl LspStore {});}local.language_server_watched_paths.remove(&server_id);+ local+ .language_server_paths_watched_for_rename+ .remove(&server_id);+ local+ .language_server_dynamic_registrations+ .remove(&server_id);let server_state = local.language_servers.remove(&server_id);self.cleanup_lsp_data(server_id);@@ -12138,13 +12261,17 @@ impl LspStore {.capabilities().diagnostic_provider.and_then(|provider| {- local+ let diagnostics = &mut local.language_server_dynamic_registrations.entry(server_id).or_default()- .diagnostics- .entry(None)- .or_insert(provider.clone());+ .diagnostics;+ if !diagnostics+ .iter()+ .any(|(source, _)| source.registration_id().is_none())+ {+ diagnostics.push((RegistrationSource::Static, provider.clone()));+ }let workspace_refresher =lsp_workspace_diagnostics_refresh(None, provider, language_server.clone(), cx)?;@@ -13128,594 +13255,6 @@ impl LspStore {}}- fn register_server_capabilities(- &mut self,- server_id: LanguageServerId,- params: lsp::RegistrationParams,- cx: &mut Context<Self>,- ) -> anyhow::Result<()> {- let server = self- .language_server_for_id(server_id)- .with_context(|| format!("no server {server_id} found"))?;- for reg in params.registrations {- match reg.method.as_str() {- "workspace/didChangeWatchedFiles" => {- if let Some(options) = reg.register_options {- let notify = if let Some(local_lsp_store) = self.as_local_mut() {- let caps = serde_json::from_value(options)?;- local_lsp_store- .on_lsp_did_change_watched_files(server_id, ®.id, caps, cx);- true- } else {- false- };- if notify {- notify_server_capabilities_updated(&server, cx);- }- }- }- "workspace/didChangeConfiguration" => {- // Ignore payload since we notify clients of setting changes unconditionally, relying on them pulling the latest settings.- }- "workspace/didChangeWorkspaceFolders" => {- // In this case register options is an empty object, we can ignore it- let caps = lsp::WorkspaceFoldersServerCapabilities {- supported: Some(true),- change_notifications: Some(OneOf::Right(reg.id)),- };- server.update_capabilities(|capabilities| {- capabilities- .workspace- .get_or_insert_default()- .workspace_folders = Some(caps);- });- notify_server_capabilities_updated(&server, cx);- }- "workspace/symbol" => {- let options = parse_register_capabilities(reg)?;- server.update_capabilities(|capabilities| {- capabilities.workspace_symbol_provider = Some(options);- });- notify_server_capabilities_updated(&server, cx);- }- "workspace/fileOperations" => {- if let Some(options) = reg.register_options {- let caps = serde_json::from_value(options)?;- server.update_capabilities(|capabilities| {- capabilities- .workspace- .get_or_insert_default()- .file_operations = Some(caps);- });- notify_server_capabilities_updated(&server, cx);- }- }- "workspace/executeCommand" => {- if let Some(options) = reg.register_options {- let options = serde_json::from_value(options)?;- server.update_capabilities(|capabilities| {- capabilities.execute_command_provider = Some(options);- });- notify_server_capabilities_updated(&server, cx);- }- }- "textDocument/rangeFormatting" => {- let options = parse_register_capabilities(reg)?;- server.update_capabilities(|capabilities| {- capabilities.document_range_formatting_provider = Some(options);- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/onTypeFormatting" => {- if let Some(options) = reg- .register_options- .map(serde_json::from_value)- .transpose()?- {- server.update_capabilities(|capabilities| {- capabilities.document_on_type_formatting_provider = Some(options);- });- notify_server_capabilities_updated(&server, cx);- }- }- "textDocument/formatting" => {- let options = parse_register_capabilities(reg)?;- server.update_capabilities(|capabilities| {- capabilities.document_formatting_provider = Some(options);- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/rename" => {- let options = parse_register_capabilities(reg)?;- server.update_capabilities(|capabilities| {- capabilities.rename_provider = Some(options);- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/inlayHint" => {- let options = parse_register_capabilities(reg)?;- server.update_capabilities(|capabilities| {- capabilities.inlay_hint_provider = Some(options);- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/documentSymbol" => {- let options = parse_register_capabilities(reg)?;- server.update_capabilities(|capabilities| {- capabilities.document_symbol_provider = Some(options);- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/codeAction" => {- let options = parse_register_capabilities(reg)?;- let provider = match options {- OneOf::Left(value) => lsp::CodeActionProviderCapability::Simple(value),- OneOf::Right(caps) => caps,- };- server.update_capabilities(|capabilities| {- capabilities.code_action_provider = Some(provider);- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/definition" => {- let options = parse_register_capabilities(reg)?;- server.update_capabilities(|capabilities| {- capabilities.definition_provider = Some(options);- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/completion" => {- if let Some(caps) = reg- .register_options- .map(serde_json::from_value::<CompletionOptions>)- .transpose()?- {- server.update_capabilities(|capabilities| {- capabilities.completion_provider = Some(caps.clone());- });-- if let Some(local) = self.as_local() {- let mut buffers_with_language_server = Vec::new();- for handle in self.buffer_store.read(cx).buffers() {- let buffer_id = handle.read(cx).remote_id();- if local- .buffers_opened_in_servers- .get(&buffer_id)- .filter(|s| s.contains(&server_id))- .is_some()- {- buffers_with_language_server.push(handle);- }- }- let triggers = caps- .trigger_characters- .unwrap_or_default()- .into_iter()- .collect::<BTreeSet<_>>();- for handle in buffers_with_language_server {- let triggers = triggers.clone();- let _ = handle.update(cx, move |buffer, cx| {- buffer.set_completion_triggers(server_id, triggers, cx);- });- }- }- notify_server_capabilities_updated(&server, cx);- }- }- "textDocument/hover" => {- let options = parse_register_capabilities(reg)?;- let provider = match options {- OneOf::Left(value) => lsp::HoverProviderCapability::Simple(value),- OneOf::Right(caps) => caps,- };- server.update_capabilities(|capabilities| {- capabilities.hover_provider = Some(provider);- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/signatureHelp" => {- if let Some(caps) = reg- .register_options- .map(serde_json::from_value)- .transpose()?- {- server.update_capabilities(|capabilities| {- capabilities.signature_help_provider = Some(caps);- });- notify_server_capabilities_updated(&server, cx);- }- }- "textDocument/didChange" => {- if let Some(sync_kind) = reg- .register_options- .and_then(|opts| opts.get("syncKind").cloned())- .map(serde_json::from_value::<lsp::TextDocumentSyncKind>)- .transpose()?- {- server.update_capabilities(|capabilities| {- let mut sync_options =- Self::take_text_document_sync_options(capabilities);- sync_options.change = Some(sync_kind);- capabilities.text_document_sync =- Some(lsp::TextDocumentSyncCapability::Options(sync_options));- });- notify_server_capabilities_updated(&server, cx);- }- }- "textDocument/didSave" => {- if let Some(include_text) = reg- .register_options- .map(|opts| {- let transpose = opts- .get("includeText")- .cloned()- .map(serde_json::from_value::<Option<bool>>)- .transpose();- match transpose {- Ok(value) => Ok(value.flatten()),- Err(e) => Err(e),- }- })- .transpose()?- {- server.update_capabilities(|capabilities| {- let mut sync_options =- Self::take_text_document_sync_options(capabilities);- sync_options.save =- Some(TextDocumentSyncSaveOptions::SaveOptions(lsp::SaveOptions {- include_text,- }));- capabilities.text_document_sync =- Some(lsp::TextDocumentSyncCapability::Options(sync_options));- });- notify_server_capabilities_updated(&server, cx);- }- }- "textDocument/codeLens" => {- if let Some(caps) = reg- .register_options- .map(serde_json::from_value)- .transpose()?- {- server.update_capabilities(|capabilities| {- capabilities.code_lens_provider = Some(caps);- });- notify_server_capabilities_updated(&server, cx);- self.refresh_code_lens(cx);- }- }- "textDocument/diagnostic" => {- if let Some(caps) = reg- .register_options- .map(serde_json::from_value::<DiagnosticServerCapabilities>)- .transpose()?- {- let local = self- .as_local_mut()- .context("Expected LSP Store to be local")?;- let state = local- .language_servers- .get_mut(&server_id)- .context("Could not obtain Language Servers state")?;- local- .language_server_dynamic_registrations- .entry(server_id)- .or_default()- .diagnostics- .insert(Some(reg.id.clone()), caps.clone());-- let supports_workspace_diagnostics =- |capabilities: &DiagnosticServerCapabilities| match capabilities {- DiagnosticServerCapabilities::Options(diagnostic_options) => {- diagnostic_options.workspace_diagnostics- }- DiagnosticServerCapabilities::RegistrationOptions(- diagnostic_registration_options,- ) => {- diagnostic_registration_options- .diagnostic_options- .workspace_diagnostics- }- };-- if supports_workspace_diagnostics(&caps) {- if let LanguageServerState::Running {- workspace_diagnostics_refresh_tasks,- ..- } = state- && let Some(task) = lsp_workspace_diagnostics_refresh(- Some(reg.id.clone()),- caps.clone(),- server.clone(),- cx,- )- {- workspace_diagnostics_refresh_tasks.insert(Some(reg.id), task);- }- }-- server.update_capabilities(|capabilities| {- capabilities.diagnostic_provider = Some(caps);- });-- notify_server_capabilities_updated(&server, cx);-- let _ = self.pull_document_diagnostics_for_server(server_id, None, cx);- }- }- "textDocument/documentColor" => {- let options = parse_register_capabilities(reg)?;- let provider = match options {- OneOf::Left(value) => lsp::ColorProviderCapability::Simple(value),- OneOf::Right(caps) => caps,- };- server.update_capabilities(|capabilities| {- capabilities.color_provider = Some(provider);- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/foldingRange" => {- let options = parse_register_capabilities(reg)?;- let provider = match options {- OneOf::Left(value) => lsp::FoldingRangeProviderCapability::Simple(value),- OneOf::Right(caps) => caps,- };- server.update_capabilities(|capabilities| {- capabilities.folding_range_provider = Some(provider);- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/documentLink" => {- if let Some(caps) = reg- .register_options- .map(serde_json::from_value)- .transpose()?- {- server.update_capabilities(|capabilities| {- capabilities.document_link_provider = Some(caps);- });- notify_server_capabilities_updated(&server, cx);- }- }- "textDocument/semanticTokens" => {- if let Some(caps) = reg- .register_options- .map(serde_json::from_value::<lsp::SemanticTokensRegistrationOptions>)- .transpose()?- {- server.update_capabilities(|capabilities| {- capabilities.semantic_tokens_provider = Some(- lsp::SemanticTokensServerCapabilities::SemanticTokensRegistrationOptions(caps),- );- });- notify_server_capabilities_updated(&server, cx);- // Re-query already-open buffers, which would otherwise keep- // tree-sitter-only highlighting until edited.- self.refresh_semantic_tokens(server_id, None, cx);- }- }- _ => log::warn!("unhandled capability registration: {reg:?}"),- }- }-- Ok(())- }-- fn unregister_server_capabilities(- &mut self,- server_id: LanguageServerId,- params: lsp::UnregistrationParams,- cx: &mut Context<Self>,- ) -> anyhow::Result<()> {- let server = self- .language_server_for_id(server_id)- .with_context(|| format!("no server {server_id} found"))?;- for unreg in params.unregisterations.iter() {- match unreg.method.as_str() {- "workspace/didChangeWatchedFiles" => {- let notify = if let Some(local_lsp_store) = self.as_local_mut() {- local_lsp_store- .on_lsp_unregister_did_change_watched_files(server_id, &unreg.id, cx);- true- } else {- false- };- if notify {- notify_server_capabilities_updated(&server, cx);- }- }- "workspace/didChangeConfiguration" => {- // Ignore payload since we notify clients of setting changes unconditionally, relying on them pulling the latest settings.- }- "workspace/didChangeWorkspaceFolders" => {- server.update_capabilities(|capabilities| {- capabilities- .workspace- .get_or_insert_with(|| lsp::WorkspaceServerCapabilities {- workspace_folders: None,- file_operations: None,- })- .workspace_folders = None;- });- notify_server_capabilities_updated(&server, cx);- }- "workspace/symbol" => {- server.update_capabilities(|capabilities| {- capabilities.workspace_symbol_provider = None- });- notify_server_capabilities_updated(&server, cx);- }- "workspace/fileOperations" => {- server.update_capabilities(|capabilities| {- capabilities- .workspace- .get_or_insert_with(|| lsp::WorkspaceServerCapabilities {- workspace_folders: None,- file_operations: None,- })- .file_operations = None;- });- notify_server_capabilities_updated(&server, cx);- }- "workspace/executeCommand" => {- server.update_capabilities(|capabilities| {- capabilities.execute_command_provider = None;- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/rangeFormatting" => {- server.update_capabilities(|capabilities| {- capabilities.document_range_formatting_provider = None- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/onTypeFormatting" => {- server.update_capabilities(|capabilities| {- capabilities.document_on_type_formatting_provider = None;- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/formatting" => {- server.update_capabilities(|capabilities| {- capabilities.document_formatting_provider = None;- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/rename" => {- server.update_capabilities(|capabilities| capabilities.rename_provider = None);- notify_server_capabilities_updated(&server, cx);- }- "textDocument/codeAction" => {- server.update_capabilities(|capabilities| {- capabilities.code_action_provider = None;- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/definition" => {- server.update_capabilities(|capabilities| {- capabilities.definition_provider = None;- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/completion" => {- server.update_capabilities(|capabilities| {- capabilities.completion_provider = None;- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/hover" => {- server.update_capabilities(|capabilities| {- capabilities.hover_provider = None;- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/signatureHelp" => {- server.update_capabilities(|capabilities| {- capabilities.signature_help_provider = None;- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/semanticTokens" => {- server.update_capabilities(|capabilities| {- capabilities.semantic_tokens_provider = None;- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/didChange" => {- server.update_capabilities(|capabilities| {- let mut sync_options = Self::take_text_document_sync_options(capabilities);- sync_options.change = None;- capabilities.text_document_sync =- Some(lsp::TextDocumentSyncCapability::Options(sync_options));- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/didSave" => {- server.update_capabilities(|capabilities| {- let mut sync_options = Self::take_text_document_sync_options(capabilities);- sync_options.save = None;- capabilities.text_document_sync =- Some(lsp::TextDocumentSyncCapability::Options(sync_options));- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/codeLens" => {- server.update_capabilities(|capabilities| {- capabilities.code_lens_provider = None;- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/diagnostic" => {- let local = self- .as_local_mut()- .context("Expected LSP Store to be local")?;-- let state = local- .language_servers- .get_mut(&server_id)- .context("Could not obtain Language Servers state")?;- let registrations = local- .language_server_dynamic_registrations- .get_mut(&server_id)- .with_context(|| {- format!("Expected dynamic registration to exist for server {server_id}")- })?;- registrations.diagnostics- .remove(&Some(unreg.id.clone()))- .with_context(|| format!(- "Attempted to unregister non-existent diagnostic registration with ID {}",- unreg.id)- )?;- let removed_last_diagnostic_provider = registrations.diagnostics.is_empty();-- if let LanguageServerState::Running {- workspace_diagnostics_refresh_tasks,- ..- } = state- {- workspace_diagnostics_refresh_tasks.remove(&Some(unreg.id.clone()));- }-- self.clear_unregistered_diagnostics(- server_id,- SharedString::from(unreg.id.clone()),- cx,- )?;-- if removed_last_diagnostic_provider {- server.update_capabilities(|capabilities| {- debug_assert!(capabilities.diagnostic_provider.is_some());- capabilities.diagnostic_provider = None;- });- }-- notify_server_capabilities_updated(&server, cx);- }- "textDocument/documentColor" => {- server.update_capabilities(|capabilities| {- capabilities.color_provider = None;- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/foldingRange" => {- server.update_capabilities(|capabilities| {- capabilities.folding_range_provider = None;- });- notify_server_capabilities_updated(&server, cx);- }- "textDocument/documentLink" => {- server.update_capabilities(|capabilities| {- capabilities.document_link_provider = None;- });- notify_server_capabilities_updated(&server, cx);- }- _ => log::warn!("unhandled capability unregistration: {unreg:?}"),- }- }-- Ok(())- }-fn clear_unregistered_diagnostics(&mut self,server_id: LanguageServerId,@@ -14035,20 +13574,6 @@ impl LspStore {Ok((buffer_version, buffer))}- fn take_text_document_sync_options(- capabilities: &mut lsp::ServerCapabilities,- ) -> lsp::TextDocumentSyncOptions {- match capabilities.text_document_sync.take() {- Some(lsp::TextDocumentSyncCapability::Options(sync_options)) => sync_options,- Some(lsp::TextDocumentSyncCapability::Kind(sync_kind)) => {- let mut sync_options = lsp::TextDocumentSyncOptions::default();- sync_options.change = Some(sync_kind);- sync_options- }- None => lsp::TextDocumentSyncOptions::default(),- }- }-pub fn downstream_client(&self) -> Option<(AnyProtoClient, u64)> {self.downstream_client.clone()}@@ -14072,27 +13597,12 @@ impl LspStore {.entry(buffer_id).or_insert_with(|| BufferLspData::new(buffer, cx));if buffer_version.changed_since(&lsp_data.buffer_version) {- // To send delta requests for semantic tokens, the previous tokens- // need to be kept between buffer changes.- let semantic_tokens = lsp_data.semantic_tokens.take();- *lsp_data = BufferLspData::new(buffer, cx);- lsp_data.semantic_tokens = semantic_tokens;+ lsp_data.reset_for_newer_buffer_version(buffer, cx);}lsp_data}}-// Registration with registerOptions as null, should fallback to true.-// https://github.com/microsoft/vscode-languageserver-node/blob/d90a87f9557a0df9142cfb33e251cfa6fe27d970/client/src/common/client.ts#L2133-fn parse_register_capabilities<T: serde::de::DeserializeOwned>(- reg: lsp::Registration,-) -> Result<OneOf<bool, T>> {- Ok(match reg.register_options {- Some(options) => OneOf::Right(serde_json::from_value::<T>(options)?),- None => OneOf::Left(true),- })-}-fn server_capabilities_support_range_formatting(capabilities: &lsp::ServerCapabilities) -> bool {matches!(capabilities.document_range_formatting_provider.as_ref(),diff --git a/crates/project/src/lsp_store/code_lens.rs b/crates/project/src/lsp_store/code_lens.rsindex 6616e4f8a42..36982102779 100644--- a/crates/project/src/lsp_store/code_lens.rs+++ b/crates/project/src/lsp_store/code_lens.rs@@ -2,7 +2,6 @@ use std::ops::Range;use std::sync::Arc;use anyhow::{Context as _, Result};-use clock::Global;use collections::{HashMap, HashSet};use futures::{FutureExt as _,@@ -20,6 +19,9 @@ use util::ResultExt as _;use crate::{CodeAction, LspAction, LspStore, LspStoreEvent, Project,lsp_command::{GetCodeLens, LspCommand as _},+ lsp_store::{+ RunningFetch, missing_servers_to_query, next_lsp_fetch_id, upstream_lsp_query_server_filter,+ },project_settings::ProjectSettings,};@@ -48,15 +50,30 @@ pub type CodeLensResolveTask = Shared<Task<Option<(CodeLensActionId, CodeAction)#[derive(Debug, Default)]pub(super) struct CodeLensData {pub(super) lens: HashMap<LanguageServerId, CodeLensActions>,+ fetched_servers: HashSet<LanguageServerId>,pub(super) next_id: u64,- pub(super) update: Option<(Global, CodeLensTask)>,+ pub(super) update: Option<RunningFetch<CodeLensTask>>,pub(super) resolving: HashMap<(LanguageServerId, CodeLensActionId), CodeLensResolveTask>,}impl CodeLensData {pub(super) fn remove_server_data(&mut self, server_id: LanguageServerId) {self.lens.remove(&server_id);+ self.fetched_servers.remove(&server_id);self.resolving.retain(|(s, _), _| *s != server_id);+ RunningFetch::discard_if_queried(&mut self.update, server_id);+ }++ fn evict(&mut self, for_server: Option<LanguageServerId>) {+ match for_server {+ Some(server_id) => self.remove_server_data(server_id),+ None => {+ self.lens.clear();+ self.fetched_servers.clear();+ self.resolving.clear();+ }+ }+ self.update = None;}}@@ -72,16 +89,25 @@ fn flatten_cache(lens: &HashMap<LanguageServerId, CodeLensActions>) -> CodeLensA}impl LspStore {- pub(super) fn refresh_code_lens(&mut self, cx: &mut Context<Self>) {+ pub(super) fn refresh_code_lens(+ &mut self,+ for_server: Option<LanguageServerId>,+ cx: &mut Context<Self>,+ ) {for lsp_data in self.lsp_data.values_mut() {- lsp_data.code_lens = None;+ if let Some(code_lens) = &mut lsp_data.code_lens {+ code_lens.evict(for_server);+ }}- cx.emit(LspStoreEvent::RefreshCodeLens);+ cx.emit(LspStoreEvent::RefreshCodeLens {+ server_id: for_server,+ });if let Some((downstream_client, project_id)) = self.downstream_client.as_ref() {downstream_client.send(proto::RefreshCodeLens {project_id: *project_id,+ server_id: for_server.map(|server_id| server_id.to_proto()),}).context("sending refresh code lens downstream").log_err();@@ -122,30 +148,32 @@ impl LspStore {) -> CodeLensTask {let version_queried_for = buffer.read(cx).version();let buffer_id = buffer.read(cx).remote_id();- let existing_servers = if let Some(local) = self.as_local() {- local- .buffers_opened_in_servers- .get(&buffer_id)- .cloned()- .unwrap_or_default()- } else {- self.relevant_server_ids_for_capability_check(buffer, cx)- .into_iter()- .collect()- };+ let current_servers = self.relevant_server_ids_for_capability_check(buffer, cx);+ let mut servers_to_query = None;if let Some(lsp_data) = self.current_lsp_data(buffer_id) {- if let Some(cached_lens) = &lsp_data.code_lens {+ if let Some(cached_lens) = &mut lsp_data.code_lens {if !version_queried_for.changed_since(&lsp_data.buffer_version) {- let cached_servers = cached_lens.lens.keys().copied().collect::<HashSet<_>>();- if existing_servers == cached_servers {- return Task::ready(Ok(Some(flatten_cache(&cached_lens.lens)))).shared();- }- } else if let Some((updating_for, running_update)) = cached_lens.update.as_ref() {- if !version_queried_for.changed_since(updating_for) {- return running_update.clone();+ match missing_servers_to_query(+ &mut cached_lens.lens,+ &mut cached_lens.fetched_servers,+ ¤t_servers,+ ) {+ Some(missing_servers) => servers_to_query = Some(missing_servers),+ None => {+ return Task::ready(Ok(Some(flatten_cache(&cached_lens.lens))))+ .shared();+ }}}+ if let Some(running) = cached_lens.update.as_ref()+ && !version_queried_for.changed_since(&running.version)+ && servers_to_query+ .as_ref()+ .is_none_or(|missing| missing.is_subset(&running.servers))+ {+ return running.task.clone();+ }}}@@ -153,79 +181,99 @@ impl LspStore {.latest_lsp_data(buffer, cx).code_lens.get_or_insert_default();+ let fetch_id = next_lsp_fetch_id();+ let queried_servers = servers_to_query+ .clone()+ .unwrap_or_else(|| current_servers.clone());let buffer = buffer.clone();let query_version_queried_for = version_queried_for.clone();let new_task = cx- .spawn(async move |lsp_store, cx| {- cx.background_executor()- .timer(Duration::from_millis(30))- .await;- let fetched_lens = lsp_store- .update(cx, |lsp_store, cx| {- lsp_store.fetch_code_lens_for_buffer(&buffer, cx)- })- .map_err(Arc::new)?- .await- .context("fetching code lens")- .map_err(Arc::new);- let fetched_lens = match fetched_lens {- Ok(fetched_lens) => fetched_lens,- Err(e) => {- lsp_store- .update(cx, |lsp_store, _| {- if let Some(lens_lsp_data) = lsp_store- .lsp_data- .get_mut(&buffer_id)- .and_then(|lsp_data| lsp_data.code_lens.as_mut())- {- lens_lsp_data.update = None;- }- })- .ok();- return Err(e);- }- };+ .spawn({+ let queried_servers = queried_servers.clone();+ async move |lsp_store, cx| {+ cx.background_executor()+ .timer(Duration::from_millis(30))+ .await;+ let fetched_lens = lsp_store+ .update(cx, |lsp_store, cx| {+ lsp_store.fetch_code_lens_for_buffer(&buffer, servers_to_query, cx)+ })+ .map_err(Arc::new)?+ .await+ .context("fetching code lens")+ .map_err(Arc::new);+ let fetched_lens = match fetched_lens {+ Ok(fetched_lens) => fetched_lens,+ Err(e) => {+ lsp_store+ .update(cx, |lsp_store, _| {+ if let Some(lens_lsp_data) = lsp_store+ .lsp_data+ .get_mut(&buffer_id)+ .and_then(|lsp_data| lsp_data.code_lens.as_mut())+ {+ RunningFetch::take_finished(+ &mut lens_lsp_data.update,+ fetch_id,+ );+ }+ })+ .ok();+ return Err(e);+ }+ };- lsp_store- .update(cx, |lsp_store, _| {- let lsp_data = lsp_store.current_lsp_data(buffer_id)?;- let code_lens = lsp_data.code_lens.as_mut()?;- if let Some(fetched_lens) = fetched_lens {- let mut tagged: HashMap<LanguageServerId, CodeLensActions> =- HashMap::default();- for (server_id, actions) in fetched_lens {- let mut cache = CodeLensActions::default();- cache.reserve(actions.len());- for action in actions {- let id = CodeLensActionId(code_lens.next_id);- code_lens.next_id += 1;- cache.insert(id, action);- }- tagged.insert(server_id, cache);+ lsp_store+ .update(cx, |lsp_store, _| {+ let lsp_data = lsp_store.current_lsp_data(buffer_id)?;+ let code_lens = lsp_data.code_lens.as_mut()?;+ if !RunningFetch::take_finished(&mut code_lens.update, fetch_id) {+ return Some(flatten_cache(&code_lens.lens));}- if lsp_data.buffer_version == query_version_queried_for {- code_lens.lens.extend(tagged);- } else if !lsp_data- .buffer_version- .changed_since(&query_version_queried_for)- {- lsp_data.buffer_version = query_version_queried_for;- code_lens.lens = tagged;+ if let Some(fetched_lens) = fetched_lens {+ let mut tagged: HashMap<LanguageServerId, CodeLensActions> =+ HashMap::default();+ for (server_id, actions) in fetched_lens {+ let mut cache = CodeLensActions::default();+ cache.reserve(actions.len());+ for action in actions {+ let id = CodeLensActionId(code_lens.next_id);+ code_lens.next_id += 1;+ cache.insert(id, action);+ }+ tagged.insert(server_id, cache);+ }+ if lsp_data.buffer_version == query_version_queried_for {+ code_lens.lens.extend(tagged);+ code_lens.fetched_servers.extend(queried_servers);+ } else if !lsp_data+ .buffer_version+ .changed_since(&query_version_queried_for)+ {+ lsp_data.buffer_version = query_version_queried_for;+ code_lens.lens = tagged;+ code_lens.fetched_servers = queried_servers;+ }}- }- code_lens.update = None;- Some(flatten_cache(&code_lens.lens))- })- .map_err(Arc::new)+ Some(flatten_cache(&code_lens.lens))+ })+ .map_err(Arc::new)+ }}).shared();- lens_lsp_data.update = Some((version_queried_for, new_task.clone()));+ lens_lsp_data.update = Some(RunningFetch {+ id: fetch_id,+ version: version_queried_for,+ servers: queried_servers,+ task: new_task.clone(),+ });new_task}fn fetch_code_lens_for_buffer(&mut self,buffer: &Entity<Buffer>,+ for_servers: Option<HashSet<LanguageServerId>>,cx: &mut Context<Self>,) -> Task<Result<Option<HashMap<LanguageServerId, Vec<CodeAction>>>>> {if let Some((upstream_client, project_id)) = self.upstream_client() {@@ -238,7 +286,7 @@ impl LspStore {.get_request_timeout();let request_task = upstream_client.request_lsp(project_id,- None,+ upstream_lsp_query_server_filter(for_servers.as_ref()),request_timeout,cx.background_executor().clone(),request.to_proto(project_id, buffer.read(cx)),@@ -286,8 +334,13 @@ impl LspStore {Ok(Some(code_lens_actions))})} else {- let code_lens_actions_task =- self.request_multiple_lsp_locally(buffer, None::<usize>, GetCodeLens, cx);+ let code_lens_actions_task = self.request_filtered_lsp_locally(+ buffer,+ None::<usize>,+ GetCodeLens,+ for_servers.as_ref(),+ cx,+ );cx.background_spawn(async move {Ok(Some(code_lens_actions_task.await.into_iter().collect()))})@@ -447,17 +500,18 @@ impl LspStore {.take()?.update.take()?- .1,+ .task,)}pub(super) async fn handle_refresh_code_lens(lsp_store: Entity<Self>,- _: TypedEnvelope<proto::RefreshCodeLens>,+ envelope: TypedEnvelope<proto::RefreshCodeLens>,mut cx: AsyncApp,) -> Result<proto::Ack> {lsp_store.update(&mut cx, |lsp_store, cx| {- lsp_store.refresh_code_lens(cx);+ let server_id = envelope.payload.server_id.map(LanguageServerId::from_proto);+ lsp_store.refresh_code_lens(server_id, cx);});Ok(proto::Ack {})}diff --git a/crates/project/src/lsp_store/document_colors.rs b/crates/project/src/lsp_store/document_colors.rsindex c181fbf3ef2..70497361f22 100644--- a/crates/project/src/lsp_store/document_colors.rs+++ b/crates/project/src/lsp_store/document_colors.rs@@ -1,7 +1,6 @@use std::{sync::Arc, time::Duration};use anyhow::{Context as _, Result};-use clock::Global;use collections::{HashMap, HashSet};use futures::{FutureExt as _,@@ -22,6 +21,10 @@ use worktree::File;use crate::{ColorPresentation, DocumentColor, LspStore,lsp_command::{GetDocumentColor, LspCommand as _, make_text_document_identifier},+ lsp_store::{+ LspStoreEvent, RunningFetch, missing_servers_to_query, next_lsp_fetch_id,+ upstream_lsp_query_server_filter,+ },project_settings::ProjectSettings,};@@ -36,16 +39,67 @@ pub(super) type DocumentColorTask =#[derive(Debug, Default)]pub(super) struct DocumentColorData {pub(super) colors: HashMap<LanguageServerId, HashSet<DocumentColor>>,- pub(super) colors_update: Option<(Global, DocumentColorTask)>,+ fetched_servers: HashSet<LanguageServerId>,+ pub(super) colors_update: Option<RunningFetch<DocumentColorTask>>,}impl DocumentColorData {pub(super) fn remove_server_data(&mut self, server_id: LanguageServerId) {self.colors.remove(&server_id);+ self.fetched_servers.remove(&server_id);+ RunningFetch::discard_if_queried(&mut self.colors_update, server_id);+ }++ fn evict(&mut self, for_server: Option<LanguageServerId>) {+ match for_server {+ Some(server_id) => self.remove_server_data(server_id),+ None => {+ self.colors.clear();+ self.fetched_servers.clear();+ }+ }+ self.colors_update = None;}}impl LspStore {+ pub(super) fn refresh_document_colors(+ &mut self,+ for_server: Option<LanguageServerId>,+ cx: &mut Context<Self>,+ ) {+ for lsp_data in self.lsp_data.values_mut() {+ if let Some(document_colors) = &mut lsp_data.document_colors {+ document_colors.evict(for_server);+ }+ }++ cx.emit(LspStoreEvent::RefreshDocumentColors {+ server_id: for_server,+ });+ if let Some((downstream_client, project_id)) = self.downstream_client.as_ref() {+ downstream_client+ .send(proto::RefreshDocumentColors {+ project_id: *project_id,+ server_id: for_server.map(|server_id| server_id.to_proto()),+ })+ .context("sending refresh document colors downstream")+ .log_err();+ }+ }++ pub(super) async fn handle_refresh_document_colors(+ lsp_store: Entity<Self>,+ envelope: TypedEnvelope<proto::RefreshDocumentColors>,+ mut cx: AsyncApp,+ ) -> Result<proto::Ack> {+ lsp_store.update(&mut cx, |lsp_store, cx| {+ let server_id = envelope.payload.server_id.map(LanguageServerId::from_proto);+ lsp_store.refresh_document_colors(server_id, cx);+ });+ Ok(proto::Ack {})+ }+pub fn document_colors(&mut self,buffer: Entity<Buffer>,@@ -54,23 +108,20 @@ impl LspStore {let version_queried_for = buffer.read(cx).version();let buffer_id = buffer.read(cx).remote_id();- let current_language_servers = self.as_local().map(|local| {- local- .buffers_opened_in_servers- .get(&buffer_id)- .cloned()- .unwrap_or_default()- });+ let current_servers = self.relevant_server_ids_for_capability_check(&buffer, cx);+ let mut servers_to_query = None;if let Some(lsp_data) = self.current_lsp_data(buffer_id) {- if let Some(cached_colors) = &lsp_data.document_colors {- if !version_queried_for.changed_since(&lsp_data.buffer_version) {- let has_different_servers =- current_language_servers.is_some_and(|current_language_servers| {- current_language_servers- != cached_colors.colors.keys().copied().collect()- });- if !has_different_servers {+ if !version_queried_for.changed_since(&lsp_data.buffer_version)+ && let Some(cached_colors) = &mut lsp_data.document_colors+ {+ match missing_servers_to_query(+ &mut cached_colors.colors,+ &mut cached_colors.fetched_servers,+ ¤t_servers,+ ) {+ Some(missing_servers) => servers_to_query = Some(missing_servers),+ None => {return Some(Task::ready(Ok(DocumentColors {colors: cached_colors.colors.values().flatten().cloned().collect(),@@ -80,82 +131,108 @@ impl LspStore {}}}+ if let Some(document_colors) = &lsp_data.document_colors+ && let Some(running) = &document_colors.colors_update+ && !version_queried_for.changed_since(&running.version)+ && servers_to_query+ .as_ref()+ .is_none_or(|missing| missing.is_subset(&running.servers))+ {+ return Some(running.task.clone());+ }}let color_lsp_data = self.latest_lsp_data(&buffer, cx).document_colors.get_or_insert_default();- if let Some((updating_for, running_update)) = &color_lsp_data.colors_update- && !version_queried_for.changed_since(updating_for)- {- return Some(running_update.clone());- }+ let fetch_id = next_lsp_fetch_id();+ let queried_servers = servers_to_query+ .clone()+ .unwrap_or_else(|| current_servers.clone());let buffer_version_queried_for = version_queried_for.clone();let new_task = cx- .spawn(async move |lsp_store, cx| {- cx.background_executor()- .timer(Duration::from_millis(30))- .await;- let fetched_colors = lsp_store- .update(cx, |lsp_store, cx| {- lsp_store.fetch_document_colors_for_buffer(&buffer, cx)- })?- .await- .context("fetching document colors")- .map_err(Arc::new);- let fetched_colors = match fetched_colors {- Ok(fetched_colors) => {- if buffer.update(cx, |buffer, _| {- buffer.version() != buffer_version_queried_for- }) {- return Ok(DocumentColors::default());+ .spawn({+ let queried_servers = queried_servers.clone();+ async move |lsp_store, cx| {+ cx.background_executor()+ .timer(Duration::from_millis(30))+ .await;+ let fetched_colors = lsp_store+ .update(cx, |lsp_store, cx| {+ lsp_store.fetch_document_colors_for_buffer(+ &buffer,+ servers_to_query,+ cx,+ )+ })?+ .await+ .context("fetching document colors")+ .map_err(Arc::new);+ let fetched_colors = match fetched_colors {+ Ok(fetched_colors) => {+ if buffer.update(cx, |buffer, _| {+ buffer.version() != buffer_version_queried_for+ }) {+ return Ok(DocumentColors::default());+ }+ fetched_colors}- fetched_colors- }- Err(e) => {- lsp_store- .update(cx, |lsp_store, _| {- if let Some(lsp_data) = lsp_store.lsp_data.get_mut(&buffer_id) {- if let Some(document_colors) = &mut lsp_data.document_colors {- document_colors.colors_update = None;+ Err(e) => {+ lsp_store+ .update(cx, |lsp_store, _| {+ if let Some(lsp_data) = lsp_store.lsp_data.get_mut(&buffer_id)+ && let Some(document_colors) = &mut lsp_data.document_colors+ {+ RunningFetch::take_finished(+ &mut document_colors.colors_update,+ fetch_id,+ );}- }- })- .ok();- return Err(e);- }- };+ })+ .ok();+ return Err(e);+ }+ };- lsp_store- .update(cx, |lsp_store, cx| {- let lsp_data = lsp_store.latest_lsp_data(&buffer, cx);- let lsp_colors = lsp_data.document_colors.get_or_insert_default();+ lsp_store+ .update(cx, |lsp_store, cx| {+ let lsp_data = lsp_store.latest_lsp_data(&buffer, cx);+ let lsp_colors = lsp_data.document_colors.get_or_insert_default();- if let Some(fetched_colors) = fetched_colors {- if lsp_data.buffer_version == buffer_version_queried_for {- lsp_colors.colors.extend(fetched_colors);- } else if !lsp_data- .buffer_version- .changed_since(&buffer_version_queried_for)+ if RunningFetch::take_finished(&mut lsp_colors.colors_update, fetch_id)+ && let Some(fetched_colors) = fetched_colors{- lsp_data.buffer_version = buffer_version_queried_for;- lsp_colors.colors = fetched_colors;+ if lsp_data.buffer_version == buffer_version_queried_for {+ lsp_colors.colors.extend(fetched_colors);+ lsp_colors.fetched_servers.extend(queried_servers);+ } else if !lsp_data+ .buffer_version+ .changed_since(&buffer_version_queried_for)+ {+ lsp_data.buffer_version = buffer_version_queried_for;+ lsp_colors.colors = fetched_colors;+ lsp_colors.fetched_servers = queried_servers;+ }}- }- lsp_colors.colors_update = None;- let colors = lsp_colors- .colors- .values()- .flatten()- .cloned()- .collect::<HashSet<_>>();- DocumentColors { colors }- })- .map_err(Arc::new)+ let colors = lsp_colors+ .colors+ .values()+ .flatten()+ .cloned()+ .collect::<HashSet<_>>();+ DocumentColors { colors }+ })+ .map_err(Arc::new)+ }}).shared();- color_lsp_data.colors_update = Some((version_queried_for, new_task.clone()));+ color_lsp_data.colors_update = Some(RunningFetch {+ id: fetch_id,+ version: version_queried_for,+ servers: queried_servers,+ task: new_task.clone(),+ });Some(new_task)}@@ -266,6 +343,7 @@ impl LspStore {pub(super) fn fetch_document_colors_for_buffer(&mut self,buffer: &Entity<Buffer>,+ for_servers: Option<HashSet<LanguageServerId>>,cx: &mut Context<Self>,) -> Task<anyhow::Result<Option<HashMap<LanguageServerId, HashSet<DocumentColor>>>>> {if let Some((client, project_id)) = self.upstream_client() {@@ -279,7 +357,7 @@ impl LspStore {.get_request_timeout();let request_task = client.request_lsp(project_id,- None,+ upstream_lsp_query_server_filter(for_servers.as_ref()),request_timeout,cx.background_executor().clone(),request.to_proto(project_id, buffer.read(cx)),@@ -325,8 +403,13 @@ impl LspStore {Ok(Some(colors))})} else {- let document_colors_task =- self.request_multiple_lsp_locally(buffer, None::<usize>, GetDocumentColor, cx);+ let document_colors_task = self.request_filtered_lsp_locally(+ buffer,+ None::<usize>,+ GetDocumentColor,+ for_servers.as_ref(),+ cx,+ );cx.background_spawn(async move {Ok(Some(document_colors_taskdiff --git a/crates/project/src/lsp_store/document_links.rs b/crates/project/src/lsp_store/document_links.rsindex 5bfcab4913b..22eca9cae0e 100644--- a/crates/project/src/lsp_store/document_links.rs+++ b/crates/project/src/lsp_store/document_links.rs@@ -4,8 +4,7 @@ use std::sync::Arc;use std::time::Duration;use anyhow::Context as _;-use clock::Global;-use collections::HashMap;+use collections::{HashMap, HashSet};use futures::FutureExt as _;use futures::future::{Shared, join_all};use gpui::{AppContext as _, AsyncApp, Context, Entity, SharedString, Task};@@ -18,7 +17,9 @@ use text::{Anchor, BufferId, ToPointUtf16 as _};use util::ResultExt as _;use crate::lsp_command::{GetDocumentLinks, LspCommand as _};-use crate::lsp_store::LspStore;+use crate::lsp_store::{+ LspStore, LspStoreEvent, RunningFetch, missing_servers_to_query, next_lsp_fetch_id,+};use crate::project_settings::ProjectSettings;#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Debug)]@@ -43,16 +44,31 @@ pub type DocumentLinkResolveTask = Shared<Task<Option<(DocumentLinkId, LspDocume#[derive(Debug, Default)]pub(super) struct DocumentLinksData {pub(super) links: BufferDocumentLinks,+ fetched_servers: HashSet<LanguageServerId>,pub(super) next_id: u64,- links_update: Option<(Global, DocumentLinksTask)>,+ links_update: Option<RunningFetch<DocumentLinksTask>>,pub(super) link_resolves: HashMap<(LanguageServerId, DocumentLinkId), DocumentLinkResolveTask>,}impl DocumentLinksData {pub(super) fn remove_server_data(&mut self, server_id: LanguageServerId) {self.links.remove(&server_id);+ self.fetched_servers.remove(&server_id);self.link_resolves.retain(|(resolved_server, _), _| *resolved_server != server_id);+ RunningFetch::discard_if_queried(&mut self.links_update, server_id);+ }++ fn evict(&mut self, for_server: Option<LanguageServerId>) {+ match for_server {+ Some(server_id) => self.remove_server_data(server_id),+ None => {+ self.links.clear();+ self.fetched_servers.clear();+ self.link_resolves.clear();+ }+ }+ self.links_update = None;}}@@ -66,6 +82,43 @@ pub enum ResolvedDocumentLink {}impl LspStore {+ pub(super) fn refresh_document_links(+ &mut self,+ for_server: Option<LanguageServerId>,+ cx: &mut Context<Self>,+ ) {+ for lsp_data in self.lsp_data.values_mut() {+ if let Some(document_links) = &mut lsp_data.document_links {+ document_links.evict(for_server);+ }+ }++ cx.emit(LspStoreEvent::RefreshDocumentLinks {+ server_id: for_server,+ });+ if let Some((downstream_client, project_id)) = self.downstream_client.as_ref() {+ downstream_client+ .send(proto::RefreshDocumentLinks {+ project_id: *project_id,+ server_id: for_server.map(|server_id| server_id.to_proto()),+ })+ .context("sending refresh document links downstream")+ .log_err();+ }+ }++ pub(super) async fn handle_refresh_document_links(+ lsp_store: Entity<Self>,+ envelope: TypedEnvelope<proto::RefreshDocumentLinks>,+ mut cx: AsyncApp,+ ) -> anyhow::Result<proto::Ack> {+ lsp_store.update(&mut cx, |lsp_store, cx| {+ let server_id = envelope.payload.server_id.map(LanguageServerId::from_proto);+ lsp_store.refresh_document_links(server_id, cx);+ });+ Ok(proto::Ack {})+ }+/// `Some(..)` means the underlying state was actually refreshed; `None`/// means the fetch was skipped or failed, and the caller should keep its/// previous data.@@ -77,24 +130,31 @@ impl LspStore {let version_queried_for = buffer.read(cx).version();let buffer_id = buffer.read(cx).remote_id();- let current_language_servers = self.as_local().map(|local| {- local- .buffers_opened_in_servers- .get(&buffer_id)- .cloned()- .unwrap_or_default()- });-- if let Some(lsp_data) = self.current_lsp_data(buffer_id)- && let Some(cached) = &lsp_data.document_links- && !version_queried_for.changed_since(&lsp_data.buffer_version)- {- let has_different_servers =- current_language_servers.is_some_and(|current_language_servers| {- current_language_servers != cached.links.keys().copied().collect()- });- if !has_different_servers {- return Task::ready(Some(cached.links.clone()));+ let current_servers = self.relevant_server_ids_for_capability_check(buffer, cx);++ let mut servers_to_query = None;+ if let Some(lsp_data) = self.current_lsp_data(buffer_id) {+ if !version_queried_for.changed_since(&lsp_data.buffer_version)+ && let Some(cached) = &mut lsp_data.document_links+ {+ match missing_servers_to_query(+ &mut cached.links,+ &mut cached.fetched_servers,+ ¤t_servers,+ ) {+ Some(missing_servers) => servers_to_query = Some(missing_servers),+ None => return Task::ready(Some(cached.links.clone())),+ }+ }+ if let Some(document_links) = &lsp_data.document_links+ && let Some(running) = &document_links.links_update+ && !version_queried_for.changed_since(&running.version)+ && servers_to_query+ .as_ref()+ .is_none_or(|missing| missing.is_subset(&running.servers))+ {+ let running = running.task.clone();+ return cx.background_spawn(async move { running.await.ok().flatten() });}}@@ -102,91 +162,104 @@ impl LspStore {.latest_lsp_data(buffer, cx).document_links.get_or_insert_default();- if let Some((updating_for, running_update)) = &links_lsp_data.links_update- && !version_queried_for.changed_since(updating_for)- {- let running = running_update.clone();- return cx.background_spawn(async move { running.await.ok().flatten() });- }-+ let fetch_id = next_lsp_fetch_id();+ let queried_servers = servers_to_query+ .clone()+ .unwrap_or_else(|| current_servers.clone());let buffer = buffer.clone();let query_version = version_queried_for.clone();let new_task = cx- .spawn(async move |lsp_store, cx| {- cx.background_executor()- .timer(Duration::from_millis(30))- .await;+ .spawn({+ let queried_servers = queried_servers.clone();+ async move |lsp_store, cx| {+ cx.background_executor()+ .timer(Duration::from_millis(30))+ .await;++ let fetched = lsp_store+ .update(cx, |lsp_store, cx| {+ lsp_store.fetch_document_links_for_buffer(&buffer, servers_to_query, cx)+ })+ .map_err(Arc::new)?+ .await+ .context("fetching document links")+ .map_err(Arc::new);++ let fetched = match fetched {+ Ok(fetched) => fetched,+ Err(e) => {+ lsp_store+ .update(cx, |lsp_store, _| {+ if let Some(lsp_data) = lsp_store.lsp_data.get_mut(&buffer_id)+ && let Some(document_links) = &mut lsp_data.document_links+ {+ RunningFetch::take_finished(+ &mut document_links.links_update,+ fetch_id,+ );+ }+ })+ .ok();+ return Err(e);+ }+ };++ lsp_store+ .update(cx, |lsp_store, cx| {+ let lsp_data = lsp_store.latest_lsp_data(&buffer, cx);+ let links_data = lsp_data.document_links.get_or_insert_default();+ if !RunningFetch::take_finished(&mut links_data.links_update, fetch_id)+ {+ return Some(links_data.links.clone());+ }- let fetched = lsp_store- .update(cx, |lsp_store, cx| {- lsp_store.fetch_document_links_for_buffer(&buffer, cx)- })- .map_err(Arc::new)?- .await- .context("fetching document links")- .map_err(Arc::new);-- let fetched = match fetched {- Ok(fetched) => fetched,- Err(e) => {- lsp_store- .update(cx, |lsp_store, _| {- if let Some(lsp_data) = lsp_store.lsp_data.get_mut(&buffer_id)- && let Some(document_links) = &mut lsp_data.document_links- {- document_links.links_update = None;+ let Some(fetched_links) = fetched else {+ return None;+ };++ let mut tagged = BufferDocumentLinks::default();+ for (server_id, server_links) in fetched_links {+ let mut by_id = HashMap::default();+ by_id.reserve(server_links.len());+ for link in server_links {+ let id = DocumentLinkId(links_data.next_id);+ links_data.next_id += 1;+ by_id.insert(id, link);}- })- .ok();- return Err(e);- }- };-- lsp_store- .update(cx, |lsp_store, cx| {- let lsp_data = lsp_store.latest_lsp_data(&buffer, cx);- let links_data = lsp_data.document_links.get_or_insert_default();- links_data.links_update = None;-- let Some(fetched_links) = fetched else {- return None;- };-- let mut tagged = BufferDocumentLinks::default();- for (server_id, server_links) in fetched_links {- let mut by_id = HashMap::default();- by_id.reserve(server_links.len());- for link in server_links {- let id = DocumentLinkId(links_data.next_id);- links_data.next_id += 1;- by_id.insert(id, link);+ tagged.insert(server_id, by_id);}- tagged.insert(server_id, by_id);- }- if lsp_data.buffer_version == query_version {- for (server_id, new_links) in &tagged {- links_data.links.insert(*server_id, new_links.clone());+ if lsp_data.buffer_version == query_version {+ for (server_id, new_links) in &tagged {+ links_data.links.insert(*server_id, new_links.clone());+ }+ links_data.fetched_servers.extend(queried_servers);+ // The newly inserted links are unresolved by definition; drop any+ // pending resolves that were keyed against the prior entries for+ // those servers so callers re-issue against the fresh ids.+ links_data.link_resolves.clear();+ Some(links_data.links.clone())+ } else if !lsp_data.buffer_version.changed_since(&query_version) {+ lsp_data.buffer_version = query_version;+ links_data.links = tagged;+ links_data.fetched_servers = queried_servers;+ links_data.link_resolves.clear();+ Some(links_data.links.clone())+ } else {+ None}- // The newly inserted links are unresolved by definition; drop any- // pending resolves that were keyed against the prior entries for- // those servers so callers re-issue against the fresh ids.- links_data.link_resolves.clear();- Some(links_data.links.clone())- } else if !lsp_data.buffer_version.changed_since(&query_version) {- lsp_data.buffer_version = query_version;- links_data.links = tagged;- links_data.link_resolves.clear();- Some(links_data.links.clone())- } else {- None- }- })- .map_err(Arc::new)+ })+ .map_err(Arc::new)+ }}).shared();- links_lsp_data.links_update = Some((version_queried_for, new_task.clone()));+ links_lsp_data.links_update = Some(RunningFetch {+ id: fetch_id,+ version: version_queried_for,+ servers: queried_servers,+ task: new_task.clone(),+ });cx.background_spawn(async move { new_task.await.ok().flatten() })}@@ -201,9 +274,14 @@ impl LspStore {fn fetch_document_links_for_buffer(&mut self,buffer: &Entity<Buffer>,+ for_servers: Option<HashSet<LanguageServerId>>,cx: &mut Context<Self>,) -> Task<anyhow::Result<Option<HashMap<LanguageServerId, Vec<LspDocumentLink>>>>> {if let Some((client, project_id)) = self.upstream_client() {+ // No `for_servers` filter is forwarded: unlike its siblings, `GetDocumentLinks`+ // is answered from the host's own `fetch_document_links` cache with the full+ // per-server map, to spare the LSP request (see collab's+ // `test_lsp_document_links`), so filtering could not reduce the work anyway.let request = GetDocumentLinks;if !self.is_capable_for_proto_request(buffer, &request, cx) {return Task::ready(Ok(None));@@ -263,8 +341,13 @@ impl LspStore {Ok(Some(result))})} else {- let links_task =- self.request_multiple_lsp_locally(buffer, None::<usize>, GetDocumentLinks, cx);+ let links_task = self.request_filtered_lsp_locally(+ buffer,+ None::<usize>,+ GetDocumentLinks,+ for_servers.as_ref(),+ cx,+ );cx.background_spawn(async move { Ok(Some(links_task.await.into_iter().collect())) })}}diff --git a/crates/project/src/lsp_store/document_symbols.rs b/crates/project/src/lsp_store/document_symbols.rsindex babb08ffc1d..20088da3211 100644--- a/crates/project/src/lsp_store/document_symbols.rs+++ b/crates/project/src/lsp_store/document_symbols.rs@@ -3,21 +3,24 @@ use std::sync::Arc;use std::time::Duration;use anyhow::Context as _;-use clock::Global;-use collections::HashMap;+use collections::{HashMap, HashSet};use futures::FutureExt as _;use futures::future::{Shared, join_all};-use gpui::{AppContext as _, Context, Entity, Task};+use gpui::{AppContext as _, AsyncApp, Context, Entity, Task};use itertools::Itertools;use language::{Buffer, BufferSnapshot, OutlineItem};use lsp::LanguageServerId;+use rpc::{TypedEnvelope, proto};use settings::Settings as _;use text::{Anchor, Bias, PointUtf16};use util::ResultExt;use crate::DocumentSymbol;use crate::lsp_command::{GetDocumentSymbols, LspCommand as _};-use crate::lsp_store::LspStore;+use crate::lsp_store::{+ LspStore, LspStoreEvent, RunningFetch, missing_servers_to_query, next_lsp_fetch_id,+ upstream_lsp_query_server_filter,+};use crate::project_settings::ProjectSettings;pub(super) type DocumentSymbolsTask =@@ -26,16 +29,67 @@ pub(super) type DocumentSymbolsTask =#[derive(Debug, Default)]pub(super) struct DocumentSymbolsData {symbols: HashMap<LanguageServerId, Vec<OutlineItem<Anchor>>>,- symbols_update: Option<(Global, DocumentSymbolsTask)>,+ fetched_servers: HashSet<LanguageServerId>,+ symbols_update: Option<RunningFetch<DocumentSymbolsTask>>,}impl DocumentSymbolsData {pub(super) fn remove_server_data(&mut self, for_server: LanguageServerId) {self.symbols.remove(&for_server);+ self.fetched_servers.remove(&for_server);+ RunningFetch::discard_if_queried(&mut self.symbols_update, for_server);+ }++ fn evict(&mut self, for_server: Option<LanguageServerId>) {+ match for_server {+ Some(server_id) => self.remove_server_data(server_id),+ None => {+ self.symbols.clear();+ self.fetched_servers.clear();+ }+ }+ self.symbols_update = None;}}impl LspStore {+ pub(super) fn refresh_document_symbols(+ &mut self,+ for_server: Option<LanguageServerId>,+ cx: &mut Context<Self>,+ ) {+ for lsp_data in self.lsp_data.values_mut() {+ if let Some(document_symbols) = &mut lsp_data.document_symbols {+ document_symbols.evict(for_server);+ }+ }++ cx.emit(LspStoreEvent::RefreshDocumentSymbols {+ server_id: for_server,+ });+ if let Some((downstream_client, project_id)) = self.downstream_client.as_ref() {+ downstream_client+ .send(proto::RefreshDocumentSymbols {+ project_id: *project_id,+ server_id: for_server.map(|server_id| server_id.to_proto()),+ })+ .context("sending refresh document symbols downstream")+ .log_err();+ }+ }++ pub(super) async fn handle_refresh_document_symbols(+ lsp_store: Entity<Self>,+ envelope: TypedEnvelope<proto::RefreshDocumentSymbols>,+ mut cx: AsyncApp,+ ) -> anyhow::Result<proto::Ack> {+ lsp_store.update(&mut cx, |lsp_store, cx| {+ let server_id = envelope.payload.server_id.map(LanguageServerId::from_proto);+ lsp_store.refresh_document_symbols(server_id, cx);+ });+ Ok(proto::Ack {})+ }+/// Returns a task that resolves to the document symbol outline items for/// the given buffer.///@@ -53,22 +107,20 @@ impl LspStore {let version_queried_for = buffer.read(cx).version();let buffer_id = buffer.read(cx).remote_id();- let current_language_servers = self.as_local().map(|local| {- local- .buffers_opened_in_servers- .get(&buffer_id)- .cloned()- .unwrap_or_default()- });+ let current_servers = self.relevant_server_ids_for_capability_check(buffer, cx);+ let mut servers_to_query = None;if let Some(lsp_data) = self.current_lsp_data(buffer_id) {- if let Some(cached) = &lsp_data.document_symbols {- if !version_queried_for.changed_since(&lsp_data.buffer_version) {- let has_different_servers =- current_language_servers.is_some_and(|current_language_servers| {- current_language_servers != cached.symbols.keys().copied().collect()- });- if !has_different_servers {+ if !version_queried_for.changed_since(&lsp_data.buffer_version)+ && let Some(cached) = &mut lsp_data.document_symbols+ {+ match missing_servers_to_query(+ &mut cached.symbols,+ &mut cached.fetched_servers,+ ¤t_servers,+ ) {+ Some(missing_servers) => servers_to_query = Some(missing_servers),+ None => {let snapshot = buffer.read(cx).snapshot();return Task::ready(cached@@ -83,90 +135,118 @@ impl LspStore {}}}+ if let Some(document_symbols) = &lsp_data.document_symbols+ && let Some(running) = &document_symbols.symbols_update+ && !version_queried_for.changed_since(&running.version)+ && servers_to_query+ .as_ref()+ .is_none_or(|missing| missing.is_subset(&running.servers))+ {+ let running = running.task.clone();+ return cx+ .background_spawn(async move { running.await.log_err().unwrap_or_default() });+ }}let doc_symbols_data = self.latest_lsp_data(buffer, cx).document_symbols.get_or_insert_default();- if let Some((updating_for, running_update)) = &doc_symbols_data.symbols_update {- if !version_queried_for.changed_since(updating_for) {- let running = running_update.clone();- return cx- .background_spawn(async move { running.await.log_err().unwrap_or_default() });- }- }-+ let fetch_id = next_lsp_fetch_id();+ let queried_servers = servers_to_query+ .clone()+ .unwrap_or_else(|| current_servers.clone());let buffer = buffer.clone();let query_version = version_queried_for.clone();let new_task = cx- .spawn(async move |lsp_store, cx| {- cx.background_executor()- .timer(Duration::from_millis(30))- .await;-- let fetched = lsp_store- .update(cx, |lsp_store, cx| {- lsp_store.fetch_document_symbols_for_buffer(&buffer, cx)- })- .map_err(Arc::new)?- .await- .context("fetching document symbols")- .map_err(Arc::new);-- let fetched = match fetched {- Ok(fetched) => fetched,- Err(e) => {- lsp_store- .update(cx, |lsp_store, _| {- if let Some(lsp_data) = lsp_store.lsp_data.get_mut(&buffer_id) {- if let Some(document_symbols) = &mut lsp_data.document_symbols {- document_symbols.symbols_update = None;+ .spawn({+ let queried_servers = queried_servers.clone();+ async move |lsp_store, cx| {+ cx.background_executor()+ .timer(Duration::from_millis(30))+ .await;++ let fetched = lsp_store+ .update(cx, |lsp_store, cx| {+ lsp_store.fetch_document_symbols_for_buffer(+ &buffer,+ servers_to_query,+ cx,+ )+ })+ .map_err(Arc::new)?+ .await+ .context("fetching document symbols")+ .map_err(Arc::new);++ let fetched = match fetched {+ Ok(fetched) => fetched,+ Err(e) => {+ lsp_store+ .update(cx, |lsp_store, _| {+ if let Some(lsp_data) = lsp_store.lsp_data.get_mut(&buffer_id)+ && let Some(document_symbols) =+ &mut lsp_data.document_symbols+ {+ RunningFetch::take_finished(+ &mut document_symbols.symbols_update,+ fetch_id,+ );}- }- })- .ok();- return Err(e);- }- };-- lsp_store- .update(cx, |lsp_store, cx| {- let snapshot = buffer.read(cx).snapshot();- let lsp_data = lsp_store.latest_lsp_data(&buffer, cx);- let doc_symbols = lsp_data.document_symbols.get_or_insert_default();-- if let Some(fetched_symbols) = fetched {- let converted = fetched_symbols- .iter()- .map(|(&server_id, symbols)| {- let mut items = Vec::new();- flatten_document_symbols(symbols, &snapshot, 0, &mut items);- (server_id, items)})- .collect();- if lsp_data.buffer_version == query_version {- doc_symbols.symbols.extend(converted);- } else if !lsp_data.buffer_version.changed_since(&query_version) {- lsp_data.buffer_version = query_version;- doc_symbols.symbols = converted;- }+ .ok();+ return Err(e);}- doc_symbols.symbols_update = None;- doc_symbols- .symbols- .values()- .flatten()- .unique()- .cloned()- .sorted_by(|a, b| a.range.start.cmp(&b.range.start, &snapshot))- .collect()- })- .map_err(Arc::new)+ };++ lsp_store+ .update(cx, |lsp_store, cx| {+ let snapshot = buffer.read(cx).snapshot();+ let lsp_data = lsp_store.latest_lsp_data(&buffer, cx);+ let doc_symbols = lsp_data.document_symbols.get_or_insert_default();++ if RunningFetch::take_finished(+ &mut doc_symbols.symbols_update,+ fetch_id,+ ) && let Some(fetched_symbols) = fetched+ {+ let converted = fetched_symbols+ .iter()+ .map(|(&server_id, symbols)| {+ let mut items = Vec::new();+ flatten_document_symbols(symbols, &snapshot, 0, &mut items);+ (server_id, items)+ })+ .collect();+ if lsp_data.buffer_version == query_version {+ doc_symbols.symbols.extend(converted);+ doc_symbols.fetched_servers.extend(queried_servers);+ } else if !lsp_data.buffer_version.changed_since(&query_version) {+ lsp_data.buffer_version = query_version;+ doc_symbols.symbols = converted;+ doc_symbols.fetched_servers = queried_servers;+ }+ }+ doc_symbols+ .symbols+ .values()+ .flatten()+ .unique()+ .cloned()+ .sorted_by(|a, b| a.range.start.cmp(&b.range.start, &snapshot))+ .collect()+ })+ .map_err(Arc::new)+ }}).shared();- doc_symbols_data.symbols_update = Some((version_queried_for, new_task.clone()));+ doc_symbols_data.symbols_update = Some(RunningFetch {+ id: fetch_id,+ version: version_queried_for,+ servers: queried_servers,+ task: new_task.clone(),+ });cx.background_spawn(async move { new_task.await.log_err().unwrap_or_default() })}@@ -174,6 +254,7 @@ impl LspStore {fn fetch_document_symbols_for_buffer(&mut self,buffer: &Entity<Buffer>,+ for_servers: Option<HashSet<LanguageServerId>>,cx: &mut Context<Self>,) -> Task<anyhow::Result<Option<HashMap<LanguageServerId, Vec<DocumentSymbol>>>>> {if let Some((client, project_id)) = self.upstream_client() {@@ -187,7 +268,7 @@ impl LspStore {.get_request_timeout();let request_task = client.request_lsp(project_id,- None,+ upstream_lsp_query_server_filter(for_servers.as_ref()),request_timeout,cx.background_executor().clone(),request.to_proto(project_id, buffer.read(cx)),@@ -235,8 +316,13 @@ impl LspStore {Ok(Some(result))})} else {- let symbols_task =- self.request_multiple_lsp_locally(buffer, None::<usize>, GetDocumentSymbols, cx);+ let symbols_task = self.request_filtered_lsp_locally(+ buffer,+ None::<usize>,+ GetDocumentSymbols,+ for_servers.as_ref(),+ cx,+ );cx.background_spawn(async move { Ok(Some(symbols_task.await.into_iter().collect())) })}}diff --git a/crates/project/src/lsp_store/dynamic_registration.rs b/crates/project/src/lsp_store/dynamic_registration.rsnew file mode 100644index 00000000000..7df7a238e40--- /dev/null+++ b/crates/project/src/lsp_store/dynamic_registration.rs@@ -0,0 +1,1054 @@+//! Handling of `client/registerCapability` and `client/unregisterCapability` requests,+//! which let language servers toggle their capabilities at runtime.+//!+//! Multiple registrations of the same capability may coexist: the most recent one is+//! "active" and mirrored into the server's [`lsp::ServerCapabilities`], while the rest+//! (including the statically declared capability, if any) are kept to be restored when+//! the active registration is unregistered.++use anyhow::{Context as _, Result};+use collections::{BTreeSet, HashSet};+use gpui::{Context, SharedString};+use lsp::{+ CompletionOptions, DiagnosticServerCapabilities, LanguageServer, LanguageServerId, OneOf,+ TextDocumentSyncSaveOptions,+};++use crate::lsp_store::{+ LanguageServerState, LspStore, RenamePathsWatchedForServer, lsp_workspace_diagnostics_refresh,+ notify_server_capabilities_updated,+};++#[derive(Debug)]+pub(super) enum RegistrationSource {+ Static,+ Dynamic(String),+}++impl RegistrationSource {+ pub(super) fn registration_id(&self) -> Option<&str> {+ match self {+ RegistrationSource::Static => None,+ RegistrationSource::Dynamic(id) => Some(id),+ }+ }+}++pub(super) type CapabilityRegistrations<T> = Vec<(RegistrationSource, T)>;++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+enum CapabilityUnregistration {+ NotFound,+ Removed { active_capability_changed: bool },+}++impl CapabilityUnregistration {+ fn removed(self) -> bool {+ self != CapabilityUnregistration::NotFound+ }++ fn capability_changed(self) -> bool {+ self == CapabilityUnregistration::Removed {+ active_capability_changed: true,+ }+ }+}++#[derive(Default, Debug)]+pub(super) struct DynamicRegistrations {+ pub(super) did_change_watched_files: HashSet<String>,+ pub(super) diagnostics: CapabilityRegistrations<DiagnosticServerCapabilities>,+ workspace_folders: CapabilityRegistrations<lsp::WorkspaceFoldersServerCapabilities>,+ workspace_symbol: CapabilityRegistrations<OneOf<bool, lsp::WorkspaceSymbolOptions>>,+ file_operations: CapabilityRegistrations<lsp::WorkspaceFileOperationsServerCapabilities>,+ execute_command: CapabilityRegistrations<lsp::ExecuteCommandOptions>,+ range_formatting: CapabilityRegistrations<OneOf<bool, lsp::DocumentRangeFormattingOptions>>,+ on_type_formatting: CapabilityRegistrations<lsp::DocumentOnTypeFormattingOptions>,+ formatting: CapabilityRegistrations<OneOf<bool, lsp::DocumentFormattingOptions>>,+ rename: CapabilityRegistrations<OneOf<bool, lsp::RenameOptions>>,+ code_action: CapabilityRegistrations<lsp::CodeActionProviderCapability>,+ definition: CapabilityRegistrations<OneOf<bool, lsp::DefinitionOptions>>,+ completion: CapabilityRegistrations<lsp::CompletionOptions>,+ hover: CapabilityRegistrations<lsp::HoverProviderCapability>,+ signature_help: CapabilityRegistrations<lsp::SignatureHelpOptions>,+ color: CapabilityRegistrations<lsp::ColorProviderCapability>,+ folding_range: CapabilityRegistrations<lsp::FoldingRangeProviderCapability>,+ document_link: CapabilityRegistrations<lsp::DocumentLinkOptions>,+ semantic_tokens: CapabilityRegistrations<lsp::SemanticTokensServerCapabilities>,+ inlay_hint: CapabilityRegistrations<OneOf<bool, lsp::InlayHintServerCapabilities>>,+ code_lens: CapabilityRegistrations<lsp::CodeLensOptions>,+ document_symbol: CapabilityRegistrations<OneOf<bool, lsp::DocumentSymbolOptions>>,+}++impl LspStore {+ /// Returns `true` when the registration changed the server's active capability value:+ /// duplicate-ID replacements of non-active registrations and (re-)registrations with+ /// options identical to the active ones do not.+ fn register_dynamic_capability<T: Clone + PartialEq>(+ &mut self,+ server: &LanguageServer,+ method: &str,+ registration_id: String,+ options: T,+ cx: &mut Context<Self>,+ registrations_of: impl FnOnce(&mut DynamicRegistrations) -> &mut CapabilityRegistrations<T>,+ capability_of: impl Fn(&mut lsp::ServerCapabilities) -> &mut Option<T>,+ ) -> anyhow::Result<bool> {+ let server_id = server.server_id();+ let local = self+ .as_local_mut()+ .context("Expected LSP Store to be local")?;+ let registrations = registrations_of(+ local+ .language_server_dynamic_registrations+ .entry(server_id)+ .or_default(),+ );+ if registrations.is_empty() {+ let mut initial_capabilities = server.capabilities();+ if let Some(static_options) = capability_of(&mut initial_capabilities).take() {+ registrations.push((RegistrationSource::Static, static_options));+ }+ }+ let previously_active = registrations.last().map(|(_, options)| options.clone());+ if let Some(index) = registrations+ .iter()+ .position(|(source, _)| source.registration_id() == Some(registration_id.as_str()))+ {+ log::warn!(+ "Received a duplicate {method} registration with ID {registration_id}, replacing the previous one"+ );+ registrations[index].1 = options;+ } else {+ registrations.push((RegistrationSource::Dynamic(registration_id), options));+ }+ let active = registrations.last().map(|(_, options)| options.clone());+ let active_changed = active != previously_active;+ if active_changed {+ server.update_capabilities(|capabilities| *capability_of(capabilities) = active);+ notify_server_capabilities_updated(server, cx);+ }+ Ok(active_changed)+ }++ fn unregister_dynamic_capability<T: Clone + PartialEq>(+ &mut self,+ server: &LanguageServer,+ unregistration: &lsp::Unregistration,+ cx: &mut Context<Self>,+ registrations_of: impl FnOnce(&mut DynamicRegistrations) -> &mut CapabilityRegistrations<T>,+ capability_of: impl FnOnce(&mut lsp::ServerCapabilities) -> &mut Option<T>,+ ) -> anyhow::Result<CapabilityUnregistration> {+ let server_id = server.server_id();+ let local = self+ .as_local_mut()+ .context("Expected LSP Store to be local")?;+ let registrations = local+ .language_server_dynamic_registrations+ .get_mut(&server_id)+ .map(registrations_of);+ let index = registrations.as_ref().and_then(|registrations| {+ registrations.iter().position(|(source, _)| {+ source.registration_id() == Some(unregistration.id.as_str())+ })+ });+ let (Some(registrations), Some(index)) = (registrations, index) else {+ log::warn!(+ "Attempted to unregister non-existent {} registration with ID {}",+ unregistration.method,+ unregistration.id+ );+ return Ok(CapabilityUnregistration::NotFound);+ };+ let removed_active = index + 1 == registrations.len();+ let (_, removed_options) = registrations.remove(index);+ let restored = registrations.last().map(|(_, options)| options.clone());+ if !removed_active || restored.as_ref() == Some(&removed_options) {+ return Ok(CapabilityUnregistration::Removed {+ active_capability_changed: false,+ });+ }+ server.update_capabilities(|capabilities| *capability_of(capabilities) = restored);+ notify_server_capabilities_updated(server, cx);+ Ok(CapabilityUnregistration::Removed {+ active_capability_changed: true,+ })+ }++ fn update_paths_watched_for_rename(&mut self, server: &LanguageServer) {+ let Some(local) = self.as_local_mut() else {+ return;+ };+ let watcher = server+ .capabilities()+ .workspace+ .and_then(|workspace| workspace.file_operations)+ .and_then(|file_operations| {+ let did_rename_caps = file_operations.did_rename.as_ref();+ let will_rename_caps = file_operations.will_rename.as_ref();+ did_rename_caps.or(will_rename_caps)?;+ Some(+ RenamePathsWatchedForServer::default()+ .with_did_rename_patterns(did_rename_caps)+ .with_will_rename_patterns(will_rename_caps),+ )+ });+ match watcher {+ Some(watcher) => {+ local+ .language_server_paths_watched_for_rename+ .insert(server.server_id(), watcher);+ }+ None => {+ local+ .language_server_paths_watched_for_rename+ .remove(&server.server_id());+ }+ }+ }++ fn apply_completion_triggers(+ &self,+ server_id: LanguageServerId,+ options: Option<CompletionOptions>,+ cx: &mut Context<Self>,+ ) {+ let Some(local) = self.as_local() else {+ return;+ };+ let mut buffers_with_language_server = Vec::new();+ for handle in self.buffer_store.read(cx).buffers() {+ let buffer_id = handle.read(cx).remote_id();+ if local+ .buffers_opened_in_servers+ .get(&buffer_id)+ .filter(|s| s.contains(&server_id))+ .is_some()+ {+ buffers_with_language_server.push(handle);+ }+ }+ let triggers = options+ .and_then(|options| options.trigger_characters)+ .unwrap_or_default()+ .into_iter()+ .collect::<BTreeSet<_>>();+ for handle in buffers_with_language_server {+ let triggers = triggers.clone();+ handle.update(cx, move |buffer, cx| {+ buffer.set_completion_triggers(server_id, triggers, cx);+ });+ }+ }++ pub(super) fn register_server_capabilities(+ &mut self,+ server_id: LanguageServerId,+ params: lsp::RegistrationParams,+ cx: &mut Context<Self>,+ ) -> anyhow::Result<()> {+ let server = self+ .language_server_for_id(server_id)+ .with_context(|| format!("no server {server_id} found"))?;+ for reg in params.registrations {+ match reg.method.as_str() {+ "workspace/didChangeWatchedFiles" => {+ if let Some(options) = reg.register_options {+ let notify = if let Some(local_lsp_store) = self.as_local_mut() {+ let caps = serde_json::from_value(options)?;+ local_lsp_store+ .on_lsp_did_change_watched_files(server_id, ®.id, caps, cx);+ true+ } else {+ false+ };+ if notify {+ notify_server_capabilities_updated(&server, cx);+ }+ }+ }+ "workspace/didChangeConfiguration" => {+ // Ignore payload since we notify clients of setting changes unconditionally, relying on them pulling the latest settings.+ }+ "workspace/didChangeWorkspaceFolders" => {+ // In this case register options is an empty object, we can ignore it+ let caps = lsp::WorkspaceFoldersServerCapabilities {+ supported: Some(true),+ change_notifications: Some(OneOf::Right(reg.id.clone())),+ };+ self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ caps,+ cx,+ |registrations| &mut registrations.workspace_folders,+ |capabilities| {+ &mut capabilities+ .workspace+ .get_or_insert_default()+ .workspace_folders+ },+ )?;+ }+ "workspace/symbol" => {+ let options = parse_register_capabilities(reg.register_options)?;+ self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ options,+ cx,+ |registrations| &mut registrations.workspace_symbol,+ |capabilities| &mut capabilities.workspace_symbol_provider,+ )?;+ }+ "workspace/fileOperations" => {+ if let Some(options) = reg.register_options {+ let caps = serde_json::from_value(options)?;+ if self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ caps,+ cx,+ |registrations| &mut registrations.file_operations,+ |capabilities| {+ &mut capabilities+ .workspace+ .get_or_insert_default()+ .file_operations+ },+ )? {+ self.update_paths_watched_for_rename(&server);+ }+ }+ }+ "workspace/executeCommand" => {+ if let Some(options) = reg.register_options {+ let options = serde_json::from_value(options)?;+ self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ options,+ cx,+ |registrations| &mut registrations.execute_command,+ |capabilities| &mut capabilities.execute_command_provider,+ )?;+ }+ }+ "textDocument/rangeFormatting" => {+ let options = parse_register_capabilities(reg.register_options)?;+ self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ options,+ cx,+ |registrations| &mut registrations.range_formatting,+ |capabilities| &mut capabilities.document_range_formatting_provider,+ )?;+ }+ "textDocument/onTypeFormatting" => {+ if let Some(options) = reg+ .register_options+ .map(serde_json::from_value)+ .transpose()?+ {+ self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ options,+ cx,+ |registrations| &mut registrations.on_type_formatting,+ |capabilities| &mut capabilities.document_on_type_formatting_provider,+ )?;+ }+ }+ "textDocument/formatting" => {+ let options = parse_register_capabilities(reg.register_options)?;+ self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ options,+ cx,+ |registrations| &mut registrations.formatting,+ |capabilities| &mut capabilities.document_formatting_provider,+ )?;+ }+ "textDocument/rename" => {+ let options = parse_register_capabilities(reg.register_options)?;+ self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ options,+ cx,+ |registrations| &mut registrations.rename,+ |capabilities| &mut capabilities.rename_provider,+ )?;+ }+ "textDocument/inlayHint" => {+ let options = parse_register_capabilities(reg.register_options)?;+ if self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ options,+ cx,+ |registrations| &mut registrations.inlay_hint,+ |capabilities| &mut capabilities.inlay_hint_provider,+ )? {+ self.refresh_inlay_hints(server_id, cx);+ }+ }+ "textDocument/documentSymbol" => {+ let options = parse_register_capabilities(reg.register_options)?;+ if self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ options,+ cx,+ |registrations| &mut registrations.document_symbol,+ |capabilities| &mut capabilities.document_symbol_provider,+ )? {+ self.refresh_document_symbols(Some(server_id), cx);+ }+ }+ "textDocument/codeAction" => {+ let options = parse_register_capabilities(reg.register_options)?;+ let provider = match options {+ OneOf::Left(value) => lsp::CodeActionProviderCapability::Simple(value),+ OneOf::Right(caps) => caps,+ };+ self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ provider,+ cx,+ |registrations| &mut registrations.code_action,+ |capabilities| &mut capabilities.code_action_provider,+ )?;+ }+ "textDocument/definition" => {+ let options = parse_register_capabilities(reg.register_options)?;+ self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ options,+ cx,+ |registrations| &mut registrations.definition,+ |capabilities| &mut capabilities.definition_provider,+ )?;+ }+ "textDocument/completion" => {+ if let Some(caps) = reg+ .register_options+ .map(serde_json::from_value::<CompletionOptions>)+ .transpose()?+ {+ if self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ caps,+ cx,+ |registrations| &mut registrations.completion,+ |capabilities| &mut capabilities.completion_provider,+ )? {+ let active = server.capabilities().completion_provider;+ self.apply_completion_triggers(server_id, active, cx);+ }+ }+ }+ "textDocument/hover" => {+ let options = parse_register_capabilities(reg.register_options)?;+ let provider = match options {+ OneOf::Left(value) => lsp::HoverProviderCapability::Simple(value),+ OneOf::Right(caps) => caps,+ };+ self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ provider,+ cx,+ |registrations| &mut registrations.hover,+ |capabilities| &mut capabilities.hover_provider,+ )?;+ }+ "textDocument/signatureHelp" => {+ if let Some(caps) = reg+ .register_options+ .map(serde_json::from_value)+ .transpose()?+ {+ self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ caps,+ cx,+ |registrations| &mut registrations.signature_help,+ |capabilities| &mut capabilities.signature_help_provider,+ )?;+ }+ }+ "textDocument/didChange" => {+ if let Some(sync_kind) = reg+ .register_options+ .and_then(|opts| opts.get("syncKind").cloned())+ .map(serde_json::from_value::<lsp::TextDocumentSyncKind>)+ .transpose()?+ {+ server.update_capabilities(|capabilities| {+ let mut sync_options = take_text_document_sync_options(capabilities);+ sync_options.change = Some(sync_kind);+ capabilities.text_document_sync =+ Some(lsp::TextDocumentSyncCapability::Options(sync_options));+ });+ notify_server_capabilities_updated(&server, cx);+ }+ }+ "textDocument/didSave" => {+ if let Some(include_text) = reg+ .register_options+ .map(|opts| {+ let transpose = opts+ .get("includeText")+ .cloned()+ .map(serde_json::from_value::<Option<bool>>)+ .transpose();+ match transpose {+ Ok(value) => Ok(value.flatten()),+ Err(e) => Err(e),+ }+ })+ .transpose()?+ {+ server.update_capabilities(|capabilities| {+ let mut sync_options = take_text_document_sync_options(capabilities);+ sync_options.save =+ Some(TextDocumentSyncSaveOptions::SaveOptions(lsp::SaveOptions {+ include_text,+ }));+ capabilities.text_document_sync =+ Some(lsp::TextDocumentSyncCapability::Options(sync_options));+ });+ notify_server_capabilities_updated(&server, cx);+ }+ }+ "textDocument/codeLens" => {+ if let Some(options) = reg+ .register_options+ .map(serde_json::from_value)+ .transpose()?+ {+ if self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ options,+ cx,+ |registrations| &mut registrations.code_lens,+ |capabilities| &mut capabilities.code_lens_provider,+ )? {+ self.refresh_code_lens(Some(server_id), cx);+ }+ }+ }+ "textDocument/diagnostic" => {+ if let Some(caps) = reg+ .register_options+ .map(serde_json::from_value::<DiagnosticServerCapabilities>)+ .transpose()?+ {+ let registration_id = reg.id.clone();+ self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ caps.clone(),+ cx,+ |registrations| &mut registrations.diagnostics,+ |capabilities| &mut capabilities.diagnostic_provider,+ )?;++ let supports_workspace_diagnostics =+ |capabilities: &DiagnosticServerCapabilities| match capabilities {+ DiagnosticServerCapabilities::Options(diagnostic_options) => {+ diagnostic_options.workspace_diagnostics+ }+ DiagnosticServerCapabilities::RegistrationOptions(+ diagnostic_registration_options,+ ) => {+ diagnostic_registration_options+ .diagnostic_options+ .workspace_diagnostics+ }+ };++ let local = self+ .as_local_mut()+ .context("Expected LSP Store to be local")?;+ let state = local+ .language_servers+ .get_mut(&server_id)+ .context("Could not obtain Language Servers state")?;+ if let LanguageServerState::Running {+ workspace_diagnostics_refresh_tasks,+ ..+ } = state+ {+ workspace_diagnostics_refresh_tasks+ .remove(&Some(registration_id.clone()));+ if supports_workspace_diagnostics(&caps)+ && let Some(task) = lsp_workspace_diagnostics_refresh(+ Some(registration_id.clone()),+ caps,+ server.clone(),+ cx,+ )+ {+ workspace_diagnostics_refresh_tasks+ .insert(Some(registration_id), task);+ }+ }++ let _ = self.pull_document_diagnostics_for_server(server_id, None, cx);+ }+ }+ "textDocument/documentColor" => {+ let options = parse_register_capabilities(reg.register_options)?;+ let provider = match options {+ OneOf::Left(value) => lsp::ColorProviderCapability::Simple(value),+ OneOf::Right(caps) => caps,+ };+ if self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ provider,+ cx,+ |registrations| &mut registrations.color,+ |capabilities| &mut capabilities.color_provider,+ )? {+ self.refresh_document_colors(Some(server_id), cx);+ }+ }+ "textDocument/foldingRange" => {+ let options = parse_register_capabilities(reg.register_options)?;+ let provider = match options {+ OneOf::Left(value) => lsp::FoldingRangeProviderCapability::Simple(value),+ OneOf::Right(caps) => caps,+ };+ if self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ provider,+ cx,+ |registrations| &mut registrations.folding_range,+ |capabilities| &mut capabilities.folding_range_provider,+ )? {+ self.refresh_folding_ranges(Some(server_id), cx);+ }+ }+ "textDocument/documentLink" => {+ if let Some(caps) = reg+ .register_options+ .map(serde_json::from_value)+ .transpose()?+ {+ if self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ caps,+ cx,+ |registrations| &mut registrations.document_link,+ |capabilities| &mut capabilities.document_link_provider,+ )? {+ self.refresh_document_links(Some(server_id), cx);+ }+ }+ }+ "textDocument/semanticTokens" => {+ if let Some(caps) = reg+ .register_options+ .map(serde_json::from_value::<lsp::SemanticTokensRegistrationOptions>)+ .transpose()?+ {+ if self.register_dynamic_capability(+ &server,+ ®.method,+ reg.id,+ lsp::SemanticTokensServerCapabilities::SemanticTokensRegistrationOptions(caps),+ cx,+ |registrations| &mut registrations.semantic_tokens,+ |capabilities| &mut capabilities.semantic_tokens_provider,+ )? {+ // Re-query already-open buffers, which would otherwise keep+ // tree-sitter-only highlighting until edited.+ self.refresh_semantic_tokens(server_id, cx);+ }+ }+ }+ _ => log::warn!("unhandled capability registration: {reg:?}"),+ }+ }++ Ok(())+ }++ pub(super) fn unregister_server_capabilities(+ &mut self,+ server_id: LanguageServerId,+ params: lsp::UnregistrationParams,+ cx: &mut Context<Self>,+ ) -> anyhow::Result<()> {+ let server = self+ .language_server_for_id(server_id)+ .with_context(|| format!("no server {server_id} found"))?;+ for unreg in params.unregisterations.iter() {+ match unreg.method.as_str() {+ "workspace/didChangeWatchedFiles" => {+ let notify = if let Some(local_lsp_store) = self.as_local_mut() {+ local_lsp_store+ .on_lsp_unregister_did_change_watched_files(server_id, &unreg.id, cx);+ true+ } else {+ false+ };+ if notify {+ notify_server_capabilities_updated(&server, cx);+ }+ }+ "workspace/didChangeConfiguration" => {+ // Ignore payload since we notify clients of setting changes unconditionally, relying on them pulling the latest settings.+ }+ "workspace/didChangeWorkspaceFolders" => {+ self.unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.workspace_folders,+ |capabilities| {+ &mut capabilities+ .workspace+ .get_or_insert_default()+ .workspace_folders+ },+ )?;+ }+ "workspace/symbol" => {+ self.unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.workspace_symbol,+ |capabilities| &mut capabilities.workspace_symbol_provider,+ )?;+ }+ "workspace/fileOperations" => {+ if self+ .unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.file_operations,+ |capabilities| {+ &mut capabilities+ .workspace+ .get_or_insert_default()+ .file_operations+ },+ )?+ .capability_changed()+ {+ self.update_paths_watched_for_rename(&server);+ }+ }+ "workspace/executeCommand" => {+ self.unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.execute_command,+ |capabilities| &mut capabilities.execute_command_provider,+ )?;+ }+ "textDocument/rangeFormatting" => {+ self.unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.range_formatting,+ |capabilities| &mut capabilities.document_range_formatting_provider,+ )?;+ }+ "textDocument/onTypeFormatting" => {+ self.unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.on_type_formatting,+ |capabilities| &mut capabilities.document_on_type_formatting_provider,+ )?;+ }+ "textDocument/formatting" => {+ self.unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.formatting,+ |capabilities| &mut capabilities.document_formatting_provider,+ )?;+ }+ "textDocument/rename" => {+ self.unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.rename,+ |capabilities| &mut capabilities.rename_provider,+ )?;+ }+ "textDocument/codeAction" => {+ self.unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.code_action,+ |capabilities| &mut capabilities.code_action_provider,+ )?;+ }+ "textDocument/definition" => {+ self.unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.definition,+ |capabilities| &mut capabilities.definition_provider,+ )?;+ }+ "textDocument/completion" => {+ if self+ .unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.completion,+ |capabilities| &mut capabilities.completion_provider,+ )?+ .capability_changed()+ {+ let restored = server.capabilities().completion_provider;+ self.apply_completion_triggers(server_id, restored, cx);+ }+ }+ "textDocument/hover" => {+ self.unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.hover,+ |capabilities| &mut capabilities.hover_provider,+ )?;+ }+ "textDocument/signatureHelp" => {+ self.unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.signature_help,+ |capabilities| &mut capabilities.signature_help_provider,+ )?;+ }+ "textDocument/semanticTokens" => {+ if self+ .unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.semantic_tokens,+ |capabilities| &mut capabilities.semantic_tokens_provider,+ )?+ .capability_changed()+ {+ self.refresh_semantic_tokens(server_id, cx);+ }+ }+ "textDocument/didChange" => {+ server.update_capabilities(|capabilities| {+ let mut sync_options = take_text_document_sync_options(capabilities);+ sync_options.change = None;+ capabilities.text_document_sync =+ Some(lsp::TextDocumentSyncCapability::Options(sync_options));+ });+ notify_server_capabilities_updated(&server, cx);+ }+ "textDocument/didSave" => {+ server.update_capabilities(|capabilities| {+ let mut sync_options = take_text_document_sync_options(capabilities);+ sync_options.save = None;+ capabilities.text_document_sync =+ Some(lsp::TextDocumentSyncCapability::Options(sync_options));+ });+ notify_server_capabilities_updated(&server, cx);+ }+ "textDocument/inlayHint" => {+ if self+ .unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.inlay_hint,+ |capabilities| &mut capabilities.inlay_hint_provider,+ )?+ .capability_changed()+ {+ self.refresh_inlay_hints(server_id, cx);+ }+ }+ "textDocument/documentSymbol" => {+ if self+ .unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.document_symbol,+ |capabilities| &mut capabilities.document_symbol_provider,+ )?+ .capability_changed()+ {+ self.refresh_document_symbols(Some(server_id), cx);+ }+ }+ "textDocument/codeLens" => {+ if self+ .unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.code_lens,+ |capabilities| &mut capabilities.code_lens_provider,+ )?+ .capability_changed()+ {+ self.refresh_code_lens(Some(server_id), cx);+ }+ }+ "textDocument/diagnostic" => {+ if self+ .unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.diagnostics,+ |capabilities| &mut capabilities.diagnostic_provider,+ )?+ .removed()+ {+ let local = self+ .as_local_mut()+ .context("Expected LSP Store to be local")?;+ let state = local+ .language_servers+ .get_mut(&server_id)+ .context("Could not obtain Language Servers state")?;+ if let LanguageServerState::Running {+ workspace_diagnostics_refresh_tasks,+ ..+ } = state+ {+ workspace_diagnostics_refresh_tasks.remove(&Some(unreg.id.clone()));+ }++ self.clear_unregistered_diagnostics(+ server_id,+ SharedString::from(unreg.id.clone()),+ cx,+ )?;+ }+ }+ "textDocument/documentColor" => {+ if self+ .unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.color,+ |capabilities| &mut capabilities.color_provider,+ )?+ .capability_changed()+ {+ self.refresh_document_colors(Some(server_id), cx);+ }+ }+ "textDocument/foldingRange" => {+ if self+ .unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.folding_range,+ |capabilities| &mut capabilities.folding_range_provider,+ )?+ .capability_changed()+ {+ self.refresh_folding_ranges(Some(server_id), cx);+ }+ }+ "textDocument/documentLink" => {+ if self+ .unregister_dynamic_capability(+ &server,+ unreg,+ cx,+ |registrations| &mut registrations.document_link,+ |capabilities| &mut capabilities.document_link_provider,+ )?+ .capability_changed()+ {+ self.refresh_document_links(Some(server_id), cx);+ }+ }+ _ => log::warn!("unhandled capability unregistration: {unreg:?}"),+ }+ }++ Ok(())+ }+}++// Registration with registerOptions as null, should fallback to true.+// https://github.com/microsoft/vscode-languageserver-node/blob/d90a87f9557a0df9142cfb33e251cfa6fe27d970/client/src/common/client.ts#L2133+fn parse_register_capabilities<T: serde::de::DeserializeOwned>(+ register_options: Option<serde_json::Value>,+) -> Result<OneOf<bool, T>> {+ Ok(match register_options {+ Some(options) => OneOf::Right(serde_json::from_value::<T>(options)?),+ None => OneOf::Left(true),+ })+}++fn take_text_document_sync_options(+ capabilities: &mut lsp::ServerCapabilities,+) -> lsp::TextDocumentSyncOptions {+ match capabilities.text_document_sync.take() {+ Some(lsp::TextDocumentSyncCapability::Options(sync_options)) => sync_options,+ Some(lsp::TextDocumentSyncCapability::Kind(sync_kind)) => {+ let mut sync_options = lsp::TextDocumentSyncOptions::default();+ sync_options.change = Some(sync_kind);+ sync_options+ }+ None => lsp::TextDocumentSyncOptions::default(),+ }+}diff --git a/crates/project/src/lsp_store/folding_ranges.rs b/crates/project/src/lsp_store/folding_ranges.rsindex 237ba9bbc02..72e7998e810 100644--- a/crates/project/src/lsp_store/folding_ranges.rs+++ b/crates/project/src/lsp_store/folding_ranges.rs@@ -3,19 +3,23 @@ use std::sync::Arc;use std::time::Duration;use anyhow::Context as _;-use clock::Global;-use collections::HashMap;+use collections::{HashMap, HashSet};use futures::FutureExt as _;use futures::future::{Shared, join_all};-use gpui::{AppContext as _, Context, Entity, SharedString, Task};+use gpui::{AppContext as _, AsyncApp, Context, Entity, SharedString, Task};use itertools::Itertools;use language::Buffer;use lsp::LanguageServerId;+use rpc::{TypedEnvelope, proto};use settings::Settings as _;use text::Anchor;+use util::ResultExt as _;use crate::lsp_command::{GetFoldingRanges, LspCommand as _};-use crate::lsp_store::LspStore;+use crate::lsp_store::{+ LspStore, LspStoreEvent, RunningFetch, missing_servers_to_query, next_lsp_fetch_id,+ upstream_lsp_query_server_filter,+};use crate::project_settings::ProjectSettings;#[derive(Clone, Debug)]@@ -30,10 +34,67 @@ pub(super) type FoldingRangeTask =#[derive(Debug, Default)]pub(super) struct FoldingRangeData {pub(super) ranges: HashMap<LanguageServerId, Vec<LspFoldingRange>>,- ranges_update: Option<(Global, FoldingRangeTask)>,+ fetched_servers: HashSet<LanguageServerId>,+ ranges_update: Option<RunningFetch<FoldingRangeTask>>,+}++impl FoldingRangeData {+ pub(super) fn remove_server_data(&mut self, server_id: LanguageServerId) {+ self.ranges.remove(&server_id);+ self.fetched_servers.remove(&server_id);+ RunningFetch::discard_if_queried(&mut self.ranges_update, server_id);+ }++ fn evict(&mut self, for_server: Option<LanguageServerId>) {+ match for_server {+ Some(server_id) => self.remove_server_data(server_id),+ None => {+ self.ranges.clear();+ self.fetched_servers.clear();+ }+ }+ self.ranges_update = None;+ }}impl LspStore {+ pub(super) fn refresh_folding_ranges(+ &mut self,+ for_server: Option<LanguageServerId>,+ cx: &mut Context<Self>,+ ) {+ for lsp_data in self.lsp_data.values_mut() {+ if let Some(folding_ranges) = &mut lsp_data.folding_ranges {+ folding_ranges.evict(for_server);+ }+ }++ cx.emit(LspStoreEvent::RefreshFoldingRanges {+ server_id: for_server,+ });+ if let Some((downstream_client, project_id)) = self.downstream_client.as_ref() {+ downstream_client+ .send(proto::RefreshFoldingRanges {+ project_id: *project_id,+ server_id: for_server.map(|server_id| server_id.to_proto()),+ })+ .context("sending refresh folding ranges downstream")+ .log_err();+ }+ }++ pub(super) async fn handle_refresh_folding_ranges(+ lsp_store: Entity<Self>,+ envelope: TypedEnvelope<proto::RefreshFoldingRanges>,+ mut cx: AsyncApp,+ ) -> anyhow::Result<proto::Ack> {+ lsp_store.update(&mut cx, |lsp_store, cx| {+ let server_id = envelope.payload.server_id.map(LanguageServerId::from_proto);+ lsp_store.refresh_folding_ranges(server_id, cx);+ });+ Ok(proto::Ack {})+ }+/// Returns a task that resolves to the folding ranges for the given buffer.////// Caches results per buffer version so repeated calls for the same version@@ -46,22 +107,20 @@ impl LspStore {let version_queried_for = buffer.read(cx).version();let buffer_id = buffer.read(cx).remote_id();- let current_language_servers = self.as_local().map(|local| {- local- .buffers_opened_in_servers- .get(&buffer_id)- .cloned()- .unwrap_or_default()- });+ let current_servers = self.relevant_server_ids_for_capability_check(buffer, cx);+ let mut servers_to_query = None;if let Some(lsp_data) = self.current_lsp_data(buffer_id) {- if let Some(cached) = &lsp_data.folding_ranges {- if !version_queried_for.changed_since(&lsp_data.buffer_version) {- let has_different_servers =- current_language_servers.is_some_and(|current_language_servers| {- current_language_servers != cached.ranges.keys().copied().collect()- });- if !has_different_servers {+ if !version_queried_for.changed_since(&lsp_data.buffer_version)+ && let Some(cached) = &mut lsp_data.folding_ranges+ {+ match missing_servers_to_query(+ &mut cached.ranges,+ &mut cached.fetched_servers,+ ¤t_servers,+ ) {+ Some(missing_servers) => servers_to_query = Some(missing_servers),+ None => {let snapshot = buffer.read(cx).snapshot();return Task::ready(cached@@ -75,80 +134,101 @@ impl LspStore {}}}+ if let Some(folding_ranges) = &lsp_data.folding_ranges+ && let Some(running) = &folding_ranges.ranges_update+ && !version_queried_for.changed_since(&running.version)+ && servers_to_query+ .as_ref()+ .is_none_or(|missing| missing.is_subset(&running.servers))+ {+ let running = running.task.clone();+ return cx.background_spawn(async move { running.await.unwrap_or_default() });+ }}let folding_lsp_data = self.latest_lsp_data(buffer, cx).folding_ranges.get_or_insert_default();- if let Some((updating_for, running_update)) = &folding_lsp_data.ranges_update {- if !version_queried_for.changed_since(updating_for) {- let running = running_update.clone();- return cx.background_spawn(async move { running.await.unwrap_or_default() });- }- }-+ let fetch_id = next_lsp_fetch_id();+ let queried_servers = servers_to_query+ .clone()+ .unwrap_or_else(|| current_servers.clone());let buffer = buffer.clone();let query_version = version_queried_for.clone();let new_task = cx- .spawn(async move |lsp_store, cx| {- cx.background_executor()- .timer(Duration::from_millis(30))- .await;-- let fetched = lsp_store- .update(cx, |lsp_store, cx| {- lsp_store.fetch_folding_ranges_for_buffer(&buffer, cx)- })- .map_err(Arc::new)?- .await- .context("fetching folding ranges")- .map_err(Arc::new);-- let fetched = match fetched {- Ok(fetched) => fetched,- Err(e) => {- lsp_store- .update(cx, |lsp_store, _| {- if let Some(lsp_data) = lsp_store.lsp_data.get_mut(&buffer_id) {- if let Some(folding_ranges) = &mut lsp_data.folding_ranges {- folding_ranges.ranges_update = None;+ .spawn({+ let queried_servers = queried_servers.clone();+ async move |lsp_store, cx| {+ cx.background_executor()+ .timer(Duration::from_millis(30))+ .await;++ let fetched = lsp_store+ .update(cx, |lsp_store, cx| {+ lsp_store.fetch_folding_ranges_for_buffer(&buffer, servers_to_query, cx)+ })+ .map_err(Arc::new)?+ .await+ .context("fetching folding ranges")+ .map_err(Arc::new);++ let fetched = match fetched {+ Ok(fetched) => fetched,+ Err(e) => {+ lsp_store+ .update(cx, |lsp_store, _| {+ if let Some(lsp_data) = lsp_store.lsp_data.get_mut(&buffer_id)+ && let Some(folding_ranges) = &mut lsp_data.folding_ranges+ {+ RunningFetch::take_finished(+ &mut folding_ranges.ranges_update,+ fetch_id,+ );}- }- })- .ok();- return Err(e);- }- };+ })+ .ok();+ return Err(e);+ }+ };++ lsp_store+ .update(cx, |lsp_store, cx| {+ let lsp_data = lsp_store.latest_lsp_data(&buffer, cx);+ let folding = lsp_data.folding_ranges.get_or_insert_default();- lsp_store- .update(cx, |lsp_store, cx| {- let lsp_data = lsp_store.latest_lsp_data(&buffer, cx);- let folding = lsp_data.folding_ranges.get_or_insert_default();-- if let Some(fetched_ranges) = fetched {- if lsp_data.buffer_version == query_version {- folding.ranges.extend(fetched_ranges);- } else if !lsp_data.buffer_version.changed_since(&query_version) {- lsp_data.buffer_version = query_version;- folding.ranges = fetched_ranges;+ if RunningFetch::take_finished(&mut folding.ranges_update, fetch_id)+ && let Some(fetched_ranges) = fetched+ {+ if lsp_data.buffer_version == query_version {+ folding.ranges.extend(fetched_ranges);+ folding.fetched_servers.extend(queried_servers);+ } else if !lsp_data.buffer_version.changed_since(&query_version) {+ lsp_data.buffer_version = query_version;+ folding.ranges = fetched_ranges;+ folding.fetched_servers = queried_servers;+ }}- }- folding.ranges_update = None;- let snapshot = buffer.read(cx).snapshot();- folding- .ranges- .values()- .flatten()- .cloned()- .sorted_by(|a, b| a.range.start.cmp(&b.range.start, &snapshot))- .collect()- })- .map_err(Arc::new)+ let snapshot = buffer.read(cx).snapshot();+ folding+ .ranges+ .values()+ .flatten()+ .cloned()+ .sorted_by(|a, b| a.range.start.cmp(&b.range.start, &snapshot))+ .collect()+ })+ .map_err(Arc::new)+ }}).shared();- folding_lsp_data.ranges_update = Some((version_queried_for, new_task.clone()));+ folding_lsp_data.ranges_update = Some(RunningFetch {+ id: fetch_id,+ version: version_queried_for,+ servers: queried_servers,+ task: new_task.clone(),+ });cx.background_spawn(async move { new_task.await.unwrap_or_default() })}@@ -156,6 +236,7 @@ impl LspStore {fn fetch_folding_ranges_for_buffer(&mut self,buffer: &Entity<Buffer>,+ for_servers: Option<HashSet<LanguageServerId>>,cx: &mut Context<Self>,) -> Task<anyhow::Result<Option<HashMap<LanguageServerId, Vec<LspFoldingRange>>>>> {if let Some((client, project_id)) = self.upstream_client() {@@ -169,7 +250,7 @@ impl LspStore {.get_request_timeout();let request_task = client.request_lsp(project_id,- None,+ upstream_lsp_query_server_filter(for_servers.as_ref()),request_timeout,cx.background_executor().clone(),request.to_proto(project_id, buffer.read(cx)),@@ -217,8 +298,13 @@ impl LspStore {Ok(Some(result))})} else {- let folding_task =- self.request_multiple_lsp_locally(buffer, None::<usize>, GetFoldingRanges, cx);+ let folding_task = self.request_filtered_lsp_locally(+ buffer,+ None::<usize>,+ GetFoldingRanges,+ for_servers.as_ref(),+ cx,+ );cx.background_spawn(async move { Ok(Some(folding_task.await.into_iter().collect())) })}}diff --git a/crates/project/src/lsp_store/inlay_hints.rs b/crates/project/src/lsp_store/inlay_hints.rsindex a5fddd11f41..e688b163040 100644--- a/crates/project/src/lsp_store/inlay_hints.rs+++ b/crates/project/src/lsp_store/inlay_hints.rs@@ -1,7 +1,7 @@use std::{collections::hash_map, ops::Range, sync::Arc};use anyhow::{Context as _, Result};-use collections::HashMap;+use collections::{HashMap, HashSet};use futures::future::Shared;use gpui::{App, AppContext as _, AsyncApp, Context, Entity, Task};use language::{@@ -12,6 +12,7 @@ use lsp::LanguageServerId;use rpc::{TypedEnvelope, proto};use settings::Settings as _;use text::{BufferId, Point};+use util::ResultExt as _;use crate::{InlayHint, InlayId, LspStore, LspStoreEvent, ResolveState, lsp_command::InlayHints,@@ -28,10 +29,7 @@ pub enum InvalidationStrategy {/// Demands to re-query all inlay hints needed and invalidate all cached entries, but does not require instant update with invalidation.////// Despite nothing forbids language server from sending this request on every edit, it is expected to be sent only when certain internal server state update, invisible for the editor otherwise.- RefreshRequested {- server_id: LanguageServerId,- request_id: Option<usize>,- },+ RefreshRequested { server_id: LanguageServerId },/// Multibuffer excerpt(s) and/or singleton buffer(s) were edited at least on one place./// Neither editor nor LSP is able to tell which open file hints' are not affected, so all of them have to be invalidated, re-queried and do that fast enough to avoid being slow, but also debounce to avoid loading hints on every fast keystroke sequence.BufferEdited,@@ -58,7 +56,8 @@ pub struct BufferInlayHints {hints_by_chunks: Vec<Option<CacheInlayHints>>,fetches_by_chunks: Vec<Option<CacheInlayHintsTask>>,hints_by_id: HashMap<InlayId, HintForId>,- latest_invalidation_requests: HashMap<LanguageServerId, Option<usize>>,+ pending_refreshes: HashSet<LanguageServerId>,+ work_end_refreshes: HashSet<LanguageServerId>,pub(super) hint_resolves: HashMap<InlayId, Shared<Task<()>>>,}@@ -89,7 +88,8 @@ impl BufferInlayHints {Self {hints_by_chunks: vec![None; chunks.len()],fetches_by_chunks: vec![None; chunks.len()],- latest_invalidation_requests: HashMap::default(),+ pending_refreshes: HashSet::default(),+ work_end_refreshes: HashSet::default(),hints_by_id: HashMap::default(),hint_resolves: HashMap::default(),chunks,@@ -135,6 +135,27 @@ impl BufferInlayHints {}}}+ self.pending_refreshes.remove(&for_server);+ self.work_end_refreshes.remove(&for_server);+ }++ fn mark_refresh_pending(&mut self, server_id: LanguageServerId) {+ self.pending_refreshes.insert(server_id);+ self.work_end_refreshes.insert(server_id);+ }++ /// A server finishing a long-running operation may have produced new hints without+ /// requesting an explicit refresh, but servers like rust-analyzer report work (e.g.+ /// flycheck) after every save: refresh at most once per server until the buffer+ /// changes. Explicit refresh requests also count against this limit, as they make a+ /// subsequent work-end refresh redundant.+ fn mark_refresh_pending_on_work_end(&mut self, server_id: LanguageServerId) -> bool {+ if self.work_end_refreshes.insert(server_id) {+ self.pending_refreshes.insert(server_id);+ true+ } else {+ false+ }}pub fn clear(&mut self) {@@ -142,7 +163,8 @@ impl BufferInlayHints {self.fetches_by_chunks = vec![None; self.chunks.len()];self.hints_by_id.clear();self.hint_resolves.clear();- self.latest_invalidation_requests.clear();+ self.pending_refreshes.clear();+ self.work_end_refreshes.clear();}pub fn insert_new_hints(@@ -186,22 +208,12 @@ impl BufferInlayHints {Some(hint)}- pub(crate) fn invalidate_for_server_refresh(- &mut self,- for_server: LanguageServerId,- request_id: Option<usize>,- ) -> bool {- match self.latest_invalidation_requests.entry(for_server) {- hash_map::Entry::Occupied(mut o) => {- if request_id > *o.get() {- o.insert(request_id);- } else {- return false;- }- }- hash_map::Entry::Vacant(v) => {- v.insert(request_id);- }+ /// Consumes a pending refresh for the given server, if any, invalidating its cached+ /// hints: only the first query after [`LspStore::refresh_inlay_hints`] invalidates,+ /// while concurrent queriers share the re-fetch it has started.+ pub(crate) fn invalidate_for_server_refresh(&mut self, for_server: LanguageServerId) -> bool {+ if !self.pending_refreshes.remove(&for_server) {+ return false;}for (chunk_id, chunk_data) in self.hints_by_chunks.iter_mut().enumerate() {@@ -299,16 +311,63 @@ impl LspStore {}}+ /// Marks the server's inlay hints as refresh-pending in every buffer, to be+ /// invalidated by the next query, and notifies the observers.+ pub(super) fn refresh_inlay_hints(+ &mut self,+ server_id: LanguageServerId,+ cx: &mut Context<Self>,+ ) {+ self.mark_inlay_hints_refresh_pending(server_id, cx);+ if let Some((downstream_client, project_id)) = self.downstream_client.as_ref() {+ downstream_client+ .send(proto::RefreshInlayHints {+ project_id: *project_id,+ server_id: server_id.to_proto(),+ request_id: Some(super::next_wire_refresh_request_id()),+ })+ .context("sending refresh inlay hints downstream")+ .log_err();+ }+ }++ pub(super) fn mark_inlay_hints_refresh_pending(+ &mut self,+ server_id: LanguageServerId,+ cx: &mut Context<Self>,+ ) {+ for lsp_data in self.lsp_data.values_mut() {+ lsp_data.inlay_hints.mark_refresh_pending(server_id);+ }+ cx.emit(LspStoreEvent::RefreshInlayHints { server_id });+ }++ /// Same as [`Self::mark_inlay_hints_refresh_pending`], but rate-limited per server+ /// via [`BufferInlayHints::mark_refresh_pending_on_work_end`].+ pub(super) fn refresh_inlay_hints_on_work_end(+ &mut self,+ server_id: LanguageServerId,+ cx: &mut Context<Self>,+ ) {+ let mut marked = false;+ for lsp_data in self.lsp_data.values_mut() {+ marked |= lsp_data+ .inlay_hints+ .mark_refresh_pending_on_work_end(server_id);+ }+ if marked {+ cx.emit(LspStoreEvent::RefreshInlayHints { server_id });+ }+ }+pub(super) async fn handle_refresh_inlay_hints(lsp_store: Entity<Self>,envelope: TypedEnvelope<proto::RefreshInlayHints>,mut cx: AsyncApp,) -> Result<proto::Ack> {- lsp_store.update(&mut cx, |_, cx| {- cx.emit(LspStoreEvent::RefreshInlayHints {- server_id: LanguageServerId::from_proto(envelope.payload.server_id),- request_id: envelope.payload.request_id.map(|id| id as usize),- });+ lsp_store.update(&mut cx, |lsp_store, cx| {+ lsp_store+ .refresh_inlay_hints(LanguageServerId::from_proto(envelope.payload.server_id), cx);});Ok(proto::Ack {})}diff --git a/crates/project/src/lsp_store/semantic_tokens.rs b/crates/project/src/lsp_store/semantic_tokens.rsindex 25617e3ad82..e4fafcfcaf7 100644--- a/crates/project/src/lsp_store/semantic_tokens.rs+++ b/crates/project/src/lsp_store/semantic_tokens.rs@@ -3,7 +3,7 @@ use std::{collections::hash_map, ops::Range, slice::ChunksExact, sync::Arc};use anyhow::Result;use clock::Global;-use collections::HashMap;+use collections::{HashMap, HashSet};use futures::{FutureExt as _,future::{Shared, join_all},@@ -80,50 +80,27 @@ impl SemanticTokenConfig {}}-#[derive(Debug, Clone, Copy)]-pub struct RefreshForServer {- pub server_id: LanguageServerId,- pub request_id: Option<usize>,-}-impl LspStore {pub fn semantic_tokens(&mut self,buffer: Entity<Buffer>,- refresh: Option<RefreshForServer>,cx: &mut Context<Self>,) -> SemanticTokensTask {let version_queried_for = buffer.read(cx).version();let latest_lsp_data = self.latest_lsp_data(&buffer, cx);let semantic_tokens_data = latest_lsp_data.semantic_tokens.get_or_insert_default();- if let Some(refresh) = refresh {- let mut invalidate_cache = true;- match semantic_tokens_data- .latest_invalidation_requests- .entry(refresh.server_id)- {- hash_map::Entry::Occupied(mut o) => {- if refresh.request_id > *o.get() {- o.insert(refresh.request_id);- } else {- invalidate_cache = false;- }- }- hash_map::Entry::Vacant(v) => {- v.insert(refresh.request_id);- }- }-- if invalidate_cache {- let SemanticTokensData {- raw_tokens,- latest_invalidation_requests: _,- update,- } = semantic_tokens_data;- *update = None;- raw_tokens.servers.clear();- }+ let refreshed_servers = std::mem::take(&mut semantic_tokens_data.pending_refreshes);+ if !refreshed_servers.is_empty() {+ semantic_tokens_data.update = None;+ semantic_tokens_data.generation += 1;}+ for refreshed_server in &refreshed_servers {+ semantic_tokens_data+ .raw_tokens+ .servers+ .remove(refreshed_server);+ }+ let query_generation = semantic_tokens_data.generation;if let Some((updating_for, task)) = &semantic_tokens_data.update&& !version_queried_for.changed_since(updating_for)@@ -131,11 +108,15 @@ impl LspStore {return task.clone();}- let new_tokens = self.fetch_semantic_tokens_for_buffer(- &buffer,- refresh.map(|refresh| refresh.server_id),- cx,- );+ let for_server = if refreshed_servers.len() == 1 {+ refreshed_servers.iter().next().copied()+ } else {+ // With multiple servers refreshed, query all of them instead of fanning out+ // filtered queries — the non-refreshed ones kept their tokens and answer+ // with cheap deltas.+ None+ };+ let new_tokens = self.fetch_semantic_tokens_for_buffer(&buffer, for_server, cx);let task_buffer = buffer.clone();let task_version_queried_for = version_queried_for.clone();@@ -150,7 +131,9 @@ impl LspStore {let semantic_tokens_data =lsp_data.semantic_tokens.get_or_insert_default();- if version_queried_for == lsp_data.buffer_version {+ if version_queried_for == lsp_data.buffer_version+ && semantic_tokens_data.generation == query_generation+ {for (server_id, new_tokens_response) in new_tokens {match new_tokens_response {SemanticTokensResponse::Full { data, result_id } => {@@ -191,10 +174,11 @@ impl LspStore {lsp_store.update(cx, |lsp_store, cx| {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{- if current_lsp_data.buffer_version == version_queried_for {- current_lsp_data.semantic_tokens = None;- }+ semantic_tokens.evict_all();}})?;None@@ -351,24 +335,25 @@ impl LspStore {}}- /// `request_id` orders per-server refreshes (a higher id invalidates the cache).- /// Client-initiated refreshes (e.g. after dynamic registration) pass `None`.+ /// Marks the server's semantic tokens as refresh-pending in every buffer, to be+ /// invalidated by the next query, and notifies the observers.pub(crate) fn refresh_semantic_tokens(&mut self,server_id: LanguageServerId,- request_id: Option<usize>,cx: &mut Context<Self>,) {- cx.emit(LspStoreEvent::RefreshSemanticTokens {- server_id,- request_id,- });+ for lsp_data in self.lsp_data.values_mut() {+ if let Some(semantic_tokens) = &mut lsp_data.semantic_tokens {+ semantic_tokens.pending_refreshes.insert(server_id);+ }+ }+ cx.emit(LspStoreEvent::RefreshSemanticTokens { server_id });if let Some((client, project_id)) = self.downstream_client.as_ref() {client.send(proto::RefreshSemanticTokens {project_id: *project_id,server_id: server_id.to_proto(),- request_id: request_id.map(|id| id as u64),+ request_id: Some(super::next_wire_refresh_request_id()),}).log_err();}@@ -379,15 +364,56 @@ impl LspStore {envelope: TypedEnvelope<proto::RefreshSemanticTokens>,mut cx: AsyncApp,) -> Result<proto::Ack> {- lsp_store.update(&mut cx, |_, cx| {- cx.emit(LspStoreEvent::RefreshSemanticTokens {- server_id: LanguageServerId::from_proto(envelope.payload.server_id),- request_id: envelope.payload.request_id.map(|id| id as usize),- });+ lsp_store.update(&mut cx, |lsp_store, cx| {+ lsp_store.refresh_semantic_tokens(+ LanguageServerId::from_proto(envelope.payload.server_id),+ cx,+ );});Ok(proto::Ack {})}+ #[cfg(any(test, feature = "test-support"))]+ pub fn semantic_token_servers(&self, buffer_id: text::BufferId) -> Vec<LanguageServerId> {+ let mut servers = self+ .lsp_data+ .get(&buffer_id)+ .and_then(|lsp_data| lsp_data.semantic_tokens.as_ref())+ .map(|semantic_tokens| {+ semantic_tokens+ .raw_tokens+ .servers+ .keys()+ .copied()+ .collect::<Vec<_>>()+ })+ .unwrap_or_default();+ servers.sort();+ servers+ }++ #[cfg(any(test, feature = "test-support"))]+ pub fn semantic_token_data(+ &self,+ buffer_id: text::BufferId,+ ) -> Vec<(LanguageServerId, Vec<u32>)> {+ let mut data = self+ .lsp_data+ .get(&buffer_id)+ .and_then(|lsp_data| lsp_data.semantic_tokens.as_ref())+ .map(|semantic_tokens| {+ semantic_tokens+ .raw_tokens+ .servers+ .iter()+ .map(|(server_id, tokens)| (*server_id, tokens.data.clone()))+ .collect::<Vec<_>>()+ })+ .unwrap_or_default();+ data.sort_by_key(|(server_id, _)| *server_id);+ data+ }+fn semantic_tokens_result_id(&mut self,server_id: LanguageServerId,@@ -629,15 +655,25 @@ async fn raw_to_buffer_semantic_tokens(#[derive(Default, Debug)]pub struct SemanticTokensData {pub(super) raw_tokens: RawSemanticTokens,- pub(super) latest_invalidation_requests: HashMap<LanguageServerId, Option<usize>>,+ pub(super) pending_refreshes: HashSet<LanguageServerId>,update: Option<(Global, SemanticTokensTask)>,+ /// Bumped on every eviction so that fetches started against the evicted state+ /// cannot write their stale results into the new one.+ generation: u64,}impl SemanticTokensData {pub(super) fn remove_server_data(&mut self, server_id: LanguageServerId) {self.raw_tokens.servers.remove(&server_id);- self.latest_invalidation_requests.remove(&server_id);+ self.pending_refreshes.remove(&server_id);+ self.update = None;+ self.generation += 1;+ }++ fn evict_all(&mut self) {+ self.raw_tokens.servers.clear();self.update = None;+ self.generation += 1;}}diff --git a/crates/project/src/project.rs b/crates/project/src/project.rsindex f7d792a7f2a..fd5954a99e7 100644--- a/crates/project/src/project.rs+++ b/crates/project/src/project.rs@@ -398,13 +398,25 @@ pub enum Event {Rejoined,RefreshInlayHints {server_id: LanguageServerId,- request_id: Option<usize>,},RefreshSemanticTokens {server_id: LanguageServerId,- request_id: Option<usize>,},- RefreshCodeLens,+ RefreshCodeLens {+ server_id: Option<LanguageServerId>,+ },+ RefreshDocumentColors {+ server_id: Option<LanguageServerId>,+ },+ RefreshDocumentLinks {+ server_id: Option<LanguageServerId>,+ },+ RefreshFoldingRanges {+ server_id: Option<LanguageServerId>,+ },+ RefreshDocumentSymbols {+ server_id: Option<LanguageServerId>,+ },RevealInProjectPanel(ProjectEntryId),SnippetEdit(BufferId, Vec<(lsp::Range, Snippet)>),ExpandedAllForEntry(WorktreeId, ProjectEntryId),@@ -3666,21 +3678,37 @@ impl Project {return;};}- LspStoreEvent::RefreshInlayHints {- server_id,- request_id,- } => cx.emit(Event::RefreshInlayHints {+ LspStoreEvent::RefreshInlayHints { server_id } => cx.emit(Event::RefreshInlayHints {server_id: *server_id,- request_id: *request_id,}),- LspStoreEvent::RefreshSemanticTokens {- server_id,- request_id,- } => cx.emit(Event::RefreshSemanticTokens {+ LspStoreEvent::RefreshSemanticTokens { server_id } => {+ cx.emit(Event::RefreshSemanticTokens {+ server_id: *server_id,+ })+ }+ LspStoreEvent::RefreshCodeLens { server_id } => cx.emit(Event::RefreshCodeLens {server_id: *server_id,- request_id: *request_id,}),- LspStoreEvent::RefreshCodeLens => cx.emit(Event::RefreshCodeLens),+ LspStoreEvent::RefreshDocumentColors { server_id } => {+ cx.emit(Event::RefreshDocumentColors {+ server_id: *server_id,+ })+ }+ LspStoreEvent::RefreshDocumentLinks { server_id } => {+ cx.emit(Event::RefreshDocumentLinks {+ server_id: *server_id,+ })+ }+ LspStoreEvent::RefreshFoldingRanges { server_id } => {+ cx.emit(Event::RefreshFoldingRanges {+ server_id: *server_id,+ })+ }+ LspStoreEvent::RefreshDocumentSymbols { server_id } => {+ cx.emit(Event::RefreshDocumentSymbols {+ server_id: *server_id,+ })+ }LspStoreEvent::LanguageServerPrompt(prompt) => {cx.emit(Event::LanguageServerPrompt(prompt.clone()))}diff --git a/crates/project/tests/integration/dynamic_registration.rs b/crates/project/tests/integration/dynamic_registration.rsnew file mode 100644index 00000000000..0dcfd708d41--- /dev/null+++ b/crates/project/tests/integration/dynamic_registration.rs@@ -0,0 +1,1880 @@+//! Tests for dynamic (un)registration of language server capabilities, handled in+//! `project::lsp_store::dynamic_registration`.++use pretty_assertions::assert_eq;++use super::*;++#[gpui::test]+async fn test_dynamic_semantic_tokens_registration(cx: &mut gpui::TestAppContext) {+ init_test(cx);++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(+ path!("/the-root"),+ json!({+ "a.rs": "fn main() {}",+ }),+ )+ .await;++ let project = Project::test(fs.clone(), [path!("/the-root").as_ref()], cx).await;+ let language_registry = project.read_with(cx, |project, _| project.languages().clone());+ language_registry.add(rust_lang());+ let mut fake_servers = language_registry.register_fake_lsp(+ "Rust",+ FakeLspAdapter {+ name: "the-language-server",+ // Crucially, no `semantic_tokens_provider` is advertised statically; the+ // server only offers it through dynamic registration (as Roslyn does).+ ..FakeLspAdapter::default()+ },+ );++ let _buffer = project+ .update(cx, |project, cx| {+ project.open_local_buffer_with_lsp(path!("/the-root/a.rs"), cx)+ })+ .await+ .unwrap();++ let fake_server = fake_servers.next().await.unwrap();+ let server_id = fake_server.server.server_id();+ cx.executor().run_until_parked();++ let semantic_tokens_provider = |cx: &mut gpui::TestAppContext| {+ project.read_with(cx, |project, cx| {+ project+ .lsp_store()+ .read(cx)+ .lsp_server_capabilities+ .get(&server_id)+ .and_then(|capabilities| capabilities.semantic_tokens_provider.clone())+ })+ };++ assert!(+ semantic_tokens_provider(cx).is_none(),+ "server should not advertise semantic tokens before dynamic registration"+ );++ fake_server+ .request::<lsp::request::RegisterCapability>(+ lsp::RegistrationParams {+ registrations: vec![lsp::Registration {+ id: "semantic-tokens".to_string(),+ method: "textDocument/semanticTokens".to_string(),+ register_options: 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(), "variable".into()],+ token_modifiers: vec![],+ },+ full: Some(lsp::SemanticTokensFullOptions::Bool(true)),+ ..lsp::SemanticTokensOptions::default()+ },+ static_registration_options: lsp::StaticRegistrationOptions {+ id: None,+ },+ },+ )+ .ok(),+ }],+ },+ DEFAULT_LSP_REQUEST_TIMEOUT,+ )+ .await+ .into_response()+ .unwrap();+ cx.executor().run_until_parked();++ let provider = semantic_tokens_provider(cx)+ .expect("semantic tokens provider should be set after dynamic registration");+ // The capability round-trips through capability-sync serialization, which may+ // normalize the registration options into plain options; either shape is fine+ // as long as the legend survives.+ let legend = match provider {+ lsp::SemanticTokensServerCapabilities::SemanticTokensOptions(options) => options.legend,+ lsp::SemanticTokensServerCapabilities::SemanticTokensRegistrationOptions(options) => {+ options.semantic_tokens_options.legend+ }+ };+ assert_eq!(+ legend.token_types,+ vec!["keyword".into(), "variable".into()],+ );++ fake_server+ .request::<lsp::request::UnregisterCapability>(+ lsp::UnregistrationParams {+ unregisterations: vec![lsp::Unregistration {+ id: "semantic-tokens".to_string(),+ method: "textDocument/semanticTokens".to_string(),+ }],+ },+ DEFAULT_LSP_REQUEST_TIMEOUT,+ )+ .await+ .into_response()+ .unwrap();+ cx.executor().run_until_parked();++ assert!(+ semantic_tokens_provider(cx).is_none(),+ "semantic tokens provider should be cleared after unregistration"+ );+}++#[gpui::test]+async fn test_multi_registration_inlay_hint(cx: &mut gpui::TestAppContext) {+ init_test(cx);+ let (project, fake_server) =+ setup_dynamic_registration_test(cx, lsp::ServerCapabilities::default()).await;+ let server_id = fake_server.server.server_id();+ let method = "textDocument/inlayHint";++ let options_a = lsp::InlayHintOptions {+ resolve_provider: Some(true),+ ..lsp::InlayHintOptions::default()+ };+ let options_b = lsp::InlayHintOptions {+ resolve_provider: Some(false),+ ..lsp::InlayHintOptions::default()+ };++ assert_eq!(+ server_capabilities(&project, server_id, cx).inlay_hint_provider,+ None,+ "expected no inlay hint provider before any registration",+ );++ register_capability(+ &fake_server,+ method,+ "inlay-hint-a",+ serde_json::to_value(&options_a).ok(),+ )+ .await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).inlay_hint_provider,+ Some(lsp::OneOf::Right(+ lsp::InlayHintServerCapabilities::Options(options_a.clone())+ )),+ "expected the first registration's options after the first registration",+ );++ register_capability(+ &fake_server,+ method,+ "inlay-hint-b",+ serde_json::to_value(&options_b).ok(),+ )+ .await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).inlay_hint_provider,+ Some(lsp::OneOf::Right(+ lsp::InlayHintServerCapabilities::Options(options_b)+ )),+ "expected the second registration's options after the second registration",+ );++ unregister_capabilities(&fake_server, method, &["inlay-hint-b"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).inlay_hint_provider,+ Some(lsp::OneOf::Right(+ lsp::InlayHintServerCapabilities::Options(options_a)+ )),+ "expected the remaining registration's options to be restored",+ );++ unregister_capabilities(&fake_server, method, &["inlay-hint-a"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).inlay_hint_provider,+ None,+ "expected inlay hint provider to be cleared after unregistering the last registration",+ );+}++#[gpui::test]+async fn test_multi_registration_code_lens(cx: &mut gpui::TestAppContext) {+ init_test(cx);+ let (project, fake_server) =+ setup_dynamic_registration_test(cx, lsp::ServerCapabilities::default()).await;+ let server_id = fake_server.server.server_id();+ let method = "textDocument/codeLens";++ let options_a = lsp::CodeLensOptions {+ resolve_provider: Some(true),+ };+ let options_b = lsp::CodeLensOptions {+ resolve_provider: Some(false),+ };++ assert_eq!(+ server_capabilities(&project, server_id, cx).code_lens_provider,+ None,+ "expected no code lens provider before any registration",+ );++ register_capability(+ &fake_server,+ method,+ "code-lens-a",+ serde_json::to_value(options_a).ok(),+ )+ .await;+ register_capability(+ &fake_server,+ method,+ "code-lens-b",+ serde_json::to_value(options_b).ok(),+ )+ .await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).code_lens_provider,+ Some(options_b),+ "expected the second registration's options after two registrations",+ );++ unregister_capabilities(&fake_server, method, &["code-lens-b"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).code_lens_provider,+ Some(options_a),+ "expected the remaining registration's options to be restored",+ );++ unregister_capabilities(&fake_server, method, &["code-lens-a"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).code_lens_provider,+ None,+ "expected code lens provider to be cleared after unregistering the last registration",+ );+}++#[gpui::test]+async fn test_multi_registration_document_symbol(cx: &mut gpui::TestAppContext) {+ init_test(cx);+ let (project, fake_server) =+ setup_dynamic_registration_test(cx, lsp::ServerCapabilities::default()).await;+ let server_id = fake_server.server.server_id();+ let method = "textDocument/documentSymbol";++ let options_b = lsp::DocumentSymbolOptions {+ label: Some("custom".to_string()),+ work_done_progress_options: lsp::WorkDoneProgressOptions::default(),+ };++ assert_eq!(+ server_capabilities(&project, server_id, cx).document_symbol_provider,+ None,+ "expected no document symbol provider before any registration",+ );++ register_capability(&fake_server, method, "document-symbol-a", None).await;+ register_capability(+ &fake_server,+ method,+ "document-symbol-b",+ serde_json::to_value(&options_b).ok(),+ )+ .await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).document_symbol_provider,+ Some(lsp::OneOf::Right(options_b)),+ "expected the second registration's options after two registrations",+ );++ unregister_capabilities(&fake_server, method, &["document-symbol-b"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).document_symbol_provider,+ Some(lsp::OneOf::Left(true)),+ "expected the remaining registration's options to be restored",+ );++ unregister_capabilities(&fake_server, method, &["document-symbol-a"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).document_symbol_provider,+ None,+ "expected document symbol provider to be cleared after unregistering the last registration",+ );+}++#[gpui::test]+async fn test_multi_registration_restores_static_capability(cx: &mut gpui::TestAppContext) {+ init_test(cx);+ let (project, fake_server) = setup_dynamic_registration_test(+ cx,+ lsp::ServerCapabilities {+ inlay_hint_provider: Some(lsp::OneOf::Left(true)),+ ..lsp::ServerCapabilities::default()+ },+ )+ .await;+ let server_id = fake_server.server.server_id();+ let method = "textDocument/inlayHint";++ assert_eq!(+ server_capabilities(&project, server_id, cx).inlay_hint_provider,+ Some(lsp::OneOf::Left(true)),+ "expected the statically declared inlay hint provider before any dynamic registration",+ );++ let dynamic_options = lsp::InlayHintOptions {+ resolve_provider: Some(true),+ ..lsp::InlayHintOptions::default()+ };+ register_capability(+ &fake_server,+ method,+ "inlay-hint-dynamic",+ serde_json::to_value(&dynamic_options).ok(),+ )+ .await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).inlay_hint_provider,+ Some(lsp::OneOf::Right(+ lsp::InlayHintServerCapabilities::Options(dynamic_options)+ )),+ "expected the dynamic registration's options to override the static capability",+ );++ unregister_capabilities(&fake_server, method, &["unknown-id", "inlay-hint-dynamic"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).inlay_hint_provider,+ Some(lsp::OneOf::Left(true)),+ "expected the static capability to be restored after unregistering the last dynamic registration, despite an unknown ID earlier in the batch",+ );+}++#[gpui::test]+async fn test_multi_registration_duplicate_id_keeps_order(cx: &mut gpui::TestAppContext) {+ init_test(cx);+ let (project, fake_server) =+ setup_dynamic_registration_test(cx, lsp::ServerCapabilities::default()).await;+ let server_id = fake_server.server.server_id();+ let method = "textDocument/inlayHint";++ let options_a = lsp::InlayHintOptions {+ resolve_provider: Some(true),+ ..lsp::InlayHintOptions::default()+ };+ let options_b = lsp::InlayHintOptions {+ resolve_provider: Some(false),+ ..lsp::InlayHintOptions::default()+ };+ let options_a_replacement = lsp::InlayHintOptions::default();++ let (refresh_events, _refresh_events_subscription) = observe_refresh_events(&project, cx);+ register_capability(+ &fake_server,+ method,+ "inlay-hint-a",+ serde_json::to_value(&options_a).ok(),+ )+ .await;+ register_capability(+ &fake_server,+ method,+ "inlay-hint-b",+ serde_json::to_value(&options_b).ok(),+ )+ .await;+ cx.executor().run_until_parked();+ assert_eq!(+ refresh_events.lock().drain(..).collect::<Vec<_>>(),+ vec![+ format!("inlay_hints({server_id})"),+ format!("inlay_hints({server_id})"),+ ],+ "expected both registrations to trigger a refresh",+ );++ register_capability(+ &fake_server,+ method,+ "inlay-hint-a",+ serde_json::to_value(&options_a_replacement).ok(),+ )+ .await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).inlay_hint_provider,+ Some(lsp::OneOf::Right(+ lsp::InlayHintServerCapabilities::Options(options_b)+ )),+ "expected the latest distinct registration to stay active after a duplicate ID replaced an older one",+ );+ assert_eq!(+ refresh_events.lock().as_slice(),+ &[] as &[String],+ "expected no refresh after a duplicate ID replaced an inactive registration",+ );++ unregister_capabilities(&fake_server, method, &["inlay-hint-b"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).inlay_hint_provider,+ Some(lsp::OneOf::Right(+ lsp::InlayHintServerCapabilities::Options(options_a_replacement)+ )),+ "expected the replaced registration's options to be restored",+ );++ unregister_capabilities(&fake_server, method, &["inlay-hint-a"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).inlay_hint_provider,+ None,+ "expected inlay hint provider to be cleared after unregistering the last registration",+ );+}++#[gpui::test]+async fn test_registration_with_unchanged_options_does_not_refresh(cx: &mut gpui::TestAppContext) {+ init_test(cx);+ let (project, fake_server) =+ setup_dynamic_registration_test(cx, lsp::ServerCapabilities::default()).await;+ let server_id = fake_server.server.server_id();+ let method = "textDocument/codeLens";++ let options = lsp::CodeLensOptions {+ resolve_provider: Some(true),+ };++ let (refresh_events, _refresh_events_subscription) = observe_refresh_events(&project, cx);+ register_capability(+ &fake_server,+ method,+ "lens-a",+ serde_json::to_value(options).ok(),+ )+ .await;+ cx.executor().run_until_parked();+ assert_eq!(+ refresh_events.lock().drain(..).collect::<Vec<_>>(),+ vec![format!("code_lens({server_id})")],+ "expected the first registration to refresh",+ );++ register_capability(+ &fake_server,+ method,+ "lens-b",+ serde_json::to_value(options).ok(),+ )+ .await;+ cx.executor().run_until_parked();+ assert_eq!(+ refresh_events.lock().as_slice(),+ &[] as &[String],+ "expected a registration with options identical to the active ones to not refresh",+ );++ unregister_capabilities(&fake_server, method, &["lens-b"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ refresh_events.lock().as_slice(),+ &[] as &[String],+ "expected an unregistration that restores identical options to not refresh",+ );+ assert_eq!(+ server_capabilities(&project, server_id, cx).code_lens_provider,+ Some(options),+ "expected the remaining registration's options to stay active",+ );++ unregister_capabilities(&fake_server, method, &["lens-a"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ refresh_events.lock().drain(..).collect::<Vec<_>>(),+ vec![format!("code_lens({server_id})")],+ "expected the last unregistration to clear the capability and refresh",+ );+ assert_eq!(+ server_capabilities(&project, server_id, cx).code_lens_provider,+ None,+ "expected the code lens provider to be cleared after unregistering the last registration",+ );+}++#[gpui::test]+async fn test_multi_registration_completion_triggers(cx: &mut gpui::TestAppContext) {+ init_test(cx);+ let (project, fake_server) =+ setup_dynamic_registration_test(cx, lsp::ServerCapabilities::default()).await;+ let method = "textDocument/completion";++ let (buffer, _lsp_handle) = project+ .update(cx, |project, cx| {+ project.open_local_buffer_with_lsp(path!("/the-root/a.rs"), cx)+ })+ .await+ .unwrap();+ let buffer_triggers = |cx: &mut gpui::TestAppContext| {+ buffer.read_with(cx, |buffer, _| buffer.completion_triggers().clone())+ };++ let options_a = lsp::CompletionOptions {+ trigger_characters: Some(vec![".".to_string()]),+ ..lsp::CompletionOptions::default()+ };+ let options_b = lsp::CompletionOptions {+ trigger_characters: Some(vec![":".to_string()]),+ ..lsp::CompletionOptions::default()+ };++ register_capability(+ &fake_server,+ method,+ "completion-a",+ serde_json::to_value(&options_a).ok(),+ )+ .await;+ cx.executor().run_until_parked();+ assert_eq!(+ buffer_triggers(cx),+ BTreeSet::from([".".to_string()]),+ "expected the first registration's triggers to be applied",+ );++ register_capability(+ &fake_server,+ method,+ "completion-b",+ serde_json::to_value(&options_b).ok(),+ )+ .await;+ cx.executor().run_until_parked();+ assert_eq!(+ buffer_triggers(cx),+ BTreeSet::from([":".to_string()]),+ "expected the second registration's triggers to replace the first ones",+ );++ let options_a_replacement = lsp::CompletionOptions {+ trigger_characters: Some(vec!["!".to_string()]),+ ..lsp::CompletionOptions::default()+ };+ register_capability(+ &fake_server,+ method,+ "completion-a",+ serde_json::to_value(&options_a_replacement).ok(),+ )+ .await;+ cx.executor().run_until_parked();+ assert_eq!(+ buffer_triggers(cx),+ BTreeSet::from([":".to_string()]),+ "expected the active registration's triggers to stay applied after a duplicate ID replaced an inactive one",+ );++ unregister_capabilities(&fake_server, method, &["completion-b"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ buffer_triggers(cx),+ BTreeSet::from(["!".to_string()]),+ "expected the replaced registration's triggers to be restored",+ );++ unregister_capabilities(&fake_server, method, &["completion-a"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ buffer_triggers(cx),+ BTreeSet::new(),+ "expected completion triggers to be cleared after unregistering the last registration",+ );+}++#[gpui::test]+async fn test_multi_registration_middle_removal(cx: &mut gpui::TestAppContext) {+ init_test(cx);+ let (project, fake_server) =+ setup_dynamic_registration_test(cx, lsp::ServerCapabilities::default()).await;+ let server_id = fake_server.server.server_id();+ let method = "textDocument/inlayHint";++ let options_a = lsp::InlayHintOptions {+ resolve_provider: Some(true),+ ..lsp::InlayHintOptions::default()+ };+ let options_b = lsp::InlayHintOptions {+ resolve_provider: Some(false),+ ..lsp::InlayHintOptions::default()+ };++ register_capability(+ &fake_server,+ method,+ "inlay-hint-a",+ serde_json::to_value(&options_a).ok(),+ )+ .await;+ register_capability(+ &fake_server,+ method,+ "inlay-hint-b",+ serde_json::to_value(&options_b).ok(),+ )+ .await;+ cx.executor().run_until_parked();++ let (refresh_events, _refresh_events_subscription) = observe_refresh_events(&project, cx);+ unregister_capabilities(&fake_server, method, &["inlay-hint-a"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).inlay_hint_provider,+ Some(lsp::OneOf::Right(+ lsp::InlayHintServerCapabilities::Options(options_b)+ )),+ "expected the latest registration to stay active after removing an older one from the middle",+ );+ assert_eq!(+ refresh_events.lock().as_slice(),+ &[] as &[String],+ "expected no refresh after removing an inactive registration",+ );++ unregister_capabilities(&fake_server, method, &["inlay-hint-b"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).inlay_hint_provider,+ None,+ "expected inlay hint provider to be cleared after unregistering the last registration",+ );+}++#[gpui::test]+async fn test_refresh_during_code_lens_fetch_does_not_resurrect_stale_data(+ cx: &mut gpui::TestAppContext,+) {+ init_test(cx);+ let (project, fake_server) =+ setup_dynamic_registration_test(cx, lsp::ServerCapabilities::default()).await;+ let method = "textDocument/codeLens";++ let (buffer, _lsp_handle) = project+ .update(cx, |project, cx| {+ project.open_local_buffer_with_lsp(path!("/the-root/a.rs"), cx)+ })+ .await+ .unwrap();++ let lens_requests = Arc::new(atomic::AtomicUsize::new(0));+ let (gate_tx, gate_rx) = futures::channel::oneshot::channel::<()>();+ let gate_rx = Arc::new(Mutex::new(Some(gate_rx)));+ fake_server.set_request_handler::<lsp::request::CodeLensRequest, _, _>({+ let lens_requests = lens_requests.clone();+ let gate_rx = gate_rx.clone();+ move |_, _| {+ lens_requests.fetch_add(1, atomic::Ordering::Release);+ let gate = gate_rx.lock().take();+ async move {+ if let Some(gate) = gate {+ gate.await.ok();+ }+ Ok(Some(vec![lsp::CodeLens {+ range: lsp::Range::new(lsp::Position::new(0, 0), lsp::Position::new(0, 1)),+ command: Some(lsp::Command {+ title: "stale lens".to_string(),+ command: "lens_cmd".to_string(),+ arguments: None,+ }),+ data: None,+ }]))+ }+ }+ });++ register_capability(+ &fake_server,+ method,+ "lens",+ serde_json::to_value(lsp::CodeLensOptions {+ resolve_provider: None,+ })+ .ok(),+ )+ .await;+ cx.executor().run_until_parked();++ let lsp_store = project.read_with(cx, |project, _| project.lsp_store());+ let first_fetch =+ lsp_store.update(cx, |lsp_store, cx| lsp_store.code_lens_actions(&buffer, cx));+ cx.executor().advance_clock(Duration::from_millis(50));+ cx.executor().run_until_parked();+ assert_eq!(+ lens_requests.load(atomic::Ordering::Acquire),+ 1,+ "expected the code lens request to be in flight before the unregistration",+ );++ unregister_capabilities(&fake_server, method, &["lens"]).await;+ cx.executor().run_until_parked();++ gate_tx.send(()).unwrap();+ first_fetch.await.unwrap();+ cx.executor().run_until_parked();++ let actions = lsp_store+ .update(cx, |lsp_store, cx| lsp_store.code_lens_actions(&buffer, cx))+ .await+ .unwrap();+ assert_eq!(+ actions.map(|actions| actions.len()),+ Some(0),+ "expected no code lens data after the unregistration, even though a stale fetch completed after it",+ );+ assert_eq!(+ lens_requests.load(atomic::Ordering::Acquire),+ 1,+ "expected the unregistered server to not be queried again",+ );+}++#[gpui::test]+async fn test_multi_registration_unregister_with_static_only(cx: &mut gpui::TestAppContext) {+ init_test(cx);+ let (project, fake_server) = setup_dynamic_registration_test(+ cx,+ lsp::ServerCapabilities {+ inlay_hint_provider: Some(lsp::OneOf::Left(true)),+ ..lsp::ServerCapabilities::default()+ },+ )+ .await;+ let server_id = fake_server.server.server_id();++ unregister_capabilities(&fake_server, "textDocument/inlayHint", &["unknown-id"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).inlay_hint_provider,+ Some(lsp::OneOf::Left(true)),+ "expected the static capability to survive unregistering an unknown ID",+ );+}++#[gpui::test]+async fn test_multi_registration_completion_static_restore(cx: &mut gpui::TestAppContext) {+ init_test(cx);+ let static_options = lsp::CompletionOptions {+ trigger_characters: Some(vec![".".to_string()]),+ ..lsp::CompletionOptions::default()+ };+ let (project, fake_server) = setup_dynamic_registration_test(+ cx,+ lsp::ServerCapabilities {+ completion_provider: Some(static_options.clone()),+ ..lsp::ServerCapabilities::default()+ },+ )+ .await;+ let server_id = fake_server.server.server_id();+ let method = "textDocument/completion";++ let (buffer, _lsp_handle) = project+ .update(cx, |project, cx| {+ project.open_local_buffer_with_lsp(path!("/the-root/a.rs"), cx)+ })+ .await+ .unwrap();+ let buffer_triggers = |cx: &mut gpui::TestAppContext| {+ buffer.read_with(cx, |buffer, _| buffer.completion_triggers().clone())+ };+ assert_eq!(+ buffer_triggers(cx),+ BTreeSet::from([".".to_string()]),+ "expected the static trigger characters before any dynamic registration",+ );++ let dynamic_options = lsp::CompletionOptions {+ trigger_characters: Some(vec![":".to_string()]),+ ..lsp::CompletionOptions::default()+ };+ register_capability(+ &fake_server,+ method,+ "completion-dynamic",+ serde_json::to_value(&dynamic_options).ok(),+ )+ .await;+ cx.executor().run_until_parked();+ assert_eq!(+ buffer_triggers(cx),+ BTreeSet::from([":".to_string()]),+ "expected the dynamic registration's triggers to override the static ones",+ );++ unregister_capabilities(&fake_server, method, &["completion-dynamic"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).completion_provider,+ Some(static_options),+ "expected the static completion provider to be restored",+ );+ assert_eq!(+ buffer_triggers(cx),+ BTreeSet::from([".".to_string()]),+ "expected the static trigger characters to be restored",+ );+}++#[gpui::test]+async fn test_multi_registration_same_id_different_methods(cx: &mut gpui::TestAppContext) {+ init_test(cx);+ let (project, fake_server) =+ setup_dynamic_registration_test(cx, lsp::ServerCapabilities::default()).await;+ let server_id = fake_server.server.server_id();++ let code_lens_options = lsp::CodeLensOptions {+ resolve_provider: Some(true),+ };+ register_capability(&fake_server, "textDocument/inlayHint", "shared-id", None).await;+ register_capability(+ &fake_server,+ "textDocument/codeLens",+ "shared-id",+ serde_json::to_value(code_lens_options).ok(),+ )+ .await;+ cx.executor().run_until_parked();++ unregister_capabilities(&fake_server, "textDocument/codeLens", &["shared-id"]).await;+ cx.executor().run_until_parked();+ let capabilities = server_capabilities(&project, server_id, cx);+ assert_eq!(+ capabilities.code_lens_provider, None,+ "expected the code lens registration to be removed",+ );+ assert_eq!(+ capabilities.inlay_hint_provider,+ Some(lsp::OneOf::Left(true)),+ "expected the inlay hint registration with the same ID to stay intact",+ );+}++#[gpui::test]+async fn test_multi_registration_diagnostics(cx: &mut gpui::TestAppContext) {+ init_test(cx);+ let (project, fake_server) =+ setup_dynamic_registration_test(cx, lsp::ServerCapabilities::default()).await;+ let server_id = fake_server.server.server_id();+ let method = "textDocument/diagnostic";+ fake_server.set_request_handler::<lsp::request::DocumentDiagnosticRequest, _, _>(+ move |_, _| async move {+ Ok(lsp::DocumentDiagnosticReportResult::Report(+ lsp::DocumentDiagnosticReport::Full(+ lsp::RelatedFullDocumentDiagnosticReport::default(),+ ),+ ))+ },+ );++ let options_a = lsp::DiagnosticServerCapabilities::Options(lsp::DiagnosticOptions {+ identifier: Some("diagnostics-a".to_string()),+ ..lsp::DiagnosticOptions::default()+ });+ let options_b = lsp::DiagnosticServerCapabilities::Options(lsp::DiagnosticOptions {+ identifier: Some("diagnostics-b".to_string()),+ ..lsp::DiagnosticOptions::default()+ });++ register_capability(+ &fake_server,+ method,+ "diag-a",+ serde_json::to_value(&options_a).ok(),+ )+ .await;+ register_capability(+ &fake_server,+ method,+ "diag-b",+ serde_json::to_value(&options_b).ok(),+ )+ .await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).diagnostic_provider,+ Some(options_b),+ "expected the latest diagnostic registration to be active",+ );++ unregister_capabilities(&fake_server, method, &["diag-b"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).diagnostic_provider,+ Some(options_a.clone()),+ "expected the remaining diagnostic registration to be restored",+ );++ unregister_capabilities(&fake_server, method, &["unknown-id"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).diagnostic_provider,+ Some(options_a),+ "expected an unknown unregistration ID to leave the diagnostic provider intact",+ );++ unregister_capabilities(&fake_server, method, &["diag-a"]).await;+ cx.executor().run_until_parked();+ assert_eq!(+ server_capabilities(&project, server_id, cx).diagnostic_provider,+ None,+ "expected the diagnostic provider to be cleared after unregistering the last registration",+ );+}++#[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() {}" }))+ .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());++ let mut static_servers = language_registry.register_fake_lsp(+ "Rust",+ 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()+ },+ ..FakeLspAdapter::default()+ },+ );+ let mut dynamic_servers = language_registry.register_fake_lsp(+ "Rust",+ FakeLspAdapter {+ name: "dynamic-server",+ ..FakeLspAdapter::default()+ },+ );+ cx.executor().run_until_parked();++ let (buffer, _lsp_handle) = project+ .update(cx, |project, cx| {+ project.open_local_buffer_with_lsp(path!("/the-root/a.rs"), cx)+ })+ .await+ .unwrap();+ 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 (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())+ };++ 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,+ },+ "expected the initial fetch to query the statically capable server",+ );+ assert_eq!(+ dynamic_counters.snapshot(),+ LspRequestCounts::default(),+ "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_capability(+ &dynamic_server,+ "textDocument/completion",+ "completions",+ serde_json::to_value(lsp::CompletionOptions {+ trigger_characters: Some(vec![":".to_string()]),+ ..lsp::CompletionOptions::default()+ })+ .ok(),+ )+ .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})"),+ ],+ "expected every dynamic registration to trigger the corresponding per-server refresh",+ );+ assert_eq!(+ buffer_triggers(cx),+ BTreeSet::from([".".to_string(), ":".to_string()]),+ "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,+ },+ "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,+ },+ "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_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})"),+ ],+ "expected every unregistration to trigger the corresponding per-server refresh",+ );+ assert_eq!(+ buffer_triggers(cx),+ BTreeSet::from([".".to_string()]),+ "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,+ },+ "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,+ },+ "expected the static server to never be re-queried by another server's capability changes",+ );+}++#[gpui::test]+async fn test_semantic_tokens_refresh_invalidates_only_the_refreshed_server(+ cx: &mut gpui::TestAppContext,+) {+ init_test(cx);++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(path!("/the-root"), json!({ "a.rs": "fn main() {}" }))+ .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());++ let semantic_tokens_capabilities = lsp::ServerCapabilities {+ semantic_tokens_provider: Some(+ lsp::SemanticTokensServerCapabilities::SemanticTokensOptions(+ lsp::SemanticTokensOptions {+ full: Some(lsp::SemanticTokensFullOptions::Bool(true)),+ ..lsp::SemanticTokensOptions::default()+ },+ ),+ ),+ ..lsp::ServerCapabilities::default()+ };+ let mut servers_a = language_registry.register_fake_lsp(+ "Rust",+ FakeLspAdapter {+ name: "server-a",+ capabilities: semantic_tokens_capabilities.clone(),+ ..FakeLspAdapter::default()+ },+ );+ let mut servers_b = language_registry.register_fake_lsp(+ "Rust",+ FakeLspAdapter {+ name: "server-b",+ capabilities: semantic_tokens_capabilities,+ ..FakeLspAdapter::default()+ },+ );+ cx.executor().run_until_parked();++ let (buffer, _lsp_handle) = project+ .update(cx, |project, cx| {+ project.open_local_buffer_with_lsp(path!("/the-root/a.rs"), cx)+ })+ .await+ .unwrap();+ let buffer_id = buffer.read_with(cx, |buffer, _| buffer.remote_id());+ let server_a = servers_a.next().await.unwrap();+ let server_b = servers_b.next().await.unwrap();+ for server in [&server_a, &server_b] {+ server.set_request_handler::<lsp::request::SemanticTokensFullRequest, _, _>(+ move |_, _| async move {+ Ok(Some(lsp::SemanticTokensResult::Tokens(+ lsp::SemanticTokens::default(),+ )))+ },+ );+ }+ let server_a_id = server_a.server.server_id();+ let server_b_id = server_b.server.server_id();+ cx.executor().run_until_parked();++ let lsp_store = project.read_with(cx, |project, _| project.lsp_store());+ let cached_token_servers = |cx: &mut gpui::TestAppContext| {+ lsp_store.read_with(cx, |lsp_store, _| {+ lsp_store.semantic_token_servers(buffer_id)+ })+ };++ lsp_store+ .update(cx, |lsp_store, cx| {+ lsp_store.semantic_tokens(buffer.clone(), cx)+ })+ .await+ .unwrap();+ assert_eq!(+ cached_token_servers(cx),+ vec![server_a_id, server_b_id],+ "expected tokens from both servers after the initial fetch",+ );++ for repetition in 0..2 {+ server_a+ .request::<lsp::request::SemanticTokensRefresh>((), DEFAULT_LSP_REQUEST_TIMEOUT)+ .await+ .into_response()+ .unwrap();+ let refresh_task = lsp_store.update(cx, |lsp_store, cx| {+ lsp_store.semantic_tokens(buffer.clone(), cx)+ });+ assert_eq!(+ cached_token_servers(cx),+ vec![server_b_id],+ "expected refresh {repetition} to invalidate only the refreshed server's tokens",+ );+ let concurrent_task = lsp_store.update(cx, |lsp_store, cx| {+ lsp_store.semantic_tokens(buffer.clone(), cx)+ });+ assert_eq!(+ cached_token_servers(cx),+ vec![server_b_id],+ "expected a concurrent query {repetition} to not invalidate the data again",+ );+ refresh_task.await.unwrap();+ concurrent_task.await.unwrap();+ assert_eq!(+ cached_token_servers(cx),+ vec![server_a_id, server_b_id],+ "expected the refreshed server's tokens to be re-fetched after refresh {repetition}",+ );+ }+}++#[gpui::test]+async fn test_semantic_tokens_refresh_during_fetch_does_not_resurrect_stale_data(+ cx: &mut gpui::TestAppContext,+) {+ init_test(cx);+ let (project, fake_server) = setup_dynamic_registration_test(+ cx,+ lsp::ServerCapabilities {+ semantic_tokens_provider: Some(+ lsp::SemanticTokensServerCapabilities::SemanticTokensOptions(+ lsp::SemanticTokensOptions {+ full: Some(lsp::SemanticTokensFullOptions::Bool(true)),+ ..lsp::SemanticTokensOptions::default()+ },+ ),+ ),+ ..lsp::ServerCapabilities::default()+ },+ )+ .await;+ let server_id = fake_server.server.server_id();++ let (buffer, _lsp_handle) = project+ .update(cx, |project, cx| {+ project.open_local_buffer_with_lsp(path!("/the-root/a.rs"), cx)+ })+ .await+ .unwrap();+ let buffer_id = buffer.read_with(cx, |buffer, _| buffer.remote_id());+ cx.executor().run_until_parked();++ let stale_data = vec![0, 0, 2, 0, 0];+ let fresh_data = vec![0, 0, 2, 0, 0, 0, 3, 4, 0, 0];+ let token_requests = Arc::new(atomic::AtomicUsize::new(0));+ let (gate_tx, gate_rx) = futures::channel::oneshot::channel::<()>();+ let gate_rx = Arc::new(Mutex::new(Some(gate_rx)));+ fake_server.set_request_handler::<lsp::request::SemanticTokensFullRequest, _, _>({+ let token_requests = token_requests.clone();+ let gate_rx = gate_rx.clone();+ let stale_data = stale_data.clone();+ let fresh_data = fresh_data.clone();+ move |_, _| {+ let request = token_requests.fetch_add(1, atomic::Ordering::Release);+ let gate = gate_rx.lock().take();+ let data = if request == 0 {+ stale_data.clone()+ } else {+ fresh_data.clone()+ };+ async move {+ if let Some(gate) = gate {+ gate.await.ok();+ }+ Ok(Some(lsp::SemanticTokensResult::Tokens(+ lsp::SemanticTokens {+ result_id: None,+ data,+ },+ )))+ }+ }+ });++ let lsp_store = project.read_with(cx, |project, _| project.lsp_store());+ let stale_fetch = lsp_store.update(cx, |lsp_store, cx| {+ lsp_store.semantic_tokens(buffer.clone(), cx)+ });+ cx.executor().run_until_parked();+ assert_eq!(+ token_requests.load(atomic::Ordering::Acquire),+ 1,+ "expected the first fetch to be in flight before the refresh",+ );++ fake_server+ .request::<lsp::request::SemanticTokensRefresh>((), DEFAULT_LSP_REQUEST_TIMEOUT)+ .await+ .into_response()+ .unwrap();+ cx.executor().run_until_parked();++ let fresh_fetch = lsp_store.update(cx, |lsp_store, cx| {+ lsp_store.semantic_tokens(buffer.clone(), cx)+ });+ fresh_fetch.await.unwrap();++ gate_tx.send(()).unwrap();+ stale_fetch.await.unwrap();+ cx.executor().run_until_parked();++ assert_eq!(+ lsp_store.read_with(cx, |lsp_store, _| lsp_store.semantic_token_data(buffer_id)),+ vec![(server_id, fresh_data)],+ "expected the stale fetch, completed after the refresh, to not overwrite the refreshed tokens",+ );+ assert_eq!(+ token_requests.load(atomic::Ordering::Acquire),+ 2,+ "expected exactly the stale and the fresh fetches to have queried the server",+ );+}++#[gpui::test]+async fn test_code_lens_concurrent_fetches_are_deduplicated(cx: &mut gpui::TestAppContext) {+ init_test(cx);+ let (project, fake_server) = setup_dynamic_registration_test(+ cx,+ lsp::ServerCapabilities {+ code_lens_provider: Some(lsp::CodeLensOptions {+ resolve_provider: None,+ }),+ ..lsp::ServerCapabilities::default()+ },+ )+ .await;++ let (buffer, _lsp_handle) = project+ .update(cx, |project, cx| {+ project.open_local_buffer_with_lsp(path!("/the-root/a.rs"), cx)+ })+ .await+ .unwrap();+ cx.executor().run_until_parked();++ let lens_requests = Arc::new(atomic::AtomicUsize::new(0));+ fake_server.set_request_handler::<lsp::request::CodeLensRequest, _, _>({+ let lens_requests = lens_requests.clone();+ move |_, _| {+ lens_requests.fetch_add(1, atomic::Ordering::Release);+ async move { Ok(Some(Vec::new())) }+ }+ });++ let lsp_store = project.read_with(cx, |project, _| project.lsp_store());+ let first_fetch =+ lsp_store.update(cx, |lsp_store, cx| lsp_store.code_lens_actions(&buffer, cx));+ let second_fetch =+ lsp_store.update(cx, |lsp_store, cx| lsp_store.code_lens_actions(&buffer, cx));+ cx.executor().advance_clock(Duration::from_millis(50));+ first_fetch.await.unwrap();+ second_fetch.await.unwrap();+ assert_eq!(+ lens_requests.load(atomic::Ordering::Acquire),+ 1,+ "expected concurrent code lens fetches to share one LSP request",+ );++ lsp_store+ .update(cx, |lsp_store, cx| lsp_store.code_lens_actions(&buffer, cx))+ .await+ .unwrap();+ assert_eq!(+ lens_requests.load(atomic::Ordering::Acquire),+ 1,+ "expected a repeated fetch for the unchanged buffer to be served from the cache",+ );+}++#[gpui::test]+async fn test_multiple_did_change_watched_files_registrations(cx: &mut gpui::TestAppContext) {+ init_test(cx);++ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(+ path!("/root"),+ json!({+ "src": {+ "a.rs": "",+ "b.rs": "",+ },+ "docs": {+ "readme.md": "",+ },+ }),+ )+ .await;++ let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;+ let language_registry = project.read_with(cx, |project, _| project.languages().clone());+ language_registry.add(rust_lang());+ let mut fake_servers = language_registry.register_fake_lsp(+ "Rust",+ FakeLspAdapter {+ name: "the-language-server",+ ..FakeLspAdapter::default()+ },+ );++ cx.executor().run_until_parked();++ project+ .update(cx, |project, cx| {+ project.open_local_buffer_with_lsp(path!("/root/src/a.rs"), cx)+ })+ .await+ .unwrap();++ let fake_server = fake_servers.next().await.unwrap();+ cx.executor().run_until_parked();++ let file_changes = Arc::new(Mutex::new(Vec::new()));++ // Register two separate watched file registrations.+ register_capability(+ &fake_server,+ "workspace/didChangeWatchedFiles",+ "reg-1",+ serde_json::to_value(lsp::DidChangeWatchedFilesRegistrationOptions {+ watchers: vec![lsp::FileSystemWatcher {+ glob_pattern: lsp::GlobPattern::String(path!("/root/src/*.rs").to_string()),+ kind: None,+ }],+ })+ .ok(),+ )+ .await;++ register_capability(+ &fake_server,+ "workspace/didChangeWatchedFiles",+ "reg-2",+ serde_json::to_value(lsp::DidChangeWatchedFilesRegistrationOptions {+ watchers: vec![lsp::FileSystemWatcher {+ glob_pattern: lsp::GlobPattern::String(path!("/root/docs/*.md").to_string()),+ kind: None,+ }],+ })+ .ok(),+ )+ .await;++ fake_server.handle_notification::<lsp::notification::DidChangeWatchedFiles, _>({+ let file_changes = file_changes.clone();+ move |params, _| {+ let mut file_changes = file_changes.lock();+ file_changes.extend(params.changes);+ file_changes.sort_by(|a, b| a.uri.cmp(&b.uri));+ }+ });++ cx.executor().run_until_parked();++ // Both registrations should match their respective patterns.+ fs.create_file(+ path!("/root/src/c.rs").as_ref(),+ fs::CreateOptions::default(),+ )+ .await+ .unwrap();+ fs.create_file(+ path!("/root/docs/guide.md").as_ref(),+ fs::CreateOptions::default(),+ )+ .await+ .unwrap();+ cx.executor().run_until_parked();++ assert_eq!(+ &*file_changes.lock(),+ &[+ lsp::FileEvent {+ uri: lsp::Uri::from_file_path(path!("/root/docs/guide.md")).unwrap(),+ typ: lsp::FileChangeType::CREATED,+ },+ lsp::FileEvent {+ uri: lsp::Uri::from_file_path(path!("/root/src/c.rs")).unwrap(),+ typ: lsp::FileChangeType::CREATED,+ },+ ]+ );+ file_changes.lock().clear();++ // Unregister the first registration.+ unregister_capabilities(&fake_server, "workspace/didChangeWatchedFiles", &["reg-1"]).await;+ cx.executor().run_until_parked();++ // Only the second registration should still match.+ fs.create_file(+ path!("/root/src/d.rs").as_ref(),+ fs::CreateOptions::default(),+ )+ .await+ .unwrap();+ fs.create_file(+ path!("/root/docs/notes.md").as_ref(),+ fs::CreateOptions::default(),+ )+ .await+ .unwrap();+ cx.executor().run_until_parked();++ assert_eq!(+ &*file_changes.lock(),+ &[lsp::FileEvent {+ uri: lsp::Uri::from_file_path(path!("/root/docs/notes.md")).unwrap(),+ typ: lsp::FileChangeType::CREATED,+ }]+ );+}++async fn setup_dynamic_registration_test(+ cx: &mut gpui::TestAppContext,+ capabilities: lsp::ServerCapabilities,+) -> (Entity<Project>, lsp::FakeLanguageServer) {+ let fs = FakeFs::new(cx.executor());+ fs.insert_tree(path!("/the-root"), json!({ "a.rs": "" }))+ .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());+ let mut fake_servers = language_registry.register_fake_lsp(+ "Rust",+ FakeLspAdapter {+ name: "the-language-server",+ capabilities,+ ..FakeLspAdapter::default()+ },+ );++ cx.executor().run_until_parked();++ project+ .update(cx, |project, cx| {+ project.open_local_buffer_with_lsp(path!("/the-root/a.rs"), cx)+ })+ .await+ .unwrap();++ let fake_server = fake_servers.next().await.unwrap();+ cx.executor().run_until_parked();+ (project, fake_server)+}++async fn register_capability(+ fake_server: &lsp::FakeLanguageServer,+ method: &str,+ id: &str,+ register_options: Option<serde_json::Value>,+) {+ fake_server+ .request::<lsp::request::RegisterCapability>(+ lsp::RegistrationParams {+ registrations: vec![lsp::Registration {+ id: id.to_string(),+ method: method.to_string(),+ register_options,+ }],+ },+ DEFAULT_LSP_REQUEST_TIMEOUT,+ )+ .await+ .into_response()+ .unwrap();+}++async fn unregister_capabilities(+ fake_server: &lsp::FakeLanguageServer,+ method: &str,+ ids: &[&str],+) {+ fake_server+ .request::<lsp::request::UnregisterCapability>(+ lsp::UnregistrationParams {+ unregisterations: ids+ .iter()+ .map(|id| lsp::Unregistration {+ id: id.to_string(),+ method: method.to_string(),+ })+ .collect(),+ },+ DEFAULT_LSP_REQUEST_TIMEOUT,+ )+ .await+ .into_response()+ .unwrap();+}++fn server_capabilities(+ project: &Entity<Project>,+ server_id: LanguageServerId,+ cx: &mut gpui::TestAppContext,+) -> lsp::ServerCapabilities {+ project.read_with(cx, |project, cx| {+ project+ .lsp_store()+ .read(cx)+ .language_server_for_id(server_id)+ .unwrap()+ .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,+) -> (Arc<Mutex<Vec<String>>>, gpui::Subscription) {+ let events = Arc::new(Mutex::new(Vec::new()));+ let subscription = cx.update({+ let events = events.clone();+ let project = project.clone();+ move |cx| {+ cx.subscribe(&project, move |_, event, _| {+ let label = |name: &str, server_id: &Option<LanguageServerId>| {+ let server_id = server_id+ .map_or_else(|| "all".to_string(), |server_id| server_id.to_string());+ format!("{name}({server_id})")+ };+ let event = match event {+ Event::RefreshInlayHints { server_id, .. } => {+ format!("inlay_hints({server_id})")+ }+ Event::RefreshSemanticTokens { server_id, .. } => {+ format!("semantic_tokens({server_id})")+ }+ Event::RefreshCodeLens { server_id } => label("code_lens", server_id),+ Event::RefreshDocumentColors { server_id } => {+ label("document_colors", server_id)+ }+ Event::RefreshDocumentLinks { server_id } => label("document_links", server_id),+ Event::RefreshFoldingRanges { server_id } => label("folding_ranges", server_id),+ Event::RefreshDocumentSymbols { server_id } => {+ label("document_symbols", server_id)+ }+ _ => return,+ };+ events.lock().push(event);+ })+ }+ });+ (events, subscription)+}++async fn fetch_lsp_data(+ project: &Entity<Project>,+ buffer: &Entity<Buffer>,+ cx: &mut gpui::TestAppContext,+) {+ let lsp_store = project.read_with(cx, |project, _| project.lsp_store());+ let colors = lsp_store.update(cx, |lsp_store, cx| {+ lsp_store.document_colors(buffer.clone(), cx)+ });+ let links = lsp_store.update(cx, |lsp_store, cx| {+ lsp_store.fetch_document_links(buffer, cx)+ });+ let folding_ranges = lsp_store.update(cx, |lsp_store, cx| {+ lsp_store.fetch_folding_ranges(buffer, cx)+ });+ let document_symbols = lsp_store.update(cx, |lsp_store, cx| {+ lsp_store.fetch_document_symbols(buffer, cx)+ });+ let code_lens = lsp_store.update(cx, |lsp_store, cx| lsp_store.code_lens_actions(buffer, cx));+ let semantic_tokens = lsp_store.update(cx, |lsp_store, cx| {+ lsp_store.semantic_tokens(buffer.clone(), cx)+ });+ if let Some(colors) = colors {+ colors.await.unwrap();+ }+ links.await;+ folding_ranges.await;+ document_symbols.await;+ code_lens.await.unwrap();+ semantic_tokens.await.unwrap();+}++fn sorted(events: impl IntoIterator<Item = String>) -> Vec<String> {+ let mut events = events.into_iter().collect::<Vec<_>>();+ events.sort();+ events+}diff --git a/crates/project/tests/integration/project_tests.rs b/crates/project/tests/integration/project_tests.rsindex f6f8ac8eab8..13051448ca3 100644--- a/crates/project/tests/integration/project_tests.rs+++ b/crates/project/tests/integration/project_tests.rs@@ -5,6 +5,7 @@ mod bookmark_store;mod color_extractor;mod context_server_store;mod debugger;+mod dynamic_registration;mod git_store;mod image_store;mod lsp_command;@@ -2289,131 +2290,6 @@ async fn test_rescan_fs_change_is_reported_to_language_servers_as_changed();}-#[gpui::test]-async fn test_dynamic_semantic_tokens_registration(cx: &mut gpui::TestAppContext) {- init_test(cx);-- let fs = FakeFs::new(cx.executor());- fs.insert_tree(- path!("/the-root"),- json!({- "a.rs": "fn main() {}",- }),- )- .await;-- let project = Project::test(fs.clone(), [path!("/the-root").as_ref()], cx).await;- let language_registry = project.read_with(cx, |project, _| project.languages().clone());- language_registry.add(rust_lang());- let mut fake_servers = language_registry.register_fake_lsp(- "Rust",- FakeLspAdapter {- name: "the-language-server",- // Crucially, no `semantic_tokens_provider` is advertised statically; the- // server only offers it through dynamic registration (as Roslyn does).- ..Default::default()- },- );-- let _buffer = project- .update(cx, |project, cx| {- project.open_local_buffer_with_lsp(path!("/the-root/a.rs"), cx)- })- .await- .unwrap();-- let fake_server = fake_servers.next().await.unwrap();- let server_id = fake_server.server.server_id();- cx.executor().run_until_parked();-- let semantic_tokens_provider = |cx: &mut gpui::TestAppContext| {- project.read_with(cx, |project, cx| {- project- .lsp_store()- .read(cx)- .lsp_server_capabilities- .get(&server_id)- .and_then(|capabilities| capabilities.semantic_tokens_provider.clone())- })- };-- assert!(- semantic_tokens_provider(cx).is_none(),- "server should not advertise semantic tokens before dynamic registration"- );-- fake_server- .request::<lsp::request::RegisterCapability>(- lsp::RegistrationParams {- registrations: vec![lsp::Registration {- id: "semantic-tokens".to_string(),- method: "textDocument/semanticTokens".to_string(),- register_options: 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(), "variable".into()],- token_modifiers: vec![],- },- full: Some(lsp::SemanticTokensFullOptions::Bool(true)),- ..Default::default()- },- static_registration_options: lsp::StaticRegistrationOptions {- id: None,- },- },- )- .ok(),- }],- },- DEFAULT_LSP_REQUEST_TIMEOUT,- )- .await- .into_response()- .unwrap();- cx.executor().run_until_parked();-- let provider = semantic_tokens_provider(cx)- .expect("semantic tokens provider should be set after dynamic registration");- // The capability round-trips through capability-sync serialization, which may- // normalize the registration options into plain options; either shape is fine- // as long as the legend survives.- let legend = match provider {- lsp::SemanticTokensServerCapabilities::SemanticTokensOptions(options) => options.legend,- lsp::SemanticTokensServerCapabilities::SemanticTokensRegistrationOptions(options) => {- options.semantic_tokens_options.legend- }- };- assert_eq!(- legend.token_types,- vec!["keyword".into(), "variable".into()],- );-- fake_server- .request::<lsp::request::UnregisterCapability>(- lsp::UnregistrationParams {- unregisterations: vec![lsp::Unregistration {- id: "semantic-tokens".to_string(),- method: "textDocument/semanticTokens".to_string(),- }],- },- DEFAULT_LSP_REQUEST_TIMEOUT,- )- .await- .into_response()- .unwrap();- cx.executor().run_until_parked();-- assert!(- semantic_tokens_provider(cx).is_none(),- "semantic tokens provider should be cleared after unregistration"- );-}-#[gpui::test]async fn test_reporting_fs_changes_to_language_servers(cx: &mut gpui::TestAppContext) {init_test(cx);@@ -2721,170 +2597,6 @@ async fn test_reporting_fs_changes_to_language_servers(cx: &mut gpui::TestAppCon);}-#[gpui::test]-async fn test_multiple_did_change_watched_files_registrations(cx: &mut gpui::TestAppContext) {- init_test(cx);-- let fs = FakeFs::new(cx.executor());- fs.insert_tree(- path!("/root"),- json!({- "src": {- "a.rs": "",- "b.rs": "",- },- "docs": {- "readme.md": "",- },- }),- )- .await;-- let project = Project::test(fs.clone(), [path!("/root").as_ref()], cx).await;- let language_registry = project.read_with(cx, |project, _| project.languages().clone());- language_registry.add(rust_lang());- let mut fake_servers = language_registry.register_fake_lsp(- "Rust",- FakeLspAdapter {- name: "the-language-server",- ..Default::default()- },- );-- cx.executor().run_until_parked();-- project- .update(cx, |project, cx| {- project.open_local_buffer_with_lsp(path!("/root/src/a.rs"), cx)- })- .await- .unwrap();-- let fake_server = fake_servers.next().await.unwrap();- cx.executor().run_until_parked();-- let file_changes = Arc::new(Mutex::new(Vec::new()));-- // Register two separate watched file registrations.- fake_server- .request::<lsp::request::RegisterCapability>(- lsp::RegistrationParams {- registrations: vec![lsp::Registration {- id: "reg-1".to_string(),- method: "workspace/didChangeWatchedFiles".to_string(),- register_options: serde_json::to_value(- lsp::DidChangeWatchedFilesRegistrationOptions {- watchers: vec![lsp::FileSystemWatcher {- glob_pattern: lsp::GlobPattern::String(- path!("/root/src/*.rs").to_string(),- ),- kind: None,- }],- },- )- .ok(),- }],- },- DEFAULT_LSP_REQUEST_TIMEOUT,- )- .await- .into_response()- .unwrap();-- fake_server- .request::<lsp::request::RegisterCapability>(- lsp::RegistrationParams {- registrations: vec![lsp::Registration {- id: "reg-2".to_string(),- method: "workspace/didChangeWatchedFiles".to_string(),- register_options: serde_json::to_value(- lsp::DidChangeWatchedFilesRegistrationOptions {- watchers: vec![lsp::FileSystemWatcher {- glob_pattern: lsp::GlobPattern::String(- path!("/root/docs/*.md").to_string(),- ),- kind: None,- }],- },- )- .ok(),- }],- },- DEFAULT_LSP_REQUEST_TIMEOUT,- )- .await- .into_response()- .unwrap();-- fake_server.handle_notification::<lsp::notification::DidChangeWatchedFiles, _>({- let file_changes = file_changes.clone();- move |params, _| {- let mut file_changes = file_changes.lock();- file_changes.extend(params.changes);- file_changes.sort_by(|a, b| a.uri.cmp(&b.uri));- }- });-- cx.executor().run_until_parked();-- // Both registrations should match their respective patterns.- fs.create_file(path!("/root/src/c.rs").as_ref(), Default::default())- .await- .unwrap();- fs.create_file(path!("/root/docs/guide.md").as_ref(), Default::default())- .await- .unwrap();- cx.executor().run_until_parked();-- assert_eq!(- &*file_changes.lock(),- &[- lsp::FileEvent {- uri: lsp::Uri::from_file_path(path!("/root/docs/guide.md")).unwrap(),- typ: lsp::FileChangeType::CREATED,- },- lsp::FileEvent {- uri: lsp::Uri::from_file_path(path!("/root/src/c.rs")).unwrap(),- typ: lsp::FileChangeType::CREATED,- },- ]- );- file_changes.lock().clear();-- // Unregister the first registration.- fake_server- .request::<lsp::request::UnregisterCapability>(- lsp::UnregistrationParams {- unregisterations: vec![lsp::Unregistration {- id: "reg-1".to_string(),- method: "workspace/didChangeWatchedFiles".to_string(),- }],- },- DEFAULT_LSP_REQUEST_TIMEOUT,- )- .await- .into_response()- .unwrap();- cx.executor().run_until_parked();-- // Only the second registration should still match.- fs.create_file(path!("/root/src/d.rs").as_ref(), Default::default())- .await- .unwrap();- fs.create_file(path!("/root/docs/notes.md").as_ref(), Default::default())- .await- .unwrap();- cx.executor().run_until_parked();-- assert_eq!(- &*file_changes.lock(),- &[lsp::FileEvent {- uri: lsp::Uri::from_file_path(path!("/root/docs/notes.md")).unwrap(),- typ: lsp::FileChangeType::CREATED,- }]- );-}-#[gpui::test]async fn test_single_file_worktrees_diagnostics(cx: &mut gpui::TestAppContext) {init_test(cx);diff --git a/crates/proto/proto/lsp.proto b/crates/proto/proto/lsp.protoindex 2e87e1ec12c..4016656e0aa 100644--- a/crates/proto/proto/lsp.proto+++ b/crates/proto/proto/lsp.proto@@ -584,6 +584,27 @@ message GetCodeLensResponse {message RefreshCodeLens {uint64 project_id = 1;+ optional uint64 server_id = 2;+}++message RefreshDocumentColors {+ uint64 project_id = 1;+ optional uint64 server_id = 2;+}++message RefreshDocumentLinks {+ uint64 project_id = 1;+ optional uint64 server_id = 2;+}++message RefreshFoldingRanges {+ uint64 project_id = 1;+ optional uint64 server_id = 2;+}++message RefreshDocumentSymbols {+ uint64 project_id = 1;+ optional uint64 server_id = 2;}message MarkupContent {diff --git a/crates/proto/proto/zed.proto b/crates/proto/proto/zed.protoindex e4011bcf97f..47895a18d29 100644--- a/crates/proto/proto/zed.proto+++ b/crates/proto/proto/zed.proto@@ -501,7 +501,11 @@ message Envelope {GitAddPathToGitignore git_add_path_to_gitignore = 470;GitAddPathToGitInfoExclude git_add_path_to_git_info_exclude = 471;LoadCommitTemplate load_commit_template = 472;- LoadCommitTemplateResponse load_commit_template_response = 473; // current max+ LoadCommitTemplateResponse load_commit_template_response = 473;+ RefreshDocumentColors refresh_document_colors = 474;+ RefreshDocumentLinks refresh_document_links = 475;+ RefreshFoldingRanges refresh_folding_ranges = 476;+ RefreshDocumentSymbols refresh_document_symbols = 477; // current max}reserved 87 to 88;diff --git a/crates/proto/src/proto.rs b/crates/proto/src/proto.rsindex 47dbb972e4b..37aaa42504a 100644--- a/crates/proto/src/proto.rs+++ b/crates/proto/src/proto.rs@@ -206,6 +206,10 @@ messages!((ProjectEntryResponse, Foreground),(RefreshInlayHints, Background),(RefreshSemanticTokens, Background),+ (RefreshDocumentColors, Background),+ (RefreshDocumentLinks, Background),+ (RefreshFoldingRanges, Background),+ (RefreshDocumentSymbols, Background),(RegisterBufferWithLanguageServers, Background),(RejoinChannelBuffers, Foreground),(RejoinChannelBuffersResponse, Foreground),@@ -480,6 +484,10 @@ request_messages!((RefreshInlayHints, Ack),(RefreshSemanticTokens, Ack),(RefreshCodeLens, Ack),+ (RefreshDocumentColors, Ack),+ (RefreshDocumentLinks, Ack),+ (RefreshFoldingRanges, Ack),+ (RefreshDocumentSymbols, Ack),(RejoinChannelBuffers, RejoinChannelBuffersResponse),(RejoinRoom, RejoinRoomResponse),(ReloadBuffers, ReloadBuffersResponse),@@ -724,6 +732,10 @@ entity_messages!(RefreshInlayHints,RefreshSemanticTokens,RefreshCodeLens,+ RefreshDocumentColors,+ RefreshDocumentLinks,+ RefreshFoldingRanges,+ RefreshDocumentSymbols,ReloadBuffers,RemoveProjectCollaborator,RenameProjectEntry,diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rsindex 0d53e3d9b47..8d07bfeb49a 100644--- a/crates/remote_server/src/remote_editing_tests.rs+++ b/crates/remote_server/src/remote_editing_tests.rs@@ -49,7 +49,10 @@ use std::{path::{Path, PathBuf},rc::Rc,str::FromStr,- sync::Arc,+ sync::{+ Arc,+ atomic::{AtomicUsize, Ordering},+ },};use unindent::Unindent as _;use util::{path, path_list::PathList, paths::PathMatcher, rel_path::rel_path};@@ -1191,6 +1194,462 @@ async fn test_remote_code_lens_fetch_after_lsp_starts();}+#[gpui::test]+async fn test_remote_code_lens_refetch_after_refresh(+ cx: &mut TestAppContext,+ server_cx: &mut TestAppContext,+) {+ let fs = FakeFs::new(server_cx.executor());+ fs.insert_tree(+ path!("/code"),+ json!({+ "project1": {+ ".git": {},+ "src": {+ "lib.rs": "fn one() -> usize { 1 }"+ }+ },+ }),+ )+ .await;++ let (project, headless) = init_test(&fs, cx, server_cx).await;++ let capabilities = lsp::ServerCapabilities {+ code_lens_provider: Some(lsp::CodeLensOptions {+ resolve_provider: None,+ }),+ ..lsp::ServerCapabilities::default()+ };++ cx.update_entity(&project, |project, _| {+ project.languages().register_test_language(LanguageConfig {+ name: "Rust".into(),+ matcher: LanguageMatcher {+ path_suffixes: vec!["rs".into()],+ ..LanguageMatcher::default()+ },+ ..LanguageConfig::default()+ });+ project.languages().register_fake_lsp_adapter(+ "Rust",+ FakeLspAdapter {+ name: "rust-analyzer",+ capabilities: capabilities.clone(),+ ..FakeLspAdapter::default()+ },+ );+ });++ let lens_generation = Arc::new(AtomicUsize::new(0));+ let mut fake_lsp_servers = server_cx.update(|cx| {+ headless.read(cx).languages.register_fake_lsp_server(+ LanguageServerName("rust-analyzer".into()),+ capabilities,+ Some(Box::new({+ let lens_generation = lens_generation.clone();+ move |fake_lsp| {+ let lens_generation = lens_generation.clone();+ fake_lsp.set_request_handler::<lsp::request::CodeLensRequest, _, _>(+ move |_, _| {+ let generation = lens_generation.load(Ordering::Acquire);+ async move {+ Ok(Some(vec![lsp::CodeLens {+ range: lsp::Range::new(+ lsp::Position::new(0, 0),+ lsp::Position::new(0, 9),+ ),+ command: Some(lsp::Command {+ title: format!("{generation} references"),+ command: "lens_cmd".to_string(),+ arguments: None,+ }),+ data: None,+ }]))+ }+ },+ );+ }+ })),+ )+ });++ cx.run_until_parked();++ let worktree_id = project+ .update(cx, |project, cx| {+ project.languages().add(rust_lang());+ project.find_or_create_worktree(path!("/code/project1"), true, cx)+ })+ .await+ .unwrap()+ .0+ .read_with(cx, |worktree, _| worktree.id());+ cx.run_until_parked();++ let (buffer, _handle) = project+ .update(cx, |project, cx| {+ project.open_buffer_with_lsp((worktree_id, rel_path("src/lib.rs")), cx)+ })+ .await+ .unwrap();+ let fake_lsp = fake_lsp_servers.next().await.unwrap();+ cx.run_until_parked();++ let lsp_store = project.read_with(cx, |project, _| project.lsp_store());+ let actions = lsp_store+ .update(cx, |lsp_store, cx| lsp_store.code_lens_actions(&buffer, cx))+ .await+ .unwrap()+ .expect("Should have code lens actions after the initial fetch");+ assert_eq!(+ actions+ .values()+ .map(|action| action.lsp_action.title().to_owned())+ .collect::<Vec<_>>(),+ vec!["0 references".to_string()],+ "Expected the initial code lens data on the client",+ );++ lens_generation.store(1, Ordering::Release);+ fake_lsp+ .request::<lsp::request::CodeLensRefresh>((), DEFAULT_LSP_REQUEST_TIMEOUT)+ .await+ .into_response()+ .unwrap();+ cx.run_until_parked();++ let actions = lsp_store+ .update(cx, |lsp_store, cx| lsp_store.code_lens_actions(&buffer, cx))+ .await+ .unwrap()+ .expect("Should have code lens actions after the refresh");+ assert_eq!(+ actions+ .values()+ .map(|action| action.lsp_action.title().to_owned())+ .collect::<Vec<_>>(),+ vec!["1 references".to_string()],+ "Expected the client to re-fetch code lens data after the server-initiated refresh, without any buffer edits",+ );+}++#[gpui::test]+async fn test_remote_lsp_data_cache_converges_with_multiple_servers(+ cx: &mut TestAppContext,+ server_cx: &mut TestAppContext,+) {+ let fs = FakeFs::new(server_cx.executor());+ fs.insert_tree(+ path!("/code"),+ json!({+ "project1": {+ ".git": {},+ "src": {+ "lib.rs": "fn one() -> usize { 1 }"+ }+ },+ "project2": {+ ".git": {},+ "src": {+ "lib.rs": "fn two() -> usize { 2 }"+ }+ },+ }),+ )+ .await;++ let (project, headless) = init_test(&fs, cx, server_cx).await;++ let capabilities = lsp::ServerCapabilities {+ code_lens_provider: Some(lsp::CodeLensOptions {+ resolve_provider: None,+ }),+ ..lsp::ServerCapabilities::default()+ };++ cx.update_entity(&project, |project, _| {+ project.languages().register_test_language(LanguageConfig {+ name: "Rust".into(),+ matcher: LanguageMatcher {+ path_suffixes: vec!["rs".into()],+ ..LanguageMatcher::default()+ },+ ..LanguageConfig::default()+ });+ project.languages().register_fake_lsp_adapter(+ "Rust",+ FakeLspAdapter {+ name: "rust-analyzer",+ capabilities: capabilities.clone(),+ ..FakeLspAdapter::default()+ },+ );+ });++ let queried_uris = Arc::new(std::sync::Mutex::new(Vec::new()));+ let mut fake_lsp_servers = server_cx.update(|cx| {+ headless.read(cx).languages.register_fake_lsp_server(+ LanguageServerName("rust-analyzer".into()),+ capabilities,+ Some(Box::new({+ let queried_uris = queried_uris.clone();+ move |fake_lsp| {+ let queried_uris = queried_uris.clone();+ fake_lsp.set_request_handler::<lsp::request::CodeLensRequest, _, _>(+ move |params, _| {+ queried_uris.lock().unwrap().push(params.text_document.uri);+ async move {+ Ok(Some(vec![lsp::CodeLens {+ range: lsp::Range::new(+ lsp::Position::new(0, 0),+ lsp::Position::new(0, 9),+ ),+ command: Some(lsp::Command {+ title: "the lens".to_string(),+ command: "lens_cmd".to_string(),+ arguments: None,+ }),+ data: None,+ }]))+ }+ },+ );+ }+ })),+ )+ });++ cx.run_until_parked();++ project.update(cx, |project, cx| {+ project.languages().add(rust_lang());+ cx.notify();+ });+ let mut buffers = Vec::new();+ let mut fake_lsps = Vec::new();+ for project_root in [path!("/code/project1"), path!("/code/project2")] {+ let worktree_id = project+ .update(cx, |project, cx| {+ project.find_or_create_worktree(project_root, true, cx)+ })+ .await+ .unwrap()+ .0+ .read_with(cx, |worktree, _| worktree.id());+ cx.run_until_parked();+ buffers.push(+ project+ .update(cx, |project, cx| {+ project.open_buffer_with_lsp((worktree_id, rel_path("src/lib.rs")), cx)+ })+ .await+ .unwrap(),+ );+ fake_lsps.push(fake_lsp_servers.next().await.unwrap());+ cx.run_until_parked();+ }+ let (buffer_1, _handle_1) = &buffers[0];+ let queried_lib_1 = vec![lsp::Uri::from_file_path(path!("/code/project1/src/lib.rs")).unwrap()];++ let lsp_store = project.read_with(cx, |project, _| project.lsp_store());+ lsp_store+ .update(cx, |lsp_store, cx| {+ lsp_store.code_lens_actions(buffer_1, cx)+ })+ .await+ .unwrap();+ assert_eq!(+ *queried_uris.lock().unwrap(),+ queried_lib_1,+ "Expected the initial fetch to query the buffer's own language server only",+ );++ lsp_store+ .update(cx, |lsp_store, cx| {+ lsp_store.code_lens_actions(buffer_1, cx)+ })+ .await+ .unwrap();+ assert_eq!(+ *queried_uris.lock().unwrap(),+ queried_lib_1,+ "Expected a repeated fetch to be served from the cache, despite the other worktree's server \+ never answering for this buffer",+ );++ let (buffer_1, _) = &buffers[0];+ buffer_1.update(cx, |buffer, cx| buffer.set_language(None, cx));+ cx.run_until_parked();+ let actions = lsp_store+ .update(cx, |lsp_store, cx| {+ lsp_store.code_lens_actions(buffer_1, cx)+ })+ .await+ .unwrap()+ .expect("Should have code lens actions cached");+ assert_eq!(+ actions+ .values()+ .map(|action| action.lsp_action.title().to_owned())+ .collect::<Vec<_>>(),+ vec!["the lens".to_string()],+ "Expected the cached data to survive an empty relevant server set (buffer without a language)",+ );+ assert_eq!(+ *queried_uris.lock().unwrap(),+ queried_lib_1,+ "Expected no new queries for the buffer without a language",+ );+}++#[gpui::test]+async fn test_remote_per_server_refresh_queries_only_the_refreshed_server(+ cx: &mut TestAppContext,+ server_cx: &mut TestAppContext,+) {+ let fs = FakeFs::new(server_cx.executor());+ fs.insert_tree(+ path!("/code"),+ json!({+ "project1": {+ ".git": {},+ "src": {+ "lib.fake": "fn one() -> usize { 1 }"+ }+ },+ }),+ )+ .await;++ let (project, headless) = init_test(&fs, cx, server_cx).await;++ let capabilities = lsp::ServerCapabilities {+ code_lens_provider: Some(lsp::CodeLensOptions {+ resolve_provider: None,+ }),+ ..lsp::ServerCapabilities::default()+ };++ // Both the client and the headless registries need the language and the adapters:+ // the client filters relevant servers by adapter names, while the headless one+ // detects the buffer's language and starts the servers.+ let fake_language_config = || LanguageConfig {+ name: "Fake".into(),+ matcher: LanguageMatcher {+ path_suffixes: vec!["fake".into()],+ ..LanguageMatcher::default()+ },+ ..LanguageConfig::default()+ };+ let fake_adapter =+ |server_name: &'static str, capabilities: &lsp::ServerCapabilities| FakeLspAdapter {+ name: server_name,+ capabilities: capabilities.clone(),+ ..FakeLspAdapter::default()+ };+ cx.update_entity(&project, |project, _| {+ project+ .languages()+ .register_test_language(fake_language_config());+ for server_name in ["server-a", "server-b"] {+ project+ .languages()+ .register_fake_lsp_adapter("Fake", fake_adapter(server_name, &capabilities));+ }+ });++ let request_counter = |fake_lsp: &mut lsp::FakeLanguageServer, counter: &Arc<AtomicUsize>| {+ let counter = counter.clone();+ fake_lsp.set_request_handler::<lsp::request::CodeLensRequest, _, _>(move |_, _| {+ counter.fetch_add(1, Ordering::Release);+ async move { Ok(Some(Vec::new())) }+ });+ };+ let lens_requests_a = Arc::new(AtomicUsize::new(0));+ let lens_requests_b = Arc::new(AtomicUsize::new(0));+ let (mut fake_lsp_servers_a, mut fake_lsp_servers_b) = server_cx.update(|cx| {+ let languages = &headless.read(cx).languages;+ languages.register_test_language(fake_language_config());+ for server_name in ["server-a", "server-b"] {+ languages.register_fake_lsp_adapter("Fake", fake_adapter(server_name, &capabilities));+ }+ let fake_lsp_servers_a = languages.register_fake_lsp_server(+ LanguageServerName("server-a".into()),+ capabilities.clone(),+ Some(Box::new({+ let lens_requests_a = lens_requests_a.clone();+ move |fake_lsp| request_counter(fake_lsp, &lens_requests_a)+ })),+ );+ let fake_lsp_servers_b = languages.register_fake_lsp_server(+ LanguageServerName("server-b".into()),+ capabilities.clone(),+ Some(Box::new({+ let lens_requests_b = lens_requests_b.clone();+ move |fake_lsp| request_counter(fake_lsp, &lens_requests_b)+ })),+ );+ (fake_lsp_servers_a, fake_lsp_servers_b)+ });++ cx.run_until_parked();++ let worktree_id = project+ .update(cx, |project, cx| {+ project.find_or_create_worktree(path!("/code/project1"), true, cx)+ })+ .await+ .unwrap()+ .0+ .read_with(cx, |worktree, _| worktree.id());+ cx.run_until_parked();++ let (buffer, _handle) = project+ .update(cx, |project, cx| {+ project.open_buffer_with_lsp((worktree_id, rel_path("src/lib.fake")), cx)+ })+ .await+ .unwrap();+ let fake_lsp_a = fake_lsp_servers_a.next().await.unwrap();+ let _fake_lsp_b = fake_lsp_servers_b.next().await.unwrap();+ cx.run_until_parked();++ let lsp_store = project.read_with(cx, |project, _| project.lsp_store());+ lsp_store+ .update(cx, |lsp_store, cx| lsp_store.code_lens_actions(&buffer, cx))+ .await+ .unwrap();+ assert_eq!(+ (+ lens_requests_a.load(Ordering::Acquire),+ lens_requests_b.load(Ordering::Acquire),+ ),+ (1, 1),+ "Expected the initial fetch to query both servers",+ );++ fake_lsp_a+ .request::<lsp::request::CodeLensRefresh>((), DEFAULT_LSP_REQUEST_TIMEOUT)+ .await+ .into_response()+ .unwrap();+ cx.run_until_parked();++ lsp_store+ .update(cx, |lsp_store, cx| lsp_store.code_lens_actions(&buffer, cx))+ .await+ .unwrap();+ assert_eq!(+ (+ lens_requests_a.load(Ordering::Acquire),+ lens_requests_b.load(Ordering::Acquire),+ ),+ (2, 1),+ "Expected the refetch after a per-server refresh to query the refreshed server only",+ );+}+#[gpui::test]async fn test_remote_code_lens_resolve(cx: &mut TestAppContext, server_cx: &mut TestAppContext) {cx.update(|cx| {diff --git a/crates/search/src/project_search.rs b/crates/search/src/project_search.rsindex 4498920db75..39764a066ac 100644--- a/crates/search/src/project_search.rs+++ b/crates/search/src/project_search.rs@@ -5495,18 +5495,17 @@ pub mod tests {"Newly opened editor should have the correct text with hints",);});- project.update(cx, |_, cx| {- cx.emit(project::Event::RefreshInlayHints {- server_id: fake_server.server.server_id(),- request_id: Some(1),- });- });+ fake_server+ .request::<lsp::request::InlayHintRefreshRequest>((), lsp::DEFAULT_LSP_REQUEST_TIMEOUT)+ .await+ .into_response()+ .unwrap();cx.executor().advance_clock(Duration::from_secs(1));cx.executor().run_until_parked();assert_eq!(requests_count.load(atomic::Ordering::Acquire),5,- "After a simulated server refresh request, we should have sent another request",+ "After a server refresh request, we should have sent another request",);perform_search(search_view, "let ", cx);