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): Run jdtls with a Lombok agent and show build errors at launch (#9)
l0ng-aiacf693101785
diff --git a/crates/ide-core/src/settings.rs b/crates/ide-core/src/settings.rsindex e78c87356..38dece8b1 100644--- a/crates/ide-core/src/settings.rs+++ b/crates/ide-core/src/settings.rs@@ -335,6 +335,7 @@ pub struct LanguagesSettings {pub rust: RustSettings,pub go: GoSettings,pub typescript: TypeScriptSettings,+ pub java: JavaSettings,}#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]@@ -397,6 +398,14 @@ pub struct GoSettings {pub gopath: String,}+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]+#[serde(default, rename_all = "camelCase")]+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,+}+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]#[serde(default, rename_all = "camelCase")]pub struct TypeScriptSettings {diff --git a/crates/ide-lsp/src/jdtls.rs b/crates/ide-lsp/src/jdtls.rsindex 8b861964a..a3821b131 100644--- a/crates/ide-lsp/src/jdtls.rs+++ b/crates/ide-lsp/src/jdtls.rs@@ -24,6 +24,10 @@ const BUILD_TIMEOUT: Duration = Duration::from_secs(300);const COMMAND_TIMEOUT: Duration = Duration::from_secs(120);/// How long to retry while the project is still being imported.const IMPORT_WAIT: Duration = Duration::from_secs(90);+/// Compile errors listed with a launch; the rest are only counted.+const MAX_LAUNCH_ERRORS: usize = 10;+/// Build markers can be published just after `java/buildWorkspace` answers.+const ERRORS_WAIT: Duration = Duration::from_secs(2);/// Result of `java/buildWorkspace` (jdtls `BuildWorkspaceStatus`).#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]@@ -70,6 +74,43 @@ pub struct JavaLaunchInfo {pub java_home: Option<ide_core::IpcPath>,/// The `java` launcher to use (filled in by the caller from the installed JDKs).pub java_exec: Option<String>,+ /// First compile errors of the workspace when the build had errors.+ pub errors: Vec<JavaCompileError>,+ /// All compile errors (`errors` is capped).+ pub error_count: u32,+ /// Likely causes of the errors worth telling the user (e.g. a missing Lombok agent).+ pub hints: Vec<String>,+}++/// One error diagnostic; `line` / `column` are 1-based for display.+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]+#[serde(rename_all = "camelCase")]+pub struct JavaCompileError {+ pub path: ide_core::IpcPath,+ pub line: u32,+ pub column: u32,+ pub message: String,+}++/// Error diagnostics sorted by file and position, capped at `limit`, and their total.+pub fn compile_errors(+ diagnostics: Vec<(PathBuf, lsp_types::Diagnostic)>,+ limit: usize,+) -> (Vec<JavaCompileError>, u32) {+ let mut errors: Vec<JavaCompileError> = diagnostics+ .into_iter()+ .filter(|(_, d)| d.severity == Some(lsp_types::DiagnosticSeverity::ERROR))+ .map(|(path, d)| JavaCompileError {+ path: path.into(),+ line: d.range.start.line + 1,+ column: d.range.start.character + 1,+ message: d.message.lines().next().unwrap_or_default().to_owned(),+ })+ .collect();+ errors.sort_by(|a, b| (&a.path, a.line, a.column).cmp(&(&b.path, b.line, b.column)));+ let count = u32::try_from(errors.len()).unwrap_or(u32::MAX);+ errors.truncate(limit);+ (errors, count)}/// `java.project.getClasspaths` result.@@ -210,6 +251,10 @@ impl LspManager {/// Builds (when asked), then resolves the classpath and JDK of the module at `module`.pub async fn java_launch(&self, module: &Path, test: bool, build: bool) -> IdeResult<JavaLaunchInfo> {let build = if build { Some(self.java_build(module).await?) } else { None };+ let (errors, error_count) = match build {+ Some(JavaBuildStatus::WithErrors | JavaBuildStatus::Failed) => self.java_compile_errors(module).await,+ _ => (Vec::new(), 0),+ };let cp = self.java_classpath(module, test).await?;let java_home = match self.java_vm_location(module).await {Ok(home) => home,@@ -225,9 +270,24 @@ impl LspManager {module_paths: cp.module_paths,java_home: java_home.map(Into::into),java_exec: None,+ errors,+ error_count,+ hints: Vec::new(),})}+ /// Compile errors jdtls reports for its workspace (all modules it imported).+ async fn java_compile_errors(&self, module: &Path) -> (Vec<JavaCompileError>, u32) {+ let Ok((server, _)) = self.jdtls(module).await else { return (Vec::new(), 0) };+ let collect = || compile_errors(server.diagnostics_snapshot(), MAX_LAUNCH_ERRORS);+ let found = collect();+ if found.1 > 0 {+ return found;+ }+ let _ = tokio::time::timeout(ERRORS_WAIT, server.published_notify.notified()).await;+ collect()+ }+/// Starts (or reuses) java-debug's DAP server inside jdtls and returns its port.pub async fn java_debug_server(&self, path: &Path) -> IdeResult<u16> {let v = self.jdtls_command(path, "vscode.java.startDebugSession", Vec::new()).await.map_err(|e| {@@ -256,6 +316,28 @@ impl LspManager {mod tests {use super::*;+ #[test]+ fn launch_errors_are_sorted_and_capped() {+ let diag = |line: u32, severity, message: &str| lsp_types::Diagnostic {+ range: lsp_types::Range::new(lsp_types::Position::new(line, 4), lsp_types::Position::new(line, 9)),+ severity: Some(severity),+ message: message.into(),+ ..Default::default()+ };+ let (errors, count) = compile_errors(+ vec![+ (PathBuf::from("/p/B.java"), diag(1, lsp_types::DiagnosticSeverity::ERROR, "b")),+ (PathBuf::from("/p/A.java"), diag(9, lsp_types::DiagnosticSeverity::ERROR, "a2\nmore")),+ (PathBuf::from("/p/A.java"), diag(2, lsp_types::DiagnosticSeverity::WARNING, "warning")),+ (PathBuf::from("/p/A.java"), diag(3, lsp_types::DiagnosticSeverity::ERROR, "a1")),+ ],+ 2,+ );+ assert_eq!(count, 3);+ let shown: Vec<(u32, u32, &str)> = errors.iter().map(|e| (e.line, e.column, e.message.as_str())).collect();+ assert_eq!(shown, [(4, 5, "a1"), (10, 5, "a2")]);+ }+#[test]fn classpaths() {let v = json!({diff --git a/crates/ide-lsp/src/server.rs b/crates/ide-lsp/src/server.rsindex 96b82e58c..4568ca442 100644--- a/crates/ide-lsp/src/server.rs+++ b/crates/ide-lsp/src/server.rs@@ -330,6 +330,12 @@ impl Server {self.diagnostics.lock().get(path).cloned().unwrap_or_default()}+ /// Every published diagnostic, by file.+ pub fn diagnostics_snapshot(&self) -> Vec<(PathBuf, lsp::Diagnostic)> {+ let d = self.diagnostics.lock();+ d.iter().flat_map(|(p, items)| items.iter().map(move |i| (p.clone(), i.clone()))).collect()+ }+pub fn take_diagnostic_paths(&self) -> Vec<PathBuf> {self.published.lock().clear();self.diagnostics.lock().drain().map(|(p, _)| p).collect()diff --git a/crates/ide-sdk/src/apply.rs b/crates/ide-sdk/src/apply.rsindex 47bbe4369..50957d344 100644--- a/crates/ide-sdk/src/apply.rs+++ b/crates/ide-sdk/src/apply.rs@@ -166,6 +166,12 @@ pub fn configure_server(cfg: &mut LanguageServerConfig, root: &Path, server_root}}+ if name == "jdtls" {+ // The jdtls launcher forwards `--jvm-arg=` values to the JVM it starts.+ let args = s.languages.java.jdtls_vm_args.split_whitespace().map(|a| format!("--jvm-arg={a}"));+ cfg.args.extend(args);+ }+if let Some(lib) = tsdk(server_root, s).or_else(|| tsdk(root, s)) {let lib_s = lib.to_string_lossy().into_owned();match name {diff --git a/crates/ide-sdk/src/java.rs b/crates/ide-sdk/src/java.rsindex c21c6eebe..6a38e7d03 100644--- a/crates/ide-sdk/src/java.rs+++ b/crates/ide-sdk/src/java.rs@@ -266,12 +266,22 @@ pub fn configure_jdtls(jdks: &[Jdk],min_java: u32,bundles: &[PathBuf],+ lombok: Option<&Path>,) {if cfg.name != "jdtls" {return;}+ // A Lombok agent from the user's JVM arguments wins.+ let own_agent = crate::lombok::agent_in_args(cfg.args.iter().map(String::as_str));+ let agent = own_agent.as_deref().or(lombok);if !cfg.args.iter().any(|a| a == "-data") {- let dir = data_dir.join("lsp").join("jdtls").join(path_key(server_root));+ // ECJ builds incrementally: classes compiled without (or with another) Lombok+ // agent would be kept, so each agent gets its own workspace and a full build.+ let key = match agent {+ Some(jar) => format!("{}-{}", path_key(server_root), path_key(jar)),+ None => path_key(server_root),+ };+ let dir = data_dir.join("lsp").join("jdtls").join(key);cfg.args.extend(["-data".to_owned(), dir.to_string_lossy().into_owned()]);}// jdtls reads this one as a system property (its file-system bundle@@ -279,6 +289,11 @@ pub fn configure_jdtls(if !cfg.args.iter().any(|a| a.contains(METADATA_PROPERTY)) {cfg.args.push(format!("--jvm-arg=-D{METADATA_PROPERTY}=false"));}+ if own_agent.is_none()+ && let Some(jar) = lombok+ {+ cfg.args.push(format!("--jvm-arg=-javaagent:{}", jar.to_string_lossy()));+ }if !cfg.env.contains_key("JAVA_HOME") {match jdtls_runtime(jdks, min_java) {Some(jdk) => {@@ -369,7 +384,7 @@ pub fn project_java_version(module_dir: &Path) -> Option<u32> {None}-fn xml_value(text: &str, tag: &str) -> Option<String> {+pub(crate) fn xml_value(text: &str, tag: &str) -> Option<String> {let open = format!("<{tag}>");let start = text.find(&open)? + open.len();let end = text[start..].find('<')?;@@ -409,7 +424,7 @@ mod tests {Jdk { major: 8, home: PathBuf::from("/jdk8") },];let bundles = [PathBuf::from("/tools/java-debug/bin/com.microsoft.java.debug.plugin.jar")];- configure_jdtls(&mut cfg, Path::new("/p/demo"), Path::new("/data"), &jdks, JDTLS_MIN_JAVA, &bundles);+ configure_jdtls(&mut cfg, Path::new("/p/demo"), Path::new("/data"), &jdks, JDTLS_MIN_JAVA, &bundles, None);assert_eq!(cfg.args[0], "-data");assert!(cfg.args[1].starts_with("/data/lsp/jdtls/"), "{}", cfg.args[1]);assert_eq!(cfg.args[2], "--jvm-arg=-Djava.import.generatesMetadataFilesAtProjectRoot=false");@@ -424,32 +439,57 @@ mod tests {// Deterministic (reconfigure compares configs) and idempotent.let before = cfg.clone();- configure_jdtls(&mut cfg, Path::new("/p/demo"), Path::new("/data"), &jdks, JDTLS_MIN_JAVA, &bundles);+ configure_jdtls(&mut cfg, Path::new("/p/demo"), Path::new("/data"), &jdks, JDTLS_MIN_JAVA, &bundles, None);assert_eq!(cfg, before);let mut other: LanguageServerConfig = toml::from_str("name = \"pyright\"\ncommand = \"x\"").unwrap();- configure_jdtls(&mut other, Path::new("/p"), Path::new("/data"), &jdks, JDTLS_MIN_JAVA, &bundles);+ configure_jdtls(&mut other, Path::new("/p"), Path::new("/data"), &jdks, JDTLS_MIN_JAVA, &bundles, None);assert!(other.args.is_empty() && other.initialization_options.is_none());}+ #[test]+ fn jdtls_lombok_agent() {+ let jdtls = || -> LanguageServerConfig { toml::from_str("name = \"jdtls\"\ncommand = \"jdtls\"").unwrap() };+ let jar = Path::new("/m2/lombok-1.18.48.jar");+ let mut cfg = jdtls();+ configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &[], JDTLS_MIN_JAVA, &[], Some(jar));+ let agent = format!("--jvm-arg=-javaagent:{}", jar.to_string_lossy());+ assert!(cfg.args.contains(&agent), "{:?}", cfg.args);+ let mut plain = jdtls();+ configure_jdtls(&mut plain, Path::new("/p"), Path::new("/data"), &[], JDTLS_MIN_JAVA, &[], None);+ assert_ne!(cfg.args[1], plain.args[1], "a separate workspace, so everything is rebuilt with the agent");+ let before = cfg.clone();+ configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &[], JDTLS_MIN_JAVA, &[], Some(jar));+ assert_eq!(cfg, before, "idempotent");++ let mut cfg = jdtls();+ cfg.args.push("--jvm-arg=-javaagent:/own/lombok.jar".into());+ configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &[], JDTLS_MIN_JAVA, &[], Some(jar));+ assert!(!cfg.args.contains(&agent), "the user's agent wins");+ let mut own = jdtls();+ own.args.push("--jvm-arg=-javaagent:/own/lombok.jar".into());+ configure_jdtls(&mut own, Path::new("/p"), Path::new("/data"), &[], JDTLS_MIN_JAVA, &[], None);+ assert_eq!(cfg.args, own.args, "its workspace follows the agent in use");+ }+#[test]fn jdtls_needs_a_new_enough_jdk_to_run() {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 mut cfg = jdtls();- configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &old, JDTLS_MIN_JAVA, &[]);+ configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &old, JDTLS_MIN_JAVA, &[], None);assert!(!cfg.env.contains_key("JAVA_HOME"));let err = cfg.launch_error.unwrap();assert!(err.contains("JDK 21 or newer") && err.contains("found JDK 8, 17"), "{err}");let mut cfg = jdtls();- configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &[], JDTLS_MIN_JAVA, &[]);+ configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &[], JDTLS_MIN_JAVA, &[], None);assert!(cfg.launch_error.unwrap().contains("no JDK was found"));// An explicit JAVA_HOME is the user's call.let mut cfg = jdtls();cfg.env.insert("JAVA_HOME".into(), "/custom".into());- configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &old, JDTLS_MIN_JAVA, &[]);+ configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &old, 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") }];@@ -457,7 +497,7 @@ mod tests {// A jdtls whose bundles need 25 doesn't start on 21, and says what it needs.let mut cfg = jdtls();- configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &mixed, 25, &[]);+ configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &mixed, 25, &[], None);let err = cfg.launch_error.unwrap();assert!(err.contains("JDK 25 or newer") && err.contains("found JDK 17, 21"), "{err}");}diff --git a/crates/ide-sdk/src/lib.rs b/crates/ide-sdk/src/lib.rsindex 48485aae6..faa821f50 100644--- a/crates/ide-sdk/src/lib.rs+++ b/crates/ide-sdk/src/lib.rs@@ -10,6 +10,7 @@ mod discover;mod exec;pub mod java;pub mod locate;+pub mod lombok;pub mod python;use serde::{Deserialize, Serialize};diff --git a/crates/ide-sdk/src/lombok.rs b/crates/ide-sdk/src/lombok.rsnew file mode 100644index 000000000..e812e3cd4--- /dev/null+++ b/crates/ide-sdk/src/lombok.rs@@ -0,0 +1,272 @@+//! Lombok for jdtls: ECJ only generates Lombok members when the language+//! server's JVM runs `-javaagent:lombok.jar`, so a project using Lombok gets the+//! newest jar available, managed (installed by the IDE) or in the Maven / Gradle caches.++use crate::home_dir;+use std::path::{Path, PathBuf};++/// Oldest Lombok whose ECJ handlers work in current jdtls builds (Eclipse 2024-06 support);+/// older ones throw `NoSuchMethodError` and drop every annotation of the compilation unit.+pub const LOMBOK_MIN: [u32; 3] = [1, 18, 34];++/// What a jdtls instance gets for Lombok.+#[derive(Clone, Debug, PartialEq, Eq)]+pub enum LombokAgent {+ /// The project doesn't use Lombok.+ Unused,+ /// The project uses Lombok but no jar was found.+ Missing,+ Found {+ jar: PathBuf,+ /// `None` for the managed jar (the latest release when installed).+ version: Option<String>,+ },+}++impl LombokAgent {+ pub fn jar(&self) -> Option<&Path> {+ match self {+ Self::Found { jar, .. } => Some(jar),+ _ => None,+ }+ }++ /// Too old for current jdtls.+ pub fn outdated(&self) -> bool {+ matches!(self, Self::Found { version: Some(v), .. } if parse_version(v).is_some_and(|v| v < LOMBOK_MIN))+ }++ /// Why Lombok-generated members may be missing, if they may be.+ pub fn problem(&self) -> Option<String> {+ const INSTALL: &str =+ "Install Lombok in Settings › Languages & Frameworks › Language Servers (jdtls restarts with it)";+ match self {+ Self::Missing => Some(format!(+ "The project uses Lombok, but no lombok.jar was found for the Java language server, so Lombok-generated \+ members are missing. {INSTALL}."+ )),+ Self::Found { version: Some(v), .. } if self.outdated() => Some(format!(+ "Lombok {v} is too old for the Java language server (needs {}.{}.{} or newer): classes using it may \+ miss generated members. {INSTALL}.",+ LOMBOK_MIN[0], LOMBOK_MIN[1], LOMBOK_MIN[2]+ )),+ _ => None,+ }+ }+}++/// The Lombok jar of a `-javaagent:` among JVM arguments (bare or as `--jvm-arg=`).+pub fn agent_in_args<'a>(args: impl IntoIterator<Item = &'a str>) -> Option<PathBuf> {+ args.into_iter().find_map(|a| {+ let jar = a.split_once("-javaagent:")?.1;+ jar.to_ascii_lowercase().contains("lombok").then(|| PathBuf::from(jar))+ })+}++/// The Lombok agent for the project at `root`: the user's own (`own`, from the JVM+/// options) wins, then `managed` (the IDE-installed jar), then the build caches.+pub fn lombok_agent(root: &Path, own: Option<PathBuf>, managed: Option<PathBuf>) -> LombokAgent {+ if let Some(jar) = own {+ let version = jar+ .file_stem()+ .and_then(|s| s.to_str()?.strip_prefix("lombok-"))+ .filter(|v| parse_version(v).is_some())+ .map(str::to_owned);+ return LombokAgent::Found { jar, version };+ }+ if !uses_lombok(root) {+ return LombokAgent::Unused;+ }+ if let Some(jar) = managed {+ return LombokAgent::Found { jar, version: None };+ }+ let home = home_dir();+ let mut dirs = Vec::new();+ if let Some(repo) = maven_repository(home.as_deref()) {+ dirs.push(repo.join("org").join("projectlombok").join("lombok"));+ }+ if let Some(gradle) =+ std::env::var_os("GRADLE_USER_HOME").map(PathBuf::from).or_else(|| home.map(|h| h.join(".gradle")))+ {+ dirs.push(gradle.join("caches").join("modules-2").join("files-2.1").join("org.projectlombok").join("lombok"));+ }+ match newest_cached(&dirs) {+ Some((version, jar)) => LombokAgent::Found { jar, version: Some(version) },+ None => LombokAgent::Missing,+ }+}++/// Build files under `root` (a few levels, for multi-module builds) mentioning Lombok.+pub fn uses_lombok(root: &Path) -> bool {+ const FILES: [&str; 4] = ["pom.xml", "build.gradle", "build.gradle.kts", "libs.versions.toml"];+ const SKIP: [&str; 7] = ["target", "build", "node_modules", "out", "bin", "src", ".gradle"];+ fn walk(dir: &Path, depth: usize) -> bool {+ if dir.join("lombok.config").is_file() {+ return true;+ }+ let Ok(entries) = std::fs::read_dir(dir) else { return false };+ let mut subdirs = Vec::new();+ for e in entries.flatten() {+ let name = e.file_name();+ let name = name.to_string_lossy();+ let Ok(ty) = e.file_type() else { continue };+ if ty.is_dir() {+ if depth > 0 && !name.starts_with('.') && !SKIP.contains(&name.as_ref()) {+ subdirs.push(e.path());+ }+ } else if FILES.contains(&name.as_ref())+ && std::fs::read_to_string(e.path()).is_ok_and(|t| t.contains("lombok"))+ {+ return true;+ }+ }+ subdirs.iter().any(|d| walk(d, depth - 1))+ }+ // `gradle/libs.versions.toml` sits one level down, modules usually no deeper than three.+ walk(root, 3)+}++/// `<localRepository>` of `~/.m2/settings.xml`, else `~/.m2/repository`.+fn maven_repository(home: Option<&Path>) -> Option<PathBuf> {+ let m2 = home?.join(".m2");+ let custom = std::fs::read_to_string(m2.join("settings.xml"))+ .ok()+ .and_then(|s| crate::java::xml_value(&strip_xml_comments(&s), "localRepository"))+ .filter(|v| !v.is_empty() && !v.contains("${"))+ .map(PathBuf::from);+ Some(custom.unwrap_or_else(|| m2.join("repository")))+}++fn strip_xml_comments(text: &str) -> String {+ let mut out = String::with_capacity(text.len());+ let mut rest = text;+ while let Some(i) = rest.find("<!--") {+ out.push_str(&rest[..i]);+ rest = rest[i..].find("-->").map_or("", |j| &rest[i + j + 3..]);+ }+ out.push_str(rest);+ out+}++/// Highest release `<dir>/<version>/…/lombok-<version>.jar` (Maven: directly in+/// the version directory; Gradle: one hash directory below it).+fn newest_cached(dirs: &[PathBuf]) -> Option<(String, PathBuf)> {+ let mut best: Option<([u32; 3], String, PathBuf)> = None;+ for dir in dirs {+ let Ok(entries) = std::fs::read_dir(dir) else { continue };+ for e in entries.flatten() {+ let version = e.file_name().to_string_lossy().into_owned();+ let Some(parsed) = parse_version(&version) else { continue };+ if best.as_ref().is_some_and(|(b, ..)| *b >= parsed) {+ continue;+ }+ let name = format!("lombok-{version}.jar");+ let direct = e.path().join(&name);+ let jar = if direct.is_file() {+ Some(direct)+ } else {+ std::fs::read_dir(e.path())+ .into_iter()+ .flatten()+ .flatten()+ .map(|h| h.path().join(&name))+ .find(|p| p.is_file())+ };+ if let Some(jar) = jar {+ best = Some((parsed, version, jar));+ }+ }+ }+ best.map(|(_, v, jar)| (v, jar))+}++/// `1.18.34` → `[1, 18, 34]`; snapshots and other qualifiers don't count as releases.+fn parse_version(v: &str) -> Option<[u32; 3]> {+ let mut parts = v.split('.').map(|p| p.parse::<u32>().ok());+ let out = [parts.next()??, parts.next()??, parts.next().unwrap_or(Some(0))?];+ parts.next().is_none().then_some(out)+}++#[cfg(test)]+mod tests {+ use super::*;+ use std::fs;++ #[test]+ fn detects_lombok_in_build_files() {+ let tmp = tempfile::tempdir().unwrap();+ let root = tmp.path();+ fs::write(root.join("pom.xml"), "<project><modules><module>api</module></modules></project>").unwrap();+ assert!(!uses_lombok(root));+ fs::create_dir_all(root.join("api/src/main")).unwrap();+ fs::write(root.join("api/src/main/pom.xml"), "<artifactId>lombok</artifactId>").unwrap();+ assert!(!uses_lombok(root), "sources are not scanned");+ fs::write(root.join("api/pom.xml"), "<artifactId>lombok</artifactId>").unwrap();+ assert!(uses_lombok(root));++ let gradle = tempfile::tempdir().unwrap();+ fs::create_dir_all(gradle.path().join("gradle")).unwrap();+ fs::write(gradle.path().join("gradle/libs.versions.toml"), "lombok = \"org.projectlombok:lombok:1.18.30\"")+ .unwrap();+ assert!(uses_lombok(gradle.path()));+ }++ #[test]+ fn picks_the_newest_cached_release() {+ let tmp = tempfile::tempdir().unwrap();+ let m2 = tmp.path().join("m2");+ let gradle = tmp.path().join("gradle");+ for v in ["1.18.26", "1.18.36", "1.18.99-SNAPSHOT"] {+ fs::create_dir_all(m2.join(v)).unwrap();+ fs::write(m2.join(v).join(format!("lombok-{v}.jar")), b"PK").unwrap();+ }+ fs::create_dir_all(m2.join("1.18.40")).unwrap(); // only a .pom: not usable+ fs::create_dir_all(gradle.join("1.18.38/abc123")).unwrap();+ fs::write(gradle.join("1.18.38/abc123/lombok-1.18.38.jar"), b"PK").unwrap();+ let (v, jar) = newest_cached(&[m2.clone(), gradle.clone()]).unwrap();+ assert_eq!(v, "1.18.38");+ assert_eq!(jar, gradle.join("1.18.38/abc123/lombok-1.18.38.jar"));+ assert_eq!(newest_cached(std::slice::from_ref(&m2)).unwrap().0, "1.18.36");+ assert_eq!(newest_cached(&[tmp.path().join("none")]), None);+ }++ #[test]+ fn old_versions_are_reported() {+ let found = |v: Option<&str>| LombokAgent::Found { jar: "/l.jar".into(), version: v.map(Into::into) };+ assert!(found(Some("1.18.26")).outdated());+ assert!(found(Some("1.18.26")).problem().unwrap().contains("1.18.26 is too old"));+ assert!(!found(Some("1.18.34")).outdated());+ assert_eq!(found(None).problem(), None);+ assert!(LombokAgent::Missing.problem().is_some());+ assert_eq!(LombokAgent::Unused.problem(), None);+ assert_eq!(parse_version("1.18"), Some([1, 18, 0]));+ assert_eq!(parse_version("edge-SNAPSHOT"), None);+ }++ #[test]+ fn the_users_agent_wins() {+ let tmp = tempfile::tempdir().unwrap();+ let own = agent_in_args(["--jvm-arg=-Xmx2g", "--jvm-arg=-javaagent:/opt/lombok-1.18.26.jar"]);+ assert_eq!(own.as_deref(), Some(Path::new("/opt/lombok-1.18.26.jar")));+ assert_eq!(agent_in_args(["-javaagent:/opt/other.jar"]), None);+ let agent = lombok_agent(tmp.path(), own, Some("/managed/lombok.jar".into()));+ assert_eq!(agent.jar(), Some(Path::new("/opt/lombok-1.18.26.jar")));+ assert!(agent.outdated(), "its version is read from the file name");+ let plain = lombok_agent(tmp.path(), agent_in_args(["-javaagent:/opt/lombok.jar"]), None);+ assert_eq!(plain.problem(), None, "a user agent is never reported missing");+ }++ #[test]+ fn maven_settings_local_repository() {+ let tmp = tempfile::tempdir().unwrap();+ let home = tmp.path();+ assert_eq!(maven_repository(Some(home)), Some(home.join(".m2/repository")));+ fs::create_dir_all(home.join(".m2")).unwrap();+ fs::write(+ home.join(".m2/settings.xml"),+ "<settings><!-- <localRepository>/old</localRepository> --><localRepository>/repo</localRepository></settings>",+ )+ .unwrap();+ assert_eq!(maven_repository(Some(home)), Some(PathBuf::from("/repo")));+ }+}diff --git a/crates/ide-sdk/src/tests.rs b/crates/ide-sdk/src/tests.rsindex d74921218..75d099f2b 100644--- a/crates/ide-sdk/src/tests.rs+++ b/crates/ide-sdk/src/tests.rs@@ -74,6 +74,16 @@ fn pyright_gets_python_path_and_venv_env() {assert!(cfg.env["PATH"].starts_with(&*tmp.path().join(".venv").join(bin_dir()).to_string_lossy()));}+#[test]+fn jdtls_vm_args() {+ let tmp = tempfile::tempdir().unwrap();+ let mut s = Settings::default();+ s.languages.java.jdtls_vm_args = " -Xmx2g -javaagent:/opt/lombok.jar ".into();+ let mut cfg = server("jdtls");+ configure_server(&mut cfg, tmp.path(), tmp.path(), &s);+ assert_eq!(cfg.args, ["--jvm-arg=-Xmx2g", "--jvm-arg=-javaagent:/opt/lombok.jar"]);+}+#[test]fn rust_analyzer_check_command_and_toolchain() {if cfg!(windows) {diff --git a/crates/ide-tools/src/lib.rs b/crates/ide-tools/src/lib.rsindex a860ced84..c5f7dffe6 100644--- a/crates/ide-tools/src/lib.rs+++ b/crates/ide-tools/src/lib.rs@@ -216,6 +216,10 @@ fn usages(langs: &[LanguageConfig]) -> BTreeMap<String, Usage> {add(&d.adapter, &d.command, ToolKind::Debugger, d.install_hint.as_ref(), &l.name);}}+ for (plugin, host) in registry::PLUGIN_HOSTS {+ let languages = map.get(*host).map(|u| u.languages.clone()).unwrap_or_default();+ map.entry(plugin.to_string()).or_default().languages = languages;+ }map}@@ -734,6 +738,10 @@ impl Tools {let json = http.get_text(&sources::openvsx_latest_url(namespace, extension), cancel)?;sources::openvsx_pick(&json, assets, self.platform)}+ ReleaseSource::MavenCentral { group, artifact } => {+ let xml = http.get_text(&sources::maven_metadata_url(group, artifact), cancel)?;+ sources::maven_pick(group, artifact, &xml)+ }}}diff --git a/crates/ide-tools/src/registry.rs b/crates/ide-tools/src/registry.rsindex 78ea4cc07..91ff41623 100644--- a/crates/ide-tools/src/registry.rs+++ b/crates/ide-tools/src/registry.rs@@ -10,6 +10,8 @@ use specta::Type;pub enum ToolKind {LanguageServer,Debugger,+ /// Loaded into another tool's process, e.g. a jdtls agent.+ Plugin,}/// Where release archives come from.@@ -23,6 +25,8 @@ pub enum ReleaseSource {EclipseJdtls,/// Latest version of a VS Code extension (`.vsix`) on open-vsx.org.OpenVsx { namespace: &'static str, extension: &'static str },+ /// Latest release of a Maven Central artifact (the `.jar` itself).+ MavenCentral { group: &'static str, artifact: &'static str },}#[derive(Clone, Copy, Debug)]@@ -56,6 +60,7 @@ impl Method {Method::Release { source: ReleaseSource::HashiCorp { .. }, .. } => "HashiCorp release",Method::Release { source: ReleaseSource::EclipseJdtls, .. } => "Eclipse download",Method::Release { source: ReleaseSource::OpenVsx { .. }, .. } => "Open VSX",+ Method::Release { source: ReleaseSource::MavenCentral { .. }, .. } => "Maven Central",Method::Release { .. } => "GitHub release",}}@@ -86,7 +91,7 @@ impl ToolSpec {use Arch::{Arm64, X64};use Os::{Linux, Mac, Windows};-use ToolKind::{Debugger, LanguageServer};+use ToolKind::{Debugger, LanguageServer, Plugin};const V: Option<(&str, &[&str])> = None;const fn ver(cmd: &'static str) -> Option<(&'static str, &'static [&'static str])> {@@ -453,6 +458,24 @@ pub static TOOLS: &[ToolSpec] = &[version: V,homepage: "https://github.com/microsoft/java-debug",},+ ToolSpec {+ name: "lombok",+ display: "Lombok (jdtls agent)",+ kind: Plugin,+ commands: &["lombok.jar"],+ // Newer than the Lombok a project pins: old ones fail inside current ECJ.+ method: Method::Release {+ source: ReleaseSource::MavenCentral { group: "org.projectlombok", artifact: "lombok" },+ assets: &[+ any_arch(Mac, "lombok-*.jar"),+ any_arch(Linux, "lombok-*.jar"),+ any_arch(Windows, "lombok-*.jar"),+ ],+ locate: &["lombok.jar"],+ },+ version: V,+ homepage: "https://projectlombok.org",+ },ToolSpec {name: "kotlin-lsp",display: "Kotlin LSP (JetBrains)",@@ -478,6 +501,9 @@ pub static TOOLS: &[ToolSpec] = &[},];+/// Plugin tools and the tool that loads them.+pub const PLUGIN_HOSTS: &[(&str, &str)] = &[("lombok", "jdtls")];+pub fn find(name: &str) -> Option<&'static ToolSpec> {TOOLS.iter().find(|t| t.name == name)}@@ -507,7 +533,7 @@ mod tests {known.insert((d.adapter.clone(), d.command.clone()));}}- for t in TOOLS {+ for t in TOOLS.iter().filter(|t| t.kind != Plugin) {assert!(known.contains(&(t.name.to_string(), t.commands[0].to_string())),"{} / {} is not referenced by languages/*.toml",@@ -517,6 +543,14 @@ mod tests {}}+ #[test]+ fn plugins_have_a_known_host() {+ for t in TOOLS.iter().filter(|t| t.kind == Plugin) {+ let host = PLUGIN_HOSTS.iter().find(|(p, _)| *p == t.name).map(|(_, h)| *h);+ assert!(host.and_then(find).is_some(), "{} has no known host", t.name);+ }+ }+#[test]fn every_release_tool_covers_mac_linux_windows() {for t in TOOLS {diff --git a/crates/ide-tools/src/sources.rs b/crates/ide-tools/src/sources.rsindex 3d1036443..aa10a9852 100644--- a/crates/ide-tools/src/sources.rs+++ b/crates/ide-tools/src/sources.rs@@ -209,6 +209,39 @@ pub fn openvsx_pick(json: &str, rules: &[AssetRule], platform: Platform) -> IdeR})}+const MAVEN_CENTRAL: &str = "https://repo1.maven.org/maven2";++fn maven_dir(group: &str, artifact: &str) -> String {+ format!("{MAVEN_CENTRAL}/{}/{artifact}", group.replace('.', "/"))+}++pub fn maven_metadata_url(group: &str, artifact: &str) -> String {+ format!("{}/maven-metadata.xml", maven_dir(group, artifact))+}++/// The `<release>` jar of a `maven-metadata.xml`. Central publishes only SHA-1+/// sums for most artifacts, so the download is not checksum-verified.+pub fn maven_pick(group: &str, artifact: &str, metadata: &str) -> IdeResult<Download> {+ let tag = |t: &str| {+ let start = metadata.find(&format!("<{t}>"))? + t.len() + 2;+ let end = start + metadata[start..].find(&format!("</{t}>"))?;+ Some(metadata[start..end].trim())+ };+ let version = tag("release")+ .or_else(|| tag("latest"))+ .filter(|v| !v.is_empty() && !v.contains(['/', '\\']))+ .ok_or_else(|| proto(format!("no release in the Maven metadata of {group}:{artifact}")))?;+ let name = format!("{artifact}-{version}.jar");+ Ok(Download {+ version: version.to_string(),+ url: format!("{}/{version}/{name}", maven_dir(group, artifact)),+ name,+ size: None,+ sha256: None,+ checksum_url: None,+ })+}+/// Finds the hash for `file_name` in a checksum file: either a bare hex digest/// or `sha256sum` lines (`<hex> <name>`).pub fn parse_checksum(text: &str, file_name: &str) -> Option<String> {@@ -322,6 +355,23 @@ mod tests {assert!(openvsx_pick(&other, rules, LINUX).is_err());}+ #[test]+ fn maven_central() {+ let xml =+ "<metadata><versioning><latest>1.18.49-SNAPSHOT</latest><release>1.18.48</release></versioning></metadata>";+ assert_eq!(+ maven_metadata_url("org.projectlombok", "lombok"),+ "https://repo1.maven.org/maven2/org/projectlombok/lombok/maven-metadata.xml"+ );+ let d = maven_pick("org.projectlombok", "lombok", xml).unwrap();+ assert_eq!(d.version, "1.18.48");+ assert_eq!(d.name, "lombok-1.18.48.jar");+ assert_eq!(d.url, "https://repo1.maven.org/maven2/org/projectlombok/lombok/1.18.48/lombok-1.18.48.jar");+ assert!(select_asset(&[d.name.as_str()], find("lombok").unwrap().asset_rules(), LINUX).is_some());+ assert!(maven_pick("g", "a", "<metadata/>").is_err());+ assert!(maven_pick("g", "a", "<release>../x</release>").is_err());+ }+#[test]fn checksums() {let h = "a".repeat(64);diff --git a/src-tauri/src/commands/java.rs b/src-tauri/src/commands/java.rsindex 053e54ac2..8a52d20b3 100644--- a/src-tauri/src/commands/java.rs+++ b/src-tauri/src/commands/java.rs@@ -47,6 +47,15 @@ pub async fn java_resolve_launch(ide_sdk::java::pick_jdk(&jdks, release).map(|j| ide_sdk::java::java_executable(&j.home))});info.java_exec = Some(java.map(|p| p.to_string_lossy().into_owned()).unwrap_or_else(|| "java".to_owned()));+ if info.error_count > 0 {+ let vm_args = project.settings.effective().languages.java.jdtls_vm_args;+ let lombok = ide_sdk::lombok::lombok_agent(+ &project.root,+ ide_sdk::lombok::agent_in_args(vm_args.split_whitespace()),+ ide_tools::managed_bundle(&state.data_dir, "lombok"),+ );+ info.hints.extend(lombok.problem());+ }Ok(info)}diff --git a/src-tauri/src/state.rs b/src-tauri/src/state.rsindex f406fb828..fde81826b 100644--- a/src-tauri/src/state.rs+++ b/src-tauri/src/state.rs@@ -248,7 +248,23 @@ impl AppState {ide_tools::managed_bundle(&data_dir, "java-debug").into_iter().collect();let min_java = ide_sdk::java::jdtls_min_java(cfg);let jdks = ide_sdk::java::jdtls_jdks(min_java);- ide_sdk::java::configure_jdtls(cfg, server_root, &data_dir, &jdks, min_java, &bundles);+ let lombok = ide_sdk::lombok::lombok_agent(+ server_root,+ ide_sdk::lombok::agent_in_args(cfg.args.iter().map(String::as_str)),+ ide_tools::managed_bundle(&data_dir, "lombok"),+ );+ if let Some(problem) = lombok.problem() {+ tracing::warn!("{problem}");+ }+ ide_sdk::java::configure_jdtls(+ cfg,+ server_root,+ &data_dir,+ &jdks,+ min_java,+ &bundles,+ lombok.jar(),+ );}}));}diff --git a/src/bindings.ts b/src/bindings.tsindex c027c7898..119fb7d66 100644--- a/src/bindings.ts+++ b/src/bindings.ts@@ -2301,6 +2301,14 @@ export type JavaBuildStatus = "failed" | "succeeded" |/** Compiled, but some project has compile errors. */"withErrors" | "cancelled";+/** One error diagnostic; `line` / `column` are 1-based for display. */+export type JavaCompileError = {+ path: IpcPath,+ line: number,+ column: number,+ message: string,+};+/** Everything needed to launch a class of a module: build outcome, classpath and JDK. */export type JavaLaunchInfo = {/** `None` when no build was requested. */@@ -2312,6 +2320,20 @@ export type JavaLaunchInfo = {javaHome: IpcPath | null,/** The `java` launcher to use (filled in by the caller from the installed JDKs). */javaExec: string | null,+ /** First compile errors of the workspace when the build had errors. */+ errors: JavaCompileError[],+ /** All compile errors (`errors` is capped). */+ errorCount: number,+ /** Likely causes of the errors worth telling the user (e.g. a missing Lombok agent). */+ hints: string[],+};++export type JavaSettings = {+ /**+ * Extra JVM options for the Java language server (jdtls), space-separated+ * (VS Code's `java.jdt.ls.vmargs`).+ */+ jdtlsVmArgs?: string,};/** Editor › Code Style › <Language> › Tabs and Indents (unset fields inherit). */@@ -2371,6 +2393,7 @@ export type LanguagesSettings = {rust?: RustSettings,go?: GoSettings,typescript?: TypeScriptSettings,+ java?: JavaSettings,};/** What a freshly opened window should do once its frontend is up. */@@ -3778,7 +3801,9 @@ export type ToolInfo = {homepage: string | null,};-export type ToolKind = "languageServer" | "debugger";+export type ToolKind = "languageServer" | "debugger" |+/** Loaded into another tool's process, e.g. a jdtls agent. */+"plugin";export type ToolStatus =/** Installed by the IDE (managed tools dir or a toolchain component it manages). */diff --git a/src/features/debugger/__tests__/java.test.ts b/src/features/debugger/__tests__/java.test.tsindex a444b537b..a28e595b7 100644--- a/src/features/debugger/__tests__/java.test.ts+++ b/src/features/debugger/__tests__/java.test.ts@@ -18,6 +18,9 @@ vi.mock("@/platform/ipc", async (orig) => {modulePaths: [],javaHome: "/jdk21",javaExec: "/jdk21/bin/java",+ errors: [],+ errorCount: 0,+ hints: [],});},javaDebugServer: (...a: unknown[]) => {diff --git a/src/features/debugger/java.ts b/src/features/debugger/java.tsindex eed106d68..d8bfc44f2 100644--- a/src/features/debugger/java.ts+++ b/src/features/debugger/java.ts@@ -6,7 +6,13 @@*/import { executeAction } from "@/platform/actions";import { call, commands, IpcError, type LaunchConfig, type RunConfig } from "@/platform/ipc";-import { isJvmApplication, joinJavaArgs, parseJavaArgs, resolveJavaCommand } from "@/platform/javaLaunch";+import {+ formatCompileErrors,+ isJvmApplication,+ joinJavaArgs,+ parseJavaArgs,+ resolveJavaCommand,+} from "@/platform/javaLaunch";import { notifications } from "@/workbench/contributions";export const JAVA_ADAPTER = "java-debug";@@ -52,6 +58,14 @@ export async function javaLaunchConfig(rc: RunConfig, root: string): Promise<Lauconst parsed = parseJavaArgs(rc.args);if (!parsed.mainClass) throw new Error(`No main class in '${rc.name}'`);const info = await call(commands.javaResolveLaunch(module, parsed.classpath === "test", true));+ if (info.errorCount > 0)+ notifications().notify({+ group: "run",+ level: "warning",+ key: "debug.java-compile-errors",+ title: `'${rc.name}' has compile errors; debugging the last compiled classes`,+ body: formatCompileErrors(info).trimEnd(),+ });const resolved = resolveJavaCommand(rc, info);const port = await debugServer(module);const classPaths = parsed.explicitClasspath ? parsed.explicitClasspath.split(/[:;]/) : info.classPaths;diff --git a/src/features/run/java.test.ts b/src/features/run/java.test.tsindex f62e2fb7b..2b8476ce0 100644--- a/src/features/run/java.test.ts+++ b/src/features/run/java.test.ts@@ -1,6 +1,7 @@import { beforeEach, describe, expect, it } from "vitest";import type { JavaLaunchInfo, RunConfig } from "@/platform/ipc";import {+ formatCompileErrors,joinJavaArgs,jdwpListeningPort,parseJavaArgs,@@ -170,6 +171,31 @@ describe("application configurations", () => {});});+describe("java compile errors", () => {+ const base: Omit<JavaLaunchInfo, "errors" | "errorCount" | "hints"> = {+ build: "withErrors",+ projectRoot: "/p",+ classPaths: [],+ modulePaths: [],+ javaHome: null,+ javaExec: null,+ };++ it("lists the first errors, counts the rest and adds hints", () => {+ const report = formatCompileErrors({+ ...base,+ errors: [{ path: "/p/src/A.java", line: 72, column: 5, message: "The method getUsername() is undefined" }],+ errorCount: 3,+ hints: ["Install Lombok"],+ });+ expect(report).toBe(+ "/p/src/A.java:72:5: error: The method getUsername() is undefined\n" ++ "… and 2 more errors (see the Problems tool window)\nInstall Lombok\n",+ );+ expect(formatCompileErrors({ ...base, errors: [], errorCount: 0, hints: [] })).toBe("");+ });+});+describe("java command lines", () => {const info: JavaLaunchInfo = {build: "succeeded",@@ -178,6 +204,9 @@ describe("java command lines", () => {modulePaths: [],javaHome: "/jdk21",javaExec: "/jdk21/bin/java",+ errors: [],+ errorCount: 0,+ hints: [],};it("parses VM options, main class and program arguments", () => {diff --git a/src/features/run/store.ts b/src/features/run/store.tsindex ffdfcbc34..78484bf7a 100644--- a/src/features/run/store.ts+++ b/src/features/run/store.ts@@ -6,7 +6,7 @@import { create } from "zustand";import { Channel } from "@tauri-apps/api/core";import { call, commands, isTauri, type OutputChunk, type RunConfig, type RunId, type TestCaseReport } from "@/platform/ipc";-import { isJvmApplication, parseJavaArgs, resolveJavaCommand } from "@/platform/javaLaunch";+import { formatCompileErrors, isJvmApplication, parseJavaArgs, resolveJavaCommand } from "@/platform/javaLaunch";import { useProject } from "@/platform/project";import { workflowSettings } from "@/platform/workflowSettings";import { maybeEditorService, notifications, toolWindowService } from "@/workbench/contributions";@@ -449,6 +449,8 @@ async function resolveJvmApplication(sessionId: string, config: RunConfig): Promconst info = await call(commands.javaResolveLaunch(config.cwd ?? "", parsed.classpath === "test", true));if (info.build === "withErrors") say("Build completed with errors; launching with the last compiled classes.\n", "stderr");if (info.build === "failed") say("Build failed; launching with the last compiled classes.\n", "stderr");+ const compileReport = formatCompileErrors(info);+ if (compileReport) say(compileReport, "stderr");if (!info.classPaths.length) {say("The classpath is empty: is the module imported by the Java language server?\n", "stderr");return null;diff --git a/src/features/settings/__tests__/languages.test.ts b/src/features/settings/__tests__/languages.test.tsindex f5743cc6c..43c6ce689 100644--- a/src/features/settings/__tests__/languages.test.ts+++ b/src/features/settings/__tests__/languages.test.ts@@ -21,12 +21,14 @@ describe("languages settings", () => {node: { packageManager: "pip" },rust: { checkCommand: "clippy", checkOnSave: false },typescript: { version: "" },+ java: { jdtlsVmArgs: " -Xmx2g " },});expect(v.python).toEqual({ interpreter: "/usr/bin/python3", activateVirtualenv: true });expect(v.node.packageManager).toBe("");expect(v.rust.checkCommand).toBe("clippy");expect(v.rust.checkOnSave).toBe(false);expect(v.typescript.version).toBe("bundled");+ expect(v.java.jdtlsVmArgs).toBe("-Xmx2g");expect(validateSettings({}).languages).toEqual(DEFAULT_LANGUAGES);});@@ -48,7 +50,7 @@ describe("language pages", () => {const tree = buildPageTree(LANGUAGE_PAGES.map((p) => ({ ...p, component: p.component! })));expect(tree.map((n) => n.title)).toEqual(["Project Structure", "Languages & Frameworks"]);const langs = tree.find((n) => n.title === "Languages & Frameworks")!;- expect(langs.children.map((n) => n.title)).toEqual(["Go", "Node.js", "Python Interpreter", "Rust", "TypeScript"]);+ expect(langs.children.map((n) => n.title)).toEqual(["Go", "Java", "Node.js", "Python Interpreter", "Rust", "TypeScript"]);});it("filters packages and shortens home paths", () => {diff --git a/src/features/settings/languages/LanguagePages.tsx b/src/features/settings/languages/LanguagePages.tsxindex 27aca0589..832b91b8a 100644--- a/src/features/settings/languages/LanguagePages.tsx+++ b/src/features/settings/languages/LanguagePages.tsx@@ -1,5 +1,5 @@/**- * Settings › Languages & Frameworks › Go / Node.js / Rust / TypeScript: the+ * Settings › Languages & Frameworks › Go / Java / Node.js / Rust / TypeScript: the* toolchain each language's server and run configurations use (applied by* `ide-sdk` when language servers start and when run configurations load).*/@@ -209,6 +209,34 @@ export function GoPage() {);}+// ---------------------------------------------------------------------------+// Java++export function JavaPage() {+ const [vmArgs, setVmArgs] = useProjectSetting<string>("languages.java.jdtlsVmArgs");+ const id = useId();+ return (+ <div className={styles.page}>+ <Section title="Language Server">+ <Row+ label="JVM options"+ htmlFor={id}+ hint="Passed to the JVM running jdtls (java.jdt.ls.vmargs), e.g. -Xmx2g. A Lombok agent is added automatically when the project uses Lombok."+ >+ <Input+ id={id}+ mono+ className={styles.pathInput}+ value={vmArgs}+ placeholder="-Xmx2g"+ onChange={(e) => setVmArgs(e.target.value)}+ />+ </Row>+ </Section>+ </div>+ );+}+// ---------------------------------------------------------------------------// TypeScriptdiff --git a/src/features/settings/pages/languages.tsx b/src/features/settings/pages/languages.tsxindex 547256eee..ab88dcc8d 100644--- a/src/features/settings/pages/languages.tsx+++ b/src/features/settings/pages/languages.tsx@@ -1,9 +1,9 @@/*** PyCharm's top-level "Python" group (Interpreter), "Project Structure", and- * Languages & Frameworks › Go / Node.js / Rust / TypeScript. Pages live in+ * Languages & Frameworks › Go / Java / Node.js / Rust / TypeScript. Pages live in* `../languages/`; settings are `languages.*` / `projectStructure.*`.*/-import { GoPage, NodePage, RustPage, TypeScriptPage } from "../languages/LanguagePages";+import { GoPage, JavaPage, NodePage, RustPage, TypeScriptPage } from "../languages/LanguagePages";import { ProjectStructurePage } from "../languages/ProjectStructurePage";import { PythonInterpreterPage } from "../languages/PythonInterpreterPage";import type { PageSpec } from "./spec";@@ -47,6 +47,14 @@ export const LANGUAGE_PAGES: PageSpec[] = [keywords: ["goroot", "gopath", "go sdk", "gopls"],component: GoPage,},+ {+ id: "languages.java",+ title: "Java",+ group: LANGUAGES_GROUP,+ order: 395,+ keywords: ["jdtls", "jvm options", "vmargs", "lombok", "javaagent", "eclipse jdt"],+ component: JavaPage,+ },{id: "languages.node",title: "Node.js",diff --git a/src/features/tools/LanguageServersPage.tsx b/src/features/tools/LanguageServersPage.tsxindex 7b838e6bb..d1bc29bf2 100644--- a/src/features/tools/LanguageServersPage.tsx+++ b/src/features/tools/LanguageServersPage.tsx@@ -186,6 +186,7 @@ export function LanguageServersPage() {<div className={styles.toolName}><span className={styles.display}>{t.displayName}</span>{t.kind === "debugger" && <span className={styles.kindTag}>Debugger</span>}+ {t.kind === "plugin" && <span className={styles.kindTag}>Plugin</span>}</div>{(t.path ?? (t.command !== t.displayName ? t.command : null)) && (<div className={styles.sub} title={t.path ?? undefined}>diff --git a/src/platform/javaLaunch.ts b/src/platform/javaLaunch.tsindex 58090a8d8..e2136366d 100644--- a/src/platform/javaLaunch.ts+++ b/src/platform/javaLaunch.ts@@ -81,6 +81,15 @@ export function resolveJavaCommand(config: RunConfig, info: JavaLaunchInfo, pathreturn { ...config, command, args };}+/** Console report of a launch's compile errors (`path:line:col: error: …`) and their likely causes; "" when none. */+export function formatCompileErrors(info: JavaLaunchInfo): string {+ const lines = info.errors.map((e) => `${e.path}:${e.line}:${e.column}: error: ${e.message}`);+ const more = info.errorCount - info.errors.length;+ if (more > 0) lines.push(`… and ${more} more error${more === 1 ? "" : "s"} (see the Problems tool window)`);+ lines.push(...info.hints);+ return lines.length ? `${lines.join("\n")}\n` : "";+}+/** Joins arguments into one string for adapters that take `args` / `vmArgs` as text (java-debug). */export function joinJavaArgs(args: readonly string[]): string {return args.map((a) => (a === "" ? '""' : /[\s"]/.test(a) ? `"${a.replace(/(["\\])/g, "\\$1")}"` : a)).join(" ");diff --git a/src/platform/languageSettings.ts b/src/platform/languageSettings.tsindex 89aefe0ea..895700669 100644--- a/src/platform/languageSettings.ts+++ b/src/platform/languageSettings.ts@@ -11,6 +11,7 @@ export interface LanguagesValid {rust: { toolchain: string; stdlib: string; checkOnSave: boolean; checkCommand: "check" | "clippy"; rustfmtArgs: string };go: { goroot: string; gopath: string };typescript: { version: string };+ java: { jdtlsVmArgs: string };}export interface ProjectStructureValid {@@ -29,6 +30,7 @@ export const DEFAULT_LANGUAGES: LanguagesValid = {rust: { toolchain: "", stdlib: "", checkOnSave: true, checkCommand: "check", rustfmtArgs: "" },go: { goroot: "", gopath: "" },typescript: { version: "bundled" },+ java: { jdtlsVmArgs: "" },};export const DEFAULT_PROJECT_STRUCTURE: ProjectStructureValid = {@@ -73,6 +75,7 @@ export function validateLanguages(raw: unknown): LanguagesValid {const rust = obj(l.rust);const go = obj(l.go);const ts = obj(l.typescript);+ const java = obj(l.java);return {python: {interpreter: text(py.interpreter, d.python.interpreter),@@ -91,6 +94,7 @@ export function validateLanguages(raw: unknown): LanguagesValid {},go: { goroot: text(go.goroot, d.go.goroot), gopath: text(go.gopath, d.go.gopath) },typescript: { version: text(ts.version, d.typescript.version) || d.typescript.version },+ java: { jdtlsVmArgs: text(java.jdtlsVmArgs, d.java.jdtlsVmArgs) },};}