Skip to content

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.

fix(java): run the language server on a JDK so the debugger can start (#815)

l0ng-ai3be40bd57c57
diff --git a/crates/ide-core/src/java_runtime.rs b/crates/ide-core/src/java_runtime.rs
new file mode 100644
index 000000000..83d1ee217
--- /dev/null
+++ b/crates/ide-core/src/java_runtime.rs
@@ -0,0 +1,25 @@
+//! Capabilities needed by the JVM hosting Java language-server bundles.
+
+use std::path::Path;
+
+/// jdtls' javac bundle, java-debug / hot code replace, and Lombok / Gradle tooling.
+const BUNDLE_MODULES: &[&str] = &["jdk.compiler", "jdk.jdi", "jdk.unsupported"];
+
+/// Require a full JDK, including the modules used by jdtls and its bundles.
+/// Temurin JREs can list the build JDK's modules in `release` even when the runtime
+/// image omits them, so module metadata alone does not establish suitability.
+pub fn supports_java_bundles(home: &Path) -> bool {
+ let Ok(release) = std::fs::read_to_string(home.join("release")) else { return false };
+ let property =
+ |key: &str| release.lines().find_map(|line| line.trim().strip_prefix(key)).map(|v| v.trim().trim_matches('"'));
+ let javac = if cfg!(windows) { "javac.exe" } else { "javac" };
+ if property("IMAGE_TYPE=").is_some_and(|image| image.eq_ignore_ascii_case("jre"))
+ || !home.join("bin").join(javac).is_file()
+ {
+ return false;
+ }
+ match property("MODULES=") {
+ Some(modules) => BUNDLE_MODULES.iter().all(|required| modules.split_whitespace().any(|m| m == *required)),
+ None => BUNDLE_MODULES.iter().all(|m| home.join("jmods").join(format!("{m}.jmod")).is_file()),
+ }
+}
diff --git a/crates/ide-core/src/lib.rs b/crates/ide-core/src/lib.rs
index fcb39a1f2..023f9d729 100644
--- a/crates/ide-core/src/lib.rs
+++ b/crates/ide-core/src/lib.rs
@@ -11,6 +11,7 @@ pub mod ids;
pub mod ignored;
pub mod inspection_settings;
pub mod ipc_path;
+pub mod java_runtime;
pub mod jsonc;
pub mod output_encoding;
pub mod process;
diff --git a/crates/ide-sdk/src/apply.rs b/crates/ide-sdk/src/apply.rs
index a397529c2..8f60fa5d3 100644
--- a/crates/ide-sdk/src/apply.rs
+++ b/crates/ide-sdk/src/apply.rs
@@ -88,6 +88,9 @@ pub fn project_jdk(root: &Path, s: &Settings) -> Option<crate::java::Jdk> {
pub fn jdtls_jdk(root: &Path, s: &Settings) -> Result<Option<crate::java::Jdk>, String> {
match jdk_setting(root, &s.languages.java.jdtls_jdk) {
None => Ok(None),
+ Some(Ok(jdk)) if !ide_core::java_runtime::supports_java_bundles(&jdk.home) => {
+ Err(crate::java::server_jdk_incomplete_message(&jdk, jdk.major.max(crate::java::JDTLS_MIN_JAVA)))
+ }
Some(Ok(jdk)) => Ok(Some(jdk)),
Some(Err(p)) => Err(format!(
"The language server JDK {} is not a JDK home (Settings › Languages & Frameworks › Java).",
diff --git a/crates/ide-sdk/src/java.rs b/crates/ide-sdk/src/java.rs
index 814ccf7db..23835c3d9 100644
--- a/crates/ide-sdk/src/java.rs
+++ b/crates/ide-sdk/src/java.rs
@@ -16,6 +16,13 @@ pub struct Jdk {
pub home: PathBuf,
}
+pub(crate) fn server_jdk_incomplete_message(jdk: &Jdk, min_java: u32) -> String {
+ format!(
+ "The language server JDK ({}) must be a full JDK with jdk.compiler, jdk.jdi and jdk.unsupported for Java language support and debugging. jdtls needs JDK {min_java} or newer. Download JDK {min_java}, choose a full JDK in {SERVER_JDK_SETTING}, or set it to Auto.",
+ jdk.home.display()
+ )
+}
+
/// `JAVA_VERSION="21.0.3"` (or `"1.8.0_372"`) from a JDK's `release` file.
pub fn parse_release(release: &str) -> Option<u32> {
let line = release.lines().find_map(|l| l.trim().strip_prefix("JAVA_VERSION="))?;
@@ -199,7 +206,7 @@ pub const JDTLS_MIN_JAVA: u32 = 21;
/// The JDK to run jdtls with: the first found that is new enough (`JAVA_HOME` wins).
pub fn jdtls_runtime(jdks: &[Jdk], min_java: u32) -> Option<&Jdk> {
- jdks.iter().find(|j| j.major >= min_java)
+ jdks.iter().find(|j| j.major >= min_java && ide_core::java_runtime::supports_java_bundles(&j.home))
}
/// The Java version the jdtls that `cfg` launches needs: the highest any of its
@@ -421,6 +428,9 @@ pub fn configure_jdtls(
if !cfg.env.contains_key("JAVA_HOME") {
let runtime = match server_jdk {
Some(jdk) if jdk.major < min_java => Err(server_jdk_too_old_message(jdk, min_java)),
+ Some(jdk) if !ide_core::java_runtime::supports_java_bundles(&jdk.home) => {
+ Err(server_jdk_incomplete_message(jdk, min_java))
+ }
Some(jdk) => Ok(jdk),
None => jdtls_runtime(jdks, min_java).ok_or_else(|| missing_runtime_message(jdks, min_java)),
};
@@ -430,6 +440,10 @@ pub fn configure_jdtls(
}
Err(e) => cfg.launch_error = Some(e),
}
+ } else if let Some(jdk) = cfg.env.get("JAVA_HOME").and_then(|home| jdk_at(Path::new(home)))
+ && !ide_core::java_runtime::supports_java_bundles(&jdk.home)
+ {
+ cfg.launch_error = Some(server_jdk_incomplete_message(&jdk, min_java));
}
let mut runtimes = runtimes(&project_jdks);
if let Some(project) = project_jdk.or_else(|| pick_jdk(&project_jdks, project_java_version(server_root))) {
@@ -573,6 +587,19 @@ fn parse_java_version(v: &str) -> Option<u32> {
mod tests {
use super::*;
+ fn test_jdk(root: &Path, major: u32, name: &str) -> Jdk {
+ let home = root.join(name.trim_start_matches('/'));
+ std::fs::create_dir_all(home.join("bin")).unwrap();
+ std::fs::write(
+ home.join("release"),
+ format!("JAVA_VERSION=\"{major}\"\nMODULES=\"java.base jdk.compiler jdk.jdi jdk.unsupported\"\n"),
+ )
+ .unwrap();
+ std::fs::write(java_executable(&home), "").unwrap();
+ std::fs::write(home.join("bin").join(crate::exe("javac")), "").unwrap();
+ Jdk { major, home }
+ }
+
#[test]
fn unmanaged_source_models_have_separate_jdtls_workspaces() {
let data = tempfile::tempdir().unwrap();
@@ -599,8 +626,13 @@ mod tests {
let project_root = data.path().join("tools/jdks");
let project_home = project_root.join("temurin-21");
std::fs::create_dir_all(project_home.join("bin")).unwrap();
- std::fs::write(project_home.join("release"), "JAVA_VERSION=\"21.0.1\"\n").unwrap();
+ std::fs::write(
+ project_home.join("release"),
+ "JAVA_VERSION=\"21.0.1\"\nMODULES=\"java.base jdk.compiler jdk.jdi jdk.unsupported\"\n",
+ )
+ .unwrap();
std::fs::write(java_executable(&project_home), "").unwrap();
+ std::fs::write(project_home.join("bin").join(crate::exe("javac")), "").unwrap();
let project = jdk_at(&project_home).unwrap();
let discover = || jdk_homes(&project_root).filter_map(|home| jdk_at(&home)).collect::<Vec<_>>();
let installed = discover();
@@ -608,8 +640,13 @@ mod tests {
assert!(jdtls_runtime(&runtime_candidates(&installed, data.path()), 25).is_none());
let home = language_server_runtimes_dir(data.path()).join("temurin-25");
std::fs::create_dir_all(home.join("bin")).unwrap();
- std::fs::write(home.join("release"), "JAVA_VERSION=\"25.0.1\"\n").unwrap();
+ std::fs::write(
+ home.join("release"),
+ "JAVA_VERSION=\"25.0.1\"\nMODULES=\"java.base jdk.compiler jdk.jdi jdk.unsupported\"\n",
+ )
+ .unwrap();
std::fs::write(java_executable(&home), "").unwrap();
+ std::fs::write(home.join("bin").join(crate::exe("javac")), "").unwrap();
let candidates = runtime_candidates(&installed, data.path());
assert_eq!(jdtls_runtime(&candidates, 25).unwrap().major, 25);
assert_eq!(jdtls_runtime(&candidates, 21), Some(&project));
@@ -628,11 +665,47 @@ mod tests {
);
}
+ #[test]
+ fn jdtls_rejects_jre_for_auto_explicit_and_managed_runtimes() {
+ let tmp = tempfile::tempdir().unwrap();
+ let jre = test_jdk(tmp.path(), 25, "jre");
+ std::fs::write(jre.home.join("release"), "JAVA_VERSION=\"25\"\nMODULES=\"java.base java.compiler\"\n").unwrap();
+ let jdk = test_jdk(tmp.path(), 25, "jdk");
+ let installed = [jre.clone(), jdk.clone()];
+ assert_eq!(jdtls_runtime(&installed, 25), Some(&jdk));
+ assert!(jdtls_runtime(std::slice::from_ref(&jre), 25).is_none());
+ let managed = language_server_runtimes_dir(tmp.path()).join("temurin-25");
+ std::fs::create_dir_all(managed.parent().unwrap()).unwrap();
+ std::fs::rename(&jre.home, &managed).unwrap();
+ assert!(jdtls_runtime(&runtime_candidates(&[], tmp.path()), 25).is_none());
+ let jre = jdk_at(&managed).unwrap();
+ for env_override in [false, true] {
+ let mut cfg: LanguageServerConfig = toml::from_str("name = 'jdtls'\ncommand = 'jdtls'").unwrap();
+ if env_override {
+ cfg.env.insert("JAVA_HOME".into(), jre.home.to_string_lossy().into_owned());
+ }
+ configure_jdtls(&mut cfg, tmp.path(), tmp.path(), &installed[1..], None, Some(&jre), 25, &[], None);
+ let err = cfg.launch_error.unwrap();
+ assert!(
+ err.contains("full JDK with jdk.compiler, jdk.jdi and jdk.unsupported")
+ && err.contains("Download JDK 25")
+ && err.contains(SERVER_JDK_SETTING),
+ "{err}"
+ );
+ }
+ std::fs::write(
+ managed.join("release"),
+ "JAVA_VERSION=\"25\"\nMODULES=\"java.base jdk.compiler jdk.jdi jdk.unsupported\"\n",
+ )
+ .unwrap();
+ assert!(jdtls_runtime(&runtime_candidates(&[], tmp.path()), 25).is_some());
+ }
+
#[test]
fn implicit_compiler_default_matches_project_pick_with_duplicate_versions() {
- let installed =
- [Jdk { major: 21, home: PathBuf::from("/jdk21a") }, Jdk { major: 21, home: PathBuf::from("/jdk21b") }];
- let server = Jdk { major: 25, home: PathBuf::from("/custom-server-runtime") };
+ let fixtures = tempfile::tempdir().unwrap();
+ let installed = [test_jdk(fixtures.path(), 21, "/jdk21a"), test_jdk(fixtures.path(), 21, "/jdk21b")];
+ let server = test_jdk(fixtures.path(), 25, "/custom-server-runtime");
let mut cfg: LanguageServerConfig = toml::from_str("name = 'jdtls'\ncommand = 'jdtls'").unwrap();
configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &installed, None, Some(&server), 25, &[], None);
let opts = serde_json::to_value(cfg.initialization_options.unwrap()).unwrap();
@@ -642,7 +715,7 @@ mod tests {
"name": "JavaSE-21", "path": pick_jdk(&installed, None).unwrap().home, "default": true
}])
);
- assert_eq!(cfg.env["JAVA_HOME"], "/custom-server-runtime");
+ assert_eq!(cfg.env["JAVA_HOME"], fixtures.path().join("custom-server-runtime").to_string_lossy());
}
#[test]
@@ -655,15 +728,16 @@ mod tests {
#[test]
fn jdtls_workspace_and_runtimes() {
+ let fixtures = tempfile::tempdir().unwrap();
if cfg!(windows) {
return; // Unix paths and shells
}
let mut cfg: LanguageServerConfig = toml::from_str("name = \"jdtls\"\ncommand = \"jdtls\"").unwrap();
let jdks = [
- Jdk { major: 25, home: PathBuf::from("/jdk25") },
- Jdk { major: 21, home: PathBuf::from("/jdk21a") },
- Jdk { major: 21, home: PathBuf::from("/jdk21b") },
- Jdk { major: 8, home: PathBuf::from("/jdk8") },
+ test_jdk(fixtures.path(), 25, "/jdk25"),
+ test_jdk(fixtures.path(), 21, "/jdk21a"),
+ test_jdk(fixtures.path(), 21, "/jdk21b"),
+ test_jdk(fixtures.path(), 8, "/jdk8"),
];
let bundles = [PathBuf::from("/tools/java-debug/bin/com.microsoft.java.debug.plugin.jar")];
configure_jdtls(
@@ -690,11 +764,15 @@ mod tests {
);
let opts = serde_json::to_value(cfg.initialization_options.clone().unwrap()).unwrap();
let rt = &opts["settings"]["java"]["configuration"]["runtimes"];
- assert_eq!(rt[0], json!({ "name": "JavaSE-1.8", "path": "/jdk8" }));
- assert_eq!(rt[1], json!({ "name": "JavaSE-21", "path": "/jdk21a" }));
- assert_eq!(rt[2], json!({ "name": "JavaSE-25", "path": "/jdk25", "default": true }));
+ assert_eq!(rt[0], json!({ "name": "JavaSE-1.8", "path": fixtures.path().join("jdk8") }));
+ assert_eq!(rt[1], json!({ "name": "JavaSE-21", "path": fixtures.path().join("jdk21a") }));
+ assert_eq!(rt[2], json!({ "name": "JavaSE-25", "path": fixtures.path().join("jdk25"), "default": true }));
assert_eq!(opts["bundles"], json!(["/tools/java-debug/bin/com.microsoft.java.debug.plugin.jar"]));
- assert_eq!(cfg.env["JAVA_HOME"], "/jdk25", "first JDK new enough to run jdtls");
+ assert_eq!(
+ cfg.env["JAVA_HOME"],
+ fixtures.path().join("jdk25").to_string_lossy(),
+ "first JDK new enough to run jdtls"
+ );
assert_eq!(cfg.launch_error, None);
// Deterministic (reconfigure compares configs) and idempotent.
@@ -713,7 +791,7 @@ mod tests {
assert_eq!(cfg, before);
// The project JDK is the default runtime, and runs the server when new enough.
- let project = Jdk { major: 21, home: PathBuf::from("/jdk21b") };
+ let project = test_jdk(fixtures.path(), 21, "/jdk21b");
let mut cfg: LanguageServerConfig = toml::from_str("name = \"jdtls\"\ncommand = \"jdtls\"").unwrap();
configure_jdtls(
&mut cfg,
@@ -728,8 +806,8 @@ mod tests {
);
let opts = serde_json::to_value(cfg.initialization_options.clone().unwrap()).unwrap();
let rt = &opts["settings"]["java"]["configuration"]["runtimes"];
- assert_eq!(rt[1], json!({ "name": "JavaSE-21", "path": "/jdk21b", "default": true }));
- assert_eq!(cfg.env["JAVA_HOME"], "/jdk21b");
+ assert_eq!(rt[1], json!({ "name": "JavaSE-21", "path": fixtures.path().join("jdk21b"), "default": true }));
+ assert_eq!(cfg.env["JAVA_HOME"], fixtures.path().join("jdk21b").to_string_lossy());
let mut other: LanguageServerConfig = toml::from_str("name = \"pyright\"\ncommand = \"x\"").unwrap();
configure_jdtls(
@@ -836,8 +914,9 @@ mod tests {
#[test]
fn jdtls_needs_a_new_enough_jdk_to_run() {
+ let fixtures = tempfile::tempdir().unwrap();
let jdtls = || -> LanguageServerConfig { toml::from_str("name = \"jdtls\"\ncommand = \"jdtls\"").unwrap() };
- let old = [Jdk { major: 17, home: PathBuf::from("/jdk17") }, Jdk { major: 8, home: PathBuf::from("/jdk8") }];
+ let old = [test_jdk(fixtures.path(), 17, "/jdk17"), test_jdk(fixtures.path(), 8, "/jdk8")];
let mut cfg = jdtls();
configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &old, None, None, JDTLS_MIN_JAVA, &[], None);
assert!(!cfg.env.contains_key("JAVA_HOME"));
@@ -856,7 +935,7 @@ mod tests {
configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &old, None, None, JDTLS_MIN_JAVA, &[], None);
assert_eq!((cfg.env["JAVA_HOME"].as_str(), cfg.launch_error), ("/custom", None));
- let mixed = [old[0].clone(), Jdk { major: 21, home: PathBuf::from("/jdk21") }];
+ let mixed = [old[0].clone(), test_jdk(fixtures.path(), 21, "/jdk21")];
assert_eq!(jdtls_runtime(&mixed, 21).unwrap().major, 21);
// A jdtls whose bundles need 25 doesn't start on 21, and says what it needs.
@@ -869,11 +948,12 @@ mod tests {
#[test]
fn issue_49_jdtls_needs_25_with_8_17_21_installed() {
+ let fixtures = tempfile::tempdir().unwrap();
let jdtls = || -> LanguageServerConfig { toml::from_str("name = \"jdtls\"\ncommand = \"jdtls\"").unwrap() };
let installed = [
- Jdk { major: 21, home: PathBuf::from("/jdk21") },
- Jdk { major: 17, home: PathBuf::from("/jdk17") },
- Jdk { major: 8, home: PathBuf::from("/jdk8") },
+ test_jdk(fixtures.path(), 21, "/jdk21"),
+ test_jdk(fixtures.path(), 17, "/jdk17"),
+ test_jdk(fixtures.path(), 8, "/jdk8"),
];
let mut cfg = jdtls();
configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &installed, None, None, 25, &[], None);
@@ -882,12 +962,11 @@ mod tests {
assert!(err.contains("Download JDK 25"), "{err}");
// Once a JDK 25 has been downloaded, Auto runs jdtls on it.
- let downloaded =
- [installed.as_slice(), &[Jdk { major: 25, home: PathBuf::from("/tools/jdks/temurin-25") }]].concat();
+ let downloaded = [installed.as_slice(), &[test_jdk(fixtures.path(), 25, "/tools/jdks/temurin-25")]].concat();
let mut cfg = jdtls();
configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &downloaded, None, None, 25, &[], None);
assert_eq!(cfg.launch_error, None);
- assert_eq!(cfg.env["JAVA_HOME"], Path::new("/tools/jdks/temurin-25").to_string_lossy());
+ assert_eq!(cfg.env["JAVA_HOME"], fixtures.path().join("tools/jdks/temurin-25").to_string_lossy());
}
#[test]
@@ -924,8 +1003,9 @@ mod tests {
#[test]
fn jdtls_runs_on_the_chosen_server_jdk() {
+ let fixtures = tempfile::tempdir().unwrap();
let jdtls = || -> LanguageServerConfig { toml::from_str("name = \"jdtls\"\ncommand = \"jdtls\"").unwrap() };
- let jdk = |major: u32, home: &str| Jdk { major, home: PathBuf::from(home) };
+ let jdk = |major: u32, home: &str| test_jdk(fixtures.path(), major, home);
let installed = [jdk(25, "/jdk25"), jdk(21, "/jdk21"), jdk(17, "/jdk17")];
let project = jdk(17, "/jdk17");
let run = |server: Option<&Jdk>, min_java: u32| {
@@ -946,18 +1026,25 @@ mod tests {
// Project on JDK 17, server on the chosen 21: each keeps its own JDK.
let cfg = run(Some(&jdk(21, "/jdk21")), JDTLS_MIN_JAVA);
- assert_eq!((cfg.env["JAVA_HOME"].as_str(), cfg.launch_error), ("/jdk21", None));
+ assert_eq!(
+ (cfg.env["JAVA_HOME"].clone(), cfg.launch_error),
+ (fixtures.path().join("jdk21").to_string_lossy().into_owned(), None)
+ );
let opts = serde_json::to_value(cfg.initialization_options.unwrap()).unwrap();
let rt = &opts["settings"]["java"]["configuration"]["runtimes"];
- assert_eq!(rt[0], json!({ "name": "JavaSE-17", "path": "/jdk17", "default": true }), "still compiles on 17");
+ assert_eq!(
+ rt[0],
+ json!({ "name": "JavaSE-17", "path": fixtures.path().join("jdk17"), "default": true }),
+ "still compiles on 17"
+ );
// Not set: the first installed JDK new enough, as before.
- assert_eq!(run(None, JDTLS_MIN_JAVA).env["JAVA_HOME"], "/jdk25");
+ assert_eq!(run(None, JDTLS_MIN_JAVA).env["JAVA_HOME"], fixtures.path().join("jdk25").to_string_lossy());
// A chosen JDK outside the scanned locations.
let own = jdk(25, "/opt/own-jdk");
let cfg = run(Some(&own), 25);
- assert_eq!(cfg.env["JAVA_HOME"], "/opt/own-jdk");
+ assert_eq!(cfg.env["JAVA_HOME"], fixtures.path().join("opt/own-jdk").to_string_lossy());
// Too old for this jdtls: the user's choice is not overridden, it is explained.
let cfg = run(Some(&jdk(21, "/jdk21")), 25);
diff --git a/crates/ide-sdk/src/jdtls.rs b/crates/ide-sdk/src/jdtls.rs
index f9ee72399..75520eed7 100644
--- a/crates/ide-sdk/src/jdtls.rs
+++ b/crates/ide-sdk/src/jdtls.rs
@@ -249,6 +249,10 @@ pub fn launch_directly(cfg: &mut LanguageServerConfig) {
}),
};
let Some((java, jdk)) = jdk.filter(|(java, _)| java.is_file()) else { return };
+ if !ide_core::java_runtime::supports_java_bundles(&jdk.home) {
+ cfg.launch_error = Some(crate::java::server_jdk_incomplete_message(&jdk, crate::java::jdtls_min_java(cfg)));
+ return;
+ }
cfg.args = java_args(&install, jdk.major, &cfg.args);
cfg.command = java.to_string_lossy().into_owned();
}
@@ -465,7 +469,12 @@ mod tests {
std::fs::set_permissions(&script, std::os::unix::fs::PermissionsExt::from_mode(0o755)).unwrap();
let jdk = dir.path().join("jdk-25");
std::fs::create_dir_all(jdk.join("bin")).unwrap();
- std::fs::write(jdk.join("release"), "JAVA_VERSION=\"25.0.1\"\n").unwrap();
+ std::fs::write(
+ jdk.join("release"),
+ "JAVA_VERSION=\"25.0.1\"\nMODULES=\"java.base jdk.compiler jdk.jdi jdk.unsupported\"\n",
+ )
+ .unwrap();
+ std::fs::write(jdk.join("bin/javac"), "").unwrap();
std::fs::write(jdk.join("bin/java"), "").unwrap();
let cfg = |command: &str| -> LanguageServerConfig {
@@ -486,6 +495,15 @@ mod tests {
assert!(direct.args[jar + 1].ends_with("org.eclipse.equinox.launcher_1.7.0.jar"));
assert_eq!(direct.args[jar + 2..], strings(&["-data", "/ws"]));
+ let jre = dir.path().join("jre-25");
+ std::fs::create_dir_all(jre.join("bin")).unwrap();
+ std::fs::write(jre.join("bin/java"), "").unwrap();
+ std::fs::write(jre.join("release"), "JAVA_VERSION=\"25\"\nIMAGE_TYPE=\"JRE\"\n").unwrap();
+ let mut overridden = cfg("jdtls");
+ overridden.args.push(format!("--java-executable={}", jre.join("bin/java").display()));
+ launch_directly(&mut overridden);
+ assert!(overridden.launch_error.unwrap().contains("jdk.jdi"));
+
// Someone's own wrapper, or no usable JDK: the command is kept.
std::fs::write(home.join("bin/my-jdtls"), "#!/bin/sh\n").unwrap();
std::fs::set_permissions(home.join("bin/my-jdtls"), std::os::unix::fs::PermissionsExt::from_mode(0o755))
diff --git a/crates/ide-sdk/src/tests.rs b/crates/ide-sdk/src/tests.rs
index 37adca8be..5f3ed5a0a 100644
--- a/crates/ide-sdk/src/tests.rs
+++ b/crates/ide-sdk/src/tests.rs
@@ -166,7 +166,12 @@ fn run_configs_use_selected_interpreter_and_package_manager() {
fn fake_jdk(dir: &Path) {
std::fs::create_dir_all(dir.join("bin")).unwrap();
std::fs::write(dir.join("bin").join(exe("java")), "").unwrap();
- std::fs::write(dir.join("release"), "JAVA_VERSION=\"17.0.9\"\n").unwrap();
+ std::fs::write(
+ dir.join("release"),
+ "JAVA_VERSION=\"17.0.9\"\nMODULES=\"java.base jdk.compiler jdk.jdi jdk.unsupported\"\n",
+ )
+ .unwrap();
+ std::fs::write(dir.join("bin").join(crate::exe("javac")), "").unwrap();
}
#[test]
@@ -307,6 +312,12 @@ fn jdtls_jdk_setting() {
assert_eq!(jdtls_jdk(tmp.path(), &s), Ok(None));
s.languages.java.jdtls_jdk = "jdk17/bin".into();
assert_eq!(jdtls_jdk(tmp.path(), &s).unwrap().map(|j| j.major), Some(17));
+ std::fs::write(
+ tmp.path().join("jdk17/release"),
+ "JAVA_VERSION=\"25\"\nIMAGE_TYPE=\"JRE\"\nMODULES=\"java.base jdk.compiler jdk.jdi jdk.unsupported\"\n",
+ )
+ .unwrap();
+ assert!(jdtls_jdk(tmp.path(), &s).unwrap_err().contains("full JDK"));
// A chosen path that is not a JDK is an error, not a silent fallback.
s.languages.java.jdtls_jdk = "missing".into();
assert!(jdtls_jdk(tmp.path(), &s).unwrap_err().contains("is not a JDK home"));
diff --git a/crates/ide-tools/src/jdk.rs b/crates/ide-tools/src/jdk.rs
index a96ff2924..b8264ec7f 100644
--- a/crates/ide-tools/src/jdk.rs
+++ b/crates/ide-tools/src/jdk.rs
@@ -108,26 +108,7 @@ fn adoptium_arch(arch: Arch) -> &'static str {
/// The latest Temurin JDK build of Java `feature` for `platform`.
pub fn adoptium_assets_url(feature: u32, platform: Platform) -> String {
- assets_url(feature, platform, ImageType::Jdk)
-}
-
-#[derive(Clone, Copy)]
-enum ImageType {
- Jdk,
- Jre,
-}
-
-impl ImageType {
- fn name(self) -> &'static str {
- match self {
- Self::Jdk => "jdk",
- Self::Jre => "jre",
- }
- }
-}
-
-fn assets_url(feature: u32, platform: Platform, image: ImageType) -> String {
- let image = image.name();
+ let image = "jdk";
format!(
"{ADOPTIUM_API}/assets/latest/{feature}/hotspot?architecture={}&image_type={image}&os={}&vendor=eclipse",
adoptium_arch(platform.arch),
@@ -190,16 +171,12 @@ impl AssetVersion {
/// The JDK archive (`.tar.gz` on macOS / Linux, `.zip` on Windows) in an Adoptium
/// `assets/latest` response; `None` when there is no build for the platform.
pub fn adoptium_pick(json: &str, platform: Platform) -> IdeResult<Option<(Download, u32)>> {
- pick_image(json, platform, ImageType::Jdk)
-}
-
-fn pick_image(json: &str, platform: Platform, image: ImageType) -> IdeResult<Option<(Download, u32)>> {
let assets: Vec<Asset> =
serde_json::from_str(json).map_err(|e| proto(format!("unexpected Adoptium response: {e}")))?;
let ext = if platform.os == Os::Windows { ".zip" } else { ".tar.gz" };
let os = adoptium_os(platform.os);
let found = assets.into_iter().find(|a| {
- a.binary.image_type.as_deref().is_none_or(|t| t == image.name())
+ a.binary.image_type.as_deref().is_none_or(|t| t == "jdk")
&& a.binary.heap_size.as_deref().is_none_or(|h| h == "normal")
&& a.binary.os.as_deref().is_none_or(|o| o == os)
&& a.binary.package.name.ends_with(ext)
@@ -249,6 +226,10 @@ pub fn find_jdk_home(dir: &Path, platform: Platform) -> Option<PathBuf> {
subdirs.iter().flat_map(|d| candidates(d)).find(|h| is_jdk_home(h, platform))
}
+fn usable_java_home(dir: &Path, platform: Platform, runtime: bool) -> Option<PathBuf> {
+ find_jdk_home(dir, platform).filter(|home| !runtime || ide_core::java_runtime::supports_java_bundles(home))
+}
+
/// The directory to move into place: the archive's single top-level folder
/// holding the JDK, else everything that was unpacked.
fn unpacked_root(pkg: &Path, home: &Path) -> PathBuf {
@@ -283,8 +264,8 @@ impl Tools {
self.download_java(vendor, feature, location, false, cancel, emit)
}
- /// Downloads a runtime for a language server, preferring a JRE. Only a
- /// platform without a JRE build falls back to a full JDK.
+ /// Downloads a full JDK for a language server and its bundles (java-debug
+ /// needs `jdk.jdi`). Kept outside project JDK discovery roots.
pub fn download_java_runtime(
&self,
feature: u32,
@@ -310,19 +291,8 @@ impl Tools {
let http = self.http()?;
let location = location.map(Path::to_path_buf).unwrap_or_else(|| self.root.join("jdks"));
emit(InstallEvent::Line { text: format!("Resolving the latest Eclipse Temurin {feature}…") });
- let mut picked = if runtime {
- pick_image(
- &http.get_text_or_empty_on_404(&assets_url(feature, self.platform, ImageType::Jre), cancel)?,
- self.platform,
- ImageType::Jre,
- )?
- } else {
- None
- };
- if picked.is_none() {
- picked =
- adoptium_pick(&http.get_text(&adoptium_assets_url(feature, self.platform), cancel)?, self.platform)?;
- }
+ let mut picked =
+ adoptium_pick(&http.get_text(&adoptium_assets_url(feature, self.platform), cancel)?, self.platform)?;
if picked.is_none() && matches!(self.platform.os, Os::Mac | Os::Windows) && self.platform.arch == Arch::Arm64 {
// Older JDKs may need the OS-provided x64 emulation.
let intel = Platform { os: self.platform.os, arch: Arch::X64 };
@@ -336,7 +306,7 @@ impl Tools {
})?;
let target = location.join(jdk_dir_name(vendor, &dl.version));
let done = |home: PathBuf| DownloadedJdk { home: home.into(), version: dl.version.clone(), major };
- if let Some(home) = find_jdk_home(&target, self.platform) {
+ if let Some(home) = usable_java_home(&target, self.platform, runtime) {
emit(InstallEvent::Line { text: format!("{} is already installed", target.display()) });
return Ok(done(home));
}
@@ -351,7 +321,7 @@ impl Tools {
emit(InstallEvent::Line { text: "Extracting…".into() });
let pkg = staging.join("pkg");
archive::extract(&archive, archive::ArchiveKind::from_name(&dl.name), &pkg, "java", cancel)?;
- let home = find_jdk_home(&pkg, self.platform)
+ let home = usable_java_home(&pkg, self.platform, runtime)
.ok_or_else(|| IdeError::new(ErrorKind::Io, format!("no JDK found in {}", dl.name)))?;
// Last point to stop: from here the JDK replaces what is at `target`.
if cancel.is_cancelled() {
@@ -362,7 +332,7 @@ impl Tools {
}
std::fs::rename(unpacked_root(&pkg, &home), &target)?;
clear_quarantine(&target);
- find_jdk_home(&target, self.platform)
+ usable_java_home(&target, self.platform, runtime)
.ok_or_else(|| IdeError::new(ErrorKind::Io, format!("no JDK found in {}", target.display())))
})();
let _ = std::fs::remove_dir_all(&staging);
@@ -437,18 +407,56 @@ mod tests {
}
#[test]
- fn runtime_assets_use_jre_without_changing_jdk_downloads() {
+ fn runtime_assets_require_jdk_images() {
for platform in [MAC_ARM, LINUX_X64, WIN_X64] {
- assert!(assets_url(25, platform, ImageType::Jre).contains("image_type=jre"));
assert!(adoptium_assets_url(25, platform).contains("image_type=jdk"));
let ext = if platform.os == Os::Windows { "zip" } else { "tar.gz" };
let jdk = asset(&format!("java.{ext}"), adoptium_os(platform.os), "normal", "");
let jre = jdk.replace("\"image_type\":\"jdk\"", "\"image_type\":\"jre\"");
- assert!(pick_image(&format!("[{jre}]"), platform, ImageType::Jre).unwrap().is_some());
+ assert!(adoptium_pick(&format!("[{jre},{jdk}]"), platform).unwrap().is_some());
assert!(adoptium_pick(&format!("[{jre}]"), platform).unwrap().is_none());
- assert!(pick_image(&format!("[{jdk}]"), platform, ImageType::Jre).unwrap().is_none());
- assert!(pick_image("[]", platform, ImageType::Jre).unwrap().is_none());
- assert!(pick_image("offline", platform, ImageType::Jre).is_err());
+ }
+ }
+
+ #[test]
+ fn stale_runtime_is_replaced_even_at_the_same_version() {
+ for platform in [MAC_ARM, LINUX_X64, WIN_X64] {
+ let tmp = tempfile::tempdir().unwrap();
+ let target = tmp.path().join(jdk_dir_name(TEMURIN, "25.0.1"));
+ let home = if platform.os == Os::Mac { target.join("Contents/Home") } else { target.clone() };
+ fake_jdk(&home, platform);
+ let javac = home.join("bin").join(if cfg!(windows) { "javac.exe" } else { "javac" });
+ std::fs::write(&javac, "").unwrap();
+ for modules in [None, Some("java.base java.compiler jdk.jdix"), Some("java.base jdk.jdi.agent")] {
+ let line = modules.map(|m| format!("MODULES=\"{m}\"\n")).unwrap_or_default();
+ std::fs::write(home.join("release"), format!("JAVA_VERSION=\"25.0.1\"\n{line}")).unwrap();
+ assert!(usable_java_home(&target, platform, true).is_none(), "{modules:?}");
+ assert_eq!(usable_java_home(&target, platform, false), Some(home.clone()));
+ }
+ std::fs::write(
+ home.join("release"),
+ "JAVA_VERSION=\"25.0.1\"\nMODULES=\"java.base jdk.compiler jdk.jdi jdk.unsupported\"\n",
+ )
+ .unwrap();
+ assert_eq!(usable_java_home(&target, platform, true), Some(home.clone()));
+ std::fs::write(home.join("release"), "JAVA_VERSION=\"25.0.1\"\n").unwrap();
+ std::fs::create_dir_all(home.join("jmods")).unwrap();
+ for module in ["jdk.compiler", "jdk.jdi", "jdk.unsupported"] {
+ std::fs::write(home.join("jmods").join(format!("{module}.jmod")), "").unwrap();
+ }
+ assert_eq!(usable_java_home(&target, platform, true), Some(home.clone()));
+ std::fs::write(
+ home.join("release"),
+ "IMAGE_TYPE=\"JRE\"\nMODULES=\"java.base jdk.compiler jdk.jdi jdk.unsupported\"\n",
+ )
+ .unwrap();
+ assert!(usable_java_home(&target, platform, true).is_none(), "Temurin JRE release can list absent modules");
+ std::fs::write(home.join("release"), "MODULES=\"java.base jdk.compiler jdk.jdi jdk.unsupported\"\n")
+ .unwrap();
+ std::fs::remove_file(javac).unwrap();
+ assert!(usable_java_home(&target, platform, true).is_none(), "custom runtime without compiler");
+ std::fs::write(home.join("release"), "MODULES=\"java.base\"\n").unwrap();
+ assert!(usable_java_home(&target, platform, true).is_none(), "release describes the runtime image");
}
}
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index 844d50811..f12eafbdc 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -1,4 +1,5 @@
{
+ "The language server JDK ({path}) must be a full JDK with jdk.compiler, jdk.jdi and jdk.unsupported for Java language support and debugging. jdtls needs JDK {version} or newer. Download JDK {version}, choose a full JDK in {setting}, or set it to Auto.": "语言服务器 JDK({path})必须是包含 jdk.compiler、jdk.jdi 和 jdk.unsupported 的完整 JDK,才能支持 Java 语言功能和调试。jdtls 需要 JDK {version} 或更高版本。请下载 JDK {version},在 {setting} 中选择完整 JDK,或设为自动。",
"Apple's clangd does not run clang-tidy, so checks from .clang-tidy are not shown. Install clangd (LLVM) to get them.": "Apple 的 clangd 不运行 clang-tidy,因此不会显示 .clang-tidy 中配置的检查。请安装 clangd(LLVM)以启用这些检查。",
"Newer dependency version available": "有更新的依赖版本可用",
"Reports newer crate versions that Cargo.toml requirements do not already allow.": "报告 Cargo.toml 版本要求尚未允许的较新 crate 版本。",