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.sqlindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.rsindex 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.protoindex 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 {