Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Allow to restart stopped servers (#65387)
Kirill Bulatov2dcc4cc04d74
diff --git a/crates/collab/tests/integration/remote_editing_collaboration_tests.rs b/crates/collab/tests/integration/remote_editing_collaboration_tests.rsindex d34501e19f8..78c70af1df7 100644--- a/crates/collab/tests/integration/remote_editing_collaboration_tests.rs+++ b/crates/collab/tests/integration/remote_editing_collaboration_tests.rs@@ -14,7 +14,9 @@ use gpui::{use http_client::BlockedHttpClient;use language::{FakeLspAdapter, Language, LanguageConfig, LanguageMatcher, LanguageRegistry,- language_settings::{ConfiguredLanguageServer, Formatter, FormatterList, LanguageSettings},+ language_settings::{+ ConfiguredLanguageServer, Formatter, FormatterList, LanguageSettings, all_language_settings,+ },rust_lang, tree_sitter_typescript,};use node_runtime::NodeRuntime;@@ -33,7 +35,7 @@ use rpc::proto;use serde_json::json;use settings::{InlayHintSettingsContent, LanguageServerFormatterSpecifier, PrettierSettingsContent,- SettingsStore,+ SemanticTokens, SettingsStore,};use std::{path::{Path, PathBuf},@@ -939,7 +941,7 @@ async fn test_ssh_restarting_language_server_replaces_remote_status(});project_a.update(cx_a, |project, cx| {- project.restart_language_servers_for_buffers(vec![buffer], HashSet::default(), true, cx);+ project.restart_language_servers_for_buffers(vec![buffer.clone()], HashSet::default(), cx);});let restarted_server = fake_language_servers.next().await.unwrap();@@ -979,6 +981,53 @@ async fn test_ssh_restarting_language_server_replaces_remote_status("restarting a remote language server should replace the old log store entry");});++ let lsp_store = project_a.read_with(cx_a, |project, _| project.lsp_store());+ lsp_store.update(cx_a, |lsp_store, cx| {+ lsp_store.stop_all_language_servers(cx);+ });+ executor.run_until_parked();+ lsp_store.read_with(cx_a, |lsp_store, _| {+ assert_eq!(lsp_store.language_server_statuses().count(), 0);+ });++ cx_a.update_global::<SettingsStore, _>(|store, cx| {+ store.update_user_settings(cx, |settings| {+ settings.project.all_languages.defaults.semantic_tokens = Some(SemanticTokens::Full);+ });+ });+ executor.run_until_parked();+ server_cx.read(|cx| {+ assert_eq!(+ all_language_settings(None, cx).defaults.semantic_tokens,+ SemanticTokens::Full+ );+ });+ lsp_store.read_with(cx_a, |lsp_store, _| {+ assert_eq!(lsp_store.language_server_statuses().count(), 0);+ });++ project_a.update(cx_a, |project, cx| {+ project.restart_language_servers_for_buffers(vec![buffer.clone()], HashSet::default(), cx);+ });+ executor.run_until_parked();+ lsp_store.read_with(cx_a, |lsp_store, _| {+ assert_eq!(lsp_store.language_server_statuses().count(), 1);+ });+ let mut resumed_server = fake_language_servers.next().await.unwrap();+ assert_ne!(resumed_server.server.server_id(), restarted_server_id);+ assert_eq!(+ resumed_server+ .receive_notification::<lsp::notification::DidOpenTextDocument>()+ .await+ .text_document,+ lsp::TextDocumentItem {+ uri: lsp::Uri::from_file_path(path!("/project/a.rs")).unwrap(),+ language_id: "rust".to_owned(),+ version: 0,+ text: "fn main() {}".to_owned(),+ }+ );}#[gpui::test]diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rsindex dc7cdad5f87..4fddce235a0 100644--- a/crates/editor/src/editor.rs+++ b/crates/editor/src/editor.rs@@ -8693,7 +8693,6 @@ impl Editor {project.restart_language_servers_for_buffers(multi_buffer.all_buffers().into_iter().collect(),HashSet::default(),- true,cx,);});diff --git a/crates/editor/src/editor_tests.rs b/crates/editor/src/editor_tests.rsindex 94fe9821d0b..93a8a33f6e8 100644--- a/crates/editor/src/editor_tests.rs+++ b/crates/editor/src/editor_tests.rs@@ -39254,6 +39254,79 @@ async fn test_dynamic_document_highlight_registration_refreshes_editor(cx: &mut);}+#[gpui::test]+async fn test_restart_language_server_action_after_stop(cx: &mut TestAppContext) {+ init_test(cx, |_| {});+ let mut cx = EditorLspTestContext::new_rust(lsp::ServerCapabilities::default(), cx).await;+ cx.set_state("fn main() {}ˇ");+ let project = cx.update_editor(|editor, _, _| editor.project.clone().unwrap());+ let lsp_store = cx.read(|cx| project.read(cx).lsp_store());+ let server_name = cx.lsp.server.name();+ let mut server_id = cx.lsp.server.server_id();+ let (shutdown_sender, mut shutdown_receiver) = mpsc::unbounded();+ let mut fake_servers = cx.read(|cx| {+ project.read(cx).languages().register_fake_lsp_server(+ server_name,+ lsp::ServerCapabilities::default(),+ Some(Box::new(move |fake_server| {+ let shutdown_sender = shutdown_sender.clone();+ fake_server.set_request_handler::<lsp::request::Shutdown, _, _>(move |_, _| {+ let (reply_sender, reply_receiver) = oneshot::channel::<()>();+ shutdown_sender.unbounded_send(reply_sender).unwrap();+ async move {+ reply_receiver.await?;+ Ok(())+ }+ });+ })),+ )+ });++ for stop_all in [false, true] {+ if stop_all {+ cx.update(|_, cx| {+ lsp_store.update(cx, |lsp_store, cx| lsp_store.stop_all_language_servers(cx));+ });+ shutdown_receiver.next().await.unwrap().send(()).unwrap();+ } else {+ cx.dispatch_action(StopLanguageServer);+ }+ cx.run_until_parked();+ cx.read(|cx| assert_eq!(lsp_store.read(cx).language_server_statuses().count(), 0));++ cx.dispatch_action(RestartLanguageServer);+ cx.run_until_parked();+ cx.read(|cx| assert_eq!(lsp_store.read(cx).language_server_statuses().count(), 1));+ let mut restarted_server = fake_servers.next().await.unwrap();+ assert_ne!(restarted_server.server.server_id(), server_id);+ server_id = restarted_server.server.server_id();+ let document = restarted_server+ .receive_notification::<lsp::notification::DidOpenTextDocument>()+ .await+ .text_document;+ assert_eq!(document.uri, cx.buffer_lsp_url);+ assert_eq!(document.text, "fn main() {}");+ }++ let mut events = cx.events(&project);+ cx.dispatch_action(RestartLanguageServer);+ let reply_sender = shutdown_receiver.next().await.unwrap();+ cx.update(|_, cx| {+ lsp_store.update(cx, |lsp_store, cx| lsp_store.stop_all_language_servers(cx));+ });+ reply_sender.send(()).unwrap();+ cx.run_until_parked();+ cx.read(|cx| assert_eq!(lsp_store.read(cx).language_server_statuses().count(), 0));+ assert!(fake_servers.next().now_or_never().is_none());+ let removed_servers = std::iter::from_fn(|| events.next().now_or_never().flatten())+ .filter_map(|event| match event {+ project::Event::LanguageServerRemoved(id) => Some(id),+ _ => None,+ })+ .collect::<Vec<_>>();+ assert_eq!(removed_servers, vec![server_id]);+}+#[gpui::test]async fn test_rename_with_duplicate_edits(cx: &mut TestAppContext) {init_test(cx, |_| {});diff --git a/crates/extension_host/src/extension_store_test.rs b/crates/extension_host/src/extension_store_test.rsindex 4a5e4c067a4..4cffd2dd1d7 100644--- a/crates/extension_host/src/extension_store_test.rs+++ b/crates/extension_host/src/extension_store_test.rs@@ -1202,12 +1202,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {// Start a new instance of the language server.project.update(cx, |project, cx| {- project.restart_language_servers_for_buffers(- vec![buffer.clone()],- HashSet::default(),- true,- cx,- )+ project.restart_language_servers_for_buffers(vec![buffer.clone()], HashSet::default(), cx)});cx.executor().run_until_parked();@@ -1248,12 +1243,7 @@ async fn test_extension_store_with_test_extension(cx: &mut TestAppContext) {.await;cx.executor().run_until_parked();project.update(cx, |project, cx| {- project.restart_language_servers_for_buffers(- vec![buffer.clone()],- HashSet::default(),- true,- cx,- )+ project.restart_language_servers_for_buffers(vec![buffer.clone()], HashSet::default(), cx)});// The extension re-fetches the latest version of the language server.diff --git a/crates/language_tools/src/lsp_button.rs b/crates/language_tools/src/lsp_button.rsindex a8915b9a642..08f3c831743 100644--- a/crates/language_tools/src/lsp_button.rs+++ b/crates/language_tools/src/lsp_button.rs@@ -572,7 +572,6 @@ impl LanguageServerState {HashSet::from_iter([LanguageServerSelector::Name(server_name_for_restart.clone(),)]),- true,cx,);})diff --git a/crates/project/src/lsp_store.rs b/crates/project/src/lsp_store.rsindex 8060738d850..5085e907aa0 100644--- a/crates/project/src/lsp_store.rs+++ b/crates/project/src/lsp_store.rs@@ -357,8 +357,9 @@ pub struct LocalLspStore {HashMap<Option<SharedString>, HashMap<PathBuf, Option<SharedString>>>,>,restricted_worktrees_tasks: HashMap<WorktreeId, (Subscription, watch::Receiver<bool>)>,- all_language_servers_stopped: bool,- stopped_language_servers: HashSet<LanguageServerName>,+ auto_start_language_servers: bool,+ language_server_start_overrides: HashMap<LanguageServerName, bool>,+ language_server_restart_tasks: Vec<Task<()>>,buffers_to_refresh_hash_set: HashSet<BufferId>,buffers_to_refresh_queue: VecDeque<BufferId>,@@ -380,6 +381,12 @@ fn workspace_folder_uri(worktree: &Worktree, path: &RelPath) -> Option<Uri> {}}+#[derive(Clone, Copy, PartialEq, Eq)]+enum LanguageServerStartMode {+ Automatic,+ Explicit,+}+impl LocalLspStore {/// Returns the running language server for the given ID. Note if the language server is starting, it will not be returned.pub fn running_language_server_for_id(@@ -394,14 +401,22 @@ impl LocalLspStore {}}+ fn can_start_language_server(&self, name: &LanguageServerName) -> bool {+ self.language_server_start_overrides+ .get(name)+ .copied()+ .unwrap_or(self.auto_start_language_servers)+ }+fn get_or_insert_language_server(&mut self,worktree_handle: &Entity<Worktree>,delegate: Arc<LocalLspAdapterDelegate>,disposition: &Arc<LaunchDisposition>,language_name: &LanguageName,+ start_mode: LanguageServerStartMode,cx: &mut App,- ) -> LanguageServerId {+ ) -> Option<LanguageServerId> {let key = LanguageServerSeed {worktree_id: worktree_handle.read(cx).id(),name: disposition.server_name.clone(),@@ -411,10 +426,19 @@ impl LocalLspStore {},toolchain: disposition.toolchain.clone(),};+ if start_mode == LanguageServerStartMode::Explicit {+ self.language_server_start_overrides+ .insert(key.name.clone(), true);+ }if let Some(state) = self.language_server_ids.get_mut(&key) {state.project_roots.insert(disposition.path.path.clone());- state.id+ Some(state.id)} else {+ if start_mode == LanguageServerStartMode::Automatic+ && !self.can_start_language_server(&key.name)+ {+ return None;+ }let adapter = self.languages.lsp_adapters(language_name)@@ -438,7 +462,7 @@ impl LocalLspStore {"Expected `start_language_server` to ensure that `key` exists in a map");}- new_language_server_id+ Some(new_language_server_id)}}@@ -3139,11 +3163,9 @@ impl LocalLspStore {&mut self,buffer_handle: &Entity<Buffer>,only_register_servers: HashSet<LanguageServerSelector>,+ start_mode: LanguageServerStartMode,cx: &mut Context<LspStore>,) {- if self.all_language_servers_stopped {- return;- }let buffer = buffer_handle.read(cx);let buffer_id = buffer.remote_id();@@ -3188,9 +3210,9 @@ impl LocalLspStore {return;};let language_name = language.name();- let (reused, delegate, servers) = self+ let (delegate, servers) = self.reuse_existing_language_server(&self.lsp_tree, &worktree, &language_name, cx)- .map(|(delegate, apply)| (true, delegate, apply(&mut self.lsp_tree)))+ .map(|(delegate, apply)| (delegate, apply(&mut self.lsp_tree))).unwrap_or_else(|| {let lsp_delegate = LocalLspAdapterDelegate::from_local_lsp(self, &worktree, cx);let delegate: Arc<dyn ManifestDelegate> =@@ -3206,19 +3228,11 @@ impl LocalLspStore {cx,).collect::<Vec<_>>();- (false, lsp_delegate, servers)+ (lsp_delegate, servers)});let servers_and_adapters = servers.into_iter().filter_map(|server_node| {- if reused && server_node.server_id().is_none() {- return None;- }- if let Some(name) = server_node.name()- && self.stopped_language_servers.contains(&name)- {- return None;- }if !only_register_servers.is_empty() {if let Some(server_id) = server_node.server_id()&& !only_register_servers.contains(&LanguageServerSelector::Id(server_id))@@ -3243,15 +3257,16 @@ impl LocalLspStore {delegate.clone(),disposition,&language_name,+ start_mode,cx,- );+ )?;if let Some(state) = self.language_servers.get(&server_id)&& let Some(workspace_folder) = workspace_folder{state.add_workspace_folder(workspace_folder);};- server_id+ Some(server_id)}})?;let server_state = self.language_servers.get(&server_id)?;@@ -3351,7 +3366,12 @@ impl LocalLspStore {.map(move |(_, (server_node, server_languages))| {(worktree_id, server_node, server_languages)})- .filter(|(_, _, server_languages)| server_languages.contains(language_name))+ .filter(|(_, node, server_languages)| {+ server_languages.contains(language_name)+ && node+ .id()+ .is_some_and(|id| self.language_servers.contains_key(&id))+ }).map(|(worktree_id, server_node, _)| {(*worktree_id,@@ -4961,8 +4981,9 @@ impl LspStore {buffer_pull_diagnostics_result_ids: HashMap::default(),workspace_pull_diagnostics_result_ids: HashMap::default(),restricted_worktrees_tasks: HashMap::default(),- all_language_servers_stopped: false,- stopped_language_servers: HashSet::default(),+ auto_start_language_servers: true,+ language_server_start_overrides: HashMap::default(),+ language_server_restart_tasks: Vec::new(),watched_manifest_filenames: ManifestProvidersStore::global(cx).manifest_file_names(),}),@@ -5081,7 +5102,12 @@ impl LspStore {if let Some(local) = self.as_local_mut() {local.initialize_buffer(buffer, cx);if local.registered_buffers.contains_key(&buffer_id) {- local.register_buffer_with_language_servers(buffer, HashSet::default(), cx);+ local.register_buffer_with_language_servers(+ buffer,+ HashSet::default(),+ LanguageServerStartMode::Automatic,+ cx,+ );}}}@@ -5312,16 +5338,13 @@ impl LspStore {&mut self,buffer: &Entity<Buffer>,only_register_servers: HashSet<LanguageServerSelector>,- ignore_refcounts: bool,cx: &mut Context<Self>,) -> OpenLspBufferHandle {let buffer_id = buffer.read(cx).remote_id();let handle = OpenLspBufferHandle(cx.new(|_| OpenLspBuffer(buffer.clone())));if let Some(local) = self.as_local_mut() {let refcount = local.registered_buffers.entry(buffer_id).or_insert(0);- if !ignore_refcounts {- *refcount += 1;- }+ *refcount += 1;// We run early exits on non-existing buffers AFTER we mark the buffer as registered in order to handle buffer saving.// When a new unnamed buffer is created and saved, we will start loading it's language. Once the language is loaded, we go over all "language-less" buffers and try to fit that new language@@ -5334,69 +5357,70 @@ impl LspStore {return handle;}- if ignore_refcounts || *refcount == 1 {- local.register_buffer_with_language_servers(buffer, only_register_servers, cx);+ if *refcount == 1 {+ local.register_buffer_with_language_servers(+ buffer,+ only_register_servers,+ LanguageServerStartMode::Automatic,+ cx,+ );}- if !ignore_refcounts {- cx.observe_release(&handle.0, move |lsp_store, buffer, cx| {- let refcount = {- let local = lsp_store.as_local_mut().unwrap();- let Some(refcount) = local.registered_buffers.get_mut(&buffer_id) else {- debug_panic!("bad refcounting");- return;- };-- *refcount -= 1;- *refcount+ cx.observe_release(&handle.0, move |lsp_store, buffer, cx| {+ let refcount = {+ let local = lsp_store.as_local_mut().unwrap();+ let Some(refcount) = local.registered_buffers.get_mut(&buffer_id) else {+ debug_panic!("bad refcounting");+ return;};- if refcount == 0 {- lsp_store.lsp_data.remove(&buffer_id);- lsp_store.buffer_reload_tasks.remove(&buffer_id);- let local = lsp_store.as_local_mut().unwrap();- local.registered_buffers.remove(&buffer_id);-- local.buffers_opened_in_servers.remove(&buffer_id);- if let Some(file) = File::from_dyn(buffer.0.read(cx).file()).cloned() {- local.unregister_old_buffer_from_language_servers(&buffer.0, &file, cx);-- let buffer_abs_path = file.abs_path(cx);- for (_, buffer_pull_diagnostics_result_ids) in- &mut local.buffer_pull_diagnostics_result_ids- {- buffer_pull_diagnostics_result_ids.retain(- |_, buffer_result_ids| {- buffer_result_ids.remove(&buffer_abs_path);- !buffer_result_ids.is_empty()- },- );- }- // Closing the buffer does not change which servers are relevant- // to its path, so pushed diagnostics stay: a running server may- // still describe the file. Pulled document diagnostics need an- // open document to be refreshed, so they are dropped, except for- // servers whose workspace pull still owns the path's verdict.- let servers_to_clear = local- .language_servers- .keys()- .copied()- .filter(|server_id| {- !local.server_pulls_workspace_diagnostics(*server_id)- })- .collect::<Vec<_>>();- lsp_store.clear_path_diagnostics_for_servers(- buffer_abs_path,- servers_to_clear,- |_, diagnostic, _| {- diagnostic.source_kind != DiagnosticSourceKind::Pulled- },- cx,- );+ *refcount -= 1;+ *refcount+ };+ if refcount == 0 {+ lsp_store.lsp_data.remove(&buffer_id);+ lsp_store.buffer_reload_tasks.remove(&buffer_id);+ let local = lsp_store.as_local_mut().unwrap();+ local.registered_buffers.remove(&buffer_id);++ local.buffers_opened_in_servers.remove(&buffer_id);+ if let Some(file) = File::from_dyn(buffer.0.read(cx).file()).cloned() {+ local.unregister_old_buffer_from_language_servers(&buffer.0, &file, cx);++ let buffer_abs_path = file.abs_path(cx);+ for (_, buffer_pull_diagnostics_result_ids) in+ &mut local.buffer_pull_diagnostics_result_ids+ {+ buffer_pull_diagnostics_result_ids.retain(|_, buffer_result_ids| {+ buffer_result_ids.remove(&buffer_abs_path);+ !buffer_result_ids.is_empty()+ });}++ // Closing the buffer does not change which servers are relevant+ // to its path, so pushed diagnostics stay: a running server may+ // still describe the file. Pulled document diagnostics need an+ // open document to be refreshed, so they are dropped, except for+ // servers whose workspace pull still owns the path's verdict.+ let servers_to_clear = local+ .language_servers+ .keys()+ .copied()+ .filter(|server_id| {+ !local.server_pulls_workspace_diagnostics(*server_id)+ })+ .collect::<Vec<_>>();+ lsp_store.clear_path_diagnostics_for_servers(+ buffer_abs_path,+ servers_to_clear,+ |_, diagnostic, _| {+ diagnostic.source_kind != DiagnosticSourceKind::Pulled+ },+ cx,+ );}- })- .detach();- }+ }+ })+ .detach();} else if let Some((upstream_client, upstream_project_id)) = self.upstream_client() {let buffer_id = buffer.read(cx).remote_id().to_proto();cx.background_spawn(async move {@@ -5518,6 +5542,7 @@ impl LspStore {local.register_buffer_with_language_servers(&buffer,HashSet::default(),+ LanguageServerStartMode::Automatic,cx,);}@@ -5536,6 +5561,7 @@ impl LspStore {local.register_buffer_with_language_servers(&buffer,HashSet::default(),+ LanguageServerStartMode::Automatic,cx,);}@@ -5685,7 +5711,12 @@ impl LspStore {if let Some(local) = self.as_local_mut()&& local.registered_buffers.contains_key(&buffer_id){- local.register_buffer_with_language_servers(buffer_entity, HashSet::default(), cx);+ local.register_buffer_with_language_servers(+ buffer_entity,+ HashSet::default(),+ LanguageServerStartMode::Automatic,+ cx,+ );}Some(worktree.read(cx).id())} else {@@ -6354,16 +6385,13 @@ impl LspStore {.semantic_token_config.update_global_mode(new_global_semantic_tokens_mode){- let all_stopped = self- .as_local()- .is_some_and(|local| local.all_language_servers_stopped);- if !all_stopped {- // Restart servers without clearing per-server stopped status.- // Individually-stopped servers will be skipped by the guard in- // register_buffer_with_language_servers.- let buffers = self.buffer_store.read(cx).buffers().collect();- self.restart_language_servers_for_buffers(buffers, HashSet::default(), false, cx);- }+ let buffers = self.buffer_store.read(cx).buffers().collect();+ self.restart_local_language_servers_for_buffers(+ buffers,+ HashSet::default(),+ LanguageServerStartMode::Automatic,+ cx,+ );}cx.notify();@@ -6374,10 +6402,6 @@ impl LspStore {let Some(local) = self.as_local_mut() else {return;};- if local.all_language_servers_stopped {- return;- }- let stopped_language_servers = local.stopped_language_servers.clone();let mut adapters = BTreeMap::default();let get_adapter = {let languages = local.languages.clone();@@ -6460,11 +6484,6 @@ impl LspStore {).collect::<Vec<_>>();for node in nodes {- if let Some(name) = node.name()- && stopped_language_servers.contains(&name)- {- continue;- }let server_id = node.server_id_or_init(|disposition| {let path = &disposition.path;let workspace_folder =@@ -6485,21 +6504,24 @@ impl LspStore {language.name(),),};- local.language_server_ids.remove(&key);+ if local.can_start_language_server(&key.name) {+ local.language_server_ids.remove(&key);+ }let server_id = local.get_or_insert_language_server(&worktree,lsp_delegate.clone(),disposition,&language.name(),+ LanguageServerStartMode::Automatic,cx,- );+ )?;if let Some(state) = local.language_servers.get(&server_id)&& let Some(workspace_folder) = workspace_folder{state.add_workspace_folder(workspace_folder);};- server_id+ Some(server_id)});if let Some(language_server_id) = server_id {@@ -11250,7 +11272,6 @@ impl LspStore {})}).collect(),- false,cx,);// Pull diagnostics for the buffer even if it was already registered.@@ -12438,7 +12459,6 @@ impl LspStore {})}).collect(),- true,cx,);});@@ -12991,7 +13011,8 @@ impl LspStore {pub fn stop_all_language_servers(&mut self, cx: &mut Context<Self>) {if let Some(local) = self.as_local_mut() {- local.all_language_servers_stopped = true;+ local.auto_start_language_servers = false;+ local.language_server_start_overrides.clear();}self.shutdown_all_language_servers(cx).detach();}@@ -13011,6 +13032,7 @@ impl LspStore {let Some(local) = self.as_local_mut() else {return Task::ready(());};+ local.language_server_restart_tasks.clear();let language_servers_to_stop = local.language_server_ids.values()@@ -13029,19 +13051,17 @@ impl LspStore {pub fn restart_all_language_servers(&mut self, cx: &mut Context<Self>) {if let Some(local) = self.as_local_mut() {- local.all_language_servers_stopped = false;+ local.auto_start_language_servers = true;+ local.language_server_start_overrides.clear();}- // `restart_language_servers_for_buffers` with empty selectors and `clear_stopped`- // clears `stopped_language_servers` for us.let buffers = self.buffer_store.read(cx).buffers().collect();- self.restart_language_servers_for_buffers(buffers, HashSet::default(), true, cx);+ self.restart_language_servers_for_buffers(buffers, HashSet::default(), cx);}pub fn restart_language_servers_for_buffers(&mut self,buffers: Vec<Entity<Buffer>>,only_restart_servers: HashSet<LanguageServerSelector>,- clear_stopped: bool,cx: &mut Context<Self>,) {if let Some((client, project_id)) = self.upstream_client() {@@ -13075,44 +13095,12 @@ impl LspStore {});cx.background_spawn(request).detach_and_log_err(cx);} else {- let (stopped_names, stop_task) = if only_restart_servers.is_empty() {- self.stop_local_language_servers_for_buffers(&buffers, HashSet::default(), cx)- } else {- self.stop_local_language_servers_for_buffers(&[], only_restart_servers.clone(), cx)- };- cx.spawn(async move |lsp_store, cx| {- stop_task.await;- lsp_store.update(cx, |lsp_store, cx| {- if clear_stopped {- if let Some(local) = lsp_store.as_local_mut() {- if only_restart_servers.is_empty() {- // A full restart of these buffers un-suppresses every- // manually-stopped server, even ones that are no longer- // running (and so weren't returned in `stopped_names`).- local.stopped_language_servers.clear();- } else {- for name in &stopped_names {- local.stopped_language_servers.remove(name);- }- for selector in &only_restart_servers {- if let LanguageServerSelector::Name(name) = selector {- local.stopped_language_servers.remove(name);- }- }- }- }- }- for buffer in buffers {- lsp_store.register_buffer_with_language_servers(- &buffer,- only_restart_servers.clone(),- true,- cx,- );- }- })- })- .detach();+ self.restart_local_language_servers_for_buffers(+ buffers,+ only_restart_servers,+ LanguageServerStartMode::Explicit,+ cx,+ );}}@@ -13159,7 +13147,9 @@ impl LspStore {let (stopped_names, task) =self.stop_local_language_servers_for_buffers(&buffers, also_stop_servers, cx);if let Some(local) = self.as_local_mut() {- local.stopped_language_servers.extend(stopped_names);+ local+ .language_server_start_overrides+ .extend(stopped_names.into_iter().map(|name| (name, false)));}cx.background_spawn(async move {task.await;@@ -13168,6 +13158,54 @@ impl LspStore {}}+ fn restart_local_language_servers_for_buffers(+ &mut self,+ buffers: Vec<Entity<Buffer>>,+ only_restart_servers: HashSet<LanguageServerSelector>,+ start_mode: LanguageServerStartMode,+ cx: &mut Context<Self>,+ ) {+ let Some(local) = self.as_local_mut() else {+ return;+ };+ local+ .language_server_restart_tasks+ .retain(|task| !task.is_ready());+ let (_, stop_task) = if only_restart_servers.is_empty() {+ self.stop_local_language_servers_for_buffers(&buffers, HashSet::default(), cx)+ } else {+ self.stop_local_language_servers_for_buffers(&[], only_restart_servers.clone(), cx)+ };+ let stop_task = stop_task.shared();+ cx.background_spawn(stop_task.clone()).detach();+ let task = cx.spawn(async move |lsp_store, cx| {+ stop_task.await;+ lsp_store+ .update(cx, |lsp_store, cx| {+ let Some(local) = lsp_store.as_local_mut() else {+ return;+ };+ for buffer in buffers {+ if local+ .registered_buffers+ .contains_key(&buffer.read(cx).remote_id())+ {+ local.register_buffer_with_language_servers(+ &buffer,+ only_restart_servers.clone(),+ start_mode,+ cx,+ );+ }+ }+ })+ .ok();+ });+ if let Some(local) = self.as_local_mut() {+ local.language_server_restart_tasks.push(task);+ }+ }+fn stop_local_language_servers_for_buffers(&mut self,buffers: &[Entity<Buffer>],diff --git a/crates/project/src/manifest_tree/server_tree.rs b/crates/project/src/manifest_tree/server_tree.rsindex f38ff84cf67..485304ee164 100644--- a/crates/project/src/manifest_tree/server_tree.rs+++ b/crates/project/src/manifest_tree/server_tree.rs@@ -7,7 +7,7 @@//! to reuse existing language server.use std::{- collections::{BTreeMap, BTreeSet},+ collections::{BTreeMap, BTreeSet, btree_map::Entry},sync::{Arc, Weak},};@@ -71,10 +71,14 @@ impl LanguageServerTreeNode {/// May return None if the node no longer belongs to the server tree it was created in.pub(crate) fn server_id_or_init(&self,- init: impl FnOnce(&Arc<LaunchDisposition>) -> LanguageServerId,+ init: impl FnOnce(&Arc<LaunchDisposition>) -> Option<LanguageServerId>,) -> Option<LanguageServerId> {- let this = self.0.upgrade()?;- Some(*this.id.get_or_init(|| init(&this.disposition)))+ let node = self.0.upgrade()?;+ if let Some(server_id) = node.id.get() {+ return Some(*server_id);+ }+ let server_id = init(&node.disposition)?;+ Some(*node.id.get_or_init(|| server_id))}/// Returns a language server name as the language server adapter would return.@@ -179,23 +183,29 @@ impl LanguageServerTree {.entry(root_path.path.clone()).or_default().entry(adapter.name());- let (node, languages) = inner_node.or_insert_with(|| {+ let new_node = || {let toolchain = self.toolchains.read(cx).active_toolchain(root_path.worktree_id,&root_path.path,language_name.clone(),);- (- Arc::new(InnerTreeNode::new(- adapter.name(),- root_path.clone(),- settings.clone(),- toolchain,- )),- Default::default(),- )- });+ Arc::new(InnerTreeNode::new(+ adapter.name(),+ root_path.clone(),+ settings,+ toolchain,+ ))+ };+ let (node, languages) = match inner_node {+ Entry::Occupied(mut entry) => {+ if entry.get().0.id.get().is_none() {+ entry.get_mut().0 = new_node();+ }+ entry.into_mut()+ }+ Entry::Vacant(entry) => entry.insert((new_node(), BTreeSet::new())),+ };languages.insert(language_name.clone());Arc::downgrade(node).into()})@@ -342,6 +352,11 @@ impl LanguageServerTree {.entry(RelPath::empty_arc()).or_default().entry(node.disposition.server_name.clone())+ .and_modify(|(existing, _)| {+ if existing.id().is_none() {+ *existing = node.clone();+ }+ }).or_insert_with(|| (node, BTreeSet::new())).1.insert(language_name);@@ -353,9 +368,6 @@ pub(crate) struct ServerTreeRebase {new_tree: LanguageServerTree,/// All server IDs seen in the old tree.all_server_ids: BTreeMap<LanguageServerId, LanguageServerName>,- /// Server IDs we've preserved for a new iteration of the tree. `all_server_ids - rebased_server_ids` is the- /// set of server IDs that can be shut down.- rebased_server_ids: BTreeSet<LanguageServerId>,}impl ServerTreeRebase {@@ -385,7 +397,6 @@ impl ServerTreeRebase {old_contents,all_server_ids,new_tree,- rebased_server_ids: BTreeSet::new(),}}@@ -434,7 +445,6 @@ impl ServerTreeRebase {return Some(node);};if let Some(existing_id) = existing_node.id.get() {- self.rebased_server_ids.insert(*existing_id);live_node.id.set(*existing_id).ok();}@@ -449,11 +459,19 @@ impl ServerTreeRebase {LanguageServerTree,BTreeMap<LanguageServerId, LanguageServerName>,) {+ let preserved_server_ids = self+ .new_tree+ .instances+ .values()+ .flat_map(|servers| servers.roots.values())+ .flat_map(|nodes| nodes.values())+ .filter_map(|(node, _)| node.id())+ .collect::<BTreeSet<_>>();(self.new_tree,self.all_server_ids.into_iter()- .filter(|(id, _)| !self.rebased_server_ids.contains(id))+ .filter(|(id, _)| !preserved_server_ids.contains(id)).collect(),)}diff --git a/crates/project/src/project.rs b/crates/project/src/project.rsindex fcbe245710a..c3a979e269d 100644--- a/crates/project/src/project.rs+++ b/crates/project/src/project.rs@@ -3329,7 +3329,7 @@ impl Project {cx: &mut App,) -> OpenLspBufferHandle {self.lsp_store.update(cx, |lsp_store, cx| {- lsp_store.register_buffer_with_language_servers(buffer, HashSet::default(), false, cx)+ lsp_store.register_buffer_with_language_servers(buffer, HashSet::default(), cx)})}@@ -4200,16 +4200,10 @@ impl Project {&mut self,buffers: Vec<Entity<Buffer>>,only_restart_servers: HashSet<LanguageServerSelector>,- clear_stopped: bool,cx: &mut Context<Self>,) {self.lsp_store.update(cx, |lsp_store, cx| {- lsp_store.restart_language_servers_for_buffers(- buffers,- only_restart_servers,- clear_stopped,- cx,- )+ lsp_store.restart_language_servers_for_buffers(buffers, only_restart_servers, cx)})}diff --git a/crates/project/tests/integration/lsp_store.rs b/crates/project/tests/integration/lsp_store.rsindex b15463027b3..3bfeb1aa2f3 100644--- a/crates/project/tests/integration/lsp_store.rs+++ b/crates/project/tests/integration/lsp_store.rs@@ -5,7 +5,7 @@ use std::{time::{Duration, Instant},};-use collections::HashMap;+use collections::{HashMap, HashSet};use fs::{FakeFs, Fs};use futures::{FutureExt, StreamExt};use gpui::{Entity, TestAppContext, UpdateGlobal as _};@@ -168,7 +168,7 @@ async fn test_removing_invisible_worktree_cleans_reused_lsp_bookkeeping(cx: &mutlanguage_registry.add(rust_lang());let mut fake_servers = language_registry.register_fake_lsp("Rust", FakeLspAdapter::default());- let (_visible_buffer, _visible_handle) = project+ let (visible_buffer, _visible_handle) = project.update(cx, |project, cx| {project.open_local_buffer_with_lsp(path!("/the-root/main.rs"), cx)})@@ -186,13 +186,10 @@ async fn test_removing_invisible_worktree_cleans_reused_lsp_bookkeeping(cx: &mut.unwrap().0});+ let external_uri = Uri::from_file_path(path!("/the-registry/dep/src/dep.rs")).unwrap();let external_buffer = project.update(cx, |project, cx| {- project.open_local_buffer_via_lsp(- Uri::from_file_path(path!("/the-registry/dep/src/dep.rs")).unwrap(),- server_id,- cx,- )+ project.open_local_buffer_via_lsp(external_uri.clone(), server_id, cx)}).await.unwrap();@@ -226,6 +223,56 @@ async fn test_removing_invisible_worktree_cleans_reused_lsp_bookkeeping(cx: &mut);assert!(!lsp_store.has_language_server_seed_for_worktree(invisible_worktree_id));});++ let external_buffer = project+ .update(cx, |project, cx| {+ project.open_local_buffer_via_lsp(external_uri.clone(), server_id, cx)+ })+ .await+ .unwrap();+ let lsp_store = project.read_with(cx, |project, _| project.lsp_store());+ lsp_store.update(cx, |store, cx| store.stop_all_language_servers(cx));+ cx.run_until_parked();+ let _external_handle = project.update(cx, |project, cx| {+ project.register_buffer_with_language_servers(&external_buffer, cx)+ });+ project.update(cx, |project, cx| {+ project.restart_language_servers_for_buffers(vec![visible_buffer], HashSet::default(), cx);+ });+ cx.run_until_parked();+ lsp_store.read_with(cx, |store, _| {+ assert_eq!(store.language_server_statuses().count(), 1);+ });+ let mut fake_server = fake_servers.next().await.unwrap();+ assert_ne!(fake_server.server.server_id(), server_id);+ let document = fake_server+ .receive_notification::<lsp::notification::DidOpenTextDocument>()+ .now_or_never()+ .expect("visible buffer was not reopened")+ .text_document;+ assert_eq!(+ document.uri,+ Uri::from_file_path(path!("/the-root/main.rs")).unwrap()+ );+ project.update(cx, |project, cx| {+ project.restart_language_servers_for_buffers(+ vec![external_buffer.clone()],+ HashSet::default(),+ cx,+ );+ });+ cx.run_until_parked();+ let document = fake_server+ .receive_notification::<lsp::notification::DidOpenTextDocument>()+ .now_or_never()+ .expect("external buffer was not reopened")+ .text_document;+ assert_eq!(document.uri, external_uri);+ assert_eq!(document.text, "pub fn dep() {}");+ lsp_store.read_with(cx, |store, _| {+ assert_eq!(store.language_server_statuses().count(), 1);+ });+ assert!(fake_servers.next().now_or_never().is_none());}#[gpui::test]diff --git a/crates/project/tests/integration/project_tests.rs b/crates/project/tests/integration/project_tests.rsindex f4642a384b3..62e30539191 100644--- a/crates/project/tests/integration/project_tests.rs+++ b/crates/project/tests/integration/project_tests.rs@@ -1767,6 +1767,7 @@ async fn test_managing_language_servers(cx: &mut gpui::TestAppContext) {json!({"test.rs": "const A: i32 = 1;","test2.rs": "",+ "later.rs": "fn later() {}","Cargo.toml": "a = 1","package.json": "{\"a\": 1}",}),@@ -1817,6 +1818,26 @@ async fn test_managing_language_servers(cx: &mut gpui::TestAppContext) {},);+ let (initialize_sender, initialize_receiver) = async_channel::unbounded();+ let mut replacement_rust_servers = language_registry.register_fake_lsp(+ "Rust",+ FakeLspAdapter {+ name: "replacement-rust-server",+ opt_in_languages: HashSet::from_iter([LanguageName::new_static("Rust")]),+ initializer: Some(Box::new(move |server| {+ let initialize_sender = initialize_sender.clone();+ server.set_request_handler::<lsp::request::Initialize, _, _>(move |params, _| {+ initialize_sender.try_send(params).unwrap();+ future::ready(Ok(lsp::InitializeResult {+ capabilities: lsp::LanguageServer::full_capabilities(),+ server_info: None,+ }))+ });+ })),+ ..FakeLspAdapter::default()+ },+ );+// Open a buffer without an associated language server.let (toml_buffer, _handle) = project.update(cx, |project, cx| {@@ -2090,7 +2111,6 @@ async fn test_managing_language_servers(cx: &mut gpui::TestAppContext) {project.restart_language_servers_for_buffers(vec![rust_buffer.clone(), json_buffer.clone()],HashSet::default(),- true,cx,);});@@ -2159,6 +2179,128 @@ async fn test_managing_language_servers(cx: &mut gpui::TestAppContext) {.await,close_message,);++ let lsp_store = project.read_with(cx, |project, _| project.lsp_store());+ lsp_store.update(cx, |lsp_store, cx| lsp_store.stop_all_language_servers(cx));+ cx.run_until_parked();+ lsp_store.read_with(cx, |store, _| {+ assert_eq!(store.language_server_statuses().count(), 0)+ });++ cx.update_global::<SettingsStore, _>(|store, cx| {+ store+ .set_user_settings(+ r#"{"semantic_tokens":"combined","languages":{"Rust":{"language_servers":["replacement-rust-server"]}}}"#,+ cx,+ )+ .unwrap();+ });+ cx.run_until_parked();+ lsp_store.read_with(cx, |store, _| {+ assert_eq!(store.language_server_statuses().count(), 0)+ });+ project.update(cx, |project, cx| {+ project.restart_language_servers_for_buffers(+ vec![rust_buffer.clone()],+ HashSet::default(),+ cx,+ );+ });+ cx.run_until_parked();+ lsp_store.read_with(cx, |store, _| {+ assert_eq!(store.language_server_statuses().count(), 1)+ });+ let mut replacement_rust_server = replacement_rust_servers.next().await.unwrap();+ assert_eq!(+ initialize_receiver+ .try_recv()+ .unwrap()+ .initialization_options,+ None+ );++ let _json_handle = project.update(cx, |project, cx| {+ project.register_buffer_with_language_servers(&json_buffer, cx)+ });+ for (path, text) in [+ (path!("/dir/test.rs"), "const A: i32 = 12;"),+ (path!("/dir/later.rs"), "fn later() {}"),+ ] {+ let _registration = project+ .update(cx, |project, cx| {+ project.open_local_buffer_with_lsp(path, cx)+ })+ .await+ .unwrap();+ assert_eq!(+ replacement_rust_server+ .receive_notification::<lsp::notification::DidOpenTextDocument>()+ .await+ .text_document,+ lsp::TextDocumentItem {+ uri: lsp::Uri::from_file_path(path).unwrap(),+ version: 0,+ text: text.to_owned(),+ language_id: "rust".to_owned(),+ }+ );+ }+ let mut server_id = replacement_rust_server.server.server_id();+ for semantic_tokens in ["combined", "full"] {+ cx.update_global::<SettingsStore, _>(|store, cx| {+ store+ .set_user_settings(+ &json!({+ "semantic_tokens": semantic_tokens,+ "languages": { "Rust": { "language_servers": ["replacement-rust-server"] } },+ "lsp": { "replacement-rust-server": { "initialization_options": { "check": true } } }+ })+ .to_string(),+ cx,+ )+ .unwrap();+ });+ cx.run_until_parked();+ lsp_store.read_with(cx, |store, _| {+ assert_eq!(store.language_server_statuses().count(), 1);+ });+ let server = replacement_rust_servers+ .next()+ .now_or_never()+ .flatten()+ .expect("resumed server was not restarted after changing settings");+ assert_ne!(server.server.server_id(), server_id);+ server_id = server.server.server_id();+ let params = initialize_receiver.try_recv().unwrap();+ assert_eq!(+ params.initialization_options,+ Some(json!({ "check": true }))+ );+ assert_eq!(+ params+ .capabilities+ .text_document+ .unwrap()+ .semantic_tokens+ .unwrap()+ .augments_syntax_tokens,+ Some(semantic_tokens == "combined")+ );+ }+ for servers in [+ &mut fake_rust_servers,+ &mut fake_json_servers,+ &mut replacement_rust_servers,+ ] {+ assert_eq!(+ servers+ .next()+ .now_or_never()+ .flatten()+ .map(|server| server.server.name()),+ None,+ );+ }}#[gpui::test]@@ -3298,7 +3440,7 @@ async fn test_restarting_server_with_diagnostics_running(cx: &mut gpui::TestAppC// Restart the server before the diagnostics finish updating.project.update(cx, |project, cx| {- project.restart_language_servers_for_buffers(vec![buffer], HashSet::default(), true, cx);+ project.restart_language_servers_for_buffers(vec![buffer], HashSet::default(), cx);});let mut events = cx.events(&project);@@ -3416,12 +3558,7 @@ async fn test_restarting_server_with_diagnostics_published(cx: &mut gpui::TestAp});project.update(cx, |project, cx| {- project.restart_language_servers_for_buffers(- vec![buffer.clone()],- HashSet::default(),- true,- cx,- );+ project.restart_language_servers_for_buffers(vec![buffer.clone()], HashSet::default(), cx);});// The diagnostics are cleared.@@ -3476,12 +3613,7 @@ async fn test_restarted_server_reporting_invalid_buffer_version(cx: &mut gpui::T});cx.executor().run_until_parked();project.update(cx, |project, cx| {- project.restart_language_servers_for_buffers(- vec![buffer.clone()],- HashSet::default(),- true,- cx,- );+ project.restart_language_servers_for_buffers(vec![buffer.clone()], HashSet::default(), cx);});let mut fake_server = fake_servers.next().await.unwrap();@@ -4995,12 +5127,7 @@ async fn test_diagnostic_summaries_cleared_on_server_restart(cx: &mut gpui::Testlet mut events = cx.events(&project);project.update(cx, |project, cx| {- project.restart_language_servers_for_buffers(- vec![buffer.clone()],- HashSet::default(),- true,- cx,- );+ project.restart_language_servers_for_buffers(vec![buffer.clone()], HashSet::default(), cx);});cx.executor().run_until_parked();