The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
feat(java): share JDT LS across builds in a project window (#2272)
yoo hyeong chana46d873f6c42
diff --git a/crates/ide-core/src/settings.rs b/crates/ide-core/src/settings.rsindex 20913ed2b..bf27e06d9 100644--- a/crates/ide-core/src/settings.rs+++ b/crates/ide-core/src/settings.rs@@ -896,6 +896,8 @@ pub struct JavaSettings {/// Extra JVM options for the Java language server (jdtls), space-separated/// (VS Code's `java.jdt.ls.vmargs`).pub jdtls_vm_args: String,+ /// Share one JDT LS across builds in an ordinary project window; other windows remain separate.+ pub jdtls_shared: bool,/// Build Tools › Maven.pub maven: MavenSettings,/// Build Tools › Gradle.@@ -1477,6 +1479,26 @@ mod maven_linkage_tests {}}+#[cfg(test)]+mod java_settings_tests {+ use super::*;++ #[test]+ fn shared_jdtls_defaults_off_and_round_trips() {+ for old in [r#"{}"#, r#"{"jdk":"/jdk"}"#] {+ let java: JavaSettings = serde_json::from_str(old).unwrap();+ assert!(!java.jdtls_shared);+ }+ for shared in [false, true] {+ let java = JavaSettings { jdtls_shared: shared, ..JavaSettings::default() };+ let json = serde_json::to_value(&java).unwrap();+ assert_eq!(json["jdtlsShared"], serde_json::json!(shared));+ assert_eq!(serde_json::from_value::<JavaSettings>(json).unwrap(), java);+ }+ assert!(serde_json::from_str::<JavaSettings>(r#"{"jdtlsShared":"true"}"#).is_err());+ }+}+#[cfg(test)]mod gradle_settings_tests {use super::*;diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rsindex 57499866e..e849b9c81 100644--- a/crates/ide-host/src/project.rs+++ b/crates/ide-host/src/project.rs@@ -83,7 +83,7 @@ impl Host {let opening = self.opening(window);let _opening = opening.lock();// Reject a damaged manifest before replacing the currently open project.- ide_workspace::workspace::Workspace::load(&root)?;+ let is_workspace = ide_workspace::workspace::Workspace::load(&root)?.is_some();// The window reloaded (or asked again) for the project it already has: keep// it, with its warm index, language servers and unsaved documents.if let Ok(current) = self.project(window)@@ -137,6 +137,16 @@ impl Host {lsp.set_execution_allowed(trusted.load(Ordering::Acquire));lsp.set_content_roots(extra_roots.clone());let settings = Arc::new(settings);+ {+ let settings = settings.clone();+ // Workspace members have independent settings; target servers have their own path mappings.+ lsp.set_jdtls_shared_hook(Box::new(move || {+ let effective = settings.effective();+ !is_workspace+ && effective.languages.java.jdtls_shared+ && effective.language_server_targets.get("java").is_none_or(|target| target.target.is_empty())+ }));+ }{let settings = settings.clone();let root = root.clone();diff --git a/crates/ide-host/src/relay.rs b/crates/ide-host/src/relay.rsindex f8d870394..fb5bed5ee 100644--- a/crates/ide-host/src/relay.rs+++ b/crates/ide-host/src/relay.rs@@ -9,7 +9,7 @@ use std::sync::{Arc, Mutex, mpsc};use std::time::{Duration, Instant};const CONNECT_TIMEOUT: Duration = Duration::from_secs(10);-const EOF_GRACE: Duration = Duration::from_secs(5);+const EOF_GRACE: Duration = Duration::from_secs(10);/// `<host> <port>` from the arguments after `--connect`.pub fn parse_args(args: &[String]) -> Result<(String, u16), String> {@@ -25,7 +25,7 @@ pub fn parse_args(args: &[String]) -> Result<(String, u16), String> {/// Connects to `host:port`, copies `input` to it and its replies to `output`, and returns when/// the target is done (the copy of `input` may still be blocked: the caller exits). Fails only-/// when the connection can't be opened. An input EOF allows five idle seconds for a final reply.+/// when the connection can't be opened. An input EOF allows ten idle seconds for a final reply.pub fn relay(host: &str, port: u16, mut input: impl Read + Send + 'static, mut output: impl Write) -> io::Result<()> {let mut from_target = connect(host, port)?;from_target.set_read_timeout(Some(Duration::from_millis(100)))?;@@ -140,11 +140,11 @@ mod tests {let mut request = Vec::new();socket.read_to_end(&mut request).unwrap();// Remain open after seeing EOF, like an idle keep-alive server.- wait.recv_timeout(Duration::from_secs(10)).unwrap();+ wait.recv_timeout(Duration::from_secs(15)).unwrap();});let start = Instant::now();relay("127.0.0.1", port, io::empty(), io::sink()).unwrap();- assert!(start.elapsed() < Duration::from_secs(8));+ assert!(start.elapsed() < Duration::from_secs(13));done.send(()).unwrap();server.join().unwrap();}diff --git a/crates/ide-lsp/src/jdtls.rs b/crates/ide-lsp/src/jdtls.rsindex c9603e48b..37292a2e2 100644--- a/crates/ide-lsp/src/jdtls.rs+++ b/crates/ide-lsp/src/jdtls.rs@@ -627,7 +627,11 @@ impl LspManager {.docs.lock().values()- .filter(|d| d.language.as_str() == "java" && d.path.starts_with(&server.root))+ .filter(|d| {+ d.language.as_str() == "java"+ && d.path.is_absolute()+ && d.servers.iter().any(|a| a.server.id == server.id)+ }).map(|d| crate::uri::path_to_uri_string(&d.path)).collect();if uris.is_empty() {@@ -652,26 +656,50 @@ impl LspManager {/// started if needed and waited for.async fn jdtls(&self, path: &Path, cancel: &CancellationToken) -> IdeResult<(Arc<Server>, Running)> {let java = LanguageId::new("java");- let server = self- .servers_for(&java, path)- .into_iter()- .find(|s| s.name == SERVER)- .ok_or_else(|| IdeError::unavailable("no Java language server (jdtls) is configured"))?;- self.ensure_started(&server);- match cancellable_wait(cancel, server.wait_ready(READY_TIMEOUT)).await? {- Some(run) => Ok((server, run)),- None => {- let status = server.status();- Err(IdeError::unavailable(match status {- ide_core::event::ServerStatus::Missing => {- "jdtls is not installed (Settings › Languages & Frameworks › Language Servers)".to_owned()- }- ide_core::event::ServerStatus::Misconfigured | ide_core::event::ServerStatus::Crashed => {- server.status_message().unwrap_or_else(|| "jdtls cannot start".to_owned())- }- _ => format!("jdtls is not ready ({status:?})"),- }))+ let deadline = tokio::time::Instant::now() + READY_TIMEOUT;+ loop {+ if cancel.is_cancelled() {+ return Err(IdeError::cancelled());+ }+ let server = self+ .servers_for(&java, path)+ .into_iter()+ .find(|s| s.name == SERVER)+ .ok_or_else(|| IdeError::unavailable("no Java language server (jdtls) is configured"))?;+ self.ensure_started(&server);+ let remaining = deadline.saturating_duration_since(tokio::time::Instant::now());+ if let Some(run) = cancellable_wait(cancel, server.wait_ready(remaining)).await? {+ return Ok((server, run));}+ let status = server.status();+ if !matches!(+ status,+ ide_core::event::ServerStatus::Missing+ | ide_core::event::ServerStatus::Misconfigured+ | ide_core::event::ServerStatus::Crashed+ ) && tokio::time::Instant::now() < deadline+ && let Ok(_restart) =+ cancellable_wait(cancel, tokio::time::timeout_at(deadline, self.reconfigure_lock.lock())).await?+ {+ // A restart publishes Down while reaping its old JVM. Its successor may+ // also have a new identity after changing the shared workspace.+ if let Some(current) = self.servers_for(&java, path).into_iter().find(|s| s.name == SERVER)+ && current.root.is_dir()+ && (current.id != server.id || current.is_starting() || current.running().is_some())+ {+ continue;+ }+ }+ let status = server.status();+ return Err(IdeError::unavailable(match status {+ ide_core::event::ServerStatus::Missing => {+ "jdtls is not installed (Settings › Languages & Frameworks › Language Servers)".to_owned()+ }+ ide_core::event::ServerStatus::Misconfigured | ide_core::event::ServerStatus::Crashed => {+ server.status_message().unwrap_or_else(|| "jdtls cannot start".to_owned())+ }+ _ => format!("jdtls is not ready ({status:?})"),+ }));}}diff --git a/crates/ide-lsp/src/lib.rs b/crates/ide-lsp/src/lib.rsindex 6910ff74a..b5ce6898c 100644--- a/crates/ide-lsp/src/lib.rs+++ b/crates/ide-lsp/src/lib.rs@@ -175,6 +175,20 @@ impl DocSnap {/// Receives the folders outside the project that servers want watched.pub type WatchRootsFn = dyn Fn(Vec<PathBuf>) + Send + Sync;+pub type JdtlsSharedFn = dyn Fn() -> bool + Send + Sync;++#[derive(Default)]+struct JdtlsWorkspace {+ initialized: bool,+ shared: bool,+ roots: Vec<PathBuf>,+ transitioning: bool,+}++fn is_local_jdtls(config: &LanguageServerConfig) -> bool {+ config.name == "jdtls" && config.target_key.is_none() && config.target.is_none()+}+pub struct LspManager {me: Weak<LspManager>,project_root: PathBuf,@@ -195,6 +209,9 @@ pub struct LspManager {candidates_hook: RwLock<Option<Arc<CandidateFn>>>,excludes_hook: RwLock<Option<Arc<external_project::ExcludesFn>>>,watch_roots_hook: RwLock<Option<Arc<WatchRootsFn>>>,+ jdtls_shared_hook: RwLock<Option<Arc<JdtlsSharedFn>>>,+ jdtls_workspace: Mutex<JdtlsWorkspace>,+ reconfigure_lock: tokio::sync::Mutex<()>,shutting_down: AtomicBool,execution_allowed: AtomicBool,java_usages_warned: AtomicBool,@@ -402,6 +419,9 @@ impl LspManager {candidates_hook: RwLock::new(None),excludes_hook: RwLock::new(None),watch_roots_hook: RwLock::new(None),+ jdtls_shared_hook: RwLock::new(None),+ jdtls_workspace: Mutex::new(Default::default()),+ reconfigure_lock: tokio::sync::Mutex::new(()),shutting_down: AtomicBool::new(false),execution_allowed: AtomicBool::new(true),java_usages_warned: AtomicBool::new(false),@@ -416,7 +436,56 @@ impl LspManager {// ---- server lookup & lifecycle ----pub fn set_content_roots(&self, roots: Vec<PathBuf>) {- *self.content_roots.write() = roots;+ let changed = {+ let mut current = self.content_roots.write();+ let changed = *current != roots;+ *current = roots;+ changed+ };+ if changed+ && self.desired_jdtls_workspace().0+ && let Some(me) = self.me.upgrade()+ {+ me.reconfigure_soon();+ }+ }++ /// Shares JDT LS within this manager; callers reconfigure after the hook's value changes.+ pub fn set_jdtls_shared_hook(&self, hook: Box<JdtlsSharedFn>) {+ *self.jdtls_shared_hook.write() = Some(Arc::from(hook));+ }++ fn desired_jdtls_workspace(&self) -> (bool, Vec<PathBuf>) {+ let shared = self.jdtls_shared_hook.read().as_ref().is_some_and(|hook| hook());+ let mut roots = Vec::new();+ if shared {+ roots.push(self.project_root.clone());+ for root in self.content_roots.read().iter() {+ if root.is_absolute() && root.is_dir() && !roots.contains(root) {+ roots.push(root.clone());+ }+ }+ }+ (shared, roots)+ }++ fn jdtls_workspace_state(&self) -> parking_lot::MutexGuard<'_, JdtlsWorkspace> {+ let mut state = self.jdtls_workspace.lock();+ if !state.initialized {+ (state.shared, state.roots) = self.desired_jdtls_workspace();+ state.initialized = true;+ }+ state+ }++ fn server_workspace_roots(&self, server: &Server) -> Vec<PathBuf> {+ if is_local_jdtls(&server.config) {+ let state = self.jdtls_workspace_state();+ if state.shared {+ return state.roots.clone();+ }+ }+ vec![server.root.clone()]}fn project_root_for(&self, path: &Path) -> PathBuf {@@ -431,16 +500,21 @@ impl LspManager {}fn server_for(&self, cfg: &LanguageServerConfig, language: &LanguageId, path: &Path) -> Arc<Server> {+ let shared = is_local_jdtls(cfg).then(|| self.jdtls_workspace_state());let mut servers = self.servers.lock();- let root = launch::find_root(&self.project_root_for(path), path, &cfg.root_markers).unwrap_or_else(|| {- // Outside the project (library sources, …): reuse a running instance.- servers- .iter()- .filter(|s| s.name == cfg.name && s.config.target_key == cfg.target_key)- .min_by_key(|s| s.root != self.project_root)- .map(|s| s.root.clone())- .unwrap_or_else(|| self.project_root.clone())- });+ let root = if shared.as_ref().is_some_and(|state| state.shared) {+ self.project_root.clone()+ } else {+ launch::find_root(&self.project_root_for(path), path, &cfg.root_markers).unwrap_or_else(|| {+ // Outside the project (library sources, …): reuse a running instance.+ servers+ .iter()+ .filter(|s| s.name == cfg.name && s.config.target_key == cfg.target_key)+ .min_by_key(|s| s.root != self.project_root)+ .map(|s| s.root.clone())+ .unwrap_or_else(|| self.project_root.clone())+ })+ };if let Some(s) =servers.iter().find(|s| s.name == cfg.name && s.root == root && s.config.target_key == cfg.target_key){@@ -490,6 +564,7 @@ impl LspManager {/// to the open documents (and start them). Also attaches servers newly/// enabled in settings.fn attach_fallbacks(&self) {+ let _gate = self.injections.gate.lock();let open: Vec<(DocId, LanguageId, PathBuf)> = self.docs.lock()@@ -538,6 +613,27 @@ impl LspManager {if self.shutting_down.load(Ordering::Acquire) || !self.execution_allowed.load(Ordering::Acquire) {return;}+ let workspace = is_local_jdtls(&server.config).then(|| self.jdtls_workspace_state());+ if let Some(state) = &workspace {+ if state.transitioning || !self.servers.lock().iter().any(|s| s.id == server.id) {+ return;+ }+ let (shared, roots) = self.desired_jdtls_workspace();+ if state.shared != shared || (shared && state.roots != roots) {+ if let Some(me) = self.me.upgrade() {+ me.reconfigure_soon();+ }+ return;+ }+ }+ let startup = if is_local_jdtls(&server.config) {+ match server.startup_lock.clone().try_lock_owned() {+ Ok(guard) => Some(guard),+ Err(_) => return,+ }+ } else {+ None+ };// `begin_start` only claims Idle servers, so a claimed server is never a// live one. Its root is the process's working directory: starting with// one deleted from disk fails (`os error 267` on Windows). Such a@@ -553,7 +649,10 @@ impl LspManager {return;}let server = server.clone();- self.runtime.spawn(async move { me.run_instance(server, generation).await });+ self.runtime.spawn(async move {+ let _startup = startup;+ me.run_instance(server, generation).await;+ });}async fn run_instance(self: Arc<Self>, server: Arc<Server>, generation: u64) {@@ -561,6 +660,7 @@ impl LspManager {let handler = Arc::new(handler::ClientHandler::new(self.me.clone(), server.clone(), generation));let me = self.clone();let tail = server.clone();+ let launch_cancel = cancel.clone();// The settings hook may touch the filesystem (e.g. scanning for JDKs); TCP// servers may take a while to start listening.let launched = tokio::task::spawn_blocking(move || {@@ -568,17 +668,17 @@ impl LspManager {return Err(LaunchError::Config("Project is in Restricted Mode".into()));}let mut cfg = me.configured(&tail);- if !me.execution_allowed.load(Ordering::Acquire) || cancel.is_cancelled() {+ if !me.execution_allowed.load(Ordering::Acquire) || launch_cancel.is_cancelled() {return Err(LaunchError::Config("Project is in Restricted Mode".into()));}tail.set_effective_config(generation, cfg.clone());let prepare = me.prepare_hook.read().clone();if cfg.target.is_none()- && !cancel.is_cancelled()+ && !launch_cancel.is_cancelled()&& me.launcher.available(&cfg, &tail.root)&& let Some(prepare) = prepare{- prepare(&cfg, &tail.root, &cancel);+ prepare(&cfg, &tail.root, &launch_cancel);cfg = me.configured(&tail);}tail.set_effective_config(generation, cfg.clone());@@ -588,7 +688,7 @@ impl LspManager {let missing = cfg.target.is_none() && !me.launcher.available(&cfg, &root);return Err(if missing { LaunchError::Missing } else { LaunchError::Config(message.clone()) });}- if !me.execution_allowed.load(Ordering::Acquire) || cancel.is_cancelled() {+ if !me.execution_allowed.load(Ordering::Acquire) || launch_cancel.is_cancelled() {return Err(LaunchError::Config("Project is in Restricted Mode".into()));}me.launcher.launch_resolved(@@ -596,7 +696,7 @@ impl LspManager {&root,handler,Box::new(move |line| tail.push_stderr(generation, line)),- &cancel,+ &launch_cancel,)}).await@@ -605,7 +705,7 @@ impl LspManager {let peer = match launched {Ok((peer, binary)) => {if !server.set_resolved_binary(generation, binary) {- peer.kill();+ Self::kill_peer(&server, &peer).await;return;}peer@@ -662,9 +762,14 @@ impl LspManager {init["initializationOptions"]["triggerFiles"] = json!([uri::path_to_uri_string(&path)]);}}- let result = tokio::time::timeout(INITIALIZE_TIMEOUT, peer.request::<_, Value>("initialize", init, None))- .await- .unwrap_or(Err(RpcError::Timeout));+ let result = tokio::select! {+ biased;+ () = cancel.cancelled() => {+ Self::kill_peer(&server, &peer).await;+ return;+ }+ result = tokio::time::timeout(INITIALIZE_TIMEOUT, peer.request::<_, Value>("initialize", init, Some(cancel.clone()))) => result.unwrap_or(Err(RpcError::Timeout)),+ };let caps = match result {Ok(result) => {if let Some(info) = result.get("serverInfo") {@@ -681,7 +786,7 @@ impl LspManager {// The server is exiting: let it, so the crash report has its exit code and last output.let _ = tokio::time::timeout(Duration::from_secs(3), peer.closed()).await;}- peer.kill();+ Self::kill_peer(&server, &peer).await;// Treated like a crash so transient failures retry with backoff.self.spawn_supervisor(server, generation, peer);return;@@ -690,7 +795,7 @@ impl LspManager {let run =Running { generation, peer: peer.clone(), caps: Arc::new(RwLock::new(caps)), watchers: Default::default() };if !server.set_initializing(run.clone()) {- peer.kill();+ Self::kill_peer(&server, &peer).await;return;}if let Err(e) = peer.notify("initialized", json!({})) {@@ -709,24 +814,30 @@ impl LspManager {// Publish readiness and (re)open attached documents atomically w.r.t. did_change.let mut reopened = Vec::new();- {+ let ready = {let mut docs = self.docs.lock();if !server.mark_ready(generation, run.clone()) {- drop(docs);- peer.kill();- return;- }- let open_close = run.caps.read().open_close;- for (id, d) in docs.iter_mut() {- let params = d.did_open_params();- for a in d.servers.iter_mut().filter(|a| a.server.id == server.id && a.opened_gen != Some(generation)) {- if open_close && let Err(e) = peer.notify("textDocument/didOpen", params.clone()) {- tracing::debug!("{}: didOpen: {e}", server.name);+ false+ } else {+ let open_close = run.caps.read().open_close;+ for (id, d) in docs.iter_mut() {+ let params = d.did_open_params();+ for a in+ d.servers.iter_mut().filter(|a| a.server.id == server.id && a.opened_gen != Some(generation))+ {+ if open_close && let Err(e) = peer.notify("textDocument/didOpen", params.clone()) {+ tracing::debug!("{}: didOpen: {e}", server.name);+ }+ a.opened_gen = Some(generation);+ reopened.push(*id);}- a.opened_gen = Some(generation);- reopened.push(*id);}+ true}+ };+ if !ready {+ Self::kill_peer(&server, &peer).await;+ return;}for doc in reopened {self.schedule_pull(doc, Some(&server), Duration::ZERO);@@ -767,7 +878,6 @@ impl LspManager {fn initialize_params(&self, server: &Server) -> Value {let root_uri = uri::path_to_uri(&server.root);- let name = server.root.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| "root".into());let cfg = server.effective_config();let mut init_options =cfg.initialization_options.as_ref().and_then(|v| serde_json::to_value(v).ok()).unwrap_or(Value::Null);@@ -776,11 +886,24 @@ impl LspManager {init_options = json!({});}init_options["settings"] = handler::all_settings(&cfg);+ let shared = is_local_jdtls(&server.config) && self.jdtls_workspace_state().shared;+ if shared {+ init_options["workspaceFolders"] = json!(+ self.server_workspace_roots(server)+ .iter()+ .map(|root| uri::path_to_uri_string(root))+ .collect::<Vec<_>>()+ );+ }let triggers: Vec<_> = self.docs.lock().values()- .filter(|d| d.language.as_str() == "java" && d.path.starts_with(&server.root))+ .filter(|d| {+ d.language.as_str() == "java"+ && d.path.is_absolute()+ && d.servers.iter().any(|a| a.server.id == server.id)+ }).map(|d| uri::path_to_uri_string(&d.path)).collect();if !triggers.is_empty() && init_options.get("triggerFiles").is_none() {@@ -794,7 +917,7 @@ impl LspManager {"locale": "en","rootPath": server.root.to_string_lossy(),"rootUri": root_uri,- "workspaceFolders": [{ "uri": root_uri, "name": name }],+ "workspaceFolders": self.workspace_folders(server),"capabilities": caps::client_capabilities(),"trace": "off",});@@ -811,8 +934,16 @@ impl LspManager {}pub(crate) fn workspace_folders(&self, server: &Server) -> Value {- let name = server.root.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| "root".into());- json!([{ "uri": uri::path_to_uri(&server.root), "name": name }])+ json!(+ self.server_workspace_roots(server)+ .iter()+ .map(|root| {+ let name =+ root.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_else(|| "root".into());+ json!({"uri": uri::path_to_uri(root), "name": name})+ })+ .collect::<Vec<_>>()+ )}pub(crate) fn sink(&self) -> &SharedSink {@@ -862,6 +993,7 @@ impl LspManager {/// Opens a read-only virtual document (`jdt://…`) on the server that/// returned its URI (`didOpen` only: it is never changed or saved).pub fn did_open_virtual(&self, doc: DocId, uri: &str, language: &LanguageId, version: u32, text: &str) {+ let _gate = self.injections.gate.lock();if self.docs.lock().contains_key(&doc) {self.close_injections(doc);self.close_document(doc);@@ -2450,15 +2582,18 @@ impl LspManager {.into_iter().flat_map(|(paths, change)| paths.iter().map(move |p| (p, change)));let watchers = run.watchers.read();+ let roots = self.server_workspace_roots(&s);let changes: Vec<(&PathBuf, Change)> = if watchers.is_empty() {let languages = s.languages();all.filter(|(p, change)| {- p.starts_with(&s.root) && languages.contains(&self.languages.detect(p, None)) && send(p, *change)+ roots.iter().any(|root| p.starts_with(root))+ && languages.contains(&self.languages.detect(p, None))+ && send(p, *change)}).collect()} else {all.chain(excluded_dirs.iter().map(|p| (p, Change::Created)))- .filter(|(p, change)| watchers.wants(&s.root, p, *change) && send(p, *change))+ .filter(|(p, change)| roots.iter().any(|root| watchers.wants(root, p, *change)) && send(p, *change)).collect()};drop(watchers);@@ -3036,7 +3171,8 @@ impl LspManager {}}if allowed && !previous {- for server in self.servers.lock().iter() {+ let servers = self.servers.lock().clone();+ for server in &servers {server.reset_for_restart();self.ensure_started(server);}@@ -3053,11 +3189,13 @@ impl LspManager {}pub async fn reconfigure(&self) {+ let _reconfigure = self.reconfigure_lock.lock().await;if !self.execution_allowed.load(Ordering::Acquire) {let servers = self.servers.lock().clone();join_all(servers.iter().map(|s| self.stop_instance(s, true))).await;return;}+ self.reconfigure_jdtls_workspace().await;self.stop_unlisted().await;let Some(me) = self.me.upgrade() else { return };let servers: Vec<Arc<Server>> = self.servers.lock().clone();@@ -3120,6 +3258,39 @@ impl LspManager {self.injection_providers_changed();}+ async fn reconfigure_jdtls_workspace(&self) {+ let (shared, roots) = self.desired_jdtls_workspace();+ let retired = {+ // Opens attach atomically with root selection; no document can acquire an old+ // instance between removing the registry entries and detaching its documents.+ let _gate = self.injections.gate.lock();+ let mut state = self.jdtls_workspace_state();+ if state.shared == shared && (!shared || state.roots == roots) {+ return;+ }+ state.transitioning = true;+ state.shared = shared;+ state.roots = roots;+ let mut servers = self.servers.lock();+ let retired: Vec<_> = servers.iter().filter(|s| is_local_jdtls(&s.config)).cloned().collect();+ servers.retain(|s| !is_local_jdtls(&s.config));+ for doc in self.docs.lock().values_mut() {+ doc.servers.retain(|a| !is_local_jdtls(&a.server.config));+ }+ retired+ };+ for server in &retired {+ self.stop_instance(server, true).await;+ }+ self.forget(&retired);+ self.jdtls_workspace.lock().transitioning = false;+ self.attach_fallbacks();+ let pending: Vec<_> = self.servers.lock().iter().filter(|s| is_local_jdtls(&s.config)).cloned().collect();+ for server in pending {+ self.ensure_started(&server);+ }+ }+/// Detaches fallbacks shadowed by enabled servers and instances whose target/// no longer matches the document's language. Stop them once unused.async fn detach_shadowed_servers(&self) {@@ -3255,6 +3426,7 @@ impl LspManager {}pub async fn restart(&self, server: ide_core::ServerId) -> IdeResult<()> {+ let _reconfigure = self.reconfigure_lock.lock().await;let s = self.servers.lock()@@ -3282,7 +3454,12 @@ impl LspManager {/// Gracefully stops the current instance (`shutdown` + `exit`, then kill).async fn stop_instance(&self, server: &Arc<Server>, final_stop: bool) {- let Some(run) = server.begin_stop(&self.sink, final_stop) else { return };+ let Some(run) = server.begin_stop(&self.sink, final_stop) else {+ if is_local_jdtls(&server.config) {+ let _startup = server.startup_lock.lock().await;+ }+ return;+ };let peer = run.peer.clone();// A server we connected to without starting it (an open Godot editor) is not// ours to shut down: only the connection closes.@@ -3302,13 +3479,24 @@ impl LspManager {peer.kill();let _ = tokio::time::timeout(Duration::from_secs(2), peer.closed()).await;}- peer.kill();+ Self::kill_peer(server, &peer).await;+ if is_local_jdtls(&server.config) {+ let _startup = server.startup_lock.lock().await;+ }server.end_stop(run.generation, &self.sink);self.file_watch_roots_changed();}+ async fn kill_peer(server: &Server, peer: &ide_jsonrpc::Peer) {+ peer.kill();+ if is_local_jdtls(&server.config) && peer.pid().is_some() {+ peer.exited().await;+ }+ }+pub async fn shutdown_all(&self) {self.shutting_down.store(true, Ordering::Release);+ let _reconfigure = self.reconfigure_lock.lock().await;let servers: Vec<Arc<Server>> = self.servers.lock().clone();join_all(servers.iter().map(|s| self.stop_instance(s, true))).await;}diff --git a/crates/ide-lsp/src/server.rs b/crates/ide-lsp/src/server.rsindex 2a38dc55d..6fa363374 100644--- a/crates/ide-lsp/src/server.rs+++ b/crates/ide-lsp/src/server.rs@@ -119,6 +119,8 @@ pub struct Server {phase_notify: Notify,transient: Mutex<HashMap<PathBuf, Transient>>,pub java_build_lock: Arc<tokio::sync::Mutex<()>>,+ /// JDT retirement waits for launch and initialization cleanup, even before `Ready`.+ pub startup_lock: Arc<tokio::sync::Mutex<()>>,pub java_autobuild_suspended: std::sync::atomic::AtomicBool,pub external_project: tokio::sync::Mutex<crate::external_project::State>,pub external_diagnostics: std::sync::atomic::AtomicBool,@@ -158,6 +160,7 @@ impl Server {phase_notify: Notify::new(),transient: Mutex::new(HashMap::new()),java_build_lock: Arc::new(tokio::sync::Mutex::new(())),+ startup_lock: Arc::new(tokio::sync::Mutex::new(())),java_autobuild_suspended: std::sync::atomic::AtomicBool::new(false),external_project: tokio::sync::Mutex::new(Default::default()),external_diagnostics: std::sync::atomic::AtomicBool::new(false),@@ -269,6 +272,10 @@ impl Server {}}+ pub fn is_starting(&self) -> bool {+ matches!(self.state.lock().conn, Conn::Starting)+ }+/// The instance told `initialized`, ready or not.pub fn instance(&self) -> Option<Running> {self.running().or_else(|| self.initializing.lock().clone())diff --git a/crates/ide-lsp/tests/mock_server.rs b/crates/ide-lsp/tests/mock_server.rsindex 69fef3a03..ad30aac8f 100644--- a/crates/ide-lsp/tests/mock_server.rs+++ b/crates/ide-lsp/tests/mock_server.rs@@ -35,6 +35,8 @@ struct MockState {responder: Mutex<Option<Responder>>,/// Holds the handling of notifications of this method until the gate opens.held: Mutex<Option<(String, Arc<Gate>)>>,+ initialize_gate: Mutex<Option<Arc<Gate>>>,+ launch_gate: Mutex<Option<Arc<Gate>>>,peer: Mutex<Option<Peer>>,}@@ -73,7 +75,9 @@ fn utf16_to_byte(text: &str, line: u64, col: u64) -> usize {text.len()}-struct MockHandler(Arc<MockState>);+type MockConnection = Mutex<Option<Peer>>;++struct MockHandler(Arc<MockState>, std::sync::Weak<MockConnection>);impl Handler for MockHandler {fn on_notification(&self, method: &str, params: Value) {@@ -118,8 +122,14 @@ impl Handler for MockHandler {s.docs.lock().remove(&uri);}"exit" => {- if let Some(p) = s.peer.lock().take() {- p.kill();+ if let Some(connection) = self.1.upgrade()+ && let Some(peer) = connection.lock().take()+ {+ peer.kill();+ }+ let mut latest = s.peer.lock();+ if latest.as_ref().is_some_and(Peer::is_closed) {+ *latest = None;}}_ => {}@@ -131,7 +141,13 @@ impl Handler for MockHandler {let s = &self.0;s.requests.lock().push((method.to_owned(), params.clone()));match method {- "initialize" => Ok(json!({ "capabilities": s.caps.lock().clone(), "serverInfo": { "name": "mock" } })),+ "initialize" => {+ let gate = s.initialize_gate.lock().take();+ if let Some(gate) = gate {+ gate.hold();+ }+ Ok(json!({ "capabilities": s.caps.lock().clone(), "serverInfo": { "name": "mock" } }))+ }"shutdown" => Ok(Value::Null),_ => {if let Some(error) = s.errors.lock().get(method).cloned() {@@ -150,6 +166,7 @@ impl Handler for MockHandler {#[derive(Default)]struct MockLauncher {servers: Mutex<HashMap<String, Arc<MockState>>>,+ connections: Mutex<Vec<Arc<MockConnection>>>,}impl MockLauncher {@@ -186,10 +203,18 @@ impl Launcher for MockLauncher {state.docs.lock().clear();let (client_io, server_io) = tokio::io::duplex(1 << 20);let (sr, sw) = tokio::io::split(server_io);- let server = Peer::connect(sr, sw, Arc::new(MockHandler(state.clone())));+ let connection = Arc::new(Mutex::new(None));+ let server = Peer::connect(sr, sw, Arc::new(MockHandler(state.clone(), Arc::downgrade(&connection))));+ *connection.lock() = Some(server.clone());+ self.connections.lock().push(connection);*state.peer.lock() = Some(server);let (cr, cw) = tokio::io::split(client_io);- Ok(Peer::connect(cr, cw, handler))+ let client = Peer::connect(cr, cw, handler);+ let gate = state.launch_gate.lock().take();+ if let Some(gate) = gate {+ gate.hold();+ }+ Ok(client)}}@@ -420,6 +445,451 @@ async fn linked_projects_initialize_separate_language_server_roots() {h.mgr.shutdown_all().await;}+fn java_siblings(h: &Harness) -> Vec<PathBuf> {+ ["first", "second"]+ .into_iter()+ .map(|name| {+ let root = h.root.join(name);+ std::fs::create_dir(&root).unwrap();+ std::fs::write(root.join("mock.toml"), "").unwrap();+ let path = root.join("Main.java");+ std::fs::write(&path, "class Main {}").unwrap();+ path+ })+ .collect()+}++#[tokio::test(flavor = "multi_thread")]+async fn java_sharing_is_opt_in_and_keeps_module_requests_on_one_instance() {+ for shared in [false, true] {+ let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);+ h.mgr.set_jdtls_shared_hook(Box::new(move || shared));+ let paths = java_siblings(&h);+ std::thread::scope(|scope| {+ for path in &paths {+ scope.spawn(|| h.mgr.did_open(DocId::next(), path, &h.lang, 1, "class Main {}"));+ }+ });+ let state = h.launcher.state("jdtls");+ let count = if shared { 1 } else { 2 };+ eventually(|| state.requested("initialize").len() == count).await;+ assert_eq!(state.launches.load(Ordering::SeqCst), count);+ assert_eq!(h.mgr.servers().len(), count);+ for path in &paths {+ h.mgr.java_classpath(path.parent().unwrap(), false, &Default::default()).await.unwrap();+ }+ let requests = state.requested("workspace/executeCommand");+ let classpaths: Vec<_> = requests.iter().filter(|r| r["command"] == "java.project.getClasspaths").collect();+ assert_eq!(classpaths.len(), 2);+ for path in &paths {+ assert!(classpaths.iter().any(|r| r["arguments"][0] == uri_of(path.parent().unwrap())));+ }+ if shared {+ let init = &state.requested("initialize")[0];+ assert_eq!(init["rootUri"], uri_of(&h.root));+ assert_eq!(init["initializationOptions"]["workspaceFolders"], json!([uri_of(&h.root)]));+ }+ h.mgr.shutdown_all().await;+ }+}++#[tokio::test(flavor = "multi_thread")]+async fn java_sharing_toggle_retires_old_instances_and_reopens_every_document() {+ let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);+ let shared = Arc::new(std::sync::atomic::AtomicBool::new(false));+ h.mgr.set_jdtls_shared_hook(Box::new({+ let shared = shared.clone();+ move || shared.load(Ordering::SeqCst)+ }));+ let paths = java_siblings(&h);+ for path in &paths {+ h.mgr.did_open(DocId::next(), path, &h.lang, 1, "class Main {}");+ }+ let state = h.launcher.state("jdtls");+ eventually(|| state.requested("initialize").len() == 2).await;+ eventually(|| {+ paths+ .iter()+ .all(|path| state.notified("textDocument/didOpen").iter().any(|v| v["textDocument"]["uri"] == uri_of(path)))+ })+ .await;+ let old: Vec<_> = h.mgr.servers().into_iter().map(|s| s.id).collect();+ shared.store(true, Ordering::SeqCst);+ h.mgr.reconfigure().await;+ eventually(|| state.launches.load(Ordering::SeqCst) == 3 && state.docs.lock().len() == 2).await;+ assert_eq!(h.mgr.servers().len(), 1);+ for id in old {+ assert!(+ h.events+ .lock()+ .iter()+ .any(|event| matches!(event, IdeEvent::LanguageServerRemoved {server} if *server == id))+ );+ }+ shared.store(false, Ordering::SeqCst);+ h.mgr.reconfigure().await;+ eventually(|| state.launches.load(Ordering::SeqCst) == 5).await;+ assert_eq!(h.mgr.servers().len(), 2);+ eventually(|| {+ paths.iter().all(|path| {+ state.notified("textDocument/didOpen").iter().filter(|v| v["textDocument"]["uri"] == uri_of(path)).count()+ == 3+ })+ })+ .await;+ h.mgr.shutdown_all().await;+}++#[tokio::test(flavor = "multi_thread")]+async fn java_sharing_cancels_a_retiring_initialize_before_starting_its_replacement() {+ let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);+ let shared = Arc::new(std::sync::atomic::AtomicBool::new(false));+ h.mgr.set_jdtls_shared_hook(Box::new({+ let shared = shared.clone();+ move || shared.load(Ordering::SeqCst)+ }));+ let state = h.launcher.state("jdtls");+ let gate = Arc::new(Gate::default());+ *state.initialize_gate.lock() = Some(gate.clone());+ let path = java_siblings(&h).remove(0);+ h.mgr.did_open(DocId::next(), &path, &h.lang, 1, "class Main {}");+ eventually(|| gate.entered()).await;+ let old = state.peer();+ shared.store(true, Ordering::SeqCst);+ let switched = tokio::time::timeout(Duration::from_secs(2), h.mgr.reconfigure()).await;+ let closed_before_response = old.is_closed();+ gate.open();+ switched.expect("initialize cancellation must not wait for its response");+ eventually(|| state.requested("initialize").len() == 2).await;+ assert!(closed_before_response, "the old transport must close before its initialize response is released");+ assert_eq!(h.mgr.servers().len(), 1);+ assert_eq!(h.mgr.servers()[0].root.as_ref(), h.root.as_path());+ h.mgr.shutdown_all().await;+}++#[tokio::test(flavor = "multi_thread")]+async fn shared_java_waits_for_an_abandoned_launcher_before_replacing_the_workspace() {+ let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);+ h.mgr.set_jdtls_shared_hook(Box::new(|| true));+ let state = h.launcher.state("jdtls");+ let gate = Arc::new(Gate::default());+ *state.launch_gate.lock() = Some(gate.clone());+ h.open("Main.java", "class Main {}");+ eventually(|| gate.entered()).await;+ let old = state.peer();+ let id = h.mgr.servers()[0].id;+ let external = tempfile::tempdir().unwrap();+ h.mgr.set_content_roots(vec![dunce::canonicalize(external.path()).unwrap()]);+ eventually(|| h.mgr.servers().iter().all(|s| s.id != id)).await;+ h.open("Another.java", "class Another {}");+ let mut transition = tokio::spawn({+ let manager = h.mgr.clone();+ async move { manager.reconfigure().await }+ });+ let pending = tokio::time::timeout(Duration::from_millis(100), &mut transition).await.is_err();+ let launches = state.launches.load(Ordering::SeqCst);+ let old_alive = !old.is_closed();+ gate.open();+ assert!(pending, "retirement must wait for the launcher to return");+ assert_eq!(launches, 1, "the retiring launcher still owns its peer");+ assert!(old_alive);+ transition.await.unwrap();+ h.mgr.reconfigure().await;+ eventually(|| state.launches.load(Ordering::SeqCst) == 2 && state.docs.lock().len() == 2).await;+ assert!(old.is_closed());+ assert_eq!(h.mgr.servers().len(), 1);+ h.mgr.shutdown_all().await;+}++#[tokio::test(flavor = "multi_thread")]+async fn java_classpath_waits_for_a_config_restart_that_is_reaping_startup() {+ for (shared, failed) in [(false, false), (true, false), (false, true)] {+ let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);+ let changed = Arc::new(std::sync::atomic::AtomicBool::new(false));+ h.mgr.set_jdtls_shared_hook(Box::new({+ let changed = changed.clone();+ move || shared && changed.load(Ordering::SeqCst)+ }));+ h.mgr.set_config_hook(Box::new({+ let changed = changed.clone();+ move |cfg, _| {+ let changed = changed.load(Ordering::SeqCst);+ cfg.env.insert("MOCK_CONFIG_REVISION".into(), changed.to_string());+ if failed && changed {+ cfg.launch_error = Some("restart configuration error".into());+ }+ }+ }));+ let state = h.launcher.state("jdtls");+ let gate = Arc::new(Gate::default());+ *state.launch_gate.lock() = Some(gate.clone());+ let path = java_siblings(&h).remove(0);+ h.mgr.did_open(DocId::next(), &path, &h.lang, 1, "class Main {}");+ eventually(|| gate.entered()).await;+ let old = h.mgr.servers()[0].id;+ changed.store(true, Ordering::SeqCst);+ let restarting = tokio::spawn({+ let manager = h.mgr.clone();+ async move { manager.reconfigure().await }+ });+ h.wait_status("jdtls", ServerStatus::Stopped).await;+ let mut query = tokio::spawn({+ let manager = h.mgr.clone();+ async move { manager.java_classpath(path.parent().unwrap(), false, &Default::default()).await }+ });+ let early = tokio::time::timeout(Duration::from_millis(100), &mut query).await;+ gate.open();+ restarting.await.unwrap();+ let result = match early {+ Ok(result) => result.unwrap(),+ Err(_) => query.await.unwrap(),+ };+ if failed {+ assert!(result.unwrap_err().message.contains("restart configuration error"));+ } else {+ assert!(result.is_ok(), "a configuration restart is transient: {result:?}");+ assert_eq!(state.launches.load(Ordering::SeqCst), 2);+ assert_eq!(h.mgr.servers()[0].id != old, shared);+ }+ h.mgr.shutdown_all().await;+ }+}++#[tokio::test(flavor = "multi_thread")]+async fn java_classpath_restart_barrier_wait_remains_cancellable() {+ let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);+ let changed = Arc::new(std::sync::atomic::AtomicBool::new(false));+ h.mgr.set_config_hook(Box::new({+ let changed = changed.clone();+ move |cfg, _| {+ cfg.env.insert("MOCK_CONFIG_REVISION".into(), changed.load(Ordering::SeqCst).to_string());+ }+ }));+ let state = h.launcher.state("jdtls");+ let gate = Arc::new(Gate::default());+ *state.launch_gate.lock() = Some(gate.clone());+ h.open("Main.java", "class Main {}");+ eventually(|| gate.entered()).await;+ changed.store(true, Ordering::SeqCst);+ let restarting = tokio::spawn({+ let manager = h.mgr.clone();+ async move { manager.reconfigure().await }+ });+ h.wait_status("jdtls", ServerStatus::Stopped).await;+ let cancel = CancellationToken::new();+ let mut query = tokio::spawn({+ let manager = h.mgr.clone();+ let root = h.root.clone();+ let cancel = cancel.clone();+ async move { manager.java_classpath(&root, false, &cancel).await }+ });+ let early = tokio::time::timeout(Duration::from_millis(100), &mut query).await;+ let waiting = early.is_err();+ cancel.cancel();+ let result = match early {+ Ok(result) => Ok(result),+ Err(_) => tokio::time::timeout(Duration::from_secs(1), query).await,+ };+ gate.open();+ restarting.await.unwrap();+ assert!(waiting, "the query must wait behind the restart barrier");+ assert_eq!(result.unwrap().unwrap().unwrap_err().kind, ide_core::error::ErrorKind::Cancelled);+ h.mgr.shutdown_all().await;+}++#[tokio::test(flavor = "multi_thread")]+async fn java_classpath_does_not_retry_permanently_unavailable_servers() {+ for missing in [false, true] {+ let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);+ if missing {+ h.launcher.state("jdtls").missing.store(true, Ordering::SeqCst);+ } else {+ h.mgr.set_config_hook(Box::new(|cfg, _| {+ cfg.launch_error = Some("permanent mock configuration error".into())+ }));+ }+ let result =+ tokio::time::timeout(Duration::from_secs(1), h.mgr.java_classpath(&h.root, false, &Default::default()))+ .await+ .expect("permanent failures must not incur the Java readiness timeout");+ let error = result.unwrap_err();+ assert!(error.message.contains(if missing { "not installed" } else { "permanent mock configuration error" }));+ h.mgr.shutdown_all().await;+ }+}++#[tokio::test(flavor = "multi_thread")]+async fn shared_java_external_roots_reach_initialization_queries_and_watches() {+ let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);+ h.mgr.set_jdtls_shared_hook(Box::new(|| true));+ let external = tempfile::tempdir().unwrap();+ let external = dunce::canonicalize(external.path()).unwrap();+ h.mgr.set_content_roots(vec![external.clone(), external.clone(), h.root.clone()]);+ let file = external.join("External.java");+ std::fs::write(&file, "class External {}").unwrap();+ h.mgr.did_open(DocId::next(), &file, &h.lang, 1, "class External {}");+ let state = h.launcher.state("jdtls");+ h.wait_status("jdtls", ServerStatus::Ready).await;+ let init = &state.requested("initialize")[0];+ assert_eq!(init["initializationOptions"]["workspaceFolders"], json!([uri_of(&h.root), uri_of(&external)]));+ assert_eq!(init["initializationOptions"]["triggerFiles"], json!([uri_of(&file)]));+ let folders: Value = state.peer().request("workspace/workspaceFolders", Value::Null, None).await.unwrap();+ assert_eq!(folders, init["workspaceFolders"]);+ state.peer().request::<_, Value>("client/registerCapability", json!({"registrations":[{+ "id":"external-java", "method":"workspace/didChangeWatchedFiles", "registerOptions":{"watchers":[{"globPattern":"**/*.java"}]}+ }]}), None).await.unwrap();+ let other = external.join("Other.java");+ h.mgr.watched_files_changed(std::slice::from_ref(&other), &[], &[], &[]);+ eventually(|| {+ state.notified("workspace/didChangeWatchedFiles").iter().any(|v| v["changes"][0]["uri"] == uri_of(&other))+ })+ .await;+ h.mgr.set_content_roots(vec![]);+ h.mgr.reconfigure().await;+ eventually(|| state.requested("initialize").len() == 2).await;+ assert_eq!(state.requested("initialize")[1]["initializationOptions"]["workspaceFolders"], json!([uri_of(&h.root)]));+ assert_eq!(h.mgr.servers().len(), 1);+ h.mgr.shutdown_all().await;+}++#[tokio::test(flavor = "multi_thread")]+async fn trusting_an_existing_java_instance_restarts_it_without_locking_the_registry() {+ for shared in [false, true] {+ let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);+ h.mgr.set_jdtls_shared_hook(Box::new(move || shared));+ h.open("Main.java", "class Main {}");+ h.wait_status("jdtls", ServerStatus::Ready).await;+ let state = h.launcher.state("jdtls");+ h.mgr.set_execution_allowed(false);+ h.mgr.reconfigure().await;+ h.mgr.set_execution_allowed(true);+ eventually(|| state.launches.load(Ordering::SeqCst) == 2 && state.docs.lock().len() == 1).await;+ assert_eq!(h.mgr.servers().len(), 1);+ h.mgr.shutdown_all().await;+ }+}++#[tokio::test(flavor = "multi_thread")]+async fn java_sharing_preserves_other_servers_and_marker_scoped_fallbacks() {+ for fallback in [false, true] {+ let h = harness_for(+ "java",+ "java",+ &[("jdtls", incremental_caps()), ("other", incremental_caps())],+ if fallback { &["other"] } else { &[] },+ );+ h.mgr.set_jdtls_shared_hook(Box::new(|| true));+ h.launcher.state("jdtls").missing.store(fallback, Ordering::SeqCst);+ for path in java_siblings(&h) {+ h.mgr.did_open(DocId::next(), &path, &h.lang, 1, "class Main {}");+ }+ eventually(|| h.launcher.state("other").requested("initialize").len() == 2).await;+ let servers = h.mgr.servers();+ assert_eq!(servers.iter().filter(|s| s.name == "jdtls").count(), 1);+ assert_eq!(servers.iter().filter(|s| s.name == "other").count(), 2);+ assert_eq!(h.launcher.state("jdtls").launches.load(Ordering::SeqCst), usize::from(!fallback));+ h.mgr.shutdown_all().await;+ }+}++#[tokio::test(flavor = "multi_thread")]+async fn java_sharing_keeps_target_instances_separate_and_preserves_them_on_toggle() {+ let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);+ let shared = Arc::new(std::sync::atomic::AtomicBool::new(true));+ h.mgr.set_jdtls_shared_hook(Box::new({+ let shared = shared.clone();+ move || shared.load(Ordering::SeqCst)+ }));+ h.mgr.set_servers_hook(Box::new(|_, configs| {+ let mut target = configs[0].clone();+ target.target_key = Some("container".into());+ target+ .initialization_options+ .as_mut()+ .unwrap()+ .as_table_mut()+ .unwrap()+ .insert("selectedTarget".into(), toml::Value::Boolean(true));+ vec![configs[0].clone(), target]+ }));+ h.open("Main.java", "class Main {}");+ for path in java_siblings(&h) {+ h.mgr.did_open(DocId::next(), &path, &h.lang, 1, "class Main {}");+ }+ let state = h.launcher.state("jdtls");+ eventually(|| h.mgr.servers().iter().filter(|s| s.status == ServerStatus::Ready).count() == 4).await;+ let initial = state.requested("initialize");+ assert_eq!(initial.len(), 4);+ let targets: Vec<_> = initial.iter().filter(|v| v["initializationOptions"]["selectedTarget"] == true).collect();+ assert_eq!(targets.len(), 3, "target roots retain their marker-based identity");+ assert!(targets.iter().all(|v| v["initializationOptions"].get("workspaceFolders").is_none()));+ let local = initial.iter().find(|v| v["initializationOptions"]["selectedTarget"] != true).unwrap();+ assert_eq!(local["rootUri"], uri_of(&h.root));+ assert_eq!(local["initializationOptions"]["workspaceFolders"], json!([uri_of(&h.root)]));+ let old: HashSet<_> = h.mgr.servers().into_iter().map(|s| s.id).collect();+ shared.store(false, Ordering::SeqCst);+ h.mgr.reconfigure().await;+ eventually(|| h.mgr.servers().iter().filter(|s| s.status == ServerStatus::Ready).count() == 6).await;+ assert_eq!(+ h.mgr.servers().iter().filter(|s| old.contains(&s.id)).count(),+ 3,+ "local sharing does not retire targets"+ );+ h.mgr.shutdown_all().await;+}++#[tokio::test(flavor = "multi_thread")]+async fn virtual_java_documents_opened_during_a_toggle_attach_to_the_successor() {+ let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);+ let shared = Arc::new(std::sync::atomic::AtomicBool::new(false));+ h.mgr.set_jdtls_shared_hook(Box::new({+ let shared = shared.clone();+ move || shared.load(Ordering::SeqCst)+ }));+ let (doc, _) = h.open("Main.java", "class Main {}");+ h.wait_status("jdtls", ServerStatus::Ready).await;+ let state = h.launcher.state("jdtls");+ let uris: Vec<_> = (0..16).map(|n| format!("jdt://contents/project/Virtual{n}.class")).collect();+ state.respond(+ "textDocument/definition",+ json!(+ uris.iter()+ .map(|uri| json!({"uri":uri,"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":1}}}))+ .collect::<Vec<_>>()+ ),+ );+ h.mgr.goto(doc, Pos::default(), GotoKind::Definition).await.unwrap();+ shared.store(true, Ordering::SeqCst);+ let toggle = tokio::spawn({+ let manager = h.mgr.clone();+ async move { manager.reconfigure().await }+ });+ let mut opened = Vec::new();+ for uri in uris {+ let manager = h.mgr.clone();+ let language = h.lang.clone();+ let doc = DocId::next();+ opened.push((+ doc,+ std::thread::spawn(move || manager.did_open_virtual(doc, &uri, &language, 0, "class Virtual {}")),+ ));+ }+ let docs: Vec<_> = opened+ .into_iter()+ .map(|(doc, thread)| {+ thread.join().unwrap();+ doc+ })+ .collect();+ toggle.await.unwrap();+ eventually(|| state.docs.lock().len() == docs.len() + 1).await;+ assert_eq!(h.mgr.servers().len(), 1);+ for doc in docs {+ h.mgr.hover(doc, Pos::default(), Default::default()).await.unwrap();+ }+ h.mgr.shutdown_all().await;+}+#[tokio::test(flavor = "multi_thread")]async fn files_changed_on_disk_reach_the_servers_of_their_language() {let h = harness(&[("mock", incremental_caps())]);@@ -2730,7 +3200,7 @@ async fn noop_handler_is_usable_for_raw_peers() {let (a, b) = tokio::io::duplex(1024);let (ar, aw) = tokio::io::split(a);let (br, bw) = tokio::io::split(b);- let _server = Peer::connect(br, bw, Arc::new(MockHandler(Arc::default())));+ let _server = Peer::connect(br, bw, Arc::new(MockHandler(Arc::default(), std::sync::Weak::new())));let client = Peer::connect(ar, aw, Arc::new(NoopHandler));let v: Value = client.request("shutdown", (), None).await.unwrap();assert_eq!(v, Value::Null);diff --git a/crates/ide-lsp/tests/real_servers.rs b/crates/ide-lsp/tests/real_servers.rsindex 7bd547726..b3c4720d8 100644--- a/crates/ide-lsp/tests/real_servers.rs+++ b/crates/ide-lsp/tests/real_servers.rs@@ -63,6 +63,104 @@ fn lang(id: &str, ext: &str, server: LanguageServerConfig) -> LanguageConfig {}}+#[tokio::test(flavor = "multi_thread")]+#[ignore = "requires OPENIDEA_TEST_JDTLS and OPENIDEA_TEST_GRADLE_HOME, with JDK 21+"]+async fn shared_jdtls_imports_independent_gradle_builds_and_external_root() {+ use serde_json::json;++ let jdtls = std::env::var("OPENIDEA_TEST_JDTLS").expect("set OPENIDEA_TEST_JDTLS");+ let gradle_home = std::env::var("OPENIDEA_TEST_GRADLE_HOME").expect("set OPENIDEA_TEST_GRADLE_HOME");+ let dir = tempfile::tempdir().unwrap();+ let temp_root = dunce::canonicalize(dir.path()).unwrap();+ let root = temp_root.join("workspace");+ std::fs::create_dir(&root).unwrap();+ let root = dunce::canonicalize(root).unwrap();+ let external = temp_root.join("external");+ let mut files = Vec::new();+ for (name, build) in [("alpha", root.join("alpha")), ("beta", root.join("beta")), ("external", external.clone())] {+ let source_dir = build.join("app/src/main/java/demo");+ std::fs::create_dir_all(&source_dir).unwrap();+ std::fs::write(build.join("settings.gradle"), format!("rootProject.name = '{name}'\ninclude 'app'\n")).unwrap();+ std::fs::write(build.join("build.gradle"), "").unwrap();+ std::fs::write(build.join("app/build.gradle"), "plugins { id 'java' }\n").unwrap();+ let source = format!(+ "package demo; public class Main {{ public static void main(String[] args) {{ {name}Marker(); }} static void {name}Marker() {{}} }}\n"+ );+ let path = source_dir.join("Main.java");+ std::fs::write(&path, &source).unwrap();+ files.push((name, path, source));+ }+ let mut java = LanguageRegistry::load(None).unwrap().get(&LanguageId::new("java")).unwrap();+ java.language_servers.retain(|s| s.name == "jdtls");+ let server = &mut java.language_servers[0];+ server.command = jdtls;+ server.env.insert("GRADLE_USER_HOME".into(), dir.path().join("gradle-user-home").to_string_lossy().into_owned());+ server.args.extend(["-data".into(), dir.path().join("jdtls-data").to_string_lossy().into_owned()]);+ let options = server.initialization_options.as_mut().unwrap().as_table_mut().unwrap();+ let settings = options.get_mut("settings").unwrap().as_table_mut().unwrap();+ let java_settings = settings.get_mut("java").unwrap().as_table_mut().unwrap();+ let imports = java_settings.get_mut("import").unwrap().as_table_mut().unwrap();+ let gradle = imports.get_mut("gradle").unwrap().as_table_mut().unwrap();+ gradle.insert("home".into(), toml::Value::String(gradle_home));+ gradle.insert("wrapper".into(), toml::Value::try_from(json!({"enabled": false})).unwrap());+ if let Ok(home) = std::env::var("OPENIDEA_TEST_GRADLE_JAVA_HOME") {+ gradle.insert("java".into(), toml::Value::try_from(json!({"home": home})).unwrap());+ }+ let (mgr, events) = manager(&root, LanguageRegistry::from_configs(vec![java]));+ mgr.set_jdtls_shared_hook(Box::new(|| true));+ mgr.set_content_roots(vec![external]);+ for (_, path, source) in &files {+ mgr.did_open(DocId::next(), path, &LanguageId::new("java"), 1, source);+ }+ retry("shared jdtls ready", Duration::from_secs(60), || {+ let status = last_status(&events, "jdtls");+ if let Some((ServerStatus::Crashed | ServerStatus::Missing | ServerStatus::Misconfigured, message)) = &status {+ panic!("shared jdtls failed: {message:?}");+ }+ async move { matches!(status, Some((ServerStatus::Ready | ServerStatus::Busy, _))).then_some(()) }+ })+ .await;+ for (name, path, _) in &files {+ let cp = retry(&format!("{name} Gradle classpath"), Duration::from_secs(180), || async {+ let cp =+ tokio::time::timeout(Duration::from_secs(10), mgr.java_classpath(path, false, &Default::default()))+ .await+ .ok()?+ .ok()?;+ cp.class_paths.iter().any(|p| p.contains(&format!("/{name}/app/"))).then_some(cp)+ })+ .await;+ assert!(+ cp.class_paths+ .iter()+ .all(|p| !files.iter().any(|(other, _, _)| other != name && p.contains(&format!("/{other}/app/")))),+ "classpath leaked between builds: {cp:?}"+ );+ let launch = tokio::time::timeout(+ Duration::from_secs(30),+ mgr.java_launch(path, false, false, false, false, &Default::default()),+ )+ .await+ .expect("launch resolution timed out")+ .expect("launch resolution failed");+ assert_eq!(launch.class_paths, cp.class_paths, "launch resolved a different build for {name}");+ }+ let servers = mgr.servers().into_iter().filter(|s| s.name == "jdtls").collect::<Vec<_>>();+ assert_eq!(servers.len(), 1, "expected one JDT LS: {servers:?}");+ assert!(servers[0].pid.is_some(), "JDT LS process is not running");+ for (_, path, _) in [&files[0], &files[2]] {+ let bad = path.parent().unwrap().join("Broken.java");+ let bad_source = "package demo; class Broken { MissingType x; }";+ std::fs::write(&bad, bad_source).unwrap();+ mgr.did_open(DocId::next(), &bad, &LanguageId::new("java"), 1, bad_source);+ retry("diagnostics from shared JDT LS", Duration::from_secs(120), || {+ let found = events.lock().iter().any(|e| matches!(e, IdeEvent::Diagnostics { path, items, .. } if path.0 == bad && items.iter().any(|d| d.message.contains("MissingType"))));+ async move { found.then_some(()) }+ }).await;+ }+ tokio::time::timeout(Duration::from_secs(10), mgr.shutdown_all()).await.unwrap();+}+#[tokio::test(flavor = "multi_thread")]#[ignore = "requires kmp-lsp on PATH (or OPENIDEA_TEST_KMP_LSP)"]async fn kmp_lsp_java_end_to_end() {diff --git a/src/bindings.ts b/src/bindings.tsindex 35832e812..3a2f6a69b 100644--- a/src/bindings.ts+++ b/src/bindings.ts@@ -5271,6 +5271,8 @@ export type JavaSettings = {* (VS Code's `java.jdt.ls.vmargs`).*/jdtlsVmArgs?: string,+ /** Share one JDT LS across builds in an ordinary project window; other windows remain separate. */+ jdtlsShared?: boolean,/** Build Tools › Maven. */maven?: MavenSettings,/** Build Tools › Gradle. */diff --git a/src/features/settings/__tests__/dialog.test.tsx b/src/features/settings/__tests__/dialog.test.tsxindex 47092e220..7610a1427 100644--- a/src/features/settings/__tests__/dialog.test.tsx+++ b/src/features/settings/__tests__/dialog.test.tsx@@ -514,6 +514,94 @@ describe("Settings dialog", () => {expect(settingsSet.mock.calls).toEqual([["global", "languages.java.jdtlsVmArgs", '"-Xmx2g"']]);});+ it("stages shared JDT LS in the project and writes it on Apply", async () => {+ const dialog = await openDialog("languages.java");+ fireEvent.click(within(dialog).getByRole("radio", { name: "This project" }));+ const checkbox = within(dialog).getByRole("checkbox", { name: "Share JDT LS across builds" });+ expect(checkbox).not.toBeChecked();+ fireEvent.click(checkbox);+ expect(checkbox).toBeChecked();+ expect(settingsSet).not.toHaveBeenCalled();+ await act(async () => fireEvent.click(within(dialog).getByRole("button", { name: "Apply" })));+ expect(settingsSet.mock.calls).toEqual([["project", "languages.java.jdtlsShared", "true"]]);+ });++ it("keeps the global shared JDT LS preference separate from the project's override", async () => {+ global = setAt(global, "languages.java.jdtlsShared", true);+ current = setAt(global, "languages.java.jdtlsShared", false);+ useProject.setState({ settings: current });+ const dialog = await openDialog("languages.java");+ fireEvent.click(within(dialog).getByRole("radio", { name: "This project" }));+ expect(within(dialog).getByRole("checkbox", { name: "Share JDT LS across builds" })).not.toBeChecked();+ fireEvent.click(within(dialog).getByRole("radio", { name: "Global" }));+ const checkbox = within(dialog).getByRole("checkbox", { name: "Share JDT LS across builds" });+ expect(checkbox).toBeChecked();+ fireEvent.click(checkbox);+ await act(async () => fireEvent.click(within(dialog).getByRole("button", { name: "Apply" })));+ expect(settingsSet.mock.calls).toEqual([["global", "languages.java.jdtlsShared", "false"]]);+ });++ it("discards a shared JDT LS toggle on Cancel", async () => {+ const dialog = await openDialog("languages.java");+ fireEvent.click(within(dialog).getByRole("radio", { name: "This project" }));+ fireEvent.click(within(dialog).getByRole("checkbox", { name: "Share JDT LS across builds" }));+ fireEvent.click(within(dialog).getByRole("button", { name: "Cancel" }));+ expect(settingsSet).not.toHaveBeenCalled();+ expect(current.languages?.java?.jdtlsShared).toBe(false);+ });++ it("disables shared JDT LS only in a native Workspace's project scope", async () => {+ useProject.setState((s) => ({+ project: { ...s.project!, workspace: { version: 1, name: "Workspace", projects: ["/p/member"] } },+ }));+ const dialog = await openDialog("languages.java");+ fireEvent.click(within(dialog).getByRole("radio", { name: "This project" }));+ expect(within(dialog).getByRole("checkbox", { name: "Share JDT LS across builds" })).toBeDisabled();+ expect(within(dialog).getByText(/Open a workspace member as a project/)).toBeInTheDocument();+ fireEvent.click(within(dialog).getByRole("radio", { name: "Global" }));+ const checkbox = within(dialog).getByRole("checkbox", { name: "Share JDT LS across builds" });+ expect(checkbox).toBeEnabled();+ fireEvent.click(checkbox);+ await act(async () => fireEvent.click(within(dialog).getByRole("button", { name: "Apply" })));+ expect(settingsSet.mock.calls).toEqual([["global", "languages.java.jdtlsShared", "true"]]);+ });++ it("disables sharing for a Java language server target only in project scope", async () => {+ current = setAt(current, "languageServerTargets", { java: { target: "docker:java", server: "jdtls" } });+ useProject.setState({ settings: current });+ const dialog = await openDialog("languages.java");+ fireEvent.click(within(dialog).getByRole("radio", { name: "This project" }));+ const checkbox = within(dialog).getByRole("checkbox", { name: "Share JDT LS across builds" });+ expect(checkbox).toBeDisabled();+ expect(within(dialog).getByText(/Select Local machine for the Java language server/)).toBeInTheDocument();+ fireEvent.click(within(dialog).getByRole("radio", { name: "Global" }));+ expect(checkbox).toBeEnabled();+ fireEvent.click(checkbox);+ await act(async () => fireEvent.click(within(dialog).getByRole("button", { name: "Apply" })));+ expect(settingsSet.mock.calls).toEqual([["global", "languages.java.jdtlsShared", "true"]]);+ });++ it.each([{ java: { target: "", server: "jdtls" } }, { python: { target: "docker:python" } }])(+ "keeps sharing available when Java runs locally: %j",+ async (targets) => {+ current = setAt(current, "languageServerTargets", targets);+ useProject.setState({ settings: current });+ const dialog = await openDialog("languages.java");+ fireEvent.click(within(dialog).getByRole("radio", { name: "This project" }));+ expect(within(dialog).getByRole("checkbox", { name: "Share JDT LS across builds" })).toBeEnabled();+ },+ );++ it("uses a staged project Java language server target before Apply", async () => {+ const dialog = await openDialog("languages.java");+ fireEvent.click(within(dialog).getByRole("radio", { name: "This project" }));+ const checkbox = within(dialog).getByRole("checkbox", { name: "Share JDT LS across builds" });+ expect(checkbox).toBeEnabled();+ act(() => stage("languages.servers", "project", "languageServerTargets.java.target", "docker:java"));+ expect(checkbox).toBeDisabled();+ expect(settingsSet).not.toHaveBeenCalled();+ });+it("Settings for New Projects edits the global layer on every page", async () => {render(<SettingsDialog />);await act(async () => {diff --git a/src/features/settings/__tests__/languages.test.ts b/src/features/settings/__tests__/languages.test.tsindex fa5892f28..ed5780487 100644--- a/src/features/settings/__tests__/languages.test.ts+++ b/src/features/settings/__tests__/languages.test.ts@@ -192,6 +192,15 @@ describe("languages settings", () => {expect(folderRole(ps, "src")).toBeNull();});+ it("defaults shared JDT LS to off and accepts only boolean values", () => {+ expect(DEFAULT_LANGUAGES.java.jdtlsShared).toBe(false);+ expect(validateLanguages({}).java.jdtlsShared).toBe(false);+ expect(validateSettings({ languages: { java: { jdtlsShared: true } } }).languages.java.jdtlsShared).toBe(true);+ expect(validateLanguages({ java: { jdtlsShared: false } }).java.jdtlsShared).toBe(false);+ for (const invalid of ["true", 1, null, []])+ expect(validateLanguages({ java: { jdtlsShared: invalid } }).java.jdtlsShared).toBe(false);+ });+it("defaults Java language level to SDK default and keeps only supported levels", () => {expect(validateLanguages({}).java.languageLevel).toBe("");expect(validateLanguages({ java: { languageLevel: "8" } }).java.languageLevel).toBe("8");diff --git a/src/features/settings/languages/LanguagePages.tsx b/src/features/settings/languages/LanguagePages.tsxindex e159ab2e5..7373aca86 100644--- a/src/features/settings/languages/LanguagePages.tsx+++ b/src/features/settings/languages/LanguagePages.tsx@@ -4,15 +4,16 @@* use (applied by `ide-sdk` when language servers start and when run configurations load).*/import { LanguageServerTargetRows, LanguageServerTargetsPage } from "./LanguageServerTarget";+import { useProject } from "@/platform/project";import { useRunTargets } from "@/platform/pluginRunTargets";import { tx } from "@/platform/i18n";import { useEffect, useId, useMemo, useState } from "react";-import { call, commands, type Sdk } from "@/platform/ipc";+import { call, commands, type LanguageServerTarget, type Sdk } from "@/platform/ipc";import { IconButton, Input, type SelectOption, T } from "@/ui";import { JAVA_LANGUAGE_LEVELS, PHP_LANGUAGE_LEVELS } from "@/platform/languageSettings";import { GlobListEditor, Row, Section, Select, Toggle } from "../components/Form";import { choosePath } from "./api";-import { useSetting } from "../components/context";+import { usePageContext, useSetting } from "../components/context";import { SdkField, tildify, useDetected } from "./components";import styles from "./Sdk.module.css";@@ -387,6 +388,11 @@ export const JAVA_LEVEL_OPTIONS: SelectOption[] = JAVA_LANGUAGE_LEVELS.map((leve);export function JavaPage() {+ const [shared, setShared] = useSetting<boolean>("languages.java.jdtlsShared");+ const [serverTargets] = useSetting<Record<string, LanguageServerTarget>>("languageServerTargets", "project");+ const { scope } = usePageContext();+ const workspace = useProject((s) => !!s.project?.workspace);+ const sharedDisabled = scope === "project" && (workspace || !!serverTargets?.java?.target);const [vmArgs, setVmArgs] = useSetting<string>("languages.java.jdtlsVmArgs");const [languageLevel, setLanguageLevel] = useSetting<string>("languages.java.languageLevel");const id = useId();@@ -417,6 +423,19 @@ export function JavaPage() {</Row></Section><Section title="Language Server">+ <Toggle+ label="Share JDT LS across builds"+ checked={shared}+ onChange={setShared}+ disabled={sharedDisabled}+ hint={+ sharedDisabled+ ? workspace+ ? "Shared JDT LS is available only in local ordinary project windows. Open a workspace member as a project to change this setting for it."+ : "Shared JDT LS is available only in local ordinary project windows. Select Local machine for the Java language server to use it."+ : "Uses one JDT LS process for linked builds in each local ordinary project window. Other project windows use separate processes."+ }+ /><SdkRowk="languages.java.jdtlsJdk"label="JDK"diff --git a/src/features/settings/pages/languages.tsx b/src/features/settings/pages/languages.tsxindex 0e1f43a91..e859e63fb 100644--- a/src/features/settings/pages/languages.tsx+++ b/src/features/settings/pages/languages.tsx@@ -132,6 +132,9 @@ export const LANGUAGE_PAGES: PageSpec[] = ["lombok","javaagent","eclipse jdt",+ "shared jdtls",+ "linked builds",+ "server process",],component: JavaPage,},diff --git a/src/platform/languageSettings.ts b/src/platform/languageSettings.tsindex 329683d8c..fc4d859b6 100644--- a/src/platform/languageSettings.ts+++ b/src/platform/languageSettings.ts@@ -164,6 +164,7 @@ export interface LanguagesValid {languageLevel: (typeof JAVA_LANGUAGE_LEVELS)[number];jdtlsJdk: string;jdtlsVmArgs: string;+ jdtlsShared: boolean;gradle: {linkedProjects: string[] | null;jvm: string;@@ -243,6 +244,7 @@ export const DEFAULT_LANGUAGES: LanguagesValid = {languageLevel: "",jdtlsJdk: "",jdtlsVmArgs: "",+ jdtlsShared: false,gradle: { linkedProjects: null, jvm: "", distribution: "wrapper", home: "", userHome: "", runUsing: "gradle" },maven: {runnerJre: "",@@ -401,6 +403,7 @@ export function validateLanguages(raw: unknown): LanguagesValid {languageLevel: oneOf(java.languageLevel, JAVA_LANGUAGE_LEVELS, d.java.languageLevel),jdtlsJdk: text(java.jdtlsJdk, d.java.jdtlsJdk),jdtlsVmArgs: text(java.jdtlsVmArgs, d.java.jdtlsVmArgs),+ jdtlsShared: bool(java.jdtlsShared, d.java.jdtlsShared),gradle: {linkedProjects: Array.isArray(gradle.linkedProjects)? gradle.linkedProjects.filter((p): p is string => typeof p === "string")diff --git a/src/platform/locales/text/en.json b/src/platform/locales/text/en.jsonindex 45e25142c..02b915f9f 100644--- a/src/platform/locales/text/en.json+++ b/src/platform/locales/text/en.json@@ -1,4 +1,8 @@{+ "Shared JDT LS is available only in local ordinary project windows. Select Local machine for the Java language server to use it.": "Shared JDT LS is available only in local ordinary project windows. Select Local machine for the Java language server to use it.",+ "Share JDT LS across builds": "Share JDT LS across builds",+ "Shared JDT LS is available only in local ordinary project windows. Open a workspace member as a project to change this setting for it.": "Shared JDT LS is available only in local ordinary project windows. Open a workspace member as a project to change this setting for it.",+ "Uses one JDT LS process for linked builds in each local ordinary project window. Other project windows use separate processes.": "Uses one JDT LS process for linked builds in each local ordinary project window. Other project windows use separate processes.","Finder": "Finder","Explorer": "Explorer","Files": "Files",diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.jsonindex e525f2eb6..069609a36 100644--- a/src/platform/locales/text/zh.json+++ b/src/platform/locales/text/zh.json@@ -1,4 +1,8 @@{+ "Shared JDT LS is available only in local ordinary project windows. Select Local machine for the Java language server to use it.": "共享 JDT LS 仅适用于本机的普通项目窗口。请将 Java 语言服务器的运行位置设为本机后再使用。",+ "Share JDT LS across builds": "在构建间共享 JDT LS",+ "Shared JDT LS is available only in local ordinary project windows. Open a workspace member as a project to change this setting for it.": "共享 JDT LS 仅适用于本机的普通项目窗口。请将工作区成员作为项目打开,再修改其此项设置。",+ "Uses one JDT LS process for linked builds in each local ordinary project window. Other project windows use separate processes.": "在每个本机普通项目窗口中,已关联的构建共用一个 JDT LS 进程。其他项目窗口使用各自独立的进程。","Finder": "访达","Explorer": "资源管理器","Reveal in Finder": "在访达中显示",