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.

lsp: Scope logs and status updates to their projects (#61221)

Shuhei Kadowaki60bf47b9f2ff
diff --git a/crates/activity_indicator/src/activity_indicator.rs b/crates/activity_indicator/src/activity_indicator.rs
index dccc0bcafcc..d3a3458876f 100644
--- a/crates/activity_indicator/src/activity_indicator.rs
+++ b/crates/activity_indicator/src/activity_indicator.rs
@@ -7,8 +7,7 @@ use gpui::{
SharedString, Styled, Task, Window, actions,
};
use language::{
- BinaryStatus, LanguageRegistry, LanguageServerId, LanguageServerName,
- LanguageServerStatusUpdate, ServerHealth,
+ BinaryStatus, LanguageServerId, LanguageServerName, LanguageServerStatusUpdate, ServerHealth,
};
use project::{
LanguageServerProgress, LspStoreEvent, ProgressToken, Project, ProjectEnvironmentEvent,
@@ -91,28 +90,11 @@ struct Content {
impl ActivityIndicator {
pub fn new(
workspace: &mut Workspace,
- languages: Arc<LanguageRegistry>,
window: &mut Window,
cx: &mut Context<Workspace>,
) -> Entity<ActivityIndicator> {
let project = workspace.project().clone();
let this = cx.new(|cx| {
- let mut status_events = languages.language_server_binary_statuses();
- cx.spawn(async move |this, cx| {
- while let Some((name, binary_status)) = status_events.next().await {
- this.update(cx, |this: &mut ActivityIndicator, cx| {
- this.statuses.retain(|s| s.name != name);
- this.statuses.push(ServerStatus {
- name,
- status: LanguageServerStatusUpdate::Binary(binary_status),
- });
- cx.notify();
- })?;
- }
- anyhow::Ok(())
- })
- .detach();
-
let fs = project.read(cx).fs().clone();
let mut job_events = fs.subscribe_to_jobs();
cx.spawn(async move |this, cx| {
diff --git a/crates/collab/tests/integration/remote_editing_collaboration_tests.rs b/crates/collab/tests/integration/remote_editing_collaboration_tests.rs
index d039bce3b39..06989f81369 100644
--- a/crates/collab/tests/integration/remote_editing_collaboration_tests.rs
+++ b/crates/collab/tests/integration/remote_editing_collaboration_tests.rs
@@ -927,12 +927,12 @@ async fn test_ssh_restarting_language_server_replaces_remote_status(
let matching_server_ids = log_store
.language_servers
.iter()
- .filter_map(|(server_id, state)| {
+ .filter_map(|(key, state)| {
state
.name
.as_ref()
.is_some_and(|name| name.0 == "the-language-server")
- .then_some(*server_id)
+ .then_some(key.server_id)
})
.collect::<Vec<_>>();
assert_eq!(matching_server_ids, vec![first_server_id]);
@@ -958,10 +958,6 @@ async fn test_ssh_restarting_language_server_replaces_remote_status(
statuses[0].0, restarted_server_id,
"restarting a remote language server should publish the replacement server id"
);
- assert_ne!(
- statuses[0].0, first_server_id,
- "restarting a remote language server should remove the previous server id"
- );
assert_eq!(statuses[0].1.name.0, "the-language-server");
});
cx_a.read_global::<GlobalLogStore, _>(|global, cx| {
@@ -969,12 +965,12 @@ async fn test_ssh_restarting_language_server_replaces_remote_status(
let matching_server_ids = log_store
.language_servers
.iter()
- .filter_map(|(server_id, state)| {
+ .filter_map(|(key, state)| {
state
.name
.as_ref()
.is_some_and(|name| name.0 == "the-language-server")
- .then_some(*server_id)
+ .then_some(key.server_id)
})
.collect::<Vec<_>>();
assert_eq!(
@@ -982,10 +978,6 @@ async fn test_ssh_restarting_language_server_replaces_remote_status(
vec![restarted_server_id],
"restarting a remote language server should replace the old log store entry"
);
- assert!(
- !log_store.language_servers.contains_key(&first_server_id),
- "restarting a remote language server should remove the previous log store entry"
- );
});
}
diff --git a/crates/extension/src/extension.rs b/crates/extension/src/extension.rs
index 850da7a69e8..ceffef8efef 100644
--- a/crates/extension/src/extension.rs
+++ b/crates/extension/src/extension.rs
@@ -11,7 +11,7 @@ use std::sync::Arc;
use ::lsp::LanguageServerName;
use anyhow::{Context as _, Result, bail};
use async_trait::async_trait;
-use gpui::{App, Task};
+use gpui::{App, EntityId, Task};
use language::LanguageName;
use semver::Version;
use task::{SpawnInTerminal, ZedDebugConfig};
@@ -64,6 +64,7 @@ pub trait Extension: Send + Sync + 'static {
language_server_id: LanguageServerName,
language_name: LanguageName,
worktree: Arc<dyn WorktreeDelegate>,
+ language_server_status_source: EntityId,
) -> Result<Command>;
async fn language_server_initialization_options(
@@ -71,24 +72,28 @@ pub trait Extension: Send + Sync + 'static {
language_server_id: LanguageServerName,
language_name: LanguageName,
worktree: Arc<dyn WorktreeDelegate>,
+ language_server_status_source: EntityId,
) -> Result<Option<String>>;
async fn language_server_workspace_configuration(
&self,
language_server_id: LanguageServerName,
worktree: Arc<dyn WorktreeDelegate>,
+ language_server_status_source: EntityId,
) -> Result<Option<String>>;
async fn language_server_initialization_options_schema(
&self,
language_server_id: LanguageServerName,
worktree: Arc<dyn WorktreeDelegate>,
+ language_server_status_source: EntityId,
) -> Result<Option<String>>;
async fn language_server_workspace_configuration_schema(
&self,
language_server_id: LanguageServerName,
worktree: Arc<dyn WorktreeDelegate>,
+ language_server_status_source: EntityId,
) -> Result<Option<String>>;
async fn language_server_additional_initialization_options(
@@ -96,6 +101,7 @@ pub trait Extension: Send + Sync + 'static {
language_server_id: LanguageServerName,
target_language_server_id: LanguageServerName,
worktree: Arc<dyn WorktreeDelegate>,
+ language_server_status_source: EntityId,
) -> Result<Option<String>>;
async fn language_server_additional_workspace_configuration(
@@ -103,6 +109,7 @@ pub trait Extension: Send + Sync + 'static {
language_server_id: LanguageServerName,
target_language_server_id: LanguageServerName,
worktree: Arc<dyn WorktreeDelegate>,
+ language_server_status_source: EntityId,
) -> Result<Option<String>>;
async fn labels_for_completions(
diff --git a/crates/extension/src/extension_host_proxy.rs b/crates/extension/src/extension_host_proxy.rs
index 6190e86294a..90500170913 100644
--- a/crates/extension/src/extension_host_proxy.rs
+++ b/crates/extension/src/extension_host_proxy.rs
@@ -3,7 +3,7 @@ use std::sync::Arc;
use anyhow::Result;
use fs::Fs;
-use gpui::{App, Global, ReadGlobal, SharedString, Task};
+use gpui::{App, EntityId, Global, ReadGlobal, SharedString, Task};
use language::{BinaryStatus, LanguageLoader, LanguageMatcher, LanguageName};
use lsp::LanguageServerName;
use parking_lot::RwLock;
@@ -301,6 +301,7 @@ pub trait ExtensionLanguageServerProxy: Send + Sync + 'static {
fn update_language_server_status(
&self,
+ source: Option<EntityId>,
language_server_id: LanguageServerName,
status: BinaryStatus,
);
@@ -335,6 +336,7 @@ impl ExtensionLanguageServerProxy for ExtensionHostProxy {
fn update_language_server_status(
&self,
+ source: Option<EntityId>,
language_server_id: LanguageServerName,
status: BinaryStatus,
) {
@@ -342,7 +344,7 @@ impl ExtensionLanguageServerProxy for ExtensionHostProxy {
return;
};
- proxy.update_language_server_status(language_server_id, status)
+ proxy.update_language_server_status(source, language_server_id, status)
}
}
diff --git a/crates/extension_host/src/extension_store_test.rs b/crates/extension_host/src/extension_store_test.rs
index e39a57fb1a2..ad6679e8fe0 100644
--- a/crates/extension_host/src/extension_store_test.rs
+++ b/crates/extension_host/src/extension_store_test.rs
@@ -22,7 +22,7 @@ use extension::{
};
use fs::{FakeFs, Fs, RealFs, RemoveOptions};
use futures::{AsyncReadExt, FutureExt, StreamExt, io::BufReader};
-use gpui::{AppContext as _, BackgroundExecutor, Entity, TaskExt, TestAppContext};
+use gpui::{AppContext as _, BackgroundExecutor, Entity, EntityId, TaskExt, TestAppContext};
use http_client::{FakeHttpClient, Response};
use language::{
BinaryStatus, LanguageConfig, LanguageMatcher, LanguageName, LanguageRegistry, QueryFiles,
@@ -826,6 +826,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
let theme_registry = Arc::new(ThemeRegistry::new(Box::new(())));
theme_extension::init(proxy.clone(), theme_registry.clone(), cx.executor());
let language_registry = project.read_with(cx, |project, _cx| project.languages().clone());
+ let lsp_store_id = project.read_with(cx, |project, _| project.lsp_store().entity_id());
language_extension::init(
LspAccess::ViaLspStore(
project
@@ -837,7 +838,8 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
);
let node_runtime = NodeRuntime::unavailable();
- let mut status_updates = language_registry.language_server_binary_statuses();
+ let (mut status_updates, _status_updates_subscription) =
+ language_registry.language_server_binary_statuses();
struct FakeLanguageServerVersion {
version: String,
@@ -1093,18 +1095,25 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {
],
[
(
+ Some(lsp_store_id),
LanguageServerName::new_static("gleam"),
BinaryStatus::Starting
),
(
+ Some(lsp_store_id),
LanguageServerName::new_static("gleam"),
BinaryStatus::CheckingForUpdate
),
(
+ Some(lsp_store_id),
LanguageServerName::new_static("gleam"),
BinaryStatus::Downloading
),
- (LanguageServerName::new_static("gleam"), BinaryStatus::None)
+ (
+ Some(lsp_store_id),
+ LanguageServerName::new_static("gleam"),
+ BinaryStatus::None
+ )
]
);
@@ -4107,6 +4116,7 @@ impl Extension for FakeExtension {
_language_server_id: LanguageServerName,
_language_name: LanguageName,
_worktree: Arc<dyn WorktreeDelegate>,
+ _language_server_status_source: EntityId,
) -> anyhow::Result<Command> {
anyhow::bail!("not supported by FakeExtension")
}
@@ -4116,6 +4126,7 @@ impl Extension for FakeExtension {
_language_server_id: LanguageServerName,
_language_name: LanguageName,
_worktree: Arc<dyn WorktreeDelegate>,
+ _language_server_status_source: EntityId,
) -> anyhow::Result<Option<String>> {
anyhow::bail!("not supported by FakeExtension")
}
@@ -4124,6 +4135,7 @@ impl Extension for FakeExtension {
&self,
_language_server_id: LanguageServerName,
_worktree: Arc<dyn WorktreeDelegate>,
+ _language_server_status_source: EntityId,
) -> anyhow::Result<Option<String>> {
anyhow::bail!("not supported by FakeExtension")
}
@@ -4132,6 +4144,7 @@ impl Extension for FakeExtension {
&self,
_language_server_id: LanguageServerName,
_worktree: Arc<dyn WorktreeDelegate>,
+ _language_server_status_source: EntityId,
) -> anyhow::Result<Option<String>> {
anyhow::bail!("not supported by FakeExtension")
}
@@ -4140,6 +4153,7 @@ impl Extension for FakeExtension {
&self,
_language_server_id: LanguageServerName,
_worktree: Arc<dyn WorktreeDelegate>,
+ _language_server_status_source: EntityId,
) -> anyhow::Result<Option<String>> {
anyhow::bail!("not supported by FakeExtension")
}
@@ -4149,6 +4163,7 @@ impl Extension for FakeExtension {
_language_server_id: LanguageServerName,
_target_language_server_id: LanguageServerName,
_worktree: Arc<dyn WorktreeDelegate>,
+ _language_server_status_source: EntityId,
) -> anyhow::Result<Option<String>> {
anyhow::bail!("not supported by FakeExtension")
}
@@ -4158,6 +4173,7 @@ impl Extension for FakeExtension {
_language_server_id: LanguageServerName,
_target_language_server_id: LanguageServerName,
_worktree: Arc<dyn WorktreeDelegate>,
+ _language_server_status_source: EntityId,
) -> anyhow::Result<Option<String>> {
anyhow::bail!("not supported by FakeExtension")
}
diff --git a/crates/extension_host/src/wasm_host.rs b/crates/extension_host/src/wasm_host.rs
index c04445f4dca..857d33e0de7 100644
--- a/crates/extension_host/src/wasm_host.rs
+++ b/crates/extension_host/src/wasm_host.rs
@@ -21,7 +21,7 @@ use futures::{
},
future::BoxFuture,
};
-use gpui::{App, AsyncApp, BackgroundExecutor, Task};
+use gpui::{App, AsyncApp, BackgroundExecutor, EntityId, Task};
use http_client::HttpClient;
use language::LanguageName;
use lsp::LanguageServerName;
@@ -90,8 +90,9 @@ impl extension::Extension for WasmExtension {
language_server_id: LanguageServerName,
language_name: LanguageName,
worktree: Arc<dyn WorktreeDelegate>,
+ status_source: EntityId,
) -> Result<Command> {
- self.call(|extension, store| {
+ self.call_with_language_server_status_source(status_source, move |extension, store| {
async move {
let resource = store.data_mut().table.push(worktree)?;
let command = extension
@@ -116,8 +117,9 @@ impl extension::Extension for WasmExtension {
language_server_id: LanguageServerName,
language_name: LanguageName,
worktree: Arc<dyn WorktreeDelegate>,
+ status_source: EntityId,
) -> Result<Option<String>> {
- self.call(|extension, store| {
+ self.call_with_language_server_status_source(status_source, move |extension, store| {
async move {
let resource = store.data_mut().table.push(worktree)?;
let options = extension
@@ -140,8 +142,9 @@ impl extension::Extension for WasmExtension {
&self,
language_server_id: LanguageServerName,
worktree: Arc<dyn WorktreeDelegate>,
+ status_source: EntityId,
) -> Result<Option<String>> {
- self.call(|extension, store| {
+ self.call_with_language_server_status_source(status_source, move |extension, store| {
async move {
let resource = store.data_mut().table.push(worktree)?;
let options = extension
@@ -163,8 +166,9 @@ impl extension::Extension for WasmExtension {
&self,
language_server_id: LanguageServerName,
worktree: Arc<dyn WorktreeDelegate>,
+ status_source: EntityId,
) -> Result<Option<String>> {
- self.call(|extension, store| {
+ self.call_with_language_server_status_source(status_source, move |extension, store| {
async move {
let resource = store.data_mut().table.push(worktree)?;
extension
@@ -185,8 +189,9 @@ impl extension::Extension for WasmExtension {
&self,
language_server_id: LanguageServerName,
worktree: Arc<dyn WorktreeDelegate>,
+ status_source: EntityId,
) -> Result<Option<String>> {
- self.call(|extension, store| {
+ self.call_with_language_server_status_source(status_source, move |extension, store| {
async move {
let resource = store.data_mut().table.push(worktree)?;
extension
@@ -208,8 +213,9 @@ impl extension::Extension for WasmExtension {
language_server_id: LanguageServerName,
target_language_server_id: LanguageServerName,
worktree: Arc<dyn WorktreeDelegate>,
+ status_source: EntityId,
) -> Result<Option<String>> {
- self.call(|extension, store| {
+ self.call_with_language_server_status_source(status_source, move |extension, store| {
async move {
let resource = store.data_mut().table.push(worktree)?;
let options = extension
@@ -233,8 +239,9 @@ impl extension::Extension for WasmExtension {
language_server_id: LanguageServerName,
target_language_server_id: LanguageServerName,
worktree: Arc<dyn WorktreeDelegate>,
+ status_source: EntityId,
) -> Result<Option<String>> {
- self.call(|extension, store| {
+ self.call_with_language_server_status_source(status_source, move |extension, store| {
async move {
let resource = store.data_mut().table.push(worktree)?;
let options = extension
@@ -538,6 +545,7 @@ pub struct WasmState {
ctx: WasiCtx,
pub host: Arc<WasmHost>,
pub(crate) capability_granter: CapabilityGranter,
+ pub(crate) language_server_status_source: Option<gpui::EntityId>,
}
type MainThreadCall = Box<dyn Send + for<'a> FnOnce(&'a mut AsyncApp) -> LocalBoxFuture<'a, ()>>;
@@ -671,6 +679,7 @@ impl WasmHost {
this.granted_capabilities.clone(),
manifest.clone(),
),
+ language_server_status_source: None,
},
);
// Store will yield after 1 tick, and get a new deadline of 1 tick after each yield.
@@ -872,6 +881,34 @@ impl WasmExtension {
.with_context(|| format!("loading wasm extension: {}", manifest.id))
}
+ async fn call_with_language_server_status_source<T, Fn>(
+ &self,
+ source: EntityId,
+ f: Fn,
+ ) -> Result<T>
+ where
+ T: 'static + Send,
+ Fn: 'static
+ + Send
+ + for<'a> FnOnce(&'a mut Extension, &'a mut Store<WasmState>) -> BoxFuture<'a, T>,
+ {
+ self.call(move |extension, store| {
+ async move {
+ debug_assert!(store.data().language_server_status_source.is_none());
+
+ // The installation-status WIT methods do not receive a worktree, so expose the
+ // source through WasmState for the duration of this serialized extension call.
+ // Clear it before returning so failed calls cannot affect the next invocation.
+ store.data_mut().language_server_status_source = Some(source);
+ let result = f(extension, store).await;
+ store.data_mut().language_server_status_source = None;
+ result
+ }
+ .boxed()
+ })
+ .await
+ }
+
pub async fn call<T, Fn>(&self, f: Fn) -> Result<T>
where
T: 'static + Send,
diff --git a/crates/extension_host/src/wasm_host/wit/since_v0_0_1.rs b/crates/extension_host/src/wasm_host/wit/since_v0_0_1.rs
index 57dfa5b5afb..582e78f813b 100644
--- a/crates/extension_host/src/wasm_host/wit/since_v0_0_1.rs
+++ b/crates/extension_host/src/wasm_host/wit/since_v0_0_1.rs
@@ -148,9 +148,11 @@ impl ExtensionImports for WasmState {
LanguageServerInstallationStatus::Failed(error) => BinaryStatus::Failed { error },
};
- self.host
- .proxy
- .update_language_server_status(lsp::LanguageServerName(server_name.into()), status);
+ self.host.proxy.update_language_server_status(
+ self.language_server_status_source,
+ lsp::LanguageServerName(server_name.into()),
+ status,
+ );
Ok(())
}
diff --git a/crates/extension_host/src/wasm_host/wit/since_v0_1_0.rs b/crates/extension_host/src/wasm_host/wit/since_v0_1_0.rs
index f2b9adf5cf7..d7df044773e 100644
--- a/crates/extension_host/src/wasm_host/wit/since_v0_1_0.rs
+++ b/crates/extension_host/src/wasm_host/wit/since_v0_1_0.rs
@@ -507,9 +507,11 @@ impl ExtensionImports for WasmState {
LanguageServerInstallationStatus::Failed(error) => BinaryStatus::Failed { error },
};
- self.host
- .proxy
- .update_language_server_status(::lsp::LanguageServerName(server_name.into()), status);
+ self.host.proxy.update_language_server_status(
+ self.language_server_status_source,
+ ::lsp::LanguageServerName(server_name.into()),
+ status,
+ );
Ok(())
}
diff --git a/crates/extension_host/src/wasm_host/wit/since_v0_8_0.rs b/crates/extension_host/src/wasm_host/wit/since_v0_8_0.rs
index 4fed1b313aa..57d5e808f13 100644
--- a/crates/extension_host/src/wasm_host/wit/since_v0_8_0.rs
+++ b/crates/extension_host/src/wasm_host/wit/since_v0_8_0.rs
@@ -1064,9 +1064,11 @@ impl ExtensionImports for WasmState {
LanguageServerInstallationStatus::Failed(error) => BinaryStatus::Failed { error },
};
- self.host
- .proxy
- .update_language_server_status(::lsp::LanguageServerName(server_name.into()), status);
+ self.host.proxy.update_language_server_status(
+ self.language_server_status_source,
+ ::lsp::LanguageServerName(server_name.into()),
+ status,
+ );
Ok(())
}
diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index 82580344479..a7791c51e79 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -39,7 +39,7 @@ use collections::{HashMap, HashSet};
use futures::Future;
use futures::future::LocalBoxFuture;
use futures::lock::OwnedMutexGuard;
-use gpui::{App, AsyncApp, Entity};
+use gpui::{App, AsyncApp, Entity, EntityId};
use http_client::HttpClient;
pub use language_core::{
@@ -492,6 +492,7 @@ pub trait LspAdapterDelegate: Send + Sync {
fn worktree_id(&self) -> WorktreeId;
fn worktree_root_path(&self) -> &Path;
fn resolve_relative_path(&self, path: PathBuf) -> PathBuf;
+ fn status_source_id(&self) -> EntityId;
fn update_status(&self, language: LanguageServerName, status: BinaryStatus);
fn registered_lsp_adapters(&self) -> Vec<Arc<dyn LspAdapter>>;
async fn language_server_download_dir(&self, name: &LanguageServerName) -> Option<Arc<Path>>;
diff --git a/crates/language/src/language_registry.rs b/crates/language/src/language_registry.rs
index 22561ee834f..4a3accb9d17 100644
--- a/crates/language/src/language_registry.rs
+++ b/crates/language/src/language_registry.rs
@@ -19,7 +19,7 @@ use futures::{
future::{BoxFuture, FutureExt as _},
};
use globset::GlobSet;
-use gpui::{App, BackgroundExecutor};
+use gpui::{App, BackgroundExecutor, EntityId, Subscription};
use lsp::LanguageServerId;
use parking_lot::{Mutex, RwLock};
use postage::watch;
@@ -89,9 +89,17 @@ impl std::fmt::Display for LanguageNotFound {
}
}
+type ServerStatus = (Option<EntityId>, LanguageServerName, BinaryStatus);
+
#[derive(Clone, Default)]
struct ServerStatusSender {
- txs: Arc<Mutex<Vec<mpsc::UnboundedSender<(LanguageServerName, BinaryStatus)>>>>,
+ state: Arc<Mutex<ServerStatusSenderState>>,
+}
+
+#[derive(Default)]
+struct ServerStatusSenderState {
+ next_subscription_id: usize,
+ txs: HashMap<usize, mpsc::UnboundedSender<ServerStatus>>,
}
pub struct LoadedLanguage {
@@ -922,7 +930,17 @@ impl LanguageRegistry {
}
pub fn update_lsp_binary_status(&self, server_name: LanguageServerName, status: BinaryStatus) {
- self.lsp_binary_status_tx.send(server_name, status);
+ self.lsp_binary_status_tx.send(None, server_name, status);
+ }
+
+ pub fn update_lsp_binary_status_for_entity(
+ &self,
+ source: EntityId,
+ server_name: LanguageServerName,
+ status: BinaryStatus,
+ ) {
+ self.lsp_binary_status_tx
+ .send(Some(source), server_name, status);
}
pub fn next_language_server_id(&self) -> LanguageServerId {
@@ -968,7 +986,10 @@ impl LanguageRegistry {
pub fn language_server_binary_statuses(
&self,
- ) -> mpsc::UnboundedReceiver<(LanguageServerName, BinaryStatus)> {
+ ) -> (
+ mpsc::UnboundedReceiver<(Option<EntityId>, LanguageServerName, BinaryStatus)>,
+ Subscription,
+ ) {
self.lsp_binary_status_tx.subscribe()
}
}
@@ -1065,14 +1086,41 @@ impl LanguageRegistryState {
}
impl ServerStatusSender {
- fn subscribe(&self) -> mpsc::UnboundedReceiver<(LanguageServerName, BinaryStatus)> {
+ fn subscribe(&self) -> (mpsc::UnboundedReceiver<ServerStatus>, Subscription) {
let (tx, rx) = mpsc::unbounded();
- self.txs.lock().push(tx);
- rx
+ let subscription_id = {
+ let mut state = self.state.lock();
+ let subscription_id = post_inc(&mut state.next_subscription_id);
+ state.txs.insert(subscription_id, tx);
+ subscription_id
+ };
+ let state = self.state.clone();
+ let subscription = Subscription::new(move || {
+ state.lock().txs.remove(&subscription_id);
+ });
+ (rx, subscription)
+ }
+
+ fn send(&self, source: Option<EntityId>, name: LanguageServerName, status: BinaryStatus) {
+ let mut state = self.state.lock();
+ state.txs.retain(|_, tx| {
+ tx.unbounded_send((source, name.clone(), status.clone()))
+ .is_ok()
+ });
}
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn dropping_server_status_subscription_unregisters_sender() {
+ let sender = ServerStatusSender::default();
+ let (_receiver, subscription) = sender.subscribe();
+ assert_eq!(sender.state.lock().txs.len(), 1);
- fn send(&self, name: LanguageServerName, status: BinaryStatus) {
- let mut txs = self.txs.lock();
- txs.retain(|tx| tx.unbounded_send((name.clone(), status.clone())).is_ok());
+ drop(subscription);
+ assert!(sender.state.lock().txs.is_empty());
}
}
diff --git a/crates/language_extension/src/extension_lsp_adapter.rs b/crates/language_extension/src/extension_lsp_adapter.rs
index d9f28100d80..378e82a1609 100644
--- a/crates/language_extension/src/extension_lsp_adapter.rs
+++ b/crates/language_extension/src/extension_lsp_adapter.rs
@@ -122,6 +122,7 @@ impl ExtensionLanguageServerProxy for LanguageServerRegistryProxy {
fn update_language_server_status(
&self,
+ source: Option<gpui::EntityId>,
language_server_id: LanguageServerName,
status: BinaryStatus,
) {
@@ -130,8 +131,16 @@ impl ExtensionLanguageServerProxy for LanguageServerRegistryProxy {
language_server_id,
status
);
- self.language_registry
- .update_lsp_binary_status(language_server_id, status);
+ if let Some(source) = source {
+ self.language_registry.update_lsp_binary_status_for_entity(
+ source,
+ language_server_id,
+ status,
+ );
+ } else {
+ self.language_registry
+ .update_lsp_binary_status(language_server_id, status);
+ }
}
}
@@ -167,6 +176,7 @@ impl DynLspInstaller for ExtensionLspAdapter {
) -> LanguageServerBinaryLocations {
async move {
let ret = maybe!(async move {
+ let language_server_status_source = delegate.status_source_id();
let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
let command = self
.extension
@@ -174,6 +184,7 @@ impl DynLspInstaller for ExtensionLspAdapter {
self.language_server_id.clone(),
self.language_name.clone(),
delegate,
+ language_server_status_source,
)
.await?;
@@ -314,6 +325,7 @@ impl LspAdapter for ExtensionLspAdapter {
delegate: &Arc<dyn LspAdapterDelegate>,
_: &mut AsyncApp,
) -> Result<Option<serde_json::Value>> {
+ let language_server_status_source = delegate.status_source_id();
let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
let json_options = self
.extension
@@ -321,6 +333,7 @@ impl LspAdapter for ExtensionLspAdapter {
self.language_server_id.clone(),
self.language_name.clone(),
delegate,
+ language_server_status_source,
)
.await?;
Ok(if let Some(json_options) = json_options {
@@ -339,10 +352,15 @@ impl LspAdapter for ExtensionLspAdapter {
_: Option<Uri>,
_cx: &mut AsyncApp,
) -> Result<Value> {
+ let language_server_status_source = delegate.status_source_id();
let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
let json_options: Option<String> = self
.extension
- .language_server_workspace_configuration(self.language_server_id.clone(), delegate)
+ .language_server_workspace_configuration(
+ self.language_server_id.clone(),
+ delegate,
+ language_server_status_source,
+ )
.await?;
Ok(if let Some(json_options) = json_options {
serde_json::from_str(&json_options).with_context(|| {
@@ -359,12 +377,14 @@ impl LspAdapter for ExtensionLspAdapter {
_cached_binary: OwnedMutexGuard<Option<(bool, LanguageServerBinary)>>,
_cx: &mut AsyncApp,
) -> Option<serde_json::Value> {
+ let language_server_status_source = delegate.status_source_id();
let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
let json_schema: Option<String> = self
.extension
.language_server_initialization_options_schema(
self.language_server_id.clone(),
delegate,
+ language_server_status_source,
)
.await
.ok()
@@ -378,12 +398,14 @@ impl LspAdapter for ExtensionLspAdapter {
_cached_binary: OwnedMutexGuard<Option<(bool, LanguageServerBinary)>>,
_cx: &mut AsyncApp,
) -> Option<serde_json::Value> {
+ let language_server_status_source = delegate.status_source_id();
let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
let json_schema: Option<String> = self
.extension
.language_server_workspace_configuration_schema(
self.language_server_id.clone(),
delegate,
+ language_server_status_source,
)
.await
.ok()
@@ -396,6 +418,7 @@ impl LspAdapter for ExtensionLspAdapter {
target_language_server_id: LanguageServerName,
delegate: &Arc<dyn LspAdapterDelegate>,
) -> Result<Option<serde_json::Value>> {
+ let language_server_status_source = delegate.status_source_id();
let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
let json_options: Option<String> = self
.extension
@@ -403,6 +426,7 @@ impl LspAdapter for ExtensionLspAdapter {
self.language_server_id.clone(),
target_language_server_id.clone(),
delegate,
+ language_server_status_source,
)
.await?;
Ok(if let Some(json_options) = json_options {
@@ -424,6 +448,7 @@ impl LspAdapter for ExtensionLspAdapter {
_cx: &mut AsyncApp,
) -> Result<Option<serde_json::Value>> {
+ let language_server_status_source = delegate.status_source_id();
let delegate = Arc::new(WorktreeDelegateAdapter(delegate.clone())) as _;
let json_options: Option<String> = self
.extension
@@ -431,6 +456,7 @@ impl LspAdapter for ExtensionLspAdapter {
self.language_server_id.clone(),
target_language_server_id.clone(),
delegate,
+ language_server_status_source,
)
.await?;
Ok(if let Some(json_options) = json_options {
diff --git a/crates/language_tools/src/lsp_button.rs b/crates/language_tools/src/lsp_button.rs
index f5c3c2e28f5..49bd5053dd5 100644
--- a/crates/language_tools/src/lsp_button.rs
+++ b/crates/language_tools/src/lsp_button.rs
@@ -346,7 +346,15 @@ impl LanguageServerState {
.lsp_store
.update(cx, |lsp_store, _| lsp_store.as_remote().is_some())
.unwrap_or(false);
- let has_logs = is_remote || lsp_logs.read(cx).has_server_logs(&server_selector);
+ let has_logs = is_remote
+ || self.workspace.upgrade().is_some_and(|workspace| {
+ let project = workspace.read(cx).project();
+ lsp_logs.read(cx).has_server_logs(
+ &server_selector,
+ &project.downgrade(),
+ &self.lsp_store,
+ )
+ });
let (status_color, status_label) = server_info
.binary_status
diff --git a/crates/language_tools/src/lsp_log_view.rs b/crates/language_tools/src/lsp_log_view.rs
index ace4a0da962..338efb35e36 100644
--- a/crates/language_tools/src/lsp_log_view.rs
+++ b/crates/language_tools/src/lsp_log_view.rs
@@ -13,7 +13,9 @@ use lsp::{
};
use project::{
LanguageServerStatus, Project,
- lsp_store::log_store::{self, Event, LanguageServerKind, LogKind, LogStore, Message},
+ lsp_store::log_store::{
+ self, Event, LanguageServerKind, LanguageServerLogKey, LogKind, LogStore, Message,
+ },
search::SearchQuery,
};
use proto::toggle_lsp_logs::LogType;
@@ -44,6 +46,9 @@ pub fn open(
workspace
.update_in(cx, |workspace, window, cx| {
let project = workspace.project().clone();
+ let weak_project = project.downgrade();
+ let project_is_local = project.read(cx).is_local();
+ let weak_lsp_store = project.read(cx).lsp_store().downgrade();
let tool_log_store = log_store.clone();
let log_view = get_or_create_tool(
workspace,
@@ -53,22 +58,35 @@ pub fn open(
move |window, cx| LspLogView::new(project, tool_log_store, window, cx),
);
log_view.update(cx, |log_view, cx| {
- let server_id = match server {
- LanguageServerSelector::Id(id) => Some(id),
- LanguageServerSelector::Name(name) => {
- log_store.read(cx).language_servers.iter().find_map(
- |(id, state)| {
- if state.name.as_ref() == Some(&name) {
- Some(*id)
- } else {
- None
- }
- },
- )
- }
+ let key_priority = |key: &LanguageServerLogKey| match &key.kind {
+ LanguageServerKind::Local { .. } if project_is_local => 0,
+ LanguageServerKind::Remote { .. } if !project_is_local => 0,
+ _ => 1,
+ };
+ let server_key = match server {
+ LanguageServerSelector::Id(id) => log_store
+ .read(cx)
+ .language_servers
+ .keys()
+ .filter(|key| {
+ key.server_id == id
+ && key.is_for_project(&weak_project, &weak_lsp_store)
+ })
+ .min_by_key(|key| key_priority(key))
+ .cloned(),
+ LanguageServerSelector::Name(name) => log_store
+ .read(cx)
+ .language_servers
+ .iter()
+ .filter(|(key, state)| {
+ key.is_for_project(&weak_project, &weak_lsp_store)
+ && state.name.as_ref() == Some(&name)
+ })
+ .min_by_key(|(key, _)| key_priority(key))
+ .map(|(key, _)| key.clone()),
};
- if let Some(server_id) = server_id {
- log_view.show_logs_for_server(server_id, window, cx);
+ if let Some(server_key) = server_key {
+ log_view.show_logs_for_server(server_key, window, cx);
}
});
})
@@ -82,7 +100,7 @@ pub struct LspLogView {
pub(crate) editor: Entity<Editor>,
editor_subscriptions: Vec<Subscription>,
log_store: Entity<LogStore>,
- current_server_id: Option<LanguageServerId>,
+ current_server_key: Option<LanguageServerLogKey>,
active_entry_kind: LogKind,
project: Entity<Project>,
focus_handle: FocusHandle,
@@ -105,6 +123,12 @@ pub(crate) struct LogMenuItem {
pub server_kind: LanguageServerKind,
}
+impl LogMenuItem {
+ fn key(&self) -> LanguageServerLogKey {
+ LanguageServerLogKey::new(self.server_kind.clone(), self.server_id)
+ }
+}
+
actions!(
dev,
[
@@ -144,35 +168,38 @@ impl LspLogView {
window: &mut Window,
cx: &mut Context<Self>,
) -> Self {
- let server_id = log_store
- .read(cx)
- .language_servers
- .iter()
- .find(|(_, server)| server.kind.project() == Some(&project.downgrade()))
- .map(|(id, _)| *id);
-
let weak_project = project.downgrade();
+ let weak_lsp_store = project.read(cx).lsp_store().downgrade();
+ let server_key = log_store
+ .read(cx)
+ .server_keys_for_project(&weak_project, &weak_lsp_store)
+ .next();
let model_changes_subscription =
cx.observe_in(&log_store, window, move |this, store, window, cx| {
- let first_server_id_for_project =
- store.read(cx).server_ids_for_project(&weak_project).next();
- if let Some(current_lsp) = this.current_server_id {
- if !store.read(cx).language_servers.contains_key(&current_lsp)
- && let Some(server_id) = first_server_id_for_project
+ let first_server_key_for_project = store
+ .read(cx)
+ .server_keys_for_project(&weak_project, &weak_lsp_store)
+ .next();
+ if let Some(current_key) = this.current_server_key.as_ref() {
+ let current_server_is_for_project =
+ store.read(cx).language_servers.contains_key(current_key)
+ && current_key.is_for_project(&weak_project, &weak_lsp_store);
+ if !current_server_is_for_project
+ && let Some(server_key) = first_server_key_for_project
{
match this.active_entry_kind {
- LogKind::Rpc => this.show_rpc_trace_for_server(server_id, window, cx),
- LogKind::Trace => this.show_trace_for_server(server_id, window, cx),
- LogKind::Logs => this.show_logs_for_server(server_id, window, cx),
- LogKind::ServerInfo => this.show_server_info(server_id, window, cx),
+ LogKind::Rpc => this.show_rpc_trace_for_server(server_key, window, cx),
+ LogKind::Trace => this.show_trace_for_server(server_key, window, cx),
+ LogKind::Logs => this.show_logs_for_server(server_key, window, cx),
+ LogKind::ServerInfo => this.show_server_info(server_key, window, cx),
}
}
- } else if let Some(server_id) = first_server_id_for_project {
+ } else if let Some(server_key) = first_server_key_for_project {
match this.active_entry_kind {
- LogKind::Rpc => this.show_rpc_trace_for_server(server_id, window, cx),
- LogKind::Trace => this.show_trace_for_server(server_id, window, cx),
- LogKind::Logs => this.show_logs_for_server(server_id, window, cx),
- LogKind::ServerInfo => this.show_server_info(server_id, window, cx),
+ LogKind::Rpc => this.show_rpc_trace_for_server(server_key, window, cx),
+ LogKind::Trace => this.show_trace_for_server(server_key, window, cx),
+ LogKind::Logs => this.show_logs_for_server(server_key, window, cx),
+ LogKind::ServerInfo => this.show_server_info(server_key, window, cx),
}
}
@@ -183,8 +210,8 @@ impl LspLogView {
&log_store,
window,
move |log_view, _, e, window, cx| match e {
- Event::NewServerLogEntry { id, kind, text } => {
- if log_view.current_server_id == Some(*id)
+ Event::NewServerLogEntry { key, kind, text } => {
+ if log_view.current_server_key.as_ref() == Some(key)
&& LogKind::from_server_log_type(kind) == log_view.active_entry_kind
{
log_view.editor.update(cx, |editor, cx| {
@@ -234,12 +261,15 @@ impl LspLogView {
});
cx.on_release(|log_view, cx| {
+ let project = log_view.project.downgrade();
+ let lsp_store = log_view.project.read(cx).lsp_store().downgrade();
log_view.log_store.update(cx, |log_store, cx| {
- for (server_id, state) in &log_store.language_servers {
- if let Some(log_kind) = state.toggled_log_kind {
- if let Some(log_type) = log_type(log_kind) {
- send_toggle_log_message(state, *server_id, false, log_type, cx);
- }
+ for (key, state) in &log_store.language_servers {
+ if key.is_for_project(&project, &lsp_store)
+ && let Some(log_kind) = state.toggled_log_kind
+ && let Some(log_type) = log_type(log_kind)
+ {
+ send_toggle_log_message(key, false, log_type, cx);
}
}
});
@@ -252,7 +282,7 @@ impl LspLogView {
editor_subscriptions,
project,
log_store,
- current_server_id: None,
+ current_server_key: None,
active_entry_kind: LogKind::Logs,
_log_store_subscriptions: vec![
model_changes_subscription,
@@ -260,8 +290,8 @@ impl LspLogView {
focus_subscription,
],
};
- if let Some(server_id) = server_id {
- lsp_log_view.show_logs_for_server(server_id, window, cx);
+ if let Some(server_key) = server_key {
+ lsp_log_view.show_logs_for_server(server_key, window, cx);
}
lsp_log_view
}
@@ -342,55 +372,28 @@ impl LspLogView {
);
(editor, vec![editor_subscription, search_subscription])
}
- pub(crate) fn try_ensure_copilot_for_project(&self, cx: &mut App) {
- self.log_store.update(cx, |this, cx| {
- let copilot = EditPredictionStore::try_global(cx)
- .and_then(|store| store.read(cx).copilot_for_project(&self.project))?;
- let server = copilot.read(cx).language_server()?.clone();
- let log_subscription = this.copilot_state_for_project(&self.project.downgrade());
- if let Some(subscription_slot @ None) = log_subscription {
- let weak_lsp_store = cx.weak_entity();
- let server_id = server.server_id();
-
- let name = LanguageServerName::new_static("copilot");
- *subscription_slot =
- Some(server.on_notification::<lsp::notification::LogMessage, _>(
- move |params, cx| {
- weak_lsp_store
- .update(cx, |lsp_store, cx| {
- lsp_store.add_language_server_log(
- server_id,
- MessageType::LOG,
- &params.message,
- cx,
- );
- })
- .ok();
- },
- ));
- this.add_language_server(
- LanguageServerKind::Global,
- server.server_id(),
- Some(name),
- None,
- Some(server.clone()),
- cx,
- );
- }
-
- Some(())
+ pub(crate) fn sync_copilot_for_project(&self, cx: &mut App) {
+ let server = EditPredictionStore::try_global(cx)
+ .and_then(|store| store.read(cx).copilot_for_project(&self.project))
+ .and_then(|copilot| copilot.read(cx).language_server().cloned());
+ self.log_store.update(cx, |log_store, cx| {
+ log_store.sync_copilot_for_project(&self.project.downgrade(), server, cx);
});
}
+
pub(crate) fn menu_items(&self, cx: &mut App) -> Option<Vec<LogMenuItem>> {
- self.try_ensure_copilot_for_project(cx);
+ self.sync_copilot_for_project(cx);
let log_store = self.log_store.read(cx);
let unknown_server = LanguageServerName::new_static("unknown server");
+ let project = self.project.downgrade();
+ let lsp_store = self.project.read(cx).lsp_store().downgrade();
let mut rows = log_store
.language_servers
.iter()
- .map(|(server_id, state)| match &state.kind {
+ .filter(|(key, _)| key.is_for_project(&project, &lsp_store))
+ .map(|(key, state)| match &key.kind {
LanguageServerKind::Local { .. }
| LanguageServerKind::Remote { .. }
| LanguageServerKind::LocalSsh { .. } => {
@@ -401,9 +404,9 @@ impl LspLogView {
.unwrap_or_else(|| "Unknown worktree".to_string());
LogMenuItem {
- server_id: *server_id,
+ server_id: key.server_id,
server_name: state.name.clone().unwrap_or(unknown_server.clone()),
- server_kind: state.kind.clone(),
+ server_kind: key.kind.clone(),
worktree_root_name,
rpc_trace_enabled: state.rpc_state.is_some(),
selected_entry: self.active_entry_kind,
@@ -411,42 +414,24 @@ impl LspLogView {
}
}
- LanguageServerKind::Global => LogMenuItem {
- server_id: *server_id,
+ LanguageServerKind::Supplementary { .. } => LogMenuItem {
+ server_id: key.server_id,
server_name: state.name.clone().unwrap_or(unknown_server.clone()),
- server_kind: state.kind.clone(),
+ server_kind: key.kind.clone(),
worktree_root_name: "supplementary".to_string(),
rpc_trace_enabled: state.rpc_state.is_some(),
selected_entry: self.active_entry_kind,
trace_level: lsp::TraceValue::Off,
},
})
- .chain(
- self.project
- .read(cx)
- .supplementary_language_servers(cx)
- .filter_map(|(server_id, name)| {
- let state = log_store.language_servers.get(&server_id)?;
- Some(LogMenuItem {
- server_id,
- server_name: name,
- server_kind: state.kind.clone(),
- worktree_root_name: "supplementary".to_string(),
- rpc_trace_enabled: state.rpc_state.is_some(),
- selected_entry: self.active_entry_kind,
- trace_level: lsp::TraceValue::Off,
- })
- }),
- )
.collect::<Vec<_>>();
- rows.sort_unstable_by_key(|row| row.server_id);
- rows.dedup_by_key(|row| row.server_id);
+ rows.sort_by_key(|row| row.server_id);
Some(rows)
}
fn show_logs_for_server(
&mut self,
- server_id: LanguageServerId,
+ key: LanguageServerLogKey,
window: &mut Window,
cx: &mut Context<Self>,
) {
@@ -454,16 +439,16 @@ impl LspLogView {
.log_store
.read(cx)
.language_servers
- .get(&server_id)
+ .get(&key)
.map(|v| v.log_level)
.unwrap_or(MessageType::LOG);
let log_contents = self
.log_store
.read(cx)
- .server_logs(server_id)
+ .server_logs(&key)
.map(|v| log_contents(v, typ));
if let Some(log_contents) = log_contents {
- self.current_server_id = Some(server_id);
+ self.current_server_key = Some(key.clone());
self.active_entry_kind = LogKind::Logs;
let (editor, editor_subscriptions) = Self::editor_for_logs(log_contents, window, cx);
self.editor = editor;
@@ -472,26 +457,26 @@ impl LspLogView {
}
self.editor.read(cx).focus_handle(cx).focus(window, cx);
self.log_store.update(cx, |log_store, cx| {
- let state = log_store.get_language_server_state(server_id)?;
+ let state = log_store.get_language_server_state(&key)?;
state.toggled_log_kind = Some(LogKind::Logs);
- send_toggle_log_message(state, server_id, true, LogType::Log, cx);
+ send_toggle_log_message(&key, true, LogType::Log, cx);
Some(())
});
}
fn update_log_level(
&self,
- server_id: LanguageServerId,
+ key: LanguageServerLogKey,
level: MessageType,
window: &mut Window,
cx: &mut Context<Self>,
) {
let log_contents = self.log_store.update(cx, |this, _| {
- if let Some(state) = this.get_language_server_state(server_id) {
+ if let Some(state) = this.get_language_server_state(&key) {
state.log_level = level;
}
- this.server_logs(server_id).map(|v| log_contents(v, level))
+ this.server_logs(&key).map(|v| log_contents(v, level))
});
if let Some(log_contents) = log_contents {
@@ -507,31 +492,31 @@ impl LspLogView {
fn show_trace_for_server(
&mut self,
- server_id: LanguageServerId,
+ key: LanguageServerLogKey,
window: &mut Window,
cx: &mut Context<Self>,
) {
let trace_level = self
.log_store
.update(cx, |log_store, _| {
- Some(log_store.get_language_server_state(server_id)?.trace_level)
+ Some(log_store.get_language_server_state(&key)?.trace_level)
})
.unwrap_or(TraceValue::Messages);
let log_contents = self
.log_store
.read(cx)
- .server_trace(server_id)
+ .server_trace(&key)
.map(|v| log_contents(v, trace_level));
if let Some(log_contents) = log_contents {
- self.current_server_id = Some(server_id);
+ self.current_server_key = Some(key.clone());
self.active_entry_kind = LogKind::Trace;
let (editor, editor_subscriptions) = Self::editor_for_logs(log_contents, window, cx);
self.editor = editor;
self.editor_subscriptions = editor_subscriptions;
self.log_store.update(cx, |log_store, cx| {
- let state = log_store.get_language_server_state(server_id)?;
+ let state = log_store.get_language_server_state(&key)?;
state.toggled_log_kind = Some(LogKind::Trace);
- send_toggle_log_message(state, server_id, true, LogType::Trace, cx);
+ send_toggle_log_message(&key, true, LogType::Trace, cx);
Some(())
});
cx.notify();
@@ -541,18 +526,18 @@ impl LspLogView {
fn show_rpc_trace_for_server(
&mut self,
- server_id: LanguageServerId,
+ key: LanguageServerLogKey,
window: &mut Window,
cx: &mut Context<Self>,
) {
- self.toggle_rpc_trace_for_server(server_id, true, window, cx);
+ self.toggle_rpc_trace_for_server(key.clone(), true, window, cx);
let rpc_log = self.log_store.update(cx, |log_store, _| {
log_store
- .enable_rpc_trace_for_language_server(server_id)
+ .enable_rpc_trace_for_language_server(&key)
.map(|state| log_contents(&state.rpc_messages, ()))
});
if let Some(rpc_log) = rpc_log {
- self.current_server_id = Some(server_id);
+ self.current_server_key = Some(key);
self.active_entry_kind = LogKind::Rpc;
let (editor, editor_subscriptions) = Self::editor_for_logs(rpc_log, window, cx);
let language = self.project.read(cx).languages().language_for_name("JSON");
@@ -585,43 +570,50 @@ impl LspLogView {
fn toggle_rpc_trace_for_server(
&mut self,
- server_id: LanguageServerId,
+ key: LanguageServerLogKey,
enabled: bool,
window: &mut Window,
cx: &mut Context<Self>,
) {
self.log_store.update(cx, |log_store, cx| {
if enabled {
- log_store.enable_rpc_trace_for_language_server(server_id);
+ log_store.enable_rpc_trace_for_language_server(&key);
} else {
- log_store.disable_rpc_trace_for_language_server(server_id);
+ log_store.disable_rpc_trace_for_language_server(&key);
}
- if let Some(server_state) = log_store.language_servers.get(&server_id) {
- send_toggle_log_message(server_state, server_id, enabled, LogType::Rpc, cx);
- };
+ if log_store.language_servers.contains_key(&key) {
+ send_toggle_log_message(&key, enabled, LogType::Rpc, cx);
+ }
});
- if !enabled && Some(server_id) == self.current_server_id {
- self.show_logs_for_server(server_id, window, cx);
+ if !enabled && self.current_server_key.as_ref() == Some(&key) {
+ self.show_logs_for_server(key, window, cx);
cx.notify();
}
}
fn update_trace_level(
&self,
- server_id: LanguageServerId,
+ key: LanguageServerLogKey,
level: TraceValue,
cx: &mut Context<Self>,
) {
- if let Some(server) = self
- .project
- .read(cx)
- .lsp_store()
+ let server = self
+ .log_store
.read(cx)
- .language_server_for_id(server_id)
- {
+ .language_servers
+ .get(&key)
+ .and_then(|state| state.server())
+ .or_else(|| {
+ self.project
+ .read(cx)
+ .lsp_store()
+ .read(cx)
+ .language_server_for_id(key.server_id)
+ });
+ if let Some(server) = server {
self.log_store.update(cx, |this, _| {
- if let Some(state) = this.get_language_server_state(server_id) {
+ if let Some(state) = this.get_language_server_state(&key) {
state.trace_level = level;
}
});
@@ -634,35 +626,46 @@ impl LspLogView {
fn show_server_info(
&mut self,
- server_id: LanguageServerId,
+ key: LanguageServerLogKey,
window: &mut Window,
cx: &mut Context<Self>,
) {
- let Some(server_info) = self
- .project
+ let server_id = key.server_id;
+ let server_info = self
+ .log_store
.read(cx)
- .lsp_store()
- .update(cx, |lsp_store, _| {
- lsp_store
- .language_server_for_id(server_id)
- .as_ref()
- .map(|language_server| ServerInfo::new(language_server))
- .or_else(move || {
- let capabilities =
- lsp_store.lsp_server_capabilities.get(&server_id)?.clone();
- let status = lsp_store.language_server_statuses.get(&server_id)?.clone();
-
- Some(ServerInfo {
- id: server_id,
- capabilities,
- status,
+ .language_servers
+ .get(&key)
+ .and_then(|state| state.server())
+ .as_deref()
+ .map(ServerInfo::new);
+ let server_info = server_info.or_else(|| {
+ self.project
+ .read(cx)
+ .lsp_store()
+ .update(cx, |lsp_store, _| {
+ lsp_store
+ .language_server_for_id(server_id)
+ .as_ref()
+ .map(|language_server| ServerInfo::new(language_server))
+ .or_else(move || {
+ let capabilities =
+ lsp_store.lsp_server_capabilities.get(&server_id)?.clone();
+ let status =
+ lsp_store.language_server_statuses.get(&server_id)?.clone();
+
+ Some(ServerInfo {
+ id: server_id,
+ capabilities,
+ status,
+ })
})
- })
- })
- else {
+ })
+ });
+ let Some(server_info) = server_info else {
return;
};
- self.current_server_id = Some(server_id);
+ self.current_server_key = Some(key.clone());
self.active_entry_kind = LogKind::ServerInfo;
let (editor, editor_subscriptions) = Self::editor_for_server_info(server_info, window, cx);
self.editor = editor;
@@ -670,12 +673,12 @@ impl LspLogView {
cx.notify();
self.editor.read(cx).focus_handle(cx).focus(window, cx);
self.log_store.update(cx, |log_store, cx| {
- let state = log_store.get_language_server_state(server_id)?;
- if let Some(log_kind) = state.toggled_log_kind.take() {
- if let Some(log_type) = log_type(log_kind) {
- send_toggle_log_message(state, server_id, false, log_type, cx);
- }
- };
+ let state = log_store.get_language_server_state(&key)?;
+ if let Some(log_kind) = state.toggled_log_kind.take()
+ && let Some(log_type) = log_type(log_kind)
+ {
+ send_toggle_log_message(&key, false, log_type, cx);
+ }
Some(())
});
}
@@ -691,13 +694,12 @@ fn log_type(log_kind: LogKind) -> Option<LogType> {
}
fn send_toggle_log_message(
- server_state: &log_store::LanguageServerState,
- server_id: LanguageServerId,
+ key: &LanguageServerLogKey,
enabled: bool,
log_type: LogType,
cx: &mut App,
) {
- if let LanguageServerKind::Remote { project } = &server_state.kind {
+ if let LanguageServerKind::Remote { project } = &key.kind {
project
.update(cx, |project, cx| {
if let Some((client, project_id)) = project.lsp_store().read(cx).upstream_client() {
@@ -705,7 +707,7 @@ fn send_toggle_log_message(
.send(proto::ToggleLspLogs {
project_id,
log_type: log_type as i32,
- server_id: server_id.to_proto(),
+ server_id: key.server_id.to_proto(),
enabled,
})
.log_err();
@@ -790,12 +792,12 @@ impl Item for LspLogView {
{
Task::ready(Some(cx.new(|cx| {
let mut new_view = Self::new(self.project.clone(), self.log_store.clone(), window, cx);
- if let Some(server_id) = self.current_server_id {
+ if let Some(server_key) = self.current_server_key.clone() {
match self.active_entry_kind {
- LogKind::Rpc => new_view.show_rpc_trace_for_server(server_id, window, cx),
- LogKind::Trace => new_view.show_trace_for_server(server_id, window, cx),
- LogKind::Logs => new_view.show_logs_for_server(server_id, window, cx),
- LogKind::ServerInfo => new_view.show_server_info(server_id, window, cx),
+ LogKind::Rpc => new_view.show_rpc_trace_for_server(server_key, window, cx),
+ LogKind::Trace => new_view.show_trace_for_server(server_key, window, cx),
+ LogKind::Logs => new_view.show_logs_for_server(server_key, window, cx),
+ LogKind::ServerInfo => new_view.show_server_info(server_key, window, cx),
}
}
new_view
@@ -934,25 +936,24 @@ impl Render for LspLogToolbarItemView {
return div();
};
- let (menu_rows, current_server_id) = log_view.update(cx, |log_view, cx| {
+ let (menu_rows, current_server_key) = log_view.update(cx, |log_view, cx| {
let menu_rows = log_view.menu_items(cx).unwrap_or_default();
- let current_server_id = log_view.current_server_id;
- (menu_rows, current_server_id)
+ let current_server_key = log_view.current_server_key.clone();
+ (menu_rows, current_server_key)
});
- let current_server = current_server_id.and_then(|current_server_id| {
- if let Ok(ix) = menu_rows.binary_search_by_key(&current_server_id, |e| e.server_id) {
- Some(menu_rows[ix].clone())
- } else {
- None
- }
+ let current_server = current_server_key.and_then(|current_server_key| {
+ menu_rows
+ .iter()
+ .find(|row| row.key() == current_server_key)
+ .cloned()
});
let available_language_servers: Vec<_> = menu_rows
.into_iter()
.map(|row| {
(
- row.server_id,
+ row.key(),
row.server_name,
row.worktree_root_name,
row.selected_entry,
@@ -988,33 +989,44 @@ impl Render for LspLogToolbarItemView {
move |window, cx| {
let log_view = log_view.clone();
ContextMenu::build(window, cx, |mut menu, window, _| {
- for (server_id, name, worktree_root, active_entry_kind) in
+ for (server_key, name, worktree_root, active_entry_kind) in
available_language_servers.iter()
{
let label = format!("{name} ({worktree_root})");
- let server_id = *server_id;
+ let server_key = server_key.clone();
let active_entry_kind = *active_entry_kind;
menu = menu.entry(
label,
None,
window.handler_for(&log_view, move |view, window, cx| {
- view.current_server_id = Some(server_id);
+ view.current_server_key = Some(server_key.clone());
view.active_entry_kind = active_entry_kind;
match view.active_entry_kind {
LogKind::Rpc => {
view.toggle_rpc_trace_for_server(
- server_id, true, window, cx,
+ server_key.clone(),
+ true,
+ window,
+ cx,
+ );
+ view.show_rpc_trace_for_server(
+ server_key.clone(),
+ window,
+ cx,
);
- view.show_rpc_trace_for_server(server_id, window, cx);
- }
- LogKind::Trace => {
- view.show_trace_for_server(server_id, window, cx)
- }
- LogKind::Logs => {
- view.show_logs_for_server(server_id, window, cx)
}
+ LogKind::Trace => view.show_trace_for_server(
+ server_key.clone(),
+ window,
+ cx,
+ ),
+ LogKind::Logs => view.show_logs_for_server(
+ server_key.clone(),
+ window,
+ cx,
+ ),
LogKind::ServerInfo => {
- view.show_server_info(server_id, window, cx)
+ view.show_server_info(server_key.clone(), window, cx)
}
}
cx.notify();
@@ -1028,7 +1040,7 @@ impl Render for LspLogToolbarItemView {
});
let view_selector = current_server.map(|server| {
- let server_id = server.server_id;
+ let server_key = server.key();
let rpc_trace_enabled = server.rpc_trace_enabled;
let log_view = log_view.clone();
let label = match server.selected_entry {
@@ -1049,25 +1061,34 @@ impl Render for LspLogToolbarItemView {
.menu(move |window, cx| {
let log_toolbar_view = log_toolbar_view.upgrade()?;
let log_view = log_view.clone();
+ let server_key = server_key.clone();
Some(ContextMenu::build(window, cx, move |this, window, _| {
this.entry(
SERVER_LOGS,
None,
- window.handler_for(&log_view, move |view, window, cx| {
- view.show_logs_for_server(server_id, window, cx);
+ window.handler_for(&log_view, {
+ let server_key = server_key.clone();
+ move |view, window, cx| {
+ view.show_logs_for_server(server_key.clone(), window, cx);
+ }
}),
)
.entry(
SERVER_TRACE,
None,
- window.handler_for(&log_view, move |view, window, cx| {
- view.show_trace_for_server(server_id, window, cx);
+ window.handler_for(&log_view, {
+ let server_key = server_key.clone();
+ move |view, window, cx| {
+ view.show_trace_for_server(server_key.clone(), window, cx);
+ }
}),
)
.custom_entry(
{
let log_toolbar_view = log_toolbar_view.clone();
+ let server_key = server_key.clone();
move |window, _| {
+ let server_key = server_key.clone();
h_flex()
.w_full()
.justify_between()
@@ -1090,7 +1111,10 @@ impl Render for LspLogToolbarItemView {
ToggleState::Selected
);
view.toggle_rpc_logging_for_server(
- server_id, enabled, window, cx,
+ server_key.clone(),
+ enabled,
+ window,
+ cx,
);
cx.stop_propagation();
},
@@ -1100,15 +1124,21 @@ impl Render for LspLogToolbarItemView {
.into_any_element()
}
},
- window.handler_for(&log_view, move |view, window, cx| {
- view.show_rpc_trace_for_server(server_id, window, cx);
+ window.handler_for(&log_view, {
+ let server_key = server_key.clone();
+ move |view, window, cx| {
+ view.show_rpc_trace_for_server(server_key.clone(), window, cx);
+ }
}),
)
.entry(
SERVER_INFO,
None,
- window.handler_for(&log_view, move |view, window, cx| {
- view.show_server_info(server_id, window, cx);
+ window.handler_for(&log_view, {
+ let server_key = server_key.clone();
+ move |view, window, cx| {
+ view.show_server_info(server_key.clone(), window, cx);
+ }
}),
)
}))
@@ -1146,14 +1176,17 @@ impl Render for LspLogToolbarItemView {
let log_view = log_view;
move |window, cx| {
- let id = log_view.read(cx).current_server_id?;
+ let key =
+ log_view.read(cx).current_server_key.clone()?;
let trace_level =
log_view.update(cx, |this, cx| {
this.log_store.update(cx, |this, _| {
Some(
- this.get_language_server_state(id)?
- .trace_level,
+ this.get_language_server_state(
+ &key,
+ )?
+ .trace_level,
)
})
})?;
@@ -1173,11 +1206,12 @@ impl Render for LspLogToolbarItemView {
let log_view = log_view.clone();
move |_, cx| {
log_view.update(cx, |this, cx| {
- if let Some(id) =
- this.current_server_id
+ if let Some(key) = this
+ .current_server_key
+ .clone()
{
this.update_trace_level(
- id, option, cx,
+ key, option, cx,
);
}
});
@@ -1216,14 +1250,17 @@ impl Render for LspLogToolbarItemView {
let log_view = log_view;
move |window, cx| {
- let id = log_view.read(cx).current_server_id?;
+ let key =
+ log_view.read(cx).current_server_key.clone()?;
let log_level =
log_view.update(cx, |this, cx| {
this.log_store.update(cx, |this, _| {
Some(
- this.get_language_server_state(id)?
- .log_level,
+ this.get_language_server_state(
+ &key,
+ )?
+ .log_level,
)
})
})?;
@@ -1244,11 +1281,12 @@ impl Render for LspLogToolbarItemView {
let log_view = log_view.clone();
move |window, cx| {
log_view.update(cx, |this, cx| {
- if let Some(id) =
- this.current_server_id
+ if let Some(key) = this
+ .current_server_key
+ .clone()
{
this.update_log_level(
- id, option, window, cx,
+ key, option, window, cx,
);
}
});
@@ -1328,19 +1366,19 @@ impl LspLogToolbarItemView {
fn toggle_rpc_logging_for_server(
&mut self,
- id: LanguageServerId,
+ key: LanguageServerLogKey,
enabled: bool,
window: &mut Window,
cx: &mut Context<Self>,
) {
if let Some(log_view) = &self.log_view {
log_view.update(cx, |log_view, cx| {
- log_view.toggle_rpc_trace_for_server(id, enabled, window, cx);
- if !enabled && Some(id) == log_view.current_server_id {
- log_view.show_logs_for_server(id, window, cx);
+ log_view.toggle_rpc_trace_for_server(key.clone(), enabled, window, cx);
+ if !enabled && log_view.current_server_key.as_ref() == Some(&key) {
+ log_view.show_logs_for_server(key.clone(), window, cx);
cx.notify();
} else if enabled {
- log_view.show_rpc_trace_for_server(id, window, cx);
+ log_view.show_rpc_trace_for_server(key.clone(), window, cx);
cx.notify();
}
window.focus(&log_view.focus_handle, cx);
diff --git a/crates/language_tools/src/lsp_log_view_tests.rs b/crates/language_tools/src/lsp_log_view_tests.rs
index 326512d3741..33512fbe199 100644
--- a/crates/language_tools/src/lsp_log_view_tests.rs
+++ b/crates/language_tools/src/lsp_log_view_tests.rs
@@ -5,16 +5,323 @@ use crate::lsp_log_view::LogMenuItem;
use super::*;
use futures::StreamExt;
use gpui::{AppContext as _, TestAppContext, VisualTestContext};
-use language::{FakeLspAdapter, Language, LanguageConfig, LanguageMatcher, tree_sitter_rust};
+use language::{
+ FakeLspAdapter, Language, LanguageConfig, LanguageMatcher, LanguageServerId, tree_sitter_rust,
+};
use lsp::LanguageServerName;
use project::{
FakeFs, Project,
- lsp_store::log_store::{LanguageServerKind, LogKind, LogStore},
+ lsp_store::log_store::{LanguageServerKind, LanguageServerLogKey, LogKind, LogStore},
};
use serde_json::json;
use settings::SettingsStore;
use util::path;
+#[gpui::test]
+async fn test_lsp_log_view_filters_servers_from_other_projects(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(path!("/current-project"), json!({ "test.rs": "" }))
+ .await;
+ fs.insert_tree(path!("/other-project"), json!({ "test.rs": "" }))
+ .await;
+
+ let project = Project::test(fs.clone(), [path!("/current-project").as_ref()], cx).await;
+ let other_project = Project::test(fs.clone(), [path!("/other-project").as_ref()], cx).await;
+ let worktree_id = project.read_with(cx, |project, cx| {
+ project.worktrees(cx).next().unwrap().read(cx).id()
+ });
+ let current_lsp_store = project
+ .read_with(cx, |project, _| project.lsp_store())
+ .downgrade();
+ let other_lsp_store = other_project
+ .read_with(cx, |project, _| project.lsp_store())
+ .downgrade();
+
+ let current_ssh_server_id = LanguageServerId(99);
+ let current_server_id = LanguageServerId(100);
+ let log_store = cx.new(|cx| LogStore::new(false, cx));
+ log_store.update(cx, |store, cx| {
+ store.add_language_server(
+ LanguageServerKind::LocalSsh {
+ lsp_store: current_lsp_store,
+ },
+ current_ssh_server_id,
+ Some(LanguageServerName::new_static("current-ssh-server")),
+ Some(worktree_id),
+ None,
+ cx,
+ );
+ store.add_language_server(
+ LanguageServerKind::Local {
+ project: project.downgrade(),
+ },
+ current_server_id,
+ Some(LanguageServerName::new_static("current-server")),
+ Some(worktree_id),
+ None,
+ cx,
+ );
+ store.add_language_server(
+ LanguageServerKind::Remote {
+ project: other_project.downgrade(),
+ },
+ current_server_id,
+ Some(LanguageServerName::new_static("other-remote-server")),
+ None,
+ None,
+ cx,
+ );
+ store.add_language_server(
+ LanguageServerKind::Supplementary {
+ project: other_project.downgrade(),
+ },
+ current_server_id,
+ Some(LanguageServerName::new_static("other-supplementary-server")),
+ None,
+ None,
+ cx,
+ );
+ store.add_language_server(
+ LanguageServerKind::LocalSsh {
+ lsp_store: other_lsp_store,
+ },
+ current_ssh_server_id,
+ Some(LanguageServerName::new_static("other-ssh-server")),
+ None,
+ None,
+ cx,
+ );
+ });
+ assert_eq!(
+ log_store.read_with(cx, |store, _| store.language_servers.len()),
+ 5
+ );
+
+ let window =
+ cx.add_window(|window, cx| LspLogView::new(project.clone(), log_store, window, cx));
+ let log_view = window.root(cx).unwrap();
+ let mut cx = VisualTestContext::from_window(*window, cx);
+
+ log_view.update(&mut cx, |view, cx| {
+ let visible_servers = view
+ .menu_items(cx)
+ .unwrap()
+ .into_iter()
+ .map(|item| (item.server_id, item.server_name))
+ .collect::<Vec<_>>();
+ assert_eq!(
+ visible_servers,
+ [
+ (
+ current_ssh_server_id,
+ LanguageServerName::new_static("current-ssh-server"),
+ ),
+ (
+ current_server_id,
+ LanguageServerName::new_static("current-server"),
+ ),
+ ]
+ );
+ });
+}
+
+#[gpui::test]
+async fn test_lsp_log_view_labels_registered_supplementary_servers(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(path!("/the-root"), json!({ "test.rs": "" }))
+ .await;
+ let project = Project::test(fs, [path!("/the-root").as_ref()], cx).await;
+ let lsp_store = project.read_with(cx, |project, _| project.lsp_store());
+ let log_store = cx.new(|cx| LogStore::new(false, cx));
+ log_store.update(cx, |store, cx| store.add_project(&project, cx));
+
+ let server_id = LanguageServerId(100);
+ let (server, _fake_server) = lsp::FakeLanguageServer::new(
+ server_id,
+ lsp::LanguageServerBinary {
+ path: "path/to/prettier".into(),
+ arguments: Vec::new(),
+ env: None,
+ },
+ "prettier".to_string(),
+ Default::default(),
+ &mut cx.to_async(),
+ );
+ lsp_store.update(cx, |lsp_store, cx| {
+ lsp_store.register_supplementary_language_server_for_test(
+ server_id,
+ LanguageServerName::new_static("prettier (default)"),
+ Arc::new(server),
+ cx,
+ );
+ });
+
+ let window =
+ cx.add_window(|window, cx| LspLogView::new(project.clone(), log_store, window, cx));
+ let log_view = window.root(cx).unwrap();
+ let mut cx = VisualTestContext::from_window(*window, cx);
+
+ log_view.update(&mut cx, |view, cx| {
+ assert_eq!(
+ view.menu_items(cx).unwrap(),
+ &[LogMenuItem {
+ server_id,
+ server_name: LanguageServerName::new_static("prettier (default)"),
+ worktree_root_name: "supplementary".to_string(),
+ rpc_trace_enabled: false,
+ selected_entry: LogKind::Logs,
+ trace_level: lsp::TraceValue::Off,
+ server_kind: LanguageServerKind::Supplementary {
+ project: project.downgrade(),
+ },
+ }]
+ );
+ });
+
+ lsp_store.update(&mut cx, |lsp_store, cx| {
+ lsp_store.unregister_supplementary_language_server_for_test(server_id, cx);
+ });
+ log_view.update(&mut cx, |view, cx| {
+ assert!(view.menu_items(cx).unwrap().is_empty());
+ });
+}
+
+#[gpui::test]
+async fn test_log_store_does_not_retain_language_servers(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(path!("/the-root"), json!({ "test.rs": "" }))
+ .await;
+ let project = Project::test(fs, [path!("/the-root").as_ref()], cx).await;
+ let server_id = LanguageServerId(100);
+ let server_kind = LanguageServerKind::Local {
+ project: project.downgrade(),
+ };
+ let server_key = LanguageServerLogKey::new(server_kind.clone(), server_id);
+ let log_store = cx.new(|cx| LogStore::new(false, cx));
+
+ let (first_server, _first_fake_server) = lsp::FakeLanguageServer::new(
+ server_id,
+ lsp::LanguageServerBinary {
+ path: "path/to/first-language-server".into(),
+ arguments: Vec::new(),
+ env: None,
+ },
+ "first-language-server".to_string(),
+ Default::default(),
+ &mut cx.to_async(),
+ );
+ let first_server = Arc::new(first_server);
+ let first_server_weak = Arc::downgrade(&first_server);
+ log_store.update(cx, |store, cx| {
+ store.add_language_server(
+ server_kind.clone(),
+ server_id,
+ Some(LanguageServerName::new_static("first-language-server")),
+ None,
+ Some(first_server.clone()),
+ cx,
+ );
+ });
+
+ let (replacement_server, _replacement_fake_server) = lsp::FakeLanguageServer::new(
+ server_id,
+ lsp::LanguageServerBinary {
+ path: "path/to/replacement-language-server".into(),
+ arguments: Vec::new(),
+ env: None,
+ },
+ "replacement-language-server".to_string(),
+ Default::default(),
+ &mut cx.to_async(),
+ );
+ let replacement_server = Arc::new(replacement_server);
+ let replacement_server_weak = Arc::downgrade(&replacement_server);
+ log_store.update(cx, |store, cx| {
+ store.add_language_server(
+ server_kind,
+ server_id,
+ Some(LanguageServerName::new_static(
+ "replacement-language-server",
+ )),
+ None,
+ Some(replacement_server.clone()),
+ cx,
+ );
+ });
+
+ let stored_server = log_store
+ .read_with(cx, |store, _| {
+ store
+ .language_servers
+ .get(&server_key)
+ .and_then(|state| state.server())
+ })
+ .expect("replacement language server should be available");
+ assert!(Arc::ptr_eq(&stored_server, &replacement_server));
+ drop(stored_server);
+
+ drop(first_server);
+ assert!(first_server_weak.upgrade().is_none());
+ drop(replacement_server);
+ assert!(replacement_server_weak.upgrade().is_none());
+ assert!(
+ log_store
+ .read_with(cx, |store, _| store
+ .language_servers
+ .get(&server_key)
+ .and_then(|state| state.server()))
+ .is_none()
+ );
+}
+
+#[gpui::test]
+async fn test_log_store_removes_unavailable_copilot_server(cx: &mut TestAppContext) {
+ init_test(cx);
+
+ let fs = FakeFs::new(cx.background_executor.clone());
+ fs.insert_tree(path!("/the-root"), json!({ "test.rs": "" }))
+ .await;
+ let project = Project::test(fs, [path!("/the-root").as_ref()], cx).await;
+ let server_id = LanguageServerId(100);
+ let server_kind = LanguageServerKind::Supplementary {
+ project: project.downgrade(),
+ };
+ let server_key = LanguageServerLogKey::new(server_kind, server_id);
+ let log_store = cx.new(|cx| LogStore::new(false, cx));
+ log_store.update(cx, |log_store, cx| log_store.add_project(&project, cx));
+
+ let (server, _fake_server) = lsp::FakeLanguageServer::new(
+ server_id,
+ lsp::LanguageServerBinary {
+ path: "path/to/copilot-language-server".into(),
+ arguments: Vec::new(),
+ env: None,
+ },
+ "copilot".to_string(),
+ Default::default(),
+ &mut cx.to_async(),
+ );
+ log_store.update(cx, |log_store, cx| {
+ log_store.sync_copilot_for_project(&project.downgrade(), Some(Arc::new(server)), cx);
+ });
+ assert!(log_store.read_with(cx, |log_store, _| {
+ log_store.language_servers.contains_key(&server_key)
+ }));
+
+ log_store.update(cx, |log_store, cx| {
+ log_store.sync_copilot_for_project(&project.downgrade(), None, cx);
+ });
+ assert!(!log_store.read_with(cx, |log_store, _| {
+ log_store.language_servers.contains_key(&server_key)
+ }));
+}
+
#[gpui::test]
async fn test_lsp_log_view(cx: &mut TestAppContext) {
zlog::init_test();
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index 266d398fd5e..99bc93bd15d 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -333,6 +333,7 @@ pub struct LocalLspStore {
>,
buffer_snapshots: HashMap<BufferId, HashMap<LanguageServerId, Vec<LspBufferSnapshot>>>, // buffer_id -> server_id -> vec of snapshots
_subscription: gpui::Subscription,
+ _binary_status_task: Task<()>,
lsp_tree: LanguageServerTree,
registered_buffers: HashMap<BufferId, usize>,
buffers_opened_in_servers: HashMap<BufferId, HashSet<LanguageServerId>>,
@@ -415,6 +416,14 @@ impl LocalLspStore {
}
}
+ fn update_binary_status(&self, server_name: LanguageServerName, status: BinaryStatus) {
+ self.languages.update_lsp_binary_status_for_entity(
+ self.weak.entity_id(),
+ server_name,
+ status,
+ );
+ }
+
fn start_language_server(
&mut self,
worktree_handle: &Entity<Worktree>,
@@ -678,8 +687,7 @@ impl LocalLspStore {
};
if update_binary_status {
- self.languages
- .update_lsp_binary_status(adapter.name(), BinaryStatus::Starting);
+ self.update_binary_status(adapter.name(), BinaryStatus::Starting);
}
self.language_servers.insert(server_id, state);
@@ -707,7 +715,6 @@ impl LocalLspStore {
&& let Some(path) = settings.path.as_ref().map(PathBuf::from)
{
let settings = settings.clone();
- let languages = self.languages.clone();
return cx.background_spawn(async move {
if let Some(mut wait_until_worktree_trust) = wait_until_worktree_trust {
let already_trusted = *wait_until_worktree_trust.borrow();
@@ -726,8 +733,7 @@ impl LocalLspStore {
adapter.name(),
);
}
- languages
- .update_lsp_binary_status(adapter.name(), BinaryStatus::Starting);
+ delegate.update_status(adapter.name(), BinaryStatus::Starting);
}
let mut env = delegate.shell_env().await;
env.extend(settings.env.unwrap_or_default());
@@ -748,7 +754,6 @@ impl LocalLspStore {
#[cfg(any(test, feature = "test-support"))]
if !adapter.adapter.is_extension() && self.languages.has_fake_lsp_server(&adapter.name) {
let language_server_name = adapter.name.clone();
- let languages = self.languages.clone();
return cx.spawn(async move |_| {
if let Some(mut wait_until_worktree_trust) = wait_until_worktree_trust {
let already_trusted = *wait_until_worktree_trust.borrow();
@@ -765,7 +770,7 @@ impl LocalLspStore {
"Worktree {worktree_abs_path:?} is trusted, starting language server {language_server_name}",
);
}
- languages.update_lsp_binary_status(
+ delegate.update_status(
language_server_name.clone(),
BinaryStatus::Starting,
);
@@ -4457,7 +4462,9 @@ impl BufferLspData {
#[derive(Debug)]
pub enum LspStoreEvent {
LanguageServerAdded(LanguageServerId, LanguageServerName, Option<WorktreeId>),
+ SupplementaryLanguageServerAdded(LanguageServerId, LanguageServerName),
LanguageServerRemoved(LanguageServerId),
+ SupplementaryLanguageServerRemoved(LanguageServerId),
LanguageServerUpdate {
language_server_id: LanguageServerId,
name: Option<LanguageServerName>,
@@ -4680,7 +4687,7 @@ impl LspStore {
.detach();
cx.observe_global::<SettingsStore>(Self::on_settings_changed)
.detach();
- subscribe_to_binary_statuses(&languages, cx).detach();
+ let binary_status_task = subscribe_to_binary_statuses(&languages, cx);
let _maintain_workspace_config = {
let (sender, receiver) = watch::channel();
@@ -4717,6 +4724,7 @@ impl LspStore {
.unwrap()
.shutdown_language_servers_on_quit()
}),
+ _binary_status_task: binary_status_task,
lsp_tree: LanguageServerTree::new(
manifest_tree,
languages.clone(),
@@ -4785,7 +4793,6 @@ impl LspStore {
.detach();
cx.subscribe(&worktree_store, Self::on_worktree_store_event)
.detach();
- subscribe_to_binary_statuses(&languages, cx).detach();
let _maintain_workspace_config = {
let (sender, receiver) = watch::channel();
(Self::maintain_workspace_config(receiver, cx), sender)
@@ -4811,7 +4818,7 @@ impl LspStore {
active_entry: None,
_maintain_workspace_config,
- _maintain_buffer_languages: Self::maintain_buffer_languages(languages.clone(), cx),
+ _maintain_buffer_languages: Self::maintain_buffer_languages(languages, cx),
}
}
@@ -10953,6 +10960,19 @@ impl LspStore {
.map(|(key, value)| (*key, value))
}
+ fn should_forward_untagged_binary_status(&self, server_name: &LanguageServerName) -> bool {
+ self.as_local().is_some_and(|local| {
+ local
+ .language_server_ids
+ .keys()
+ .any(|seed| &seed.name == server_name)
+ || self
+ .language_server_statuses
+ .values()
+ .any(|status| &status.name == server_name)
+ })
+ }
+
#[cfg(feature = "test-support")]
pub fn has_language_server_seed_for_worktree(&self, worktree_id: WorktreeId) -> bool {
self.as_local().is_some_and(|local| {
@@ -12116,17 +12136,18 @@ impl LspStore {
if let Some(name) = name {
log::info!("stopping language server {name}");
- self.languages
- .update_lsp_binary_status(name.clone(), BinaryStatus::Stopping);
+ if let Some(local) = self.as_local() {
+ local.update_binary_status(name.clone(), BinaryStatus::Stopping);
+ }
cx.notify();
return cx.spawn(async move |lsp_store, cx| {
Self::shutdown_language_server(server_state, name.clone(), cx).await;
lsp_store
.update(cx, |lsp_store, cx| {
- lsp_store
- .languages
- .update_lsp_binary_status(name, BinaryStatus::Stopped);
+ if let Some(local) = lsp_store.as_local() {
+ local.update_binary_status(name, BinaryStatus::Stopped);
+ }
cx.emit(LspStoreEvent::LanguageServerRemoved(server_id));
cx.notify();
})
@@ -12677,9 +12698,7 @@ impl LspStore {
simulate_disk_based_diagnostics_completion: None,
},
);
- local
- .languages
- .update_lsp_binary_status(adapter.name(), BinaryStatus::None);
+ local.update_binary_status(adapter.name(), BinaryStatus::None);
if let Some(file_ops_caps) = language_server
.capabilities()
.workspace
@@ -12977,10 +12996,21 @@ impl LspStore {
local
.supplementary_language_servers
.insert(id, (name.clone(), server));
- cx.emit(LspStoreEvent::LanguageServerAdded(id, name, None));
+ cx.emit(LspStoreEvent::SupplementaryLanguageServerAdded(id, name));
}
}
+ #[cfg(feature = "test-support")]
+ pub fn register_supplementary_language_server_for_test(
+ &mut self,
+ id: LanguageServerId,
+ name: LanguageServerName,
+ server: Arc<LanguageServer>,
+ cx: &mut Context<Self>,
+ ) {
+ self.register_supplementary_language_server(id, name, server, cx);
+ }
+
fn unregister_supplementary_language_server(
&mut self,
id: LanguageServerId,
@@ -12988,19 +13018,17 @@ impl LspStore {
) {
if let Some(local) = self.as_local_mut() {
local.supplementary_language_servers.remove(&id);
- cx.emit(LspStoreEvent::LanguageServerRemoved(id));
+ cx.emit(LspStoreEvent::SupplementaryLanguageServerRemoved(id));
}
}
- pub(crate) fn supplementary_language_servers(
- &self,
- ) -> impl '_ + Iterator<Item = (LanguageServerId, LanguageServerName)> {
- self.as_local().into_iter().flat_map(|local| {
- local
- .supplementary_language_servers
- .iter()
- .map(|(id, (name, _))| (*id, name.clone()))
- })
+ #[cfg(feature = "test-support")]
+ pub fn unregister_supplementary_language_server_for_test(
+ &mut self,
+ id: LanguageServerId,
+ cx: &mut Context<Self>,
+ ) {
+ self.unregister_supplementary_language_server(id, cx);
}
pub fn language_server_adapter_for_id(
@@ -14015,11 +14043,19 @@ fn subscribe_to_binary_statuses(
languages: &Arc<LanguageRegistry>,
cx: &mut Context<'_, LspStore>,
) -> Task<()> {
- let mut server_statuses = languages.language_server_binary_statuses();
+ let (mut server_statuses, subscription) = languages.language_server_binary_statuses();
cx.spawn(async move |lsp_store, cx| {
- while let Some((server_name, binary_status)) = server_statuses.next().await {
+ let _subscription = subscription;
+ while let Some((source, server_name, binary_status)) = server_statuses.next().await {
if lsp_store
- .update(cx, |_, cx| {
+ .update(cx, |lsp_store, cx| {
+ if source.is_some_and(|source| source != cx.entity_id())
+ || source.is_none()
+ && !lsp_store.should_forward_untagged_binary_status(&server_name)
+ {
+ return;
+ }
+
let mut message = None;
let binary_status = match binary_status {
BinaryStatus::None => proto::ServerBinaryStatus::None,
@@ -15208,9 +15244,16 @@ impl LspAdapterDelegate for LocalLspAdapterDelegate {
Ok(())
}
+ fn status_source_id(&self) -> gpui::EntityId {
+ self.lsp_store.entity_id()
+ }
+
fn update_status(&self, server_name: LanguageServerName, status: language::BinaryStatus) {
- self.language_registry
- .update_lsp_binary_status(server_name, status);
+ self.language_registry.update_lsp_binary_status_for_entity(
+ self.status_source_id(),
+ server_name,
+ status,
+ );
}
fn registered_lsp_adapters(&self) -> Vec<Arc<dyn LspAdapter>> {
diff --git a/crates/project/src/lsp_store/log_store.rs b/crates/project/src/lsp_store/log_store.rs
index ef798c5cb2f..c6da6b5cd91 100644
--- a/crates/project/src/lsp_store/log_store.rs
+++ b/crates/project/src/lsp_store/log_store.rs
@@ -1,6 +1,6 @@
use std::{
collections::VecDeque,
- sync::Arc,
+ sync::{Arc, Weak},
time::{Duration, Instant},
};
@@ -35,7 +35,7 @@ impl Global for GlobalLogStore {}
#[derive(Debug)]
pub enum Event {
NewServerLogEntry {
- id: LanguageServerId,
+ key: LanguageServerLogKey,
kind: LanguageServerLogType,
text: String,
},
@@ -46,12 +46,13 @@ impl EventEmitter<Event> for LogStore {}
pub struct LogStore {
on_headless_host: bool,
projects: HashMap<WeakEntity<Project>, ProjectState>,
- pub language_servers: HashMap<LanguageServerId, LanguageServerState>,
- io_tx: mpsc::UnboundedSender<(LanguageServerId, IoKind, String, Instant)>,
+ pub language_servers: HashMap<LanguageServerLogKey, LanguageServerState>,
+ io_tx: mpsc::UnboundedSender<(LanguageServerLogKey, IoKind, String, Instant)>,
}
struct ProjectState {
_subscriptions: [Subscription; 2],
+ copilot_server_id: Option<LanguageServerId>,
copilot_log_subscription: Option<lsp::Subscription>,
}
@@ -132,7 +133,7 @@ impl Message for RpcMessage {
pub struct LanguageServerState {
pub name: Option<LanguageServerName>,
pub worktree_id: Option<WorktreeId>,
- pub kind: LanguageServerKind,
+ server: Option<Weak<LanguageServer>>,
log_messages: VecDeque<LogMessage>,
trace_messages: VecDeque<TraceMessage>,
pub rpc_state: Option<LanguageServerRpcState>,
@@ -142,12 +143,17 @@ pub struct LanguageServerState {
pub toggled_log_kind: Option<LogKind>,
}
+impl LanguageServerState {
+ pub fn server(&self) -> Option<Arc<LanguageServer>> {
+ self.server.as_ref()?.upgrade()
+ }
+}
+
impl std::fmt::Debug for LanguageServerState {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("LanguageServerState")
.field("name", &self.name)
.field("worktree_id", &self.worktree_id)
- .field("kind", &self.kind)
.field("log_messages", &self.log_messages)
.field("trace_messages", &self.trace_messages)
.field("rpc_state", &self.rpc_state)
@@ -158,12 +164,12 @@ impl std::fmt::Debug for LanguageServerState {
}
}
-#[derive(PartialEq, Clone)]
+#[derive(PartialEq, Eq, Hash, Clone)]
pub enum LanguageServerKind {
Local { project: WeakEntity<Project> },
Remote { project: WeakEntity<Project> },
LocalSsh { lsp_store: WeakEntity<LspStore> },
- Global,
+ Supplementary { project: WeakEntity<Project> },
}
impl std::fmt::Debug for LanguageServerKind {
@@ -172,18 +178,61 @@ impl std::fmt::Debug for LanguageServerKind {
LanguageServerKind::Local { .. } => write!(f, "LanguageServerKind::Local"),
LanguageServerKind::Remote { .. } => write!(f, "LanguageServerKind::Remote"),
LanguageServerKind::LocalSsh { .. } => write!(f, "LanguageServerKind::LocalSsh"),
- LanguageServerKind::Global => write!(f, "LanguageServerKind::Global"),
+ LanguageServerKind::Supplementary { .. } => {
+ write!(f, "LanguageServerKind::Supplementary")
+ }
}
}
}
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
+pub struct LanguageServerLogKey {
+ pub kind: LanguageServerKind,
+ pub server_id: LanguageServerId,
+}
+
+impl LanguageServerLogKey {
+ pub fn new(kind: LanguageServerKind, server_id: LanguageServerId) -> Self {
+ Self { kind, server_id }
+ }
+
+ pub fn is_for_project(
+ &self,
+ project: &WeakEntity<Project>,
+ lsp_store: &WeakEntity<LspStore>,
+ ) -> bool {
+ self.kind.is_for_project(project, lsp_store)
+ }
+}
+
impl LanguageServerKind {
pub fn project(&self) -> Option<&WeakEntity<Project>> {
match self {
- Self::Local { project } => Some(project),
- Self::Remote { project } => Some(project),
+ Self::Local { project }
+ | Self::Remote { project }
+ | Self::Supplementary { project } => Some(project),
Self::LocalSsh { .. } => None,
- Self::Global { .. } => None,
+ }
+ }
+
+ pub fn is_for_project(
+ &self,
+ project: &WeakEntity<Project>,
+ lsp_store: &WeakEntity<LspStore>,
+ ) -> bool {
+ match self {
+ Self::Local {
+ project: server_project,
+ }
+ | Self::Remote {
+ project: server_project,
+ }
+ | Self::Supplementary {
+ project: server_project,
+ } => server_project == project,
+ Self::LocalSsh {
+ lsp_store: server_lsp_store,
+ } => server_lsp_store == lsp_store,
}
}
}
@@ -400,10 +449,10 @@ impl LogStore {
io_tx,
};
cx.spawn(async move |log_store, cx| {
- while let Some((server_id, io_kind, message, observed_at)) = io_rx.next().await {
+ while let Some((server_key, io_kind, message, observed_at)) = io_rx.next().await {
if let Some(log_store) = log_store.upgrade() {
log_store.update(cx, |log_store, cx| {
- log_store.on_io(server_id, io_kind, &message, observed_at, cx);
+ log_store.on_io(&server_key, io_kind, &message, observed_at, cx);
});
}
}
@@ -423,10 +472,11 @@ impl LogStore {
cx.observe_release(project, move |this, _, _| {
this.projects.remove(&weak_project);
this.language_servers
- .retain(|_, state| state.kind.project() != Some(&weak_project));
+ .retain(|key, _| key.kind.project() != Some(&weak_project));
}),
cx.subscribe(project, move |log_store, project, event, cx| {
- let server_kind = if project.read(cx).is_local() {
+ let is_local = project.read(cx).is_local();
+ let primary_server_kind = if is_local {
LanguageServerKind::Local {
project: project.downgrade(),
}
@@ -435,10 +485,32 @@ impl LogStore {
project: project.downgrade(),
}
};
+ let server_kind_for_id = |log_store: &LogStore, server_id| {
+ // Remote project events carry host-side server IDs, which may
+ // collide numerically with locally allocated supplementary
+ // server IDs, so only local projects may resolve an ID to a
+ // supplementary server.
+ if is_local {
+ let supplementary_server_kind = LanguageServerKind::Supplementary {
+ project: project.downgrade(),
+ };
+ let supplementary_server_key = LanguageServerLogKey::new(
+ supplementary_server_kind.clone(),
+ server_id,
+ );
+ if log_store
+ .language_servers
+ .contains_key(&supplementary_server_key)
+ {
+ return supplementary_server_kind;
+ }
+ }
+ primary_server_kind.clone()
+ };
match event {
crate::Event::LanguageServerAdded(id, name, worktree_id) => {
log_store.add_language_server(
- server_kind,
+ primary_server_kind,
*id,
Some(name.clone()),
*worktree_id,
@@ -450,6 +522,22 @@ impl LogStore {
cx,
);
}
+ crate::Event::SupplementaryLanguageServerAdded(id, name) => {
+ log_store.add_language_server(
+ LanguageServerKind::Supplementary {
+ project: project.downgrade(),
+ },
+ *id,
+ Some(name.clone()),
+ None,
+ project
+ .read(cx)
+ .lsp_store()
+ .read(cx)
+ .language_server_for_id(*id),
+ cx,
+ );
+ }
crate::Event::LanguageServerBufferRegistered {
server_id,
buffer_id,
@@ -472,7 +560,7 @@ impl LogStore {
.map(|status| status.name.clone())
});
log_store.add_language_server(
- server_kind,
+ server_kind_for_id(log_store, *server_id),
*server_id,
name,
worktree_id,
@@ -481,9 +569,23 @@ impl LogStore {
);
}
crate::Event::LanguageServerRemoved(id) => {
- log_store.remove_language_server(*id, cx);
+ let server_key =
+ LanguageServerLogKey::new(primary_server_kind, *id);
+ log_store.remove_language_server(&server_key, cx);
+ }
+ crate::Event::SupplementaryLanguageServerRemoved(id) => {
+ let server_key = LanguageServerLogKey::new(
+ LanguageServerKind::Supplementary {
+ project: project.downgrade(),
+ },
+ *id,
+ );
+ log_store.remove_language_server(&server_key, cx);
}
crate::Event::LanguageServerLog(id, typ, message) => {
+ let server_kind = server_kind_for_id(log_store, *id);
+ let server_key =
+ LanguageServerLogKey::new(server_kind.clone(), *id);
log_store.add_language_server(
server_kind,
*id,
@@ -494,11 +596,16 @@ impl LogStore {
);
match typ {
crate::LanguageServerLogType::Log(typ) => {
- log_store.add_language_server_log(*id, *typ, message, cx);
+ log_store.add_language_server_log(
+ &server_key,
+ *typ,
+ message,
+ cx,
+ );
}
crate::LanguageServerLogType::Trace { verbose_info } => {
log_store.add_language_server_trace(
- *id,
+ &server_key,
message,
verbose_info.clone(),
cx,
@@ -511,7 +618,7 @@ impl LogStore {
MessageKind::Send
};
log_store.add_language_server_rpc(
- *id,
+ &server_key,
kind,
message,
RpcTiming::Forwarded(*elapsed),
@@ -525,12 +632,17 @@ impl LogStore {
enabled,
toggled_log_kind,
} => {
- log_store.toggle_lsp_logs(*server_id, *enabled, *toggled_log_kind);
+ let server_key = LanguageServerLogKey::new(
+ server_kind_for_id(log_store, *server_id),
+ *server_id,
+ );
+ log_store.toggle_lsp_logs(&server_key, *enabled, *toggled_log_kind);
}
_ => {}
}
}),
],
+ copilot_server_id: None,
copilot_log_subscription: None,
},
);
@@ -538,9 +650,9 @@ impl LogStore {
pub fn get_language_server_state(
&mut self,
- id: LanguageServerId,
+ key: &LanguageServerLogKey,
) -> Option<&mut LanguageServerState> {
- self.language_servers.get_mut(&id)
+ self.language_servers.get_mut(key)
}
pub fn add_language_server(
@@ -552,21 +664,25 @@ impl LogStore {
server: Option<Arc<LanguageServer>>,
cx: &mut Context<Self>,
) -> Option<&mut LanguageServerState> {
- let server_state = self.language_servers.entry(server_id).or_insert_with(|| {
- cx.notify();
- LanguageServerState {
- name: None,
- worktree_id: None,
- kind,
- rpc_state: None,
- log_messages: VecDeque::with_capacity(MAX_STORED_LOG_ENTRIES),
- trace_messages: VecDeque::with_capacity(MAX_STORED_LOG_ENTRIES),
- trace_level: TraceValue::Off,
- log_level: MessageType::LOG,
- io_logs_subscription: None,
- toggled_log_kind: None,
- }
- });
+ let server_key = LanguageServerLogKey::new(kind, server_id);
+ let server_state = self
+ .language_servers
+ .entry(server_key.clone())
+ .or_insert_with(|| {
+ cx.notify();
+ LanguageServerState {
+ name: None,
+ worktree_id: None,
+ server: server.as_ref().map(Arc::downgrade),
+ rpc_state: None,
+ log_messages: VecDeque::with_capacity(MAX_STORED_LOG_ENTRIES),
+ trace_messages: VecDeque::with_capacity(MAX_STORED_LOG_ENTRIES),
+ trace_level: TraceValue::Off,
+ log_level: MessageType::LOG,
+ io_logs_subscription: None,
+ toggled_log_kind: None,
+ }
+ });
if let Some(name) = name {
server_state.name = Some(name);
@@ -575,15 +691,29 @@ impl LogStore {
server_state.worktree_id = Some(worktree_id);
}
- if let Some(server) = server.filter(|_| server_state.io_logs_subscription.is_none()) {
- let io_tx = self.io_tx.clone();
- let server_id = server.server_id();
- server_state.io_logs_subscription = Some(server.on_io(move |io_kind, message| {
- let observed_at = Instant::now();
- io_tx
- .unbounded_send((server_id, io_kind, message.to_string(), observed_at))
- .ok();
- }));
+ if let Some(server) = server {
+ let is_new_server = match server_state.server() {
+ Some(current_server) => !Arc::ptr_eq(&current_server, &server),
+ None => true,
+ };
+ if is_new_server {
+ server_state.server = Some(Arc::downgrade(&server));
+ server_state.io_logs_subscription = None;
+ }
+ if server_state.io_logs_subscription.is_none() {
+ let io_tx = self.io_tx.clone();
+ server_state.io_logs_subscription = Some(server.on_io(move |io_kind, message| {
+ let observed_at = Instant::now();
+ io_tx
+ .unbounded_send((
+ server_key.clone(),
+ io_kind,
+ message.to_string(),
+ observed_at,
+ ))
+ .ok();
+ }));
+ }
}
Some(server_state)
@@ -591,13 +721,13 @@ impl LogStore {
pub fn add_language_server_log(
&mut self,
- id: LanguageServerId,
+ key: &LanguageServerLogKey,
typ: MessageType,
message: &str,
cx: &mut Context<Self>,
) -> Option<()> {
let store_logs = !self.on_headless_host;
- let language_server_state = self.get_language_server_state(id)?;
+ let language_server_state = self.get_language_server_state(key)?;
let log_lines = &mut language_server_state.log_messages;
let message = message.trim_end().to_string();
@@ -605,7 +735,7 @@ impl LogStore {
// Send all messages regardless of the visibility in case of not storing, to notify the receiver anyway
self.emit_event(
Event::NewServerLogEntry {
- id,
+ key: key.clone(),
kind: LanguageServerLogType::Log(typ),
text: message,
},
@@ -618,7 +748,7 @@ impl LogStore {
) {
self.emit_event(
Event::NewServerLogEntry {
- id,
+ key: key.clone(),
kind: LanguageServerLogType::Log(typ),
text: new_message,
},
@@ -630,20 +760,20 @@ impl LogStore {
fn add_language_server_trace(
&mut self,
- id: LanguageServerId,
+ key: &LanguageServerLogKey,
message: &str,
verbose_info: Option<String>,
cx: &mut Context<Self>,
) -> Option<()> {
let store_logs = !self.on_headless_host;
- let language_server_state = self.get_language_server_state(id)?;
+ let language_server_state = self.get_language_server_state(key)?;
let log_lines = &mut language_server_state.trace_messages;
if !store_logs {
// Send all messages regardless of the visibility in case of not storing, to notify the receiver anyway
self.emit_event(
Event::NewServerLogEntry {
- id,
+ key: key.clone(),
kind: LanguageServerLogType::Trace { verbose_info },
text: message.trim().to_string(),
},
@@ -669,7 +799,7 @@ impl LogStore {
}
self.emit_event(
Event::NewServerLogEntry {
- id,
+ key: key.clone(),
kind: LanguageServerLogType::Trace { verbose_info },
text: new_message,
},
@@ -696,7 +826,7 @@ impl LogStore {
fn add_language_server_rpc(
&mut self,
- language_server_id: LanguageServerId,
+ key: &LanguageServerLogKey,
kind: MessageKind,
message: &str,
timing: RpcTiming,
@@ -704,7 +834,7 @@ impl LogStore {
) {
let store_logs = !self.on_headless_host;
let Some(state) = self
- .get_language_server_state(language_server_id)
+ .get_language_server_state(key)
.and_then(|state| state.rpc_state.as_mut())
else {
return;
@@ -737,7 +867,7 @@ impl LogStore {
if let Some(header) = header {
// Do not send a synthetic message over the wire, it will be derived from the actual RPC message
cx.emit(Event::NewServerLogEntry {
- id: language_server_id,
+ key: key.clone(),
kind: LanguageServerLogType::Rpc {
received,
elapsed: None,
@@ -748,7 +878,7 @@ impl LogStore {
self.emit_event(
Event::NewServerLogEntry {
- id: language_server_id,
+ key: key.clone(),
kind: LanguageServerLogType::Rpc { received, elapsed },
text: message.to_owned(),
},
@@ -756,44 +886,37 @@ impl LogStore {
);
}
- pub fn remove_language_server(&mut self, id: LanguageServerId, cx: &mut Context<Self>) {
- self.language_servers.remove(&id);
+ pub fn remove_language_server(&mut self, key: &LanguageServerLogKey, cx: &mut Context<Self>) {
+ self.language_servers.remove(key);
cx.notify();
}
- pub fn server_logs(&self, server_id: LanguageServerId) -> Option<&VecDeque<LogMessage>> {
- Some(&self.language_servers.get(&server_id)?.log_messages)
+ pub fn server_logs(&self, key: &LanguageServerLogKey) -> Option<&VecDeque<LogMessage>> {
+ Some(&self.language_servers.get(key)?.log_messages)
}
- pub fn server_trace(&self, server_id: LanguageServerId) -> Option<&VecDeque<TraceMessage>> {
- Some(&self.language_servers.get(&server_id)?.trace_messages)
+ pub fn server_trace(&self, key: &LanguageServerLogKey) -> Option<&VecDeque<TraceMessage>> {
+ Some(&self.language_servers.get(key)?.trace_messages)
}
- pub fn server_ids_for_project<'a>(
+ pub fn server_keys_for_project<'a>(
&'a self,
- lookup_project: &'a WeakEntity<Project>,
- ) -> impl Iterator<Item = LanguageServerId> + 'a {
+ project: &'a WeakEntity<Project>,
+ lsp_store: &'a WeakEntity<LspStore>,
+ ) -> impl Iterator<Item = LanguageServerLogKey> + 'a {
self.language_servers
- .iter()
- .filter_map(move |(id, state)| match &state.kind {
- LanguageServerKind::Local { project } | LanguageServerKind::Remote { project } => {
- if project == lookup_project {
- Some(*id)
- } else {
- None
- }
- }
- LanguageServerKind::Global | LanguageServerKind::LocalSsh { .. } => Some(*id),
- })
+ .keys()
+ .filter(move |key| key.is_for_project(project, lsp_store))
+ .cloned()
}
pub fn enable_rpc_trace_for_language_server(
&mut self,
- server_id: LanguageServerId,
+ key: &LanguageServerLogKey,
) -> Option<&mut LanguageServerRpcState> {
let rpc_state = self
.language_servers
- .get_mut(&server_id)?
+ .get_mut(key)?
.rpc_state
.get_or_insert_with(|| LanguageServerRpcState {
rpc_messages: VecDeque::with_capacity(MAX_STORED_LOG_ENTRIES),
@@ -805,25 +928,30 @@ impl LogStore {
pub fn disable_rpc_trace_for_language_server(
&mut self,
- server_id: LanguageServerId,
+ key: &LanguageServerLogKey,
) -> Option<()> {
- self.language_servers.get_mut(&server_id)?.rpc_state.take();
+ self.language_servers.get_mut(key)?.rpc_state.take();
Some(())
}
- pub fn has_server_logs(&self, server: &LanguageServerSelector) -> bool {
- match server {
- LanguageServerSelector::Id(id) => self.language_servers.contains_key(id),
- LanguageServerSelector::Name(name) => self
- .language_servers
- .iter()
- .any(|(_, state)| state.name.as_ref() == Some(name)),
- }
+ pub fn has_server_logs(
+ &self,
+ server: &LanguageServerSelector,
+ project: &WeakEntity<Project>,
+ lsp_store: &WeakEntity<LspStore>,
+ ) -> bool {
+ self.language_servers.iter().any(|(key, state)| {
+ key.is_for_project(project, lsp_store)
+ && match server {
+ LanguageServerSelector::Id(id) => key.server_id == *id,
+ LanguageServerSelector::Name(name) => state.name.as_ref() == Some(name),
+ }
+ })
}
fn on_io(
&mut self,
- language_server_id: LanguageServerId,
+ key: &LanguageServerLogKey,
io_kind: IoKind,
message: &str,
observed_at: Instant,
@@ -833,7 +961,7 @@ impl LogStore {
IoKind::StdOut => true,
IoKind::StdIn => false,
IoKind::StdErr => {
- self.add_language_server_log(language_server_id, MessageType::LOG, message, cx);
+ self.add_language_server_log(key, MessageType::LOG, message, cx);
return Some(());
}
};
@@ -844,36 +972,30 @@ impl LogStore {
MessageKind::Send
};
- self.add_language_server_rpc(
- language_server_id,
- kind,
- message,
- RpcTiming::ObservedAt(observed_at),
- cx,
- );
+ self.add_language_server_rpc(key, kind, message, RpcTiming::ObservedAt(observed_at), cx);
cx.notify();
Some(())
}
fn emit_event(&mut self, e: Event, cx: &mut Context<Self>) {
match &e {
- Event::NewServerLogEntry { id, kind, text } => {
- if let Some(state) = self.get_language_server_state(*id) {
- let downstream_client = match &state.kind {
+ Event::NewServerLogEntry { key, kind, text } => {
+ if let Some(state) = self.get_language_server_state(key) {
+ let downstream_client = match &key.kind {
LanguageServerKind::Remote { project }
| LanguageServerKind::Local { project } => project
.upgrade()
.map(|project| project.read(cx).lsp_store()),
LanguageServerKind::LocalSsh { lsp_store } => lsp_store.upgrade(),
- LanguageServerKind::Global => None,
+ LanguageServerKind::Supplementary { .. } => None,
}
.and_then(|lsp_store| lsp_store.read(cx).downstream_client());
if let Some((client, project_id)) = downstream_client {
- if Some(LogKind::from_server_log_type(kind)) == state.toggled_log_kind {
+ if state.toggled_log_kind == Some(LogKind::from_server_log_type(kind)) {
client
.send(proto::LanguageServerLog {
project_id,
- language_server_id: id.to_proto(),
+ language_server_id: key.server_id.to_proto(),
message: text.clone(),
log_type: Some(kind.to_proto()),
})
@@ -889,31 +1011,88 @@ impl LogStore {
pub fn toggle_lsp_logs(
&mut self,
- server_id: LanguageServerId,
+ key: &LanguageServerLogKey,
enabled: bool,
toggled_log_kind: LogKind,
) {
- if let Some(server_state) = self.get_language_server_state(server_id) {
+ if let Some(server_state) = self.get_language_server_state(key) {
if enabled {
server_state.toggled_log_kind = Some(toggled_log_kind);
} else {
server_state.toggled_log_kind = None;
}
}
- if LogKind::Rpc == toggled_log_kind {
+ if toggled_log_kind == LogKind::Rpc {
if enabled {
- self.enable_rpc_trace_for_language_server(server_id);
+ self.enable_rpc_trace_for_language_server(key);
} else {
- self.disable_rpc_trace_for_language_server(server_id);
+ self.disable_rpc_trace_for_language_server(key);
}
}
}
- pub fn copilot_state_for_project(
+ pub fn sync_copilot_for_project(
&mut self,
project: &WeakEntity<Project>,
- ) -> Option<&mut Option<lsp::Subscription>> {
- self.projects
- .get_mut(project)
- .map(|project| &mut project.copilot_log_subscription)
+ server: Option<Arc<LanguageServer>>,
+ cx: &mut Context<Self>,
+ ) -> Option<()> {
+ let server_kind = LanguageServerKind::Supplementary {
+ project: project.clone(),
+ };
+ let current_server_id = server.as_ref().map(|server| server.server_id());
+ let current_server_matches = server.as_ref().is_some_and(|server| {
+ let server_key = LanguageServerLogKey::new(server_kind.clone(), server.server_id());
+ self.language_servers
+ .get(&server_key)
+ .and_then(|state| state.server())
+ .is_some_and(|current_server| Arc::ptr_eq(&current_server, server))
+ });
+ let project_state = self.projects.get_mut(project)?;
+ if project_state.copilot_server_id == current_server_id && current_server_matches {
+ return Some(());
+ }
+
+ project_state.copilot_log_subscription = None;
+ let previous_server_id = project_state.copilot_server_id.take();
+ if previous_server_id != current_server_id
+ && let Some(previous_server_id) = previous_server_id
+ {
+ let previous_server_key =
+ LanguageServerLogKey::new(server_kind.clone(), previous_server_id);
+ self.remove_language_server(&previous_server_key, cx);
+ }
+
+ let Some(server) = server else {
+ return Some(());
+ };
+ let server_id = server.server_id();
+ let server_key = LanguageServerLogKey::new(server_kind.clone(), server_id);
+ let weak_log_store = cx.weak_entity();
+ let log_subscription =
+ server.on_notification::<lsp::notification::LogMessage, _>(move |params, cx| {
+ weak_log_store
+ .update(cx, |log_store, cx| {
+ log_store.add_language_server_log(
+ &server_key,
+ MessageType::LOG,
+ &params.message,
+ cx,
+ );
+ })
+ .ok();
+ });
+ self.add_language_server(
+ server_kind,
+ server_id,
+ Some(LanguageServerName::new_static("copilot")),
+ None,
+ Some(server),
+ cx,
+ );
+
+ let project_state = self.projects.get_mut(project)?;
+ project_state.copilot_server_id = Some(server_id);
+ project_state.copilot_log_subscription = Some(log_subscription);
+ Some(())
}
}
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index 186af487088..7e94d87c76a 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -336,7 +336,9 @@ pub struct ToastLink {
#[derive(Clone, Debug, PartialEq)]
pub enum Event {
LanguageServerAdded(LanguageServerId, LanguageServerName, Option<WorktreeId>),
+ SupplementaryLanguageServerAdded(LanguageServerId, LanguageServerName),
LanguageServerRemoved(LanguageServerId),
+ SupplementaryLanguageServerRemoved(LanguageServerId),
LanguageServerLog(LanguageServerId, LanguageServerLogType, String),
// [`lsp::notification::DidOpenTextDocument`] was sent to this server using the buffer data.
// Zed's buffer-related data is updated accordingly.
@@ -3696,9 +3698,15 @@ impl Project {
LspStoreEvent::LanguageServerAdded(server_id, name, worktree_id) => cx.emit(
Event::LanguageServerAdded(*server_id, name.clone(), *worktree_id),
),
+ LspStoreEvent::SupplementaryLanguageServerAdded(server_id, name) => cx.emit(
+ Event::SupplementaryLanguageServerAdded(*server_id, name.clone()),
+ ),
LspStoreEvent::LanguageServerRemoved(server_id) => {
cx.emit(Event::LanguageServerRemoved(*server_id))
}
+ LspStoreEvent::SupplementaryLanguageServerRemoved(server_id) => {
+ cx.emit(Event::SupplementaryLanguageServerRemoved(*server_id))
+ }
LspStoreEvent::LanguageServerLog(server_id, log_type, string) => cx.emit(
Event::LanguageServerLog(*server_id, log_type.clone(), string.clone()),
),
@@ -6260,13 +6268,6 @@ impl Project {
Ok(())
}
- pub fn supplementary_language_servers<'a>(
- &'a self,
- cx: &'a App,
- ) -> impl 'a + Iterator<Item = (LanguageServerId, LanguageServerName)> {
- self.lsp_store.read(cx).supplementary_language_servers()
- }
-
pub fn any_language_server_supports_inlay_hints(&self, buffer: &Buffer, cx: &mut App) -> bool {
let Some(language) = buffer.language().cloned() else {
return false;
diff --git a/crates/remote_server/src/headless_project.rs b/crates/remote_server/src/headless_project.rs
index 7f916b3c815..370368e2a00 100644
--- a/crates/remote_server/src/headless_project.rs
+++ b/crates/remote_server/src/headless_project.rs
@@ -22,7 +22,9 @@ use project::{
debugger::{breakpoint_store::BreakpointStore, dap_store::DapStore},
git_store::GitStore,
image_store::ImageId,
- lsp_store::log_store::{self, GlobalLogStore, LanguageServerKind, LogKind},
+ lsp_store::log_store::{
+ self, GlobalLogStore, LanguageServerKind, LanguageServerLogKey, LogKind,
+ },
project_settings::SettingsObserver,
search::SearchQuery,
task_store::TaskStore,
@@ -408,13 +410,39 @@ impl HeadlessProject {
});
}
}
- LspStoreEvent::LanguageServerRemoved(id) => {
+ LspStoreEvent::SupplementaryLanguageServerAdded(id, name) => {
let log_store = cx
.try_global::<GlobalLogStore>()
.map(|lsp_logs| lsp_logs.0.clone());
if let Some(log_store) = log_store {
log_store.update(cx, |log_store, cx| {
- log_store.remove_language_server(*id, cx);
+ log_store.add_language_server(
+ LanguageServerKind::LocalSsh {
+ lsp_store: self.lsp_store.downgrade(),
+ },
+ *id,
+ Some(name.clone()),
+ None,
+ lsp_store.read(cx).language_server_for_id(*id),
+ cx,
+ );
+ });
+ }
+ }
+ LspStoreEvent::LanguageServerRemoved(id)
+ | LspStoreEvent::SupplementaryLanguageServerRemoved(id) => {
+ let log_store = cx
+ .try_global::<GlobalLogStore>()
+ .map(|lsp_logs| lsp_logs.0.clone());
+ if let Some(log_store) = log_store {
+ let server_key = LanguageServerLogKey::new(
+ LanguageServerKind::LocalSsh {
+ lsp_store: self.lsp_store.downgrade(),
+ },
+ *id,
+ );
+ log_store.update(cx, |log_store, cx| {
+ log_store.remove_language_server(&server_key, cx);
});
}
self.session
@@ -837,11 +865,12 @@ impl HeadlessProject {
}
async fn handle_toggle_lsp_logs(
- _: Entity<Self>,
+ this: Entity<Self>,
envelope: TypedEnvelope<proto::ToggleLspLogs>,
cx: AsyncApp,
) -> Result<()> {
let server_id = LanguageServerId::from_proto(envelope.payload.server_id);
+ let lsp_store = this.read_with(&cx, |this, _| this.lsp_store.downgrade());
cx.update(|cx| {
let log_store = cx
.try_global::<GlobalLogStore>()
@@ -856,8 +885,10 @@ impl HeadlessProject {
proto::toggle_lsp_logs::LogType::Trace => LogKind::Trace,
proto::toggle_lsp_logs::LogType::Rpc => LogKind::Rpc,
};
+ let server_key =
+ LanguageServerLogKey::new(LanguageServerKind::LocalSsh { lsp_store }, server_id);
log_store.update(cx, |log_store, _| {
- log_store.toggle_lsp_logs(server_id, envelope.payload.enabled, toggled_log_kind);
+ log_store.toggle_lsp_logs(&server_key, envelope.payload.enabled, toggled_log_kind);
});
anyhow::Ok(())
})?;
diff --git a/crates/remote_server/src/remote_editing_tests.rs b/crates/remote_server/src/remote_editing_tests.rs
index bd5b6d16a3a..2aaf99b9b4a 100644
--- a/crates/remote_server/src/remote_editing_tests.rs
+++ b/crates/remote_server/src/remote_editing_tests.rs
@@ -36,13 +36,14 @@ use language::{
};
use lsp::{
CompletionContext, CompletionResponse, CompletionTriggerKind, DEFAULT_LSP_REQUEST_TIMEOUT,
- LanguageServerName,
+ LanguageServerId, LanguageServerName,
};
use node_runtime::NodeRuntime;
use project::{
- ProgressToken, Project, ProjectPath,
+ LanguageServerLogType, ProgressToken, Project, ProjectPath,
agent_server_store::AgentServerCommand,
image_store,
+ lsp_store::log_store::{LanguageServerKind, LanguageServerLogKey, LogStore},
search::{SearchQuery, SearchResult},
};
use remote::{ConnectionState, RemoteClient, RemoteClientEvent};
@@ -4692,6 +4693,77 @@ async fn test_remote_project_creation_notifies_new_entity_observers(
assert!(project.read_with(cx, |project, _| project.is_remote()));
}
+#[gpui::test]
+async fn test_log_store_keys_remote_events_by_primary_kind_on_supplementary_id_collision(
+ cx: &mut TestAppContext,
+ server_cx: &mut TestAppContext,
+) {
+ let server_fs = Arc::new(FakeFs::new(server_cx.executor()));
+ server_fs
+ .insert_tree(path!("/code"), json!({ "project1": { "README.md": "" } }))
+ .await;
+ let (project, _headless) = init_test(&server_fs, cx, server_cx).await;
+
+ let log_store = cx.new(|cx| LogStore::new(false, cx));
+ log_store.update(cx, |log_store, cx| log_store.add_project(&project, cx));
+
+ // A supplementary server (e.g. Copilot) allocates its ID from the local
+ // registry, which may collide numerically with a host-side server ID.
+ let server_id = LanguageServerId(42);
+ let supplementary_server_key = LanguageServerLogKey::new(
+ LanguageServerKind::Supplementary {
+ project: project.downgrade(),
+ },
+ server_id,
+ );
+ log_store.update(cx, |log_store, cx| {
+ log_store.add_language_server(
+ LanguageServerKind::Supplementary {
+ project: project.downgrade(),
+ },
+ server_id,
+ Some(LanguageServerName::new_static("copilot")),
+ None,
+ None,
+ cx,
+ );
+ });
+
+ project.update(cx, |_, cx| {
+ cx.emit(project::Event::LanguageServerLog(
+ server_id,
+ LanguageServerLogType::Log(lsp::MessageType::LOG),
+ "host server log".to_string(),
+ ));
+ });
+ cx.run_until_parked();
+
+ let remote_server_key = LanguageServerLogKey::new(
+ LanguageServerKind::Remote {
+ project: project.downgrade(),
+ },
+ server_id,
+ );
+ log_store.read_with(cx, |log_store, _| {
+ assert_eq!(
+ log_store.server_logs(&remote_server_key).map(|logs| {
+ logs.iter()
+ .map(|log| log.as_ref().to_string())
+ .collect::<Vec<_>>()
+ }),
+ Some(vec!["host server log".to_string()]),
+ "host server logs should be keyed by the remote server kind"
+ );
+ assert_eq!(
+ log_store
+ .server_logs(&supplementary_server_key)
+ .map(|logs| logs.len()),
+ Some(0),
+ "host server logs should not leak into the supplementary server with the same ID"
+ );
+ });
+}
+
pub async fn init_test(
server_fs: &Arc<FakeFs>,
cx: &mut TestAppContext,
diff --git a/crates/zed/src/zed.rs b/crates/zed/src/zed.rs
index ebe3776df3e..3a1704b2a65 100644
--- a/crates/zed/src/zed.rs
+++ b/crates/zed/src/zed.rs
@@ -602,12 +602,7 @@ pub fn initialize_workspace(app_state: Arc<AppState>, cx: &mut App) {
let diagnostic_summary =
cx.new(|cx| diagnostics::items::DiagnosticIndicator::new(workspace, cx));
let active_file_name = cx.new(|_| workspace::active_file_name::ActiveFileName::new());
- let activity_indicator = activity_indicator::ActivityIndicator::new(
- workspace,
- workspace.project().read(cx).languages().clone(),
- window,
- cx,
- );
+ let activity_indicator = activity_indicator::ActivityIndicator::new(workspace, window, cx);
let active_buffer_encoding =
cx.new(|_| encoding_selector::ActiveBufferEncoding::new(workspace));
let active_buffer_language =
@@ -2948,9 +2943,8 @@ mod tests {
cx.add_window_view(|window, cx| MultiWorkspace::test_new(project.clone(), window, cx));
let workspace =
multi_workspace.read_with(cx, |multi_workspace, _| multi_workspace.workspace().clone());
- let languages = project.read_with(cx, |project, _| project.languages().clone());
let indicator = workspace.update_in(cx, |workspace, window, cx| {
- activity_indicator::ActivityIndicator::new(workspace, languages, window, cx)
+ activity_indicator::ActivityIndicator::new(workspace, window, cx)
});
cx.run_until_parked();