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
fix(java): build mixed-language Maven dependencies before Java launch (#659)
l0ng-ai0c54266d0398
diff --git a/crates/ide-build/src/compile/mod.rs b/crates/ide-build/src/compile/mod.rsindex 857912ada..b674e1adf 100644--- a/crates/ide-build/src/compile/mod.rs+++ b/crates/ide-build/src/compile/mod.rs@@ -237,12 +237,7 @@ fn maven_steps(root: &Path, model: &BuildModel, kind: BuildKind, module: Option<if !m.projects.iter().any(|p| p.dir == rel) {return Err(IdeError::not_found("no linked Maven project found for module"));}- let top = tops- .iter()- .filter(|t| t.dir.is_empty() || rel == t.dir || rel.starts_with(&format!("{}/", t.dir)))- .max_by_key(|t| t.dir.len())- .copied()- .unwrap_or(tops[0]);+ let top = maven_reactor(m, &rel).ok_or_else(|| IdeError::not_found("no linked Maven project found for module"))?;let top_dir = subdir(root, &top.dir);if module == top_dir {return Ok(vec![step(top, &[])]);@@ -611,6 +606,90 @@ pub fn has_non_java_sources(module: &Path) -> bool {walk(&module.join("src"), 12)}+fn reactor_projects<'a>(m: &'a maven::MavenModel, top: &'a maven::MavenProject) -> Vec<&'a maven::MavenProject> {+ let mut projects = Vec::new();+ let mut pending = vec![top];+ let mut seen = HashSet::new();+ while let Some(p) = pending.pop() {+ if !seen.insert(&p.pom) {+ continue;+ }+ projects.push(p);+ pending.extend(m.projects.iter().filter(|child| p.modules.contains(&child.pom)));+ }+ projects+}++fn maven_reactor<'a>(m: &'a maven::MavenModel, module: &str) -> Option<&'a maven::MavenProject> {+ m.projects.iter().filter(|p| !p.aggregated).find(|top| reactor_projects(m, top).iter().any(|p| p.dir == module))+}++/// Launch module first, followed by its upstream modules in the same Maven reactor.+/// External artifacts and unrelated linked reactors are never rebuilt for this launch.+fn maven_launch_projects<'a>(+ root: &Path,+ m: &'a maven::MavenModel,+ module: &Path,+ test: bool,+) -> Vec<&'a maven::MavenProject> {+ let rel = rel_str(root, module);+ let Some(top) = maven_reactor(m, &rel) else { return Vec::new() };+ let reactor = reactor_projects(m, top);+ let Some(start) = reactor.iter().find(|p| p.dir == rel) else { return Vec::new() };+ let mut pending = vec![*start];+ let mut seen = HashSet::new();+ let mut projects = Vec::new();+ while let Some(p) = pending.pop() {+ if !seen.insert(&p.pom) {+ continue;+ }+ projects.push(p);+ for dep in &p.dependencies {+ if !dep.resolved() || (dep.scope == "test" && (!test || p.pom != start.pom)) {+ continue;+ }+ if let Some(upstream) = reactor.iter().find(|u| {+ u.group_id == dep.group_id+ && u.artifact_id == dep.artifact_id+ && dep.version.as_ref().is_none_or(|v| *v == u.version)+ }) {+ pending.push(*upstream);+ }+ }+ }+ projects+}++/// Whether a launch requires the external JVM compiler. Maven includes upstream+/// reactor dependencies; adapter selection remains a separate, module-local decision.+pub fn launch_has_non_java_sources(root: &Path, model: &BuildModel, module: &Path, test: bool) -> bool {+ if let Some(m) = &model.maven {+ let projects = maven_launch_projects(root, m, module, test);+ if !projects.is_empty() {+ return projects.iter().any(|p| has_non_java_sources(&subdir(root, &p.dir)));+ }+ }+ has_non_java_sources(module)+}++fn launch_plan(root: &Path, model: &BuildModel, module: &Path, test: bool) -> IdeResult<BuildPlan> {+ let kind = if model.maven.as_ref().is_some_and(|m| m.projects.iter().any(|p| subdir(root, &p.dir) == module)) {+ // JDT may have left newer error stubs in Maven's output directories.+ BuildKind::Rebuild+ } else {+ BuildKind::Build+ };+ let mut plan = plan(root, model, kind, Some(module))?;+ if plan.system == BuildSystem::Maven && !test {+ for step in &mut plan.steps {+ if let Some(goal) = step.args.last_mut() {+ *goal = "compile".into();+ }+ }+ }+ Ok(plan)+}+/// Compiles the module at `module` with its build system before a JVM launch and/// returns the class directories it wrote, to put ahead of the jdtls classpath.pub fn build_for_launch(@@ -620,7 +699,7 @@ pub fn build_for_launch(test: bool,cancel: &CancellationToken,) -> IdeResult<Vec<PathBuf>> {- let plan = plan(root, model, BuildKind::Build, Some(module))?;+ let plan = launch_plan(root, model, module, test)?;let result = run(root, &plan, cancel, &|_| {})?;if !result.success {let errors: Vec<String> = result@@ -635,6 +714,14 @@ pub fn build_for_launch(.collect();return Err(IdeError::internal(format!("Build failed:\n{}", errors.join("\n"))));}+ if plan.system == BuildSystem::Maven+ && let Some(m) = &model.maven+ {+ return Ok(maven_launch_projects(root, m, module, test)+ .iter()+ .flat_map(|p| launch_class_dirs(plan.system, &subdir(root, &p.dir), test && subdir(root, &p.dir) == module))+ .collect());+ }Ok(launch_class_dirs(plan.system, module, test))}@@ -821,6 +908,142 @@ mod tests {}}+ fn reactor_model() -> BuildModel {+ let project = |dir: &str, deps: &[&str]| maven::MavenProject {+ pom: format!("{dir}/pom.xml"),+ dir: dir.into(),+ group_id: "probe".into(),+ artifact_id: dir.into(),+ version: "1".into(),+ aggregated: true,+ dependencies: deps+ .iter()+ .map(|d| maven::MavenDependency {+ group_id: "probe".into(),+ artifact_id: (*d).into(),+ version: Some("1".into()),+ scope: "compile".into(),+ ..Default::default()+ })+ .collect(),+ ..Default::default()+ };+ let mut projects = vec![+ project("app", &["middle"]),+ project("middle", &["lib"]),+ project("lib", &["app"]),+ project("unrelated", &[]),+ ];+ projects.insert(+ 0,+ maven::MavenProject {+ pom: "pom.xml".into(),+ artifact_id: "reactor".into(),+ command: "mvnw".into(),+ modules: projects.iter().map(|p| p.pom.clone()).collect(),+ options: vec!["-s".into(), "settings.xml".into()],+ env: BTreeMap::from([("JAVA_HOME".into(), "/jdk".into())]),+ ..Default::default()+ },+ );+ BuildModel { maven: Some(maven::MavenModel { projects, ..Default::default() }), ..Default::default() }+ }++ #[test]+ fn mixed_launch_detection_follows_only_reactor_dependencies() {+ for extension in ["kt", "groovy", "scala"] {+ let tmp = tempfile::tempdir().unwrap();+ let root = tmp.path();+ let mut model = reactor_model();+ write(root, "app/src/main/java/Application.java", "class Application {}");+ write(root, &format!("unrelated/src/main/java/Other.{extension}"), "");+ assert!(!launch_has_non_java_sources(root, &model, &root.join("app"), false));+ write(root, &format!("lib/src/main/java/Channel.{extension}"), "");+ assert!(launch_has_non_java_sources(root, &model, &root.join("app"), false));+ assert_eq!(+ maven_launch_projects(root, model.maven.as_ref().unwrap(), &root.join("app"), false).len(),+ 3,+ "cycles terminate"+ );+ let m = model.maven.as_mut().unwrap();+ m.projects[2].dependencies[0].scope = "test".into();+ assert!(+ !launch_has_non_java_sources(root, &model, &root.join("app"), true),+ "upstream test dependencies are not transitive"+ );+ let m = model.maven.as_mut().unwrap();+ m.projects[1].dependencies[0].scope = "test".into();+ m.projects[2].dependencies[0].scope = "compile".into();+ assert!(!launch_has_non_java_sources(root, &model, &root.join("app"), false));+ assert!(launch_has_non_java_sources(root, &model, &root.join("app"), true));+ model.maven.as_mut().unwrap().projects[2].dependencies[0].version = Some("external".into());+ assert!(!launch_has_non_java_sources(root, &model, &root.join("app"), true));+ model.maven.as_mut().unwrap().projects[2].dependencies[0].version = Some("1".into());+ model.maven.as_mut().unwrap().projects[3].aggregated = false;+ model.maven.as_mut().unwrap().projects[0].modules.retain(|p| p != "lib/pom.xml");+ assert!(+ !launch_has_non_java_sources(root, &model, &root.join("app"), true),+ "another linked reactor is external"+ );+ }+ }++ #[test]+ fn maven_launch_steps_use_reactor_settings_and_launch_scope() {+ let tmp = tempfile::tempdir().unwrap();+ let root = tmp.path();+ write(root, "app/pom.xml", "<project/>");+ let model = reactor_model();+ for (test, goal) in [(false, "compile"), (true, "test-compile")] {+ let plan = launch_plan(root, &model, &root.join("app"), test).unwrap();+ let step = &plan.steps[0];+ assert_eq!(step.cwd, root);+ assert_eq!(step.program, "mvnw");+ assert_eq!(step.env["JAVA_HOME"], "/jdk");+ assert_eq!(+ step.args,+ ["-B", "-Dstyle.color=never", "-s", "settings.xml", "-pl", "app", "-am", "clean", goal]+ );+ }+ }++ #[cfg(unix)]+ #[test]+ fn external_launch_returns_upstream_outputs_and_blocks_failure_or_cancellation() {+ use std::os::unix::fs::PermissionsExt;+ let tmp = tempfile::tempdir().unwrap();+ let root = tmp.path();+ write(root, "app/pom.xml", "<project/>");+ write(+ root,+ "mvnw",+ "#!/bin/sh\nmkdir -p app/target/classes middle/target/classes lib/target/classes app/target/test-classes\n",+ );+ let wrapper = root.join("mvnw");+ std::fs::set_permissions(&wrapper, std::fs::Permissions::from_mode(0o755)).unwrap();+ let mut model = reactor_model();+ model.maven.as_mut().unwrap().projects[0].command = wrapper.to_string_lossy().into_owned();+ let dirs = build_for_launch(root, &model, &root.join("app"), true, &CancellationToken::new()).unwrap();+ assert_eq!(+ dirs,+ ["app/target/test-classes", "app/target/classes", "middle/target/classes", "lib/target/classes"]+ .map(|p| root.join(p))+ );+ write(+ root,+ "mvnw",+ "#!/bin/sh\necho '[ERROR] Kotlin compilation failed: unresolved reference broken' >&2\nexit 1\n",+ );+ let error = build_for_launch(root, &model, &root.join("app"), false, &CancellationToken::new()).unwrap_err();+ assert!(error.message.contains("Kotlin compilation failed"), "{}", error.message);+ let cancel = CancellationToken::new();+ cancel.cancel();+ assert_eq!(+ build_for_launch(root, &model, &root.join("app"), false, &cancel).unwrap_err().kind,+ ide_core::error::ErrorKind::Cancelled+ );+ }+#[test]fn non_java_launch_class_dirs() {let tmp = tempfile::tempdir().unwrap();diff --git a/crates/ide-host/Cargo.toml b/crates/ide-host/Cargo.tomlindex 4518fa0ff..c63304344 100644--- a/crates/ide-host/Cargo.toml+++ b/crates/ide-host/Cargo.toml@@ -48,7 +48,7 @@ parking_lot.workspace = truedunce.workspace = truedirs.workspace = trueuuid.workspace = true+tempfile.workspace = true[dev-dependencies]tokio = { workspace = true, features = ["rt-multi-thread", "macros", "io-util", "test-util"] }-tempfile.workspace = truediff --git a/crates/ide-host/src/ops/java.rs b/crates/ide-host/src/ops/java.rsindex 4eccfb01f..6e334ca73 100644--- a/crates/ide-host/src/ops/java.rs+++ b/crates/ide-host/src/ops/java.rs@@ -5,7 +5,7 @@ use crate::rpc::Dispatcher;use super::build::load;use ide_build::compile;use ide_core::{CancellationToken, IdeError, IdeResult, RequestId};-use ide_lsp::jdtls::JavaLaunchInfo;+use ide_lsp::jdtls::{JavaBuildStatus, JavaLaunchInfo};use std::path::PathBuf;/// Cancellable with `cancel_request(request)`.@@ -39,23 +39,42 @@ async fn resolve_launch(let project = host.project(window)?;let module = project.root.join(module);let settings = project.settings.effective();- // Let jdtls finish its build before the external compiler writes Kotlin/Scala classes.- let mut info = project.lsp.java_launch(&module, test, build, cancel).await?;+ let (model, external, delegated) = {+ let project = project.clone();+ let settings = settings.clone();+ let module = module.clone();+ tokio::task::spawn_blocking(move || {+ let model = load(&project.root, &project.build_cache_dir(), &settings);+ let external = build && compile::launch_has_non_java_sources(&project.root, &model, &module, test);+ let delegated = external+ && model.maven.as_ref().is_some_and(|m| m.projects.iter().any(|p| project.root.join(&p.dir) == module));+ (model, external, delegated)+ })+ .await+ .map_err(|e| IdeError::internal(e.to_string()))?+ };+ let external_build = if delegated { Some(project.lsp.java_external_build(&module, cancel).await?) } else { None };+ let mut info = project.lsp.java_launch(&module, test, build && !delegated, cancel).await?;let lsp_ms = started.elapsed().as_millis();let data_dir = host.data_dir.clone();let cancel = cancel.clone();tokio::task::spawn_blocking(move || {- let built = if build && compile::has_non_java_sources(&module) {- compile::build_for_launch(- &project.root,- &load(&project.root, &project.build_cache_dir(), &settings),- &module,- test,- &cancel,- )?+ let _external_build = external_build;+ let built = if external {+ compile::build_for_launch(&project.root, &model, &module, test, &cancel)?} else {Vec::new()};+ let built = if delegated {+ let (snapshot, copies) = snapshot_outputs(&mut info, &built, &cancel)?;+ project.java_launch_outputs.lock().push(snapshot);+ info.build = Some(JavaBuildStatus::Succeeded);+ info.errors.clear();+ info.error_count = 0;+ copies+ } else {+ built+ };let mut class_paths: Vec<String> = built.iter().map(|p| p.to_string_lossy().into_owned()).collect();for p in std::mem::take(&mut info.class_paths) {if !class_paths.contains(&p) {@@ -103,6 +122,35 @@ async fn resolve_launch(.map_err(|e| IdeError::internal(e.to_string()))?}+fn snapshot_outputs(+ info: &mut JavaLaunchInfo,+ built: &[PathBuf],+ cancel: &CancellationToken,+) -> IdeResult<(tempfile::TempDir, Vec<PathBuf>)> {+ let snapshot = tempfile::Builder::new().prefix("openidea-java-launch-").tempdir()?;+ let mut copies = Vec::new();+ for (index, source) in built.iter().enumerate() {+ if cancel.is_cancelled() {+ return Err(IdeError::cancelled());+ }+ let dest = snapshot.path().join(index.to_string());+ ide_vfs::copy(source, &dest)?;+ let original = source.to_string_lossy();+ info.class_paths.retain(|p| p != original.as_ref());+ let mut modular = false;+ for path in &mut info.module_paths {+ if path == original.as_ref() {+ *path = dest.to_string_lossy().into_owned();+ modular = true;+ }+ }+ if !modular {+ copies.push(dest);+ }+ }+ Ok((snapshot, copies))+}+/// Port of java-debug's DAP server inside the jdtls serving `module` (started on demand).pub async fn java_debug_server(host: &Host, window: &str, module: PathBuf) -> IdeResult<u16> {host.require_trust(window)?;@@ -132,3 +180,43 @@ pub(crate) fn register(d: &mut Dispatcher) {d.add("java_debug_server", |c| async move { java_debug_server(&c.host, &c.window, c.arg("module")?).await });d.add("java_build_workspace", |c| async move { java_build_workspace(&c.host, &c.window, c.arg("module")?).await });}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn launch_snapshots_survive_jdt_overwrites_and_replace_module_outputs() {+ let root = tempfile::tempdir().unwrap();+ let app = root.path().join("app/target/classes");+ let lib = root.path().join("lib/target/classes");+ for dir in [&app, &lib] {+ std::fs::create_dir_all(dir).unwrap();+ std::fs::write(dir.join("Channel.class"), "Maven bytecode").unwrap();+ }+ let mut info = JavaLaunchInfo {+ class_paths: vec![app.to_string_lossy().into_owned(), "stdlib.jar".into()],+ module_paths: vec![lib.to_string_lossy().into_owned()],+ ..Default::default()+ };+ let (snapshot, paths) =+ snapshot_outputs(&mut info, &[app.clone(), lib.clone()], &CancellationToken::new()).unwrap();+ assert_eq!(paths, [snapshot.path().join("0")]);+ assert_eq!(info.class_paths, ["stdlib.jar"]);+ assert_eq!(info.module_paths, [snapshot.path().join("1").to_string_lossy().into_owned()]);+ std::fs::write(app.join("Channel.class"), "JDT error stub").unwrap();+ std::fs::remove_dir_all(lib).unwrap();+ for index in ["0", "1"] {+ assert_eq!(+ std::fs::read_to_string(snapshot.path().join(index).join("Channel.class")).unwrap(),+ "Maven bytecode"+ );+ }+ let cancel = CancellationToken::new();+ cancel.cancel();+ assert_eq!(+ snapshot_outputs(&mut info, &[app], &cancel).unwrap_err().kind,+ ide_core::error::ErrorKind::Cancelled+ );+ }+}diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rsindex 24cc4aa34..caf5afea0 100644--- a/crates/ide-host/src/project.rs+++ b/crates/ide-host/src/project.rs@@ -42,6 +42,8 @@ pub struct Project {pub detected_roots: Arc<RwLock<Vec<SourceFolder>>>,/// Per-project cache directory (build tool sync results…).pub cache_dir: PathBuf,+ /// Launch snapshots stay alive while any JVM of this project may load classes.+ pub(crate) java_launch_outputs: Mutex<Vec<tempfile::TempDir>>,/// Database tool window: data sources and their connections.pub db: Arc<ide_db::DbManager>,/// HTTP Client responses (IDEA's `.idea/httpRequests`), in the app data dir.@@ -366,6 +368,7 @@ impl Host {syntax,detected_roots,cache_dir: self.data_dir.join("cache").join(&project_key),+ java_launch_outputs: Mutex::new(Vec::new()),db,http_history,agents,@@ -481,6 +484,7 @@ impl Host {syntax,detected_roots: Arc::default(),cache_dir: self.data_dir.join("cache").join(&project_key),+ java_launch_outputs: Mutex::new(Vec::new()),db,http_history,agents,diff --git a/crates/ide-lsp/src/jdtls.rs b/crates/ide-lsp/src/jdtls.rsindex e66cafe63..09d6ed610 100644--- a/crates/ide-lsp/src/jdtls.rs+++ b/crates/ide-lsp/src/jdtls.rs@@ -189,6 +189,24 @@ pub struct JavaCompileError {pub message: String,}+/// Holds off JDT writers while an external compiler builds and snapshots launch outputs.+/// Restores current settings even when preparation fails or is cancelled.+pub struct JavaExternalBuild {+ server: Arc<Server>,+ run: Running,+ _lock: tokio::sync::OwnedMutexGuard<()>,+}++impl Drop for JavaExternalBuild {+ fn drop(&mut self) {+ self.server.java_autobuild_suspended.store(false, std::sync::atomic::Ordering::SeqCst);+ let settings = crate::handler::all_settings(&self.server.effective_config());+ if let Err(e) = self.run.peer.notify("workspace/didChangeConfiguration", json!({ "settings": settings })) {+ tracing::debug!("jdtls: restoring autobuild: {e}");+ }+ }+}+/// Error diagnostics sorted by file and position, capped at `limit`, and their total.pub fn compile_errors(diagnostics: Vec<(PathBuf, lsp_types::Diagnostic)>,@@ -433,9 +451,28 @@ impl LspManager {.map_err(|e| crate::rpc_err(&server.name, "java/projectConfigurationsUpdate", e))}+ /// Pause autobuild before resolving the launch classpath. That query takes the+ /// Java project's workspace scheduling rule, draining the interrupted autobuild.+ /// Keep this guard until Maven outputs have been copied out of JDT's reach.+ pub async fn java_external_build(&self, path: &Path, cancel: &CancellationToken) -> IdeResult<JavaExternalBuild> {+ let (server, run) = self.jdtls(path, cancel).await?;+ let lock = cancellable_wait(cancel, server.java_build_lock.clone().lock_owned()).await?;+ server.java_autobuild_suspended.store(true, std::sync::atomic::Ordering::SeqCst);+ let guard = JavaExternalBuild { server, run, _lock: lock };+ let settings = crate::handler::all_settings(&guard.server.effective_config());+ guard+ .run+ .peer+ .notify("workspace/didChangeConfiguration", json!({ "settings": settings }))+ .map_err(|e| crate::rpc_err(SERVER, "workspace/didChangeConfiguration", e))?;+ Ok(guard)+ }+/// Incremental build of the jdtls workspace (`java/buildWorkspace`), so/// class files are up to date before a launch.pub async fn java_build(&self, path: &Path, cancel: &CancellationToken) -> IdeResult<JavaBuildStatus> {+ let (server, _) = self.jdtls(path, cancel).await?;+ let _lock = cancellable_wait(cancel, server.java_build_lock.lock()).await?;let mut v = self.jdtls_request(path, "java/buildWorkspace", json!(false), BUILD_TIMEOUT, cancel).await?;// The first build can finish the Maven import before ServiceReady is handled.let (server, run) = self.jdtls(path, cancel).await?;diff --git a/crates/ide-lsp/src/server.rs b/crates/ide-lsp/src/server.rsindex 018c81ee0..81c21b021 100644--- a/crates/ide-lsp/src/server.rs+++ b/crates/ide-lsp/src/server.rs@@ -99,6 +99,8 @@ pub struct Server {/// Woken when the last `$/progress` task ends.idle_notify: Notify,transient: Mutex<HashMap<PathBuf, Transient>>,+ pub java_build_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,pub external_refresh_queued: std::sync::atomic::AtomicBool,@@ -126,6 +128,8 @@ impl Server {published_notify: Notify::new(),idle_notify: Notify::new(),transient: Mutex::new(HashMap::new()),+ java_build_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),external_refresh_queued: std::sync::atomic::AtomicBool::new(false),@@ -134,7 +138,13 @@ impl Server {/// Configuration of the current (or last) instance; the base config before the first launch.pub fn effective_config(&self) -> LanguageServerConfig {- self.effective.lock().clone().unwrap_or_else(|| self.config.clone())+ let mut config = self.effective.lock().clone().unwrap_or_else(|| self.config.clone());+ if self.java_autobuild_suspended.load(std::sync::atomic::Ordering::SeqCst) {+ let mut settings = crate::handler::all_settings(&config);+ settings["java"]["autobuild"]["enabled"] = serde_json::json!(false);+ config.settings = Some(settings);+ }+ config}pub fn set_effective_config(&self, config: LanguageServerConfig) {@@ -553,6 +563,19 @@ mod tests {assert_eq!(s.record_crash(), Some(Duration::from_millis(500)));}+ #[test]+ fn external_build_suspends_only_the_effective_autobuild_setting() {+ let mut config: LanguageServerConfig = toml::from_str("name = \"jdtls\"\ncommand = \"jdtls\"").unwrap();+ config.settings = Some(serde_json::json!({"java": {"autobuild": {"enabled": true}, "other": "kept"}}));+ let server = Server::new(config.clone(), PathBuf::from("/p"), LanguageId::new("java"));+ server.java_autobuild_suspended.store(true, std::sync::atomic::Ordering::SeqCst);+ let settings = crate::handler::all_settings(&server.effective_config());+ assert_eq!(settings["java"]["autobuild"]["enabled"], false);+ assert_eq!(settings["java"]["other"], "kept");+ server.java_autobuild_suspended.store(false, std::sync::atomic::Ordering::SeqCst);+ assert_eq!(server.effective_config(), config);+ }+#[tokio::test(flavor = "multi_thread")]async fn a_failed_start_reports_its_status_before_waiters_wake() {// The race behind "jdtls is not ready (Starting)": a request woken by the