Skip to content

armgit / zed

Public Imported from GitHub
0

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

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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| &registrations.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(&registration_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)>>
where
P: 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, &reg.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.rs
index 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,
+ &current_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.rs
index 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,
+ &current_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_task
diff --git a/crates/project/src/lsp_store/document_links.rs b/crates/project/src/lsp_store/document_links.rs
index 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,
+ &current_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.rs
index 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,
+ &current_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.rs
new file mode 100644
index 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, &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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,
+ &reg.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.rs
index 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,
+ &current_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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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.proto
index 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.proto
index 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.rs
index 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.rs
index 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.rs
index 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);