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): skip unchanged Maven launch builds (#667)
l0ng-aif19eacc33647
diff --git a/crates/ide-build/src/compile/fingerprint.rs b/crates/ide-build/src/compile/fingerprint.rsnew file mode 100644index 000000000..8274003d6--- /dev/null+++ b/crates/ide-build/src/compile/fingerprint.rs@@ -0,0 +1,321 @@+//! Metadata fingerprints for successful Maven launch builds.+use super::*;+use std::fs;+use std::hash::{Hash, Hasher};+use std::time::SystemTime;++#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]+pub struct LaunchFingerprint {+ version: u32,+ parameters: String,+ files: BTreeMap<PathBuf, Option<(u64, SystemTime)>>,+}++fn scan(+ path: &Path,+ files: &mut BTreeMap<PathBuf, Option<(u64, SystemTime)>>,+ ancestors: &mut HashSet<PathBuf>,+ cancel: &CancellationToken,+) -> IdeResult<()> {+ if cancel.is_cancelled() {+ return Err(IdeError::cancelled());+ }+ let meta = match fs::metadata(path) {+ Ok(meta) => meta,+ Err(e) if e.kind() == std::io::ErrorKind::NotFound => {+ files.insert(path.to_path_buf(), None);+ return Ok(());+ }+ Err(e) => return Err(e.into()),+ };+ if meta.is_dir() {+ let canonical = dunce::canonicalize(path)?;+ if !ancestors.insert(canonical.clone()) {+ return Err(IdeError::internal("cyclic launch input directory"));+ }+ // Directory mtimes change on irrelevant JDT writes. File paths detect additions/deletions.+ files.insert(path.to_path_buf(), None);+ for entry in fs::read_dir(path)? {+ scan(&entry?.path(), files, ancestors, cancel)?;+ }+ ancestors.remove(&canonical);+ } else if meta.is_file() {+ files.insert(path.to_path_buf(), Some((meta.len(), meta.modified()?)));+ } else {+ return Err(IdeError::internal("unsupported launch input file"));+ }+ Ok(())+}++/// `None` means an input cannot be resolved safely: build normally without reuse.+/// All filesystem work belongs on the caller's blocking thread.+pub fn launch_fingerprint(+ root: &Path,+ model: &BuildModel,+ module: &Path,+ test: bool,+ local_repo: Option<PathBuf>,+ cancel: &CancellationToken,+) -> IdeResult<Option<LaunchFingerprint>> {+ let Some(m) = &model.maven else { return Ok(None) };+ let projects = maven_launch_projects(root, m, module, test);+ if projects.is_empty() {+ return Ok(None);+ }+ let Some(mut inputs) = maven::launch_inputs(root, &projects, local_repo) else { return Ok(None) };+ let plan = launch_plan(root, model, module, test)?;+ let mut environment: BTreeMap<String, String> = std::env::vars()+ .map(|(key, value)| (key.to_ascii_uppercase(), value))+ .filter(|(key, _)| {+ key.starts_with("MAVEN_")+ || key.starts_with("JAVA_")+ || key.starts_with("JDK_")+ || matches!(+ key.as_str(),+ "PATH" | "HOME" | "LANG" | "LC_ALL" | "_JAVA_OPTIONS" | "M2_HOME" | "MAVEN_HOME"+ )+ })+ .collect();+ // Explicit step values override the inherited environment just as they do in Command.+ for step in &plan.steps {+ environment.extend(step.env.iter().map(|(key, value)| (key.to_ascii_uppercase(), value.clone())));+ for dir in step.cwd.ancestors() {+ inputs.extend([dir.join(".mvn"), dir.join("mvnw"), dir.join("mvnw.cmd")]);+ if dir == root {+ break;+ }+ }+ let program = process::program_path(&step.program, &step.env);+ inputs.push(program.clone());+ // Maven installed via a symlink still reads conf from its distribution.+ if let Ok(program) = dunce::canonicalize(program)+ && let Some(home) = program.parent().and_then(Path::parent)+ {+ for conf in ["conf", "libexec/conf"] {+ inputs.extend([home.join(conf).join("settings.xml"), home.join(conf).join("toolchains.xml")]);+ }+ }+ if !environment.contains_key("JAVA_HOME") {+ let java = process::program_path(if cfg!(windows) { "java.exe" } else { "java" }, &step.env);+ inputs.push(java.clone());+ if let Ok(java) = dunce::canonicalize(java)+ && let Some(home) = java.parent().and_then(Path::parent)+ {+ inputs.push(home.join("release"));+ }+ }+ for (i, arg) in step.args.iter().enumerate() {+ if matches!(arg.as_str(), "-s" | "--settings" | "-gs" | "--global-settings" | "-t" | "--toolchains")+ && let Some(file) = step.args.get(i + 1)+ {+ inputs.push(step.cwd.join(file));+ }+ for prefix in ["--settings=", "--global-settings=", "--toolchains="] {+ if let Some(file) = arg.strip_prefix(prefix) {+ inputs.push(step.cwd.join(file));+ }+ }+ }+ }+ if let Some(home) = dirs::home_dir() {+ inputs.extend([home.join(".m2/settings.xml"), home.join(".m2/toolchains.xml")]);+ }+ for key in ["MAVEN_HOME", "M2_HOME"] {+ if let Some(home) = environment.get(key) {+ inputs.extend([Path::new(home).join("conf/settings.xml"), Path::new(home).join("conf/toolchains.xml")]);+ }+ }+ if let Some(home) = environment.get("JAVA_HOME") {+ inputs.extend([+ Path::new(home).join("release"),+ Path::new(home).join("lib/modules"),+ Path::new(home).join("lib/tools.jar"),+ Path::new(home).join(if cfg!(windows) { "bin/java.exe" } else { "bin/java" }),+ ]);+ }+ let steps: Vec<_> =+ plan.steps.iter().map(|s| (process::program_path(&s.program, &s.env), &s.args, &s.cwd, &s.env)).collect();+ // Profiles and plugins can read arbitrary environment variables. Keep a signature+ // of the inherited environment without persisting unrelated credentials.+ let inherited: BTreeMap<_, _> = std::env::vars_os().collect();+ let mut inherited_hash = std::hash::DefaultHasher::new();+ inherited.hash(&mut inherited_hash);+ let parameters =+ serde_json::to_string(&(root, module, test, steps, environment, inherited_hash.finish(), projects))+ .map_err(|e| IdeError::internal(e.to_string()))?;+ let mut files = BTreeMap::new();+ for path in inputs {+ scan(&path, &mut files, &mut HashSet::new(), cancel)?;+ }+ // Store project inputs relative to the project, including each file's relative path.+ let files = files.into_iter().map(|(p, stamp)| (p.strip_prefix(root).unwrap_or(&p).to_path_buf(), stamp)).collect();+ Ok(Some(LaunchFingerprint { version: 1, parameters, files }))+}++#[cfg(test)]+mod tests {+ use super::*;++ fn write(root: &Path, rel: &str, value: &str) {+ let path = root.join(rel);+ fs::create_dir_all(path.parent().unwrap()).unwrap();+ fs::write(path, value).unwrap();+ }++ fn fixture(root: &Path) -> BuildModel {+ write(+ root,+ "pom.xml",+ r#"<project><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version>+ <packaging>pom</packaging><modules><module>lib</module><module>app</module></modules></project>"#,+ );+ write(+ root,+ "lib/pom.xml",+ r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></parent>+ <artifactId>lib</artifactId><build><sourceDirectory>code</sourceDirectory><resources><resource><directory>conf</directory></resource></resources></build></project>"#,+ );+ write(+ root,+ "app/pom.xml",+ r#"<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></parent>+ <artifactId>app</artifactId><dependencies><dependency><groupId>demo</groupId><artifactId>lib</artifactId><version>1</version></dependency></dependencies></project>"#,+ );+ write(root, "lib/src/main/kotlin/Channel.kt", "value");+ write(root, "app/src/main/resources/app.properties", "key=value");+ write(root, "lib/conf/custom.properties", "custom=value");+ write(root, "lib/code/Custom.java", "class Custom {}");+ BuildModel { maven: Some(maven::load(root)), ..Default::default() }+ }++ fn fingerprint(root: &Path, model: &BuildModel) -> Option<LaunchFingerprint> {+ launch_fingerprint(root, model, &root.join("app"), false, None, &CancellationToken::new()).unwrap()+ }++ #[test]+ fn unchanged_inputs_match_but_source_resource_pom_add_delete_and_mtime_invalidate() {+ for rel in [+ "lib/src/main/kotlin/Channel.kt",+ "app/src/main/resources/app.properties",+ "lib/conf/custom.properties",+ "lib/code/Custom.java",+ "app/pom.xml",+ "lib/pom.xml",+ "pom.xml",+ ".mvn/maven.config",+ "lib/src/main/groovy/New.groovy",+ "app/src/test/scala/Test.scala",+ ] {+ let dir = tempfile::tempdir().unwrap();+ let root = dir.path();+ let model = fixture(root);+ let before = fingerprint(root, &model);+ assert!(before.is_some());+ assert_eq!(before, fingerprint(root, &model), "unchanged {rel}");+ let serialized = serde_json::to_vec(&before).unwrap();+ assert_eq!(before, serde_json::from_slice(&serialized).unwrap());+ let value = if rel.ends_with("pom.xml") {+ format!("{}<!-- changed -->", fs::read_to_string(root.join(rel)).unwrap())+ } else {+ "changed input".to_owned()+ };+ write(root, rel, &value);+ let changed = fingerprint(root, &model);+ assert_ne!(before, changed, "changed/added {rel}");+ let file = fs::OpenOptions::new().write(true).open(root.join(rel)).unwrap();+ file.set_modified(SystemTime::UNIX_EPOCH + std::time::Duration::from_secs(42)).unwrap();+ let touched = fingerprint(root, &model);+ assert_ne!(changed, touched, "mtime-only {rel}");+ fs::remove_file(root.join(rel)).unwrap();+ assert_ne!(touched, fingerprint(root, &model), "deleted {rel}");+ }+ }++ #[test]+ fn profile_options_jdk_goal_and_wrapper_invalidate_without_using_class_outputs() {+ let dir = tempfile::tempdir().unwrap();+ let root = dir.path();+ let mut model = fixture(root);+ let before = fingerprint(root, &model);+ write(root, "lib/target/classes/Channel.class", "JDT stub");+ write(root, "app/target/classes/Main.class", "JDT stub");+ assert_eq!(before, fingerprint(root, &model));+ let mut previous = before.clone();+ for option in ["-Pdev", "-Pprod", "-DskipTests", "-o"] {+ model.maven.as_mut().unwrap().projects[0].options = vec![option.into()];+ let current = fingerprint(root, &model);+ assert_ne!(previous, current, "{option}");+ previous = current;+ }+ model.maven.as_mut().unwrap().projects[0].options.clear();+ model.maven.as_mut().unwrap().projects[0]+ .env+ .insert("JAVA_HOME".into(), root.join("jdk").to_string_lossy().into_owned());+ let jdk = fingerprint(root, &model);+ assert_ne!(before, jdk);+ write(root, "jdk/release", "JAVA_VERSION=21");+ assert_ne!(jdk, fingerprint(root, &model));+ model.maven.as_mut().unwrap().projects[0].env.clear();+ let test = launch_fingerprint(root, &model, &root.join("app"), true, None, &CancellationToken::new())+ .unwrap()+ .unwrap();+ assert_ne!(before, Some(test));+ write(root, "mvnw", "wrapper changed");+ assert_ne!(before, fingerprint(root, &model));+ }++ #[test]+ fn unresolved_roots_and_cancel_never_claim_up_to_date() {+ let dir = tempfile::tempdir().unwrap();+ let root = dir.path();+ let model = fixture(root);+ write(+ root,+ "lib/pom.xml",+ "<project><artifactId>lib</artifactId><build><sourceDirectory>${unknown}/src</sourceDirectory></build></project>",+ );+ assert!(+ launch_fingerprint(root, &model, &root.join("app"), false, None, &CancellationToken::new())+ .unwrap()+ .is_none()+ );+ let model = fixture(root);+ let cancel = CancellationToken::new();+ cancel.cancel();+ assert!(launch_fingerprint(root, &model, &root.join("app"), false, None, &cancel).is_err());+ }+ #[test]+ fn external_parent_and_selected_settings_files_invalidate() {+ let dir = tempfile::tempdir().unwrap();+ let root = dir.path().join("project");+ let repo = dir.path().join("repository");+ write(+ &repo,+ "demo/parent/1/parent-1.pom",+ "<project><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version></project>",+ );+ write(+ &root,+ "pom.xml",+ "<project><parent><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version><relativePath/></parent><artifactId>app</artifactId></project>",+ );+ let mut model = crate::load(&root, &root.join("cache"), Some(repo.clone()));+ let settings = dir.path().join("custom-settings.xml");+ fs::write(&settings, "<settings/>").unwrap();+ model.maven.as_mut().unwrap().projects[0].options = vec!["-s".into(), settings.to_string_lossy().into_owned()];+ let get =+ || launch_fingerprint(&root, &model, &root, false, Some(repo.clone()), &CancellationToken::new()).unwrap();+ let before = get();+ assert!(before.is_some());+ write(+ &repo,+ "demo/parent/1/parent-1.pom",+ "<project><groupId>demo</groupId><artifactId>parent</artifactId><version>1</version><!-- changed --></project>",+ );+ let parent = get();+ assert_ne!(before, parent);+ fs::write(settings, "<settings><activeProfiles><activeProfile>dev</activeProfile></activeProfiles></settings>")+ .unwrap();+ assert_ne!(parent, get());+ }+}diff --git a/crates/ide-build/src/compile/mod.rs b/crates/ide-build/src/compile/mod.rsindex b674e1adf..9cd0ea26f 100644--- a/crates/ide-build/src/compile/mod.rs+++ b/crates/ide-build/src/compile/mod.rs@@ -3,8 +3,11 @@//! background with cancellation and parses the compiler output into messages//! for the Build tool window, the Problems view and the editor.+mod fingerprint;mod parse;+pub use fingerprint::{LaunchFingerprint, launch_fingerprint};+use crate::process::{self, Stream};use crate::{BuildModel, maven};use ide_core::{CancellationToken, Diagnostic, IdeError, IdeResult, Pos, Range, Severity};diff --git a/crates/ide-build/src/maven.rs b/crates/ide-build/src/maven.rsindex 2c0e3f8fb..7f2561003 100644--- a/crates/ide-build/src/maven.rs+++ b/crates/ide-build/src/maven.rs@@ -601,6 +601,72 @@ impl Resolver {}}+/// Files and source/resource trees consumed by a launch build. Unresolved custom+/// roots disable reuse rather than silently omitting an input.+pub(crate) fn launch_inputs(+ root: &Path,+ projects: &[&MavenProject],+ local_repo: Option<PathBuf>,+) -> Option<Vec<PathBuf>> {+ fn roots(el: &Element, parent: &str, dir: &Path, out: &mut Vec<PathBuf>) -> Option<()> {+ let input =+ matches!(el.name.as_str(), "sourceDirectory" | "testSourceDirectory" | "sourceDir" | "testSourceDir")+ || (matches!(parent, "sources" | "sourceDirs" | "testSources" | "testSourceDirs")+ && matches!(el.name.as_str(), "source" | "sourceDir" | "testSourceDir"))+ || (matches!(parent, "resource" | "testResource" | "source" | "testSource") && el.name == "directory")+ || (parent == "filters" && el.name == "filter");+ // Profile activation may depend on the presence of an otherwise unrelated file.+ let activation = parent == "file" && matches!(el.name.as_str(), "exists" | "missing");+ if input || activation {+ // Other properties can be overridden by -D, profiles or settings.+ // Without Maven's effective roots, conservatively disable reuse for them.+ let value = el+ .text+ .trim()+ .replace("${project.basedir}", &dir.to_string_lossy())+ .replace("${basedir}", &dir.to_string_lossy());+ if value.contains("${") {+ return None;+ }+ if !value.is_empty() {+ out.push(dir.join(value));+ }+ }+ for child in &el.children {+ roots(child, &el.name, dir, out)?;+ }+ Some(())+ }+ let mut resolver = Resolver::new(local_repo.or_else(default_local_repo));+ let mut out = Vec::new();+ for project in projects {+ let dir = root.join(&project.dir);+ // Include all conventional language/resource roots, including nonstandard files under src.+ out.push(dir.join("src"));+ let pom = root.join(&project.pom);+ resolver.context(&pom, 0);+ let mut path = pom;+ let mut seen = HashSet::new();+ loop {+ let canonical = dunce::canonicalize(&path).ok()?;+ if !seen.insert(canonical) || seen.len() > MAX_PARENT_DEPTH {+ return None;+ }+ out.push(path.clone());+ let text = std::fs::read_to_string(&path).ok()?;+ roots(&xml::parse(&text)?, "", &dir, &mut out)?;+ let raw = resolver.pom(&path)?;+ let Some(parent) = raw.parent else { break };+ path = resolver.parent_path(path.parent()?, &parent)?;+ }+ }+ // Also track imported BOMs read while resolving inheritance.+ out.extend(resolver.poms.into_keys());+ out.sort();+ out.dedup();+ Some(out)+}+// ---------------------------------------------------------------- plugins/// `maven-clean-plugin` → `clean`, `spring-boot-maven-plugin` → `spring-boot`.diff --git a/crates/ide-build/src/process.rs b/crates/ide-build/src/process.rsindex b598eb791..8177089f0 100644--- a/crates/ide-build/src/process.rs+++ b/crates/ide-build/src/process.rs@@ -37,7 +37,7 @@ fn kill_tree(child: &mut Child) {/// `program` as spawnable: a bare name (`mvn`, `mvn.cmd`) resolves on the IDE's/// search path — the login shell's `PATH` plus version-manager shims — since the/// app's own `PATH` can be minimal and `Command` would not see `mvn` there.-fn program_path(program: &str, env: &BTreeMap<String, String>) -> std::path::PathBuf {+pub(crate) fn program_path(program: &str, env: &BTreeMap<String, String>) -> std::path::PathBuf {let path = std::path::Path::new(program);if !path.is_relative() || path.components().count() > 1 {return path.to_path_buf();diff --git a/crates/ide-host/src/ops/java.rs b/crates/ide-host/src/ops/java.rsindex 6e334ca73..47beb38d5 100644--- a/crates/ide-host/src/ops/java.rs+++ b/crates/ide-host/src/ops/java.rs@@ -1,4 +1,6 @@//! Java launch support: classpath / JDK resolution and the java-debug server (jdtls).+pub(crate) mod cache;+use crate::Host;use crate::rpc::Dispatcher;@@ -44,10 +46,13 @@ async fn resolve_launch(let settings = settings.clone();let module = module.clone();tokio::task::spawn_blocking(move || {+ project.java_launch_snapshots.lock().initialize();let model = load(&project.root, &project.build_cache_dir(), &settings);- let external = build && compile::launch_has_non_java_sources(&project.root, &model, &module, test);- let delegated = external- && model.maven.as_ref().is_some_and(|m| m.projects.iter().any(|p| project.root.join(&p.dir) == module));+ let non_java = build && compile::launch_has_non_java_sources(&project.root, &model, &module, test);+ let delegated = build+ && model.maven.as_ref().is_some_and(|m| m.projects.iter().any(|p| project.root.join(&p.dir) == module))+ && (non_java || cache::has_record(&project.root, &project.build_cache_dir(), &module));+ let external = non_java || delegated;(model, external, delegated)}).await@@ -60,20 +65,24 @@ async fn resolve_launch(let cancel = cancel.clone();tokio::task::spawn_blocking(move || {let _external_build = external_build;- let built = if external {- compile::build_for_launch(&project.root, &model, &module, test, &cancel)?- } else {- Vec::new()- };let built = if delegated {- let (snapshot, copies) = snapshot_outputs(&mut info, &built, &cancel)?;- project.java_launch_outputs.lock().push(snapshot);+ let outputs = project.java_launch_snapshots.lock().build(+ &project.root,+ &model,+ &module,+ test,+ ide_sdk::apply::maven_local_repository(&project.root, &settings),+ &cancel,+ )?;+ let copies = use_snapshot(&mut info, &outputs.originals, &outputs.snapshot);info.build = Some(JavaBuildStatus::Succeeded);info.errors.clear();info.error_count = 0;copies+ } else if external {+ compile::build_for_launch(&project.root, &model, &module, test, &cancel)?} else {- built+ Vec::new()};let mut class_paths: Vec<String> = built.iter().map(|p| p.to_string_lossy().into_owned()).collect();for p in std::mem::take(&mut info.class_paths) {@@ -122,19 +131,10 @@ async fn resolve_launch(.map_err(|e| IdeError::internal(e.to_string()))?}-fn snapshot_outputs(- info: &mut JavaLaunchInfo,- built: &[PathBuf],- cancel: &CancellationToken,-) -> IdeResult<(tempfile::TempDir, Vec<PathBuf>)> {- let snapshot = tempfile::Builder::new().prefix("openidea-java-launch-").tempdir()?;+fn use_snapshot(info: &mut JavaLaunchInfo, built: &[PathBuf], snapshot: &std::path::Path) -> Vec<PathBuf> {let mut copies = Vec::new();for (index, source) in built.iter().enumerate() {- if cancel.is_cancelled() {- return Err(IdeError::cancelled());- }- let dest = snapshot.path().join(index.to_string());- ide_vfs::copy(source, &dest)?;+ let dest = snapshot.join(index.to_string());let original = source.to_string_lossy();info.class_paths.retain(|p| p != original.as_ref());let mut modular = false;@@ -148,7 +148,7 @@ fn snapshot_outputs(copies.push(dest);}}- Ok((snapshot, copies))+ copies}/// Port of java-debug's DAP server inside the jdtls serving `module` (started on demand).@@ -199,8 +199,11 @@ mod tests {module_paths: vec![lib.to_string_lossy().into_owned()],..Default::default()};- let (snapshot, paths) =- snapshot_outputs(&mut info, &[app.clone(), lib.clone()], &CancellationToken::new()).unwrap();+ let snapshot = tempfile::tempdir().unwrap();+ for (i, source) in [&app, &lib].iter().enumerate() {+ ide_vfs::copy(source, &snapshot.path().join(i.to_string())).unwrap();+ }+ let paths = use_snapshot(&mut info, &[app.clone(), lib.clone()], snapshot.path());assert_eq!(paths, [snapshot.path().join("0")]);assert_eq!(info.class_paths, ["stdlib.jar"]);assert_eq!(info.module_paths, [snapshot.path().join("1").to_string_lossy().into_owned()]);@@ -212,11 +215,5 @@ mod tests {"Maven bytecode");}- let cancel = CancellationToken::new();- cancel.cancel();- assert_eq!(- snapshot_outputs(&mut info, &[app], &cancel).unwrap_err().kind,- ide_core::error::ErrorKind::Cancelled- );}}diff --git a/crates/ide-host/src/ops/java/cache.rs b/crates/ide-host/src/ops/java/cache.rsnew file mode 100644index 000000000..422ade156--- /dev/null+++ b/crates/ide-host/src/ops/java/cache.rs@@ -0,0 +1,371 @@+//! Immutable Maven outputs retained in the project cache, including across close/reopen.+use ide_build::compile::{self, LaunchFingerprint};+use ide_core::{CancellationToken, IdeError, IdeResult};+use serde::{Deserialize, Serialize};+use std::collections::HashSet;+use std::fs;+use std::path::{Path, PathBuf};++#[derive(Debug, Serialize, Deserialize)]+pub(super) struct Outputs {+ fingerprint: Option<LaunchFingerprint>,+ pub snapshot: PathBuf,+ pub originals: Vec<PathBuf>,+}++impl Outputs {+ fn reusable(&self, fingerprint: &Option<LaunchFingerprint>, snapshots: &Path) -> bool {+ fingerprint.is_some()+ && self.fingerprint == *fingerprint+ && self.snapshot.parent() == Some(snapshots)+ && !self.originals.is_empty()+ && (0..self.originals.len()).all(|i| self.snapshot.join(i.to_string()).is_dir())+ }+}++fn record_path(root: &Path, cache: &Path, module: &Path, test: bool) -> Option<PathBuf> {+ Some(cache.join("java-launch/records").join(module.strip_prefix(root).ok()?).join(if test {+ "test.json"+ } else {+ "main.json"+ }))+}++pub(super) fn has_record(root: &Path, cache: &Path, module: &Path) -> bool {+ [false, true].into_iter().any(|test| record_path(root, cache, module, test).is_some_and(|record| record.is_file()))+}++/// Owned by Project: running JVMs may still load superseded outputs until it drops.+pub(crate) struct Session {+ cache: PathBuf,+ initialized: bool,+ unreferenced: Vec<PathBuf>,+}++impl Session {+ pub(crate) fn new(cache: PathBuf) -> Self {+ Self { cache, initialized: false, unreferenced: Vec::new() }+ }++ pub(super) fn initialize(&mut self) {+ if !self.initialized {+ self.initialized = true;+ if let Err(error) = sweep(&self.cache) {+ tracing::warn!(%error, "Cannot clean previous Java launch snapshots");+ }+ }+ }++ pub(super) fn build(+ &mut self,+ root: &Path,+ model: &ide_build::BuildModel,+ module: &Path,+ test: bool,+ local_repo: Option<PathBuf>,+ cancel: &CancellationToken,+ ) -> IdeResult<Outputs> {+ self.initialize();+ let cache = &self.cache;+ let record =+ record_path(root, cache, module, test).ok_or_else(|| IdeError::internal("launch outside project"))?;+ let snapshots = cache.join("java-launch/snapshots");+ let fingerprint = || match compile::launch_fingerprint(root, model, module, test, local_repo.clone(), cancel) {+ Ok(value) => Ok(value),+ Err(e) if cancel.is_cancelled() => Err(e),+ Err(e) => {+ tracing::debug!(error = %e, "Cannot fingerprint Maven launch; rebuilding");+ Ok(None)+ }+ };+ let before = fingerprint()?;+ let previous = fs::read(&record).ok().and_then(|bytes| serde_json::from_slice::<Outputs>(&bytes).ok());+ if let Some(outputs) = previous.as_ref()+ && outputs.reusable(&before, &snapshots)+ {+ tracing::info!(module = %module.display(), test, "Reusing Maven launch snapshot");+ return Ok(previous.unwrap());+ }+ // Retain a non-reusable record even on failure, so removing the final mixed+ // source still delegates to Maven to clean its old classes on the next launch.+ fs::create_dir_all(record.parent().unwrap())?;+ fs::write(&record, b"null")?;+ if let Some(previous) = previous {+ self.unreferenced.push(previous.snapshot);+ }+ let originals = compile::build_for_launch(root, model, module, test, cancel)?;+ fs::create_dir_all(&snapshots)?;+ let snapshot = tempfile::Builder::new().prefix("launch-").tempdir_in(&snapshots)?.keep();+ // Retain every new snapshot even if copying or publishing its record fails.+ self.unreferenced.push(snapshot.clone());+ for (i, source) in originals.iter().enumerate() {+ if cancel.is_cancelled() {+ return Err(IdeError::cancelled());+ }+ ide_vfs::copy(source, &snapshot.join(i.to_string()))?;+ }+ let after = fingerprint()?;+ if cancel.is_cancelled() {+ return Err(IdeError::cancelled());+ }+ let mut outputs = Outputs { fingerprint: None, snapshot, originals };+ if before.is_some() && before == after {+ outputs.fingerprint = before;+ fs::create_dir_all(record.parent().unwrap())?;+ let mut file = tempfile::NamedTempFile::new_in(record.parent().unwrap())?;+ serde_json::to_writer(file.as_file_mut(), &outputs).map_err(|e| IdeError::internal(e.to_string()))?;+ file.persist(&record).map_err(|e| IdeError::from(e.error))?;+ self.unreferenced.retain(|path| path != &outputs.snapshot);+ }+ Ok(outputs)+ }+}++impl Drop for Session {+ fn drop(&mut self) {+ // Recheck all records: another module or launch mode may reference a path.+ if let Ok(referenced) = referenced_snapshots(&self.cache) {+ let snapshots = self.cache.join("java-launch/snapshots");+ for path in &self.unreferenced {+ remove_unreferenced(path, &snapshots, &referenced);+ }+ }+ }+}++fn referenced_snapshots(cache: &Path) -> std::io::Result<HashSet<PathBuf>> {+ let mut referenced = HashSet::new();+ let records = cache.join("java-launch/records");+ if !records.try_exists()? {+ return Ok(referenced);+ }+ let mut pending = vec![records];+ while let Some(dir) = pending.pop() {+ for entry in fs::read_dir(dir)? {+ let entry = entry?;+ let kind = entry.file_type()?;+ if kind.is_dir() {+ pending.push(entry.path());+ } else if kind.is_file() && entry.path().extension().is_some_and(|ext| ext == "json") {+ let outputs: Option<Outputs> = serde_json::from_slice(&fs::read(entry.path())?)?;+ if let Some(outputs) = outputs+ && let Ok(path) = fs::canonicalize(outputs.snapshot)+ {+ referenced.insert(path);+ }+ }+ }+ }+ Ok(referenced)+}++fn remove_unreferenced(path: &Path, snapshots: &Path, referenced: &HashSet<PathBuf>) {+ // Only real launch-* directories directly inside snapshots, never symlinks.+ if path.parent() != Some(snapshots)+ || !path.file_name().is_some_and(|name| name.to_string_lossy().starts_with("launch-"))+ || !fs::symlink_metadata(path).is_ok_and(|meta| meta.file_type().is_dir())+ {+ return;+ }+ if let (Ok(path), Ok(snapshots)) = (fs::canonicalize(path), fs::canonicalize(snapshots))+ && path.parent() == Some(snapshots.as_path())+ && !referenced.contains(&path)+ && let Err(error) = fs::remove_dir_all(&path)+ {+ tracing::warn!(%error, path = %path.display(), "Cannot remove Java launch snapshot");+ }+}++fn sweep(cache: &Path) -> std::io::Result<()> {+ let referenced = referenced_snapshots(cache)?;+ let snapshots = cache.join("java-launch/snapshots");+ if snapshots.try_exists()? {+ for entry in fs::read_dir(&snapshots)? {+ remove_unreferenced(&entry?.path(), &snapshots, &referenced);+ }+ }+ Ok(())+}++#[cfg(all(test, unix))]+mod tests {+ use super::*;+ use std::os::unix::fs::PermissionsExt;++ fn fixture(root: &Path) -> ide_build::BuildModel {+ fs::write(+ root.join("pom.xml"),+ r#"<project><groupId>demo</groupId><artifactId>app</artifactId><version>1</version></project>"#,+ )+ .unwrap();+ let script = root.join("mvnw");+ fs::write(&script, "#!/bin/sh\necho build >> calls\nif [ -f src/main/kotlin/broken ]; then exit 1; fi\nmkdir -p target/classes\ncp src/main/kotlin/Main.kt target/classes/Main.class\n").unwrap();+ fs::set_permissions(&script, fs::Permissions::from_mode(0o755)).unwrap();+ fs::create_dir_all(root.join("src/main/kotlin")).unwrap();+ fs::write(root.join("src/main/kotlin/Main.kt"), "first").unwrap();+ ide_build::load(root, &root.join("cache"), None)+ }++ #[test]+ fn successful_snapshots_reuse_across_close_and_rebuild_for_changes_missing_outputs_or_failure() {+ let dir = tempfile::tempdir().unwrap();+ let root = dir.path();+ let model = fixture(root);+ let cache = root.join("cache");+ let cancel = CancellationToken::new();+ let mut session = Session::new(cache.clone());+ let mut build = || session.build(root, &model, root, false, None, &cancel);+ let first = build().unwrap();+ let snapshot = first.snapshot.clone();+ drop(first);+ // Dropping an Outputs value leaves the persisted snapshot reusable.+ let second = build().unwrap();+ assert_eq!(snapshot, second.snapshot);+ assert_eq!(fs::read_to_string(root.join("calls")).unwrap().lines().count(), 1);+ fs::write(root.join("target/classes/Main.class"), "JDT stub").unwrap();+ assert_eq!(snapshot, build().unwrap().snapshot);+ assert_eq!(fs::read_to_string(snapshot.join("0/Main.class")).unwrap(), "first");+ fs::write(root.join("src/main/kotlin/Main.kt"), "updated").unwrap();+ let updated = build().unwrap();+ assert_ne!(snapshot, updated.snapshot);+ assert_eq!(fs::read_to_string(updated.snapshot.join("0/Main.class")).unwrap(), "updated");+ assert!(snapshot.join("0/Main.class").is_file(), "previous JVMs may still load it");+ fs::remove_dir_all(updated.snapshot.join("0")).unwrap();+ let rebuilt = build().unwrap();+ assert_ne!(rebuilt.snapshot, updated.snapshot);+ fs::write(root.join("src/main/kotlin/broken"), "broken").unwrap();+ assert!(build().is_err());+ assert_eq!(fs::read(cache.join("java-launch/records/main.json")).unwrap(), b"null");+ fs::remove_file(root.join("src/main/kotlin/broken")).unwrap();+ assert_ne!(rebuilt.snapshot, build().unwrap().snapshot, "a failed build invalidates success");+ cancel.cancel();+ assert!(build().is_err());+ assert_eq!(fs::read_to_string(root.join("calls")).unwrap().lines().count(), 5);+ }+ #[test]+ fn session_drop_removes_superseded_snapshots_and_preserves_records_across_reopen() {+ let dir = tempfile::tempdir().unwrap();+ let root = dir.path();+ let model = fixture(root);+ let cache = root.join("cache");+ let cancel = CancellationToken::new();+ let mut session = Session::new(cache.clone());+ let first = session.build(root, &model, root, false, None, &cancel).unwrap();+ fs::write(root.join("src/main/kotlin/Main.kt"), "updated").unwrap();+ let second = session.build(root, &model, root, false, None, &cancel).unwrap();+ assert!(first.snapshot.is_dir());+ assert!(second.snapshot.is_dir());+ // Another mode can keep a superseded snapshot alive.+ let test_record = cache.join("java-launch/records/nested/test.json");+ fs::create_dir_all(test_record.parent().unwrap()).unwrap();+ fs::write(&test_record, serde_json::to_vec(&first).unwrap()).unwrap();+ drop(session);+ assert!(first.snapshot.is_dir());+ assert!(second.snapshot.is_dir());+ let mut session = Session::new(cache.clone());+ let reused = session.build(root, &model, root, false, None, &cancel).unwrap();+ assert_eq!(reused.snapshot, second.snapshot);+ fs::write(root.join("src/main/kotlin/Main.kt"), "third version").unwrap();+ let third = session.build(root, &model, root, false, None, &cancel).unwrap();+ assert!(second.snapshot.is_dir());+ drop(session);+ assert!(!second.snapshot.exists());+ assert!(first.snapshot.is_dir());+ assert!(third.snapshot.is_dir());+ assert_eq!(fs::read_to_string(root.join("calls")).unwrap().lines().count(), 3);+ }++ #[test]+ fn initial_sweep_only_removes_unreferenced_direct_snapshot_directories() {+ let dir = tempfile::tempdir().unwrap();+ let cache = dir.path().join("cache");+ let snapshots = cache.join("java-launch/snapshots");+ let retained = snapshots.join("launch-retained");+ let orphan = snapshots.join("launch-orphan");+ let other = snapshots.join("other");+ let nested = other.join("launch-nested");+ let outside = dir.path().join("launch-outside");+ for path in [&retained, &orphan, &nested, &outside] {+ fs::create_dir_all(path).unwrap();+ }+ fs::write(outside.join("classes"), "keep").unwrap();+ std::os::unix::fs::symlink(&outside, snapshots.join("launch-link")).unwrap();+ fs::write(snapshots.join("launch-file"), "keep").unwrap();+ let record = cache.join("java-launch/records/deep/module/test.json");+ fs::create_dir_all(record.parent().unwrap()).unwrap();+ let outputs = Outputs { fingerprint: None, snapshot: retained.clone(), originals: Vec::new() };+ fs::write(record, serde_json::to_vec(&outputs).unwrap()).unwrap();+ let mut session = Session::new(cache);+ session.initialize();+ assert!(!orphan.exists());+ assert!(retained.is_dir());+ assert!(nested.is_dir());+ assert!(outside.join("classes").is_file());+ assert!(snapshots.join("launch-link").is_symlink());+ assert!(snapshots.join("launch-file").is_file());+ // Initialization must not sweep snapshots still in use by this session.+ fs::create_dir_all(&orphan).unwrap();+ session.initialize();+ assert!(orphan.is_dir());+ session.unreferenced.extend([outside.clone(), snapshots.join("../../launch-outside"), nested]);+ drop(session);+ assert!(outside.join("classes").is_file());+ assert!(other.join("launch-nested").is_dir());+ }++ #[test]+ fn failed_record_publish_retains_snapshot_until_session_drop() {+ let dir = tempfile::tempdir().unwrap();+ let root = dir.path();+ let model = fixture(root);+ let script = root.join("mvnw");+ let mut text = fs::read_to_string(&script).unwrap();+ text.push_str("rm cache/java-launch/records/main.json\nmkdir cache/java-launch/records/main.json\n");+ fs::write(script, text).unwrap();+ let cache = root.join("cache");+ let mut session = Session::new(cache.clone());+ assert!(session.build(root, &model, root, false, None, &CancellationToken::new()).is_err());+ assert_eq!(session.unreferenced.len(), 1);+ let snapshot = session.unreferenced[0].clone();+ assert!(snapshot.join("0/Main.class").is_file());+ drop(session);+ assert!(!snapshot.exists());+ }++ #[test]+ fn edits_during_build_do_not_publish_a_success_record() {+ let dir = tempfile::tempdir().unwrap();+ let root = dir.path();+ let model = fixture(root);+ let script = root.join("mvnw");+ let mut text = fs::read_to_string(&script).unwrap();+ text.push_str("echo edited-during-build >> src/main/kotlin/Main.kt\n");+ fs::write(script, text).unwrap();+ let cache = root.join("cache");+ let mut session = Session::new(cache.clone());+ let outputs = session.build(root, &model, root, false, None, &CancellationToken::new()).unwrap();+ assert!(outputs.fingerprint.is_none());+ assert_eq!(fs::read(cache.join("java-launch/records/main.json")).unwrap(), b"null");+ assert!(outputs.snapshot.join("0/Main.class").is_file());+ drop(session);+ assert!(!outputs.snapshot.exists());+ }+ #[test]+ fn deleting_the_last_mixed_source_keeps_maven_delegation_after_failure() {+ let dir = tempfile::tempdir().unwrap();+ let root = dir.path();+ let model = fixture(root);+ let cache = root.join("cache");+ let cancel = CancellationToken::new();+ let mut session = Session::new(cache.clone());+ let first = session.build(root, &model, root, false, None, &cancel).unwrap();+ fs::remove_file(root.join("src/main/kotlin/Main.kt")).unwrap();+ assert!(!compile::launch_has_non_java_sources(root, &model, root, false));+ assert!(has_record(root, &cache, root));+ assert!(session.build(root, &model, root, false, None, &cancel).is_err());+ assert!(has_record(root, &cache, root));+ fs::write(root.join("src/main/kotlin/Main.kt"), "restored").unwrap();+ let restored = session.build(root, &model, root, false, None, &cancel).unwrap();+ assert_ne!(first.snapshot, restored.snapshot);+ }+}diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rsindex caf5afea0..e3d868e21 100644--- a/crates/ide-host/src/project.rs+++ b/crates/ide-host/src/project.rs@@ -42,8 +42,8 @@ pub struct Project {pub detected_roots: Arc<RwLock<Vec<SourceFolder>>>,/// Per-project cache directory (build tool sync results…).pub cache_dir: PathBuf,- /// Launch snapshots stay alive while any JVM of this project may load classes.- pub(crate) java_launch_outputs: Mutex<Vec<tempfile::TempDir>>,+ /// Superseded launch snapshots retained until this project session ends.+ pub(crate) java_launch_snapshots: Mutex<crate::ops::java::cache::Session>,/// Database tool window: data sources and their connections.pub db: Arc<ide_db::DbManager>,/// HTTP Client responses (IDEA's `.idea/httpRequests`), in the app data dir.@@ -368,7 +368,9 @@ impl Host {syntax,detected_roots,cache_dir: self.data_dir.join("cache").join(&project_key),- java_launch_outputs: Mutex::new(Vec::new()),+ java_launch_snapshots: Mutex::new(crate::ops::java::cache::Session::new(+ self.data_dir.join("cache").join(&project_key).join("build"),+ )),db,http_history,agents,@@ -484,7 +486,9 @@ impl Host {syntax,detected_roots: Arc::default(),cache_dir: self.data_dir.join("cache").join(&project_key),- java_launch_outputs: Mutex::new(Vec::new()),+ java_launch_snapshots: Mutex::new(crate::ops::java::cache::Session::new(+ self.data_dir.join("cache").join(&project_key).join("build"),+ )),db,http_history,agents,