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: Register available LSP adapters locally when in remote development (#54915)

Xin Zhao9cc78ac6919b
diff --git a/crates/collab/migrations.sqlite/20221109000000_test_schema.sql b/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
index 9c39dd4c260..fe66b5749af 100644
--- a/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
+++ b/crates/collab/migrations.sqlite/20221109000000_test_schema.sql
@@ -172,6 +172,7 @@ CREATE TABLE "language_servers" (
"id" INTEGER NOT NULL,
"project_id" INTEGER NOT NULL REFERENCES projects (id) ON DELETE CASCADE,
"name" VARCHAR NOT NULL,
+ "language_name" VARCHAR,
"capabilities" TEXT NOT NULL,
"worktree_id" BIGINT,
PRIMARY KEY (project_id, id)
diff --git a/crates/collab/src/db/queries/projects.rs b/crates/collab/src/db/queries/projects.rs
index cae1f238b1d..3cf82e8518c 100644
--- a/crates/collab/src/db/queries/projects.rs
+++ b/crates/collab/src/db/queries/projects.rs
@@ -586,6 +586,7 @@ impl Database {
project_id: ActiveValue::set(project_id),
id: ActiveValue::set(server.id as i64),
name: ActiveValue::set(server.name.clone()),
+ language_name: ActiveValue::set(server.language_name.clone()),
worktree_id: ActiveValue::set(server.worktree_id.map(|id| id as i64)),
capabilities: ActiveValue::set(update.capabilities.clone()),
})
@@ -596,6 +597,7 @@ impl Database {
])
.update_columns([
language_server::Column::Name,
+ language_server::Column::LanguageName,
language_server::Column::Capabilities,
language_server::Column::WorktreeId,
])
@@ -986,6 +988,7 @@ impl Database {
id: language_server.id as u64,
name: language_server.name,
worktree_id: language_server.worktree_id.map(|id| id as u64),
+ language_name: language_server.language_name,
},
capabilities: language_server.capabilities,
})
diff --git a/crates/collab/src/db/queries/rooms.rs b/crates/collab/src/db/queries/rooms.rs
index 6e43b34507f..a04cd534102 100644
--- a/crates/collab/src/db/queries/rooms.rs
+++ b/crates/collab/src/db/queries/rooms.rs
@@ -824,6 +824,7 @@ impl Database {
id: language_server.id as u64,
name: language_server.name,
worktree_id: language_server.worktree_id.map(|id| id as u64),
+ language_name: language_server.language_name,
},
capabilities: language_server.capabilities,
})
diff --git a/crates/collab/src/db/tables/language_server.rs b/crates/collab/src/db/tables/language_server.rs
index 705aae292ba..5eddaa84847 100644
--- a/crates/collab/src/db/tables/language_server.rs
+++ b/crates/collab/src/db/tables/language_server.rs
@@ -9,6 +9,7 @@ pub struct Model {
#[sea_orm(primary_key)]
pub id: i64,
pub name: String,
+ pub language_name: Option<String>,
pub capabilities: String,
pub worktree_id: Option<i64>,
}
diff --git a/crates/collab/tests/integration/editor_tests.rs b/crates/collab/tests/integration/editor_tests.rs
index 016ae3dd16c..71040766db0 100644
--- a/crates/collab/tests/integration/editor_tests.rs
+++ b/crates/collab/tests/integration/editor_tests.rs
@@ -1524,6 +1524,177 @@ async fn test_language_server_statuses(cx_a: &mut TestAppContext, cx_b: &mut Tes
});
}
+#[gpui::test]
+async fn test_local_registration_for_new_available_server_from_remote(
+ cx_a: &mut TestAppContext,
+ cx_b: &mut TestAppContext,
+) {
+ let mut server = TestServer::start(cx_a.executor()).await;
+ let executor = cx_a.executor();
+ let client_a = server.create_client(cx_a, "user_a").await;
+ let client_b = server.create_client(cx_b, "user_b").await;
+ server
+ .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
+ .await;
+ let active_call_a = cx_a.read(ActiveCall::global);
+
+ client_a.language_registry().add(rust_lang());
+ client_b.language_registry().add(rust_lang());
+
+ // Client B has an "available" adapter for "the-language-server",
+ // but it's not regitstered for Rust
+ client_b
+ .language_registry()
+ .register_fake_available_lsp_adapter(
+ "the-language-server",
+ FakeLspAdapter {
+ name: "the-language-server",
+ ..Default::default()
+ },
+ );
+
+ client_a
+ .fs()
+ .insert_tree(
+ path!("/dir"),
+ json!({
+ "main.rs": "const ONE: usize = 1;",
+ }),
+ )
+ .await;
+ let (project_a, _) = client_a.build_local_project(path!("/dir"), cx_a).await;
+ let project_id = active_call_a
+ .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
+ .await
+ .unwrap();
+
+ executor.run_until_parked();
+ let project_b = client_b.join_remote_project(project_id, cx_b).await;
+
+ // Client A starts the language server.
+ let mut fake_language_servers = client_a.language_registry().register_fake_lsp(
+ "Rust",
+ FakeLspAdapter {
+ name: "the-language-server",
+ ..Default::default()
+ },
+ );
+
+ let _buffer_a = project_a
+ .update(cx_a, |p, cx| {
+ p.open_local_buffer_with_lsp(path!("/dir/main.rs"), cx)
+ })
+ .await
+ .unwrap();
+
+ let _fake_language_server = fake_language_servers.next().await.unwrap();
+ executor.run_until_parked();
+
+ // Verify client B has registered the adapter for Rust locally
+ project_b.read_with(cx_b, |project, cx| {
+ let statuses = project.language_server_statuses(cx).collect::<Vec<_>>();
+ assert_eq!(statuses.len(), 1);
+ assert_eq!(statuses[0].1.name.0, "the-language-server");
+ });
+
+ let rust_adapters = client_b
+ .language_registry()
+ .lsp_adapters(&language::LanguageName::new("Rust"));
+ assert!(
+ rust_adapters
+ .iter()
+ .any(|a| a.name().0 == "the-language-server")
+ );
+}
+
+#[gpui::test]
+async fn test_local_registration_for_existing_available_server_from_remote(
+ cx_a: &mut TestAppContext,
+ cx_b: &mut TestAppContext,
+) {
+ let mut server = TestServer::start(cx_a.executor()).await;
+ let executor = cx_a.executor();
+ let client_a = server.create_client(cx_a, "user_a").await;
+ let client_b = server.create_client(cx_b, "user_b").await;
+ server
+ .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
+ .await;
+ let active_call_a = cx_a.read(ActiveCall::global);
+
+ client_a.language_registry().add(rust_lang());
+ client_b.language_registry().add(rust_lang());
+
+ // Client B has an "available" adapter for "the-language-server",
+ // but it's not regitstered for Rust
+ client_b
+ .language_registry()
+ .register_fake_available_lsp_adapter(
+ "the-language-server",
+ FakeLspAdapter {
+ name: "the-language-server",
+ ..Default::default()
+ },
+ );
+
+ client_a
+ .fs()
+ .insert_tree(
+ path!("/dir"),
+ json!({
+ "main.rs": "const ONE: usize = 1;",
+ }),
+ )
+ .await;
+ let (project_a, _) = client_a.build_local_project(path!("/dir"), cx_a).await;
+
+ // Client A starts the language server FIRST.
+ let mut fake_language_servers = client_a.language_registry().register_fake_lsp(
+ "Rust",
+ FakeLspAdapter {
+ name: "the-language-server",
+ ..Default::default()
+ },
+ );
+
+ let _buffer_a = project_a
+ .update(cx_a, |p, cx| {
+ p.open_local_buffer_with_lsp(path!("/dir/main.rs"), cx)
+ })
+ .await
+ .unwrap();
+
+ let _fake_language_server = fake_language_servers.next().await.unwrap();
+ executor.run_until_parked();
+
+ let project_id = active_call_a
+ .update(cx_a, |call, cx| call.share_project(project_a.clone(), cx))
+ .await
+ .unwrap();
+
+ executor.run_until_parked();
+
+ // Client B joins the remote project.
+ let project_b = client_b.join_remote_project(project_id, cx_b).await;
+ executor.run_until_parked();
+
+ // Verify client B has registered the adapter for Rust locally.
+ let rust_adapters = client_b
+ .language_registry()
+ .lsp_adapters(&language::LanguageName::new("Rust"));
+ assert!(
+ rust_adapters
+ .iter()
+ .any(|a| a.name().0 == "the-language-server"),
+ "Adapter should have been registered upon joining"
+ );
+
+ project_b.read_with(cx_b, |project, cx| {
+ let statuses = project.language_server_statuses(cx).collect::<Vec<_>>();
+ assert_eq!(statuses.len(), 1);
+ assert_eq!(statuses[0].1.name.0, "the-language-server");
+ });
+}
+
#[gpui::test(iterations = 10)]
async fn test_share_project(
cx_a: &mut TestAppContext,
diff --git a/crates/language/src/language_registry.rs b/crates/language/src/language_registry.rs
index a9d5777be01..6207ba7e1bc 100644
--- a/crates/language/src/language_registry.rs
+++ b/crates/language/src/language_registry.rs
@@ -382,6 +382,21 @@ impl LanguageRegistry {
servers_rx
}
+ #[cfg(any(feature = "test-support", test))]
+ pub fn register_fake_available_lsp_adapter(
+ &self,
+ name: impl Into<LanguageServerName>,
+ adapter: crate::FakeLspAdapter,
+ ) {
+ let name = name.into();
+ let adapter = Arc::new(adapter);
+ let mut state = self.state.write();
+ state.available_lsp_adapters.insert(
+ name,
+ Arc::new(move || CachedLspAdapter::new(adapter.clone())),
+ );
+ }
+
#[cfg(any(feature = "test-support", test))]
pub fn has_fake_lsp_server(&self, lsp_name: &LanguageServerName) -> bool {
self.state.read().fake_server_entries.contains_key(lsp_name)
diff --git a/crates/language_tools/src/lsp_log_view.rs b/crates/language_tools/src/lsp_log_view.rs
index 159f06952ca..70ddf2aa087 100644
--- a/crates/language_tools/src/lsp_log_view.rs
+++ b/crates/language_tools/src/lsp_log_view.rs
@@ -1363,6 +1363,7 @@ impl ServerInfo {
capabilities: server.capabilities(),
status: LanguageServerStatus {
name: server.name(),
+ language_name: None,
server_version: server.version(),
server_readable_version: server.readable_version(),
pending_work: Default::default(),
diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rs
index baa37cde823..d679b531c83 100644
--- a/crates/project/src/lsp_store.rs
+++ b/crates/project/src/lsp_store.rs
@@ -630,6 +630,7 @@ impl LocalLspStore {
server.clone(),
server_id,
key,
+ language_name,
pending_workspace_folders,
cx,
);
@@ -4164,6 +4165,7 @@ pub enum LspStoreEvent {
#[derive(Clone, Debug, Serialize)]
pub struct LanguageServerStatus {
pub name: LanguageServerName,
+ pub language_name: Option<LanguageName>,
pub server_version: Option<SharedString>,
pub server_readable_version: Option<SharedString>,
pub pending_work: BTreeMap<ProgressToken, LanguageServerProgress>,
@@ -5145,13 +5147,9 @@ impl LspStore {
self.language_server_statuses
.iter()
.filter_map(|(server_id, server_status)| {
- // Include servers that are either registered for this language OR
- // available to be loaded (for SSH remote mode where adapters like
- // ty/pylsp/pyright are registered via register_available_lsp_adapter
- // but only loaded on the server side)
- let is_relevant = registered_language_servers.contains(&server_status.name)
- || self.languages.is_lsp_adapter_available(&server_status.name);
- is_relevant.then_some(*server_id)
+ registered_language_servers
+ .contains(&server_status.name)
+ .then_some(*server_id)
})
.collect()
}
@@ -8589,6 +8587,10 @@ impl LspStore {
id: server_id.to_proto(),
name: status.name.to_string(),
worktree_id: status.worktree.map(|id| id.to_proto()),
+ language_name: status
+ .language_name
+ .as_ref()
+ .map(|name| name.to_proto()),
}),
capabilities: serde_json::to_string(&server.capabilities())
.expect("serializing server LSP capabilities"),
@@ -8634,6 +8636,7 @@ impl LspStore {
let name = LanguageServerName::from_proto(server.name);
let worktree = server.worktree_id.map(WorktreeId::from_proto);
+ let language_name = server.language_name.map(LanguageName::from_proto);
if let Some(lsp_logs) = &lsp_logs {
lsp_logs.update(cx, |lsp_logs, cx| {
@@ -8651,10 +8654,15 @@ impl LspStore {
});
}
+ if let Some(ref lang_name) = language_name {
+ self.try_register_remote_adapter_locally(&name, lang_name);
+ }
+
(
server_id,
LanguageServerStatus {
name,
+ language_name: language_name,
server_version: None,
server_readable_version: None,
pending_work: Default::default(),
@@ -8671,6 +8679,38 @@ impl LspStore {
.collect();
}
+ fn try_register_remote_adapter_locally(
+ &self,
+ server_name: &LanguageServerName,
+ language_name: &LanguageName,
+ ) {
+ let already_registered = self
+ .languages
+ .lsp_adapters(language_name)
+ .iter()
+ .any(|adapter| adapter.name() == *server_name);
+
+ if already_registered {
+ return;
+ }
+
+ if let Some(adapter) = self.languages.load_available_lsp_adapter(server_name) {
+ log::info!(
+ "Registering LSP adapter '{}' for language '{}' on local client",
+ server_name.0,
+ language_name.0
+ );
+ self.languages
+ .register_lsp_adapter(language_name.clone(), adapter.adapter.clone());
+ } else {
+ log::warn!(
+ "LSP adapter '{}' for language '{}' not available locally",
+ server_name.0,
+ language_name.0
+ );
+ }
+ }
+
#[cfg(feature = "test-support")]
pub fn update_diagnostic_entries(
&mut self,
@@ -9822,13 +9862,20 @@ impl LspStore {
lsp_store.update(&mut cx, |lsp_store, cx| {
let server_id = LanguageServerId(server.id as usize);
let server_name = LanguageServerName::from_proto(server.name.clone());
+ let language_name = server.language_name.map(LanguageName::from_proto);
lsp_store
.lsp_server_capabilities
.insert(server_id, server_capabilities);
+
+ if let Some(ref lang_name) = language_name {
+ lsp_store.try_register_remote_adapter_locally(&server_name, lang_name);
+ }
+
lsp_store.language_server_statuses.insert(
server_id,
LanguageServerStatus {
name: server_name.clone(),
+ language_name,
server_version: None,
server_readable_version: None,
pending_work: Default::default(),
@@ -11735,6 +11782,7 @@ impl LspStore {
language_server: Arc<LanguageServer>,
server_id: LanguageServerId,
key: LanguageServerSeed,
+ language_name: LanguageName,
workspace_folders: Arc<Mutex<BTreeSet<Uri>>>,
cx: &mut Context<Self>,
) {
@@ -11809,6 +11857,7 @@ impl LspStore {
server_id,
LanguageServerStatus {
name: language_server.name(),
+ language_name: Some(language_name.clone()),
server_version: language_server.version(),
server_readable_version: language_server.readable_version(),
pending_work: Default::default(),
@@ -11837,6 +11886,7 @@ impl LspStore {
id: server_id.to_proto(),
name: language_server.name().to_string(),
worktree_id: Some(key.worktree_id.to_proto()),
+ language_name: Some(language_name.to_proto()),
}),
capabilities: serde_json::to_string(&server_capabilities)
.expect("serializing server LSP capabilities"),
diff --git a/crates/proto/proto/lsp.proto b/crates/proto/proto/lsp.proto
index f7aa01c02b1..2c91b41f634 100644
--- a/crates/proto/proto/lsp.proto
+++ b/crates/proto/proto/lsp.proto
@@ -573,6 +573,7 @@ message LanguageServer {
uint64 id = 1;
string name = 2;
optional uint64 worktree_id = 3;
+ optional string language_name = 4;
}
message StartLanguageServer {