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): Detect Lombok inherited from outside the project (#58)

l0ng-aicac95273d36e
diff --git a/Cargo.lock b/Cargo.lock
index 00616fb8e..0393fa55b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4274,6 +4274,7 @@ dependencies = [
"ide-language",
"ide-run",
"ide-vfs",
+ "ignore",
"serde",
"serde_json",
"specta",
diff --git a/crates/ide-sdk/Cargo.toml b/crates/ide-sdk/Cargo.toml
index 028f233f8..b83b58065 100644
--- a/crates/ide-sdk/Cargo.toml
+++ b/crates/ide-sdk/Cargo.toml
@@ -7,6 +7,7 @@ license.workspace = true
[dependencies]
dunce.workspace = true
+ignore.workspace = true
ide-core.workspace = true
ide-language.workspace = true
ide-run.workspace = true
diff --git a/crates/ide-sdk/src/lombok.rs b/crates/ide-sdk/src/lombok.rs
index e9f7ca1af..f8958bc40 100644
--- a/crates/ide-sdk/src/lombok.rs
+++ b/crates/ide-sdk/src/lombok.rs
@@ -64,7 +64,8 @@ pub fn agent_in_args<'a>(args: impl IntoIterator<Item = &'a str>) -> Option<Path
}
/// 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
+/// options) wins, then `managed` (the IDE-installed jar, always attached: it is inert
+/// without Lombok on the classpath), then, for a project using Lombok, the build caches
/// (`maven_repo`, the configured Maven local repository, else the default one).
pub fn lombok_agent(
root: &Path,
@@ -80,15 +81,16 @@ pub fn lombok_agent(
.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 maven_repo = maven_repo.or_else(|| maven_repository(home.as_deref()));
+ if !uses_lombok(root, maven_repo.as_deref()) {
+ return LombokAgent::Unused;
+ }
let mut dirs = Vec::new();
- if let Some(repo) = maven_repo.or_else(|| maven_repository(home.as_deref())) {
+ if let Some(repo) = maven_repo {
dirs.push(repo.join("org").join("projectlombok").join("lombok"));
}
if let Some(gradle) =
@@ -102,11 +104,31 @@ pub fn lombok_agent(
}
}
-/// 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 {
+/// Whether the project at `root` uses Lombok. It often arrives through inheritance the
+/// project's own build files don't show (a parent POM up the tree or only in the local
+/// repository `maven_repo`, an enclosing Gradle build, a convention plugin), so besides
+/// those this follows Maven `<parent>` chains, checks an enclosing Gradle build and, last,
+/// looks for Java sources importing Lombok, a signal independent of the build.
+pub fn uses_lombok(root: &Path, maven_repo: Option<&Path>) -> bool {
+ let mut poms = Vec::new();
+ build_files_mention_lombok(root, &mut poms)
+ || root.ancestors().skip(1).any(|d| d.join("lombok.config").is_file())
+ || parents_mention_lombok(&poms, maven_repo)
+ || enclosing_gradle_build_mentions_lombok(root)
+ || sources_import_lombok(root)
+}
+
+const BUILD_FILES: [&str; 4] = ["pom.xml", "build.gradle", "build.gradle.kts", "libs.versions.toml"];
+const OUTPUT_DIRS: [&str; 6] = ["target", "build", "node_modules", "out", "bin", ".gradle"];
+
+fn mentions_lombok(file: &Path) -> bool {
+ std::fs::read_to_string(file).is_ok_and(|t| t.contains("lombok"))
+}
+
+/// Build files under `root` (a few levels, for multi-module builds) mentioning Lombok;
+/// the POMs seen go to `poms`.
+fn build_files_mention_lombok(root: &Path, poms: &mut Vec<PathBuf>) -> bool {
+ fn walk(dir: &Path, depth: usize, poms: &mut Vec<PathBuf>) -> bool {
if dir.join("lombok.config").is_file() {
return true;
}
@@ -117,19 +139,133 @@ pub fn uses_lombok(root: &Path) -> bool {
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()) {
+ if depth > 0 && !name.starts_with('.') && name != "src" && !OUTPUT_DIRS.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;
+ } else if BUILD_FILES.contains(&name.as_ref()) {
+ if mentions_lombok(&e.path()) {
+ return true;
+ }
+ if name == "pom.xml" {
+ poms.push(e.path());
+ }
}
}
- subdirs.iter().any(|d| walk(d, depth - 1))
+ subdirs.iter().any(|d| walk(d, depth - 1, poms))
}
// `gradle/libs.versions.toml` sits one level down, modules usually no deeper than three.
- walk(root, 3)
+ walk(root, 3, poms)
+}
+
+/// Maven inherits dependencies along `<parent>`: whether an ancestor POM of `poms`
+/// mentions Lombok.
+fn parents_mention_lombok(poms: &[PathBuf], maven_repo: Option<&Path>) -> bool {
+ const MAX_HOPS: usize = 8;
+ let mut seen = std::collections::HashSet::new();
+ for pom in poms {
+ let Ok(mut text) = std::fs::read_to_string(pom) else { continue };
+ let mut current = pom.clone();
+ for _ in 0..MAX_HOPS {
+ let Some(parent) = parent_pom(&current, &text, maven_repo) else { break };
+ if !seen.insert(parent.clone()) {
+ break;
+ }
+ let Ok(parent_text) = std::fs::read_to_string(&parent) else { break };
+ if parent_text.contains("lombok") {
+ return true;
+ }
+ (current, text) = (parent, parent_text);
+ }
+ }
+ false
+}
+
+/// The parent of `pom` (content `text`) as Maven resolves it: the POM at `<relativePath>`
+/// (default `../pom.xml`, none when empty) if it is that parent, else
+/// `<groupId>/<artifactId>/<version>/<artifactId>-<version>.pom` in the local repository.
+fn parent_pom(pom: &Path, text: &str, maven_repo: Option<&Path>) -> Option<PathBuf> {
+ let text = strip_xml_comments(text);
+ let (block, _) = split_parent(&text)?;
+ let coord = |tag| crate::java::xml_value(block, tag).filter(|v| !v.is_empty());
+ let (group, artifact) = (coord("groupId")?, coord("artifactId")?);
+ let relative = if block.contains("<relativePath/>") || block.contains("<relativePath />") {
+ String::new()
+ } else {
+ crate::java::xml_value(block, "relativePath").unwrap_or_else(|| "../pom.xml".to_owned())
+ };
+ if !relative.is_empty() {
+ let mut local = pom.parent()?.join(relative.replace('\\', "/"));
+ if local.is_dir() {
+ local = local.join("pom.xml");
+ }
+ let is_parent = std::fs::read_to_string(&local)
+ .is_ok_and(|t| own_artifact_id(&strip_xml_comments(&t)).as_deref() == Some(artifact.as_str()));
+ if is_parent {
+ return Some(dunce::canonicalize(&local).unwrap_or(local));
+ }
+ }
+ let version = coord("version").filter(|v| !v.contains("${"))?;
+ let dir = group.split('.').fold(maven_repo?.to_path_buf(), |d, part| d.join(part));
+ let file = dir.join(&artifact).join(&version).join(format!("{artifact}-{version}.pom"));
+ file.is_file().then_some(file)
+}
+
+/// A POM's `<parent>…</parent>` element and the text without it.
+fn split_parent(text: &str) -> Option<(&str, String)> {
+ let start = text.find("<parent>")?;
+ let end = start + text[start..].find("</parent>")? + "</parent>".len();
+ Some((&text[start..end], format!("{}{}", &text[..start], &text[end..])))
+}
+
+/// A POM's own `<artifactId>`, not its parent's.
+fn own_artifact_id(text: &str) -> Option<String> {
+ match split_parent(text) {
+ Some((_, rest)) => crate::java::xml_value(&rest, "artifactId"),
+ None => crate::java::xml_value(text, "artifactId"),
+ }
+}
+
+/// A Gradle subproject opened on its own: the enclosing build (the nearest ancestor with
+/// `settings.gradle[.kts]`) may apply Lombok from its root build file or version catalog.
+fn enclosing_gradle_build_mentions_lombok(root: &Path) -> bool {
+ const MAX_LEVELS: usize = 4;
+ let settings = |d: &Path| d.join("settings.gradle").is_file() || d.join("settings.gradle.kts").is_file();
+ root.ancestors().skip(1).take(MAX_LEVELS).find(|d| settings(d)).is_some_and(|build| {
+ ["build.gradle", "build.gradle.kts", "gradle/libs.versions.toml"]
+ .iter()
+ .any(|f| mentions_lombok(&build.join(f)))
+ })
+}
+
+/// Java sources under `root` importing Lombok. Bounded (the heads of the first files),
+/// honouring ignore files and skipping build output.
+fn sources_import_lombok(root: &Path) -> bool {
+ use std::io::Read;
+ const MAX_ENTRIES: usize = 50_000;
+ const MAX_FILES: usize = 2000;
+ // Imports precede the first type, after at most a license header.
+ const HEAD: u64 = 8 * 1024;
+ let mut walker = ignore::WalkBuilder::new(root);
+ walker.require_git(false).follow_links(false).filter_entry(|e| {
+ e.depth() == 0
+ || !e.file_type().is_some_and(|t| t.is_dir())
+ || !OUTPUT_DIRS.contains(&e.file_name().to_string_lossy().as_ref())
+ });
+ let imports_lombok = |path: &Path| {
+ let mut head = Vec::new();
+ let read = std::fs::File::open(path).and_then(|f| f.take(HEAD).read_to_end(&mut head));
+ let head = String::from_utf8_lossy(&head);
+ read.is_ok()
+ && (head.contains("@lombok.")
+ || head.lines().any(|l| l.trim_start().starts_with("import ") && l.contains(" lombok.")))
+ };
+ walker
+ .build()
+ .take(MAX_ENTRIES)
+ .flatten()
+ .filter(|e| e.file_type().is_some_and(|t| t.is_file()) && e.path().extension().is_some_and(|x| x == "java"))
+ .take(MAX_FILES)
+ .any(|e| imports_lombok(e.path()))
}
/// `<localRepository>` of `~/.m2/settings.xml`, else `~/.m2/repository`.
@@ -203,18 +339,164 @@ mod tests {
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));
+ assert!(!uses_lombok(root, None));
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");
+ assert!(!uses_lombok(root, None), "build files under src are not scanned");
fs::write(root.join("api/pom.xml"), "<artifactId>lombok</artifactId>").unwrap();
- assert!(uses_lombok(root));
+ assert!(uses_lombok(root, None));
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()));
+ assert!(uses_lombok(gradle.path(), None));
+ }
+
+ const LOMBOK_DEP: &str = "<dependencies><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency></dependencies>";
+
+ fn pom(own: &str, parent: &str) -> String {
+ format!("<project><modelVersion>4.0.0</modelVersion>{parent}<artifactId>{own}</artifactId></project>")
+ }
+
+ fn parent(artifact: &str, extra: &str) -> String {
+ format!(
+ "<parent><groupId>com.acme</groupId><artifactId>{artifact}</artifactId><version>1.0</version>{extra}</parent>"
+ )
+ }
+
+ #[test]
+ fn parent_pom_only_in_the_local_repository() {
+ // #33: the module's parent was `mvn install`ed, its directory isn't on disk.
+ let tmp = tempfile::tempdir().unwrap();
+ let (module, repo) = (tmp.path().join("module-a"), tmp.path().join("m2"));
+ fs::create_dir_all(&module).unwrap();
+ fs::write(module.join("pom.xml"), pom("module-a", &parent("acme-parent", ""))).unwrap();
+ assert!(!uses_lombok(&module, Some(&repo)));
+ let dir = repo.join("com/acme/acme-parent/1.0");
+ fs::create_dir_all(&dir).unwrap();
+ // The dependency comes from the grandparent.
+ fs::write(dir.join("acme-parent-1.0.pom"), pom("acme-parent", &parent("acme-root", ""))).unwrap();
+ assert!(!uses_lombok(&module, Some(&repo)));
+ let root = repo.join("com/acme/acme-root/1.0");
+ fs::create_dir_all(&root).unwrap();
+ fs::write(
+ root.join("acme-root-1.0.pom"),
+ format!("<project><artifactId>acme-root</artifactId>{LOMBOK_DEP}</project>"),
+ )
+ .unwrap();
+ assert!(uses_lombok(&module, Some(&repo)));
+ assert!(!uses_lombok(&module, None), "no repository, no parent");
+ let agent = lombok_agent(&module, None, None, Some(repo.clone()));
+ assert_ne!(agent, LombokAgent::Unused, "missing, or a jar from the Gradle cache");
+ }
+
+ #[test]
+ fn parent_pom_via_relative_path_outside_the_root() {
+ let tmp = tempfile::tempdir().unwrap();
+ let project = tmp.path().join("project");
+ let module = project.join("modules/api");
+ fs::create_dir_all(&module).unwrap();
+ fs::create_dir_all(tmp.path().join("platform")).unwrap();
+ fs::write(
+ module.join("pom.xml"),
+ pom("api", &parent("platform", "<relativePath>../../../platform</relativePath>")),
+ )
+ .unwrap();
+ fs::write(
+ tmp.path().join("platform/pom.xml"),
+ format!("<project><artifactId>platform</artifactId>{LOMBOK_DEP}</project>"),
+ )
+ .unwrap();
+ assert!(uses_lombok(&module, None));
+ assert!(uses_lombok(&project, None), "modules' parents are followed too");
+
+ // The default `../pom.xml`, but it is another project's POM: not the parent.
+ let other = tempfile::tempdir().unwrap();
+ let child = other.path().join("child");
+ fs::create_dir_all(&child).unwrap();
+ fs::write(child.join("pom.xml"), pom("child", &parent("acme-parent", ""))).unwrap();
+ fs::write(
+ other.path().join("pom.xml"),
+ format!("<project><artifactId>unrelated</artifactId>{LOMBOK_DEP}</project>"),
+ )
+ .unwrap();
+ assert!(!uses_lombok(&child, None));
+ fs::write(
+ other.path().join("pom.xml"),
+ format!("<project><artifactId>acme-parent</artifactId>{LOMBOK_DEP}</project>"),
+ )
+ .unwrap();
+ assert!(uses_lombok(&child, None));
+ // An empty relativePath means: from the repository only.
+ fs::write(child.join("pom.xml"), pom("child", &parent("acme-parent", "<relativePath/>"))).unwrap();
+ assert!(!uses_lombok(&child, None));
+ }
+
+ #[test]
+ fn parent_cycles_terminate() {
+ let tmp = tempfile::tempdir().unwrap();
+ let a = tmp.path().join("a");
+ fs::create_dir_all(&a).unwrap();
+ fs::write(a.join("pom.xml"), pom("a", &parent("root", ""))).unwrap();
+ fs::write(tmp.path().join("pom.xml"), pom("root", &parent("root", "<relativePath>pom.xml</relativePath>")))
+ .unwrap();
+ assert!(!uses_lombok(&a, None));
+ }
+
+ #[test]
+ fn enclosing_gradle_build() {
+ let tmp = tempfile::tempdir().unwrap();
+ let sub = tmp.path().join("services/billing");
+ fs::create_dir_all(&sub).unwrap();
+ fs::write(sub.join("build.gradle.kts"), "plugins { java }").unwrap();
+ fs::write(tmp.path().join("settings.gradle.kts"), "include(\"services:billing\")").unwrap();
+ assert!(!uses_lombok(&sub, None));
+ fs::write(
+ tmp.path().join("build.gradle.kts"),
+ "subprojects { dependencies { \"compileOnly\"(\"org.projectlombok:lombok:1.18.36\") } }",
+ )
+ .unwrap();
+ assert!(uses_lombok(&sub, None));
+ }
+
+ #[test]
+ fn sources_importing_lombok() {
+ // E.g. a Gradle convention plugin in buildSrc/src or an included build adds it.
+ let tmp = tempfile::tempdir().unwrap();
+ let root = tmp.path();
+ let pkg = root.join("app/src/main/java/com/acme");
+ fs::create_dir_all(&pkg).unwrap();
+ fs::write(root.join("build.gradle"), "plugins { id 'acme.java-conventions' }").unwrap();
+ fs::write(pkg.join("Plain.java"), "package com.acme;\n\nimport java.util.List;\n\nclass Plain {}\n").unwrap();
+ assert!(!uses_lombok(root, None));
+ // Build output and ignored files don't count.
+ fs::create_dir_all(root.join("app/build/generated")).unwrap();
+ fs::write(root.join("app/build/generated/G.java"), "import lombok.Data;\n").unwrap();
+ fs::write(root.join(".ignore"), "vendor/\n").unwrap();
+ fs::create_dir_all(root.join("vendor")).unwrap();
+ fs::write(root.join("vendor/V.java"), "import lombok.Value;\n").unwrap();
+ assert!(!uses_lombok(root, None));
+ fs::write(
+ pkg.join("User.java"),
+ "/* License */\npackage com.acme;\n\nimport lombok.Data;\n\n@Data\nclass User {}\n",
+ )
+ .unwrap();
+ assert!(uses_lombok(root, None));
+ fs::write(pkg.join("User.java"), "package com.acme;\n\[email protected]\nclass User {}\n").unwrap();
+ assert!(uses_lombok(root, None));
+ fs::write(pkg.join("User.java"), "package com.acme;\nimport static lombok.AccessLevel.PRIVATE;\n").unwrap();
+ assert!(uses_lombok(root, None));
+ }
+
+ #[test]
+ fn the_installed_agent_applies_without_detection() {
+ let tmp = tempfile::tempdir().unwrap();
+ let repo = tmp.path().join("m2");
+ assert_eq!(lombok_agent(tmp.path(), None, None, Some(repo.clone())), LombokAgent::Unused);
+ let managed = lombok_agent(tmp.path(), None, Some("/managed/lombok.jar".into()), Some(repo));
+ assert_eq!(managed.jar(), Some(Path::new("/managed/lombok.jar")));
+ assert_eq!(managed.problem(), None);
}
#[test]
diff --git a/src-tauri/src/commands/java.rs b/src-tauri/src/commands/java.rs
index 9c06a1c69..76a56de12 100644
--- a/src-tauri/src/commands/java.rs
+++ b/src-tauri/src/commands/java.rs
@@ -55,13 +55,15 @@ pub async fn java_resolve_launch(
let shorten = ide_run::java_cmdline::shortening_for(&exec, &info.class_paths, &info.module_paths, cfg!(windows));
info.shorten_command_line = Some(shorten.as_str().to_owned());
if info.error_count > 0 {
- let vm_args = &settings.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"),
- ide_sdk::apply::maven_local_repository(&project.root, &settings),
- );
+ let own = ide_sdk::lombok::agent_in_args(settings.languages.java.jdtls_vm_args.split_whitespace());
+ let managed = ide_tools::managed_bundle(&state.data_dir, "lombok");
+ let repo = ide_sdk::apply::maven_local_repository(&project.root, &settings);
+ let root = project.root.clone();
+ // Detection may read the project's sources.
+ let lombok =
+ tauri::async_runtime::spawn_blocking(move || ide_sdk::lombok::lombok_agent(&root, own, managed, repo))
+ .await
+ .map_err(|e| IdeError::internal(e.to_string()))?;
info.hints.extend(lombok.problem());
}
Ok(info)
diff --git a/src/features/settings/languages/LanguagePages.tsx b/src/features/settings/languages/LanguagePages.tsx
index 5b0284842..efe571a65 100644
--- a/src/features/settings/languages/LanguagePages.tsx
+++ b/src/features/settings/languages/LanguagePages.tsx
@@ -249,7 +249,7 @@ export function JavaPage() {
<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."
+ hint="Passed to the JVM running jdtls (java.jdt.ls.vmargs), e.g. -Xmx2g. A Lombok agent is added automatically: the one installed in Language Servers, else, when the project uses Lombok (its build, an inherited parent POM or Gradle build, or its sources' imports), the newest from the Maven / Gradle caches."
>
<Input
id={id}
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index 80c581066..b3dd9d601 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -1357,7 +1357,7 @@
"Passed as -Dmaven.repo.local.": "以 -Dmaven.repo.local 传入。",
"Passed as -s (mirrors, servers, proxies).": "以 -s 传入(镜像、服务器、代理)。",
"Passed to rustfmt when reformatting, e.g. --edition 2024": "重新格式化时传递给 rustfmt,例如 --edition 2024",
- "Passed to the JVM running jdtls (java.jdt.ls.vmargs), e.g. -Xmx2g. A Lombok agent is added automatically when the project uses Lombok.": "传递给运行 jdtls 的 JVM (java.jdt.ls.vmargs),例如 -Xmx2g。项目使用 Lombok 时会自动添加 Lombok 代理。",
+ "Passed to the JVM running jdtls (java.jdt.ls.vmargs), e.g. -Xmx2g. A Lombok agent is added automatically: the one installed in Language Servers, else, when the project uses Lombok (its build, an inherited parent POM or Gradle build, or its sources' imports), the newest from the Maven / Gradle caches.": "传递给运行 jdtls 的 JVM (java.jdt.ls.vmargs),例如 -Xmx2g。会自动添加 Lombok 代理:优先使用在“语言服务器”中安装的版本;否则当项目使用 Lombok(构建文件、继承的父 POM 或 Gradle 构建、源码中的 import)时,使用 Maven / Gradle 缓存中最新的版本。",
"Pop stash": "弹出储藏",
"Preview Source": "预览源代码",
"Reinstate index": "恢复索引",