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.

feat(run): share Java preparation and add incremental build policies (#2156)

misswell9f9a2d8cf033
diff --git a/crates/ide-build/src/compile/fingerprint.rs b/crates/ide-build/src/compile/fingerprint.rs
index 7ed4b9237..a9297c106 100644
--- a/crates/ide-build/src/compile/fingerprint.rs
+++ b/crates/ide-build/src/compile/fingerprint.rs
@@ -95,7 +95,7 @@ pub fn launch_fingerprint(
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 plan = launch_plan(root, model, module, test, BuildKind::Build)?;
let mut environment: BTreeMap<String, String> = std::env::vars()
.map(|(key, value)| (key.to_ascii_uppercase(), value))
.filter(|(key, _)| {
diff --git a/crates/ide-build/src/compile/mod.rs b/crates/ide-build/src/compile/mod.rs
index 954c95962..993d510a3 100644
--- a/crates/ide-build/src/compile/mod.rs
+++ b/crates/ide-build/src/compile/mod.rs
@@ -772,13 +772,7 @@ pub fn launch_has_non_java_sources(root: &Path, model: &BuildModel, module: &Pat
has_non_java_sources(module)
}
-fn launch_plan(root: &Path, model: &BuildModel, module: &Path, test: bool) -> IdeResult<BuildPlan> {
- let kind = if model.maven.as_ref().is_some_and(|m| m.projects.iter().any(|p| subdir(root, &p.dir) == module)) {
- // JDT may have left newer error stubs in Maven's output directories.
- BuildKind::Rebuild
- } else {
- BuildKind::Build
- };
+fn launch_plan(root: &Path, model: &BuildModel, module: &Path, test: bool, kind: BuildKind) -> IdeResult<BuildPlan> {
let mut plan = plan(root, model, kind, Some(module), None)?;
if plan.system == BuildSystem::Maven && !test {
for step in &mut plan.steps {
@@ -790,6 +784,12 @@ fn launch_plan(root: &Path, model: &BuildModel, module: &Path, test: bool) -> Id
Ok(plan)
}
+#[derive(Debug)]
+pub struct LaunchBuild {
+ pub class_dirs: Vec<PathBuf>,
+ pub failure: Option<String>,
+}
+
/// Compiles the module at `module` with its build system before a JVM launch and
/// returns the class directories it wrote, to put ahead of the jdtls classpath.
pub fn build_for_launch(
@@ -797,11 +797,12 @@ pub fn build_for_launch(
model: &BuildModel,
module: &Path,
test: bool,
+ kind: BuildKind,
cancel: &CancellationToken,
-) -> IdeResult<Vec<PathBuf>> {
- let plan = launch_plan(root, model, module, test)?;
+) -> IdeResult<LaunchBuild> {
+ let plan = launch_plan(root, model, module, test, kind)?;
let result = run(root, &plan, cancel, &|_| {})?;
- if !result.success {
+ let failure = if !result.success {
let errors: Vec<String> = result
.messages
.iter()
@@ -812,17 +813,21 @@ pub fn build_for_launch(
_ => m.text.clone(),
})
.collect();
- return Err(IdeError::internal(format!("Build failed:\n{}", errors.join("\n"))));
- }
- if plan.system == BuildSystem::Maven
+ Some(format!("Build failed:\n{}", errors.join("\n")))
+ } else {
+ None
+ };
+ let class_dirs = if plan.system == BuildSystem::Maven
&& let Some(m) = &model.maven
{
- return Ok(maven_launch_projects(root, m, module, test)
+ maven_launch_projects(root, m, module, test)
.iter()
.flat_map(|p| launch_class_dirs(plan.system, &subdir(root, &p.dir), test && subdir(root, &p.dir) == module))
- .collect());
- }
- Ok(launch_class_dirs(plan.system, module, test))
+ .collect()
+ } else {
+ launch_class_dirs(plan.system, module, test)
+ };
+ Ok(LaunchBuild { class_dirs, failure })
}
fn launch_class_dirs(system: BuildSystem, module: &Path, test: bool) -> Vec<PathBuf> {
@@ -1309,13 +1314,17 @@ mod tests {
write(root, "app/pom.xml", "<project/>");
let model = reactor_model();
for (test, goal) in [(false, "compile"), (true, "test-compile")] {
- let plan = launch_plan(root, &model, &root.join("app"), test).unwrap();
+ // A normal launch is incremental: no `clean` (IDEA's Make, not Rebuild).
+ let plan = launch_plan(root, &model, &root.join("app"), test, BuildKind::Build).unwrap();
let step = &plan.steps[0];
assert_eq!(step.cwd, root);
assert_eq!(step.program, "mvnw");
assert_eq!(step.env["JAVA_HOME"], "/jdk");
+ assert_eq!(step.args, ["-B", "-Dstyle.color=never", "-s", "settings.xml", "-pl", "app", "-am", goal]);
+ // Rebuild cleans first, as IDEA's Rebuild does.
+ let plan = launch_plan(root, &model, &root.join("app"), test, BuildKind::Rebuild).unwrap();
assert_eq!(
- step.args,
+ plan.steps[0].args,
["-B", "-Dstyle.color=never", "-s", "settings.xml", "-pl", "app", "-am", "clean", goal]
);
}
@@ -1337,9 +1346,10 @@ mod tests {
std::fs::set_permissions(&wrapper, std::fs::Permissions::from_mode(0o755)).unwrap();
let mut model = reactor_model();
model.maven.as_mut().unwrap().projects[0].command = wrapper.to_string_lossy().into_owned();
- let dirs = build_for_launch(root, &model, &root.join("app"), true, &CancellationToken::new()).unwrap();
+ let dirs = build_for_launch(root, &model, &root.join("app"), true, BuildKind::Build, &CancellationToken::new())
+ .unwrap();
assert_eq!(
- dirs,
+ dirs.class_dirs,
["app/target/test-classes", "app/target/classes", "middle/target/classes", "lib/target/classes"]
.map(|p| root.join(p))
);
@@ -1348,12 +1358,16 @@ mod tests {
"mvnw",
"#!/bin/sh\necho '[ERROR] Kotlin compilation failed: unresolved reference broken' >&2\nexit 1\n",
);
- let error = build_for_launch(root, &model, &root.join("app"), false, &CancellationToken::new()).unwrap_err();
- assert!(error.message.contains("Kotlin compilation failed"), "{}", error.message);
+ let error =
+ build_for_launch(root, &model, &root.join("app"), false, BuildKind::Build, &CancellationToken::new())
+ .unwrap()
+ .failure
+ .unwrap();
+ assert!(error.contains("Kotlin compilation failed"), "{error}");
let cancel = CancellationToken::new();
cancel.cancel();
assert_eq!(
- build_for_launch(root, &model, &root.join("app"), false, &cancel).unwrap_err().kind,
+ build_for_launch(root, &model, &root.join("app"), false, BuildKind::Build, &cancel).unwrap_err().kind,
ide_core::error::ErrorKind::Cancelled
);
}
diff --git a/crates/ide-host/src/ops/java.rs b/crates/ide-host/src/ops/java.rs
index adb8c63d3..9b954c3c8 100644
--- a/crates/ide-host/src/ops/java.rs
+++ b/crates/ide-host/src/ops/java.rs
@@ -8,6 +8,7 @@ use super::build::load;
use ide_build::compile;
use ide_core::{CancellationToken, IdeError, IdeResult, RequestId};
use ide_lsp::jdtls::{JavaBuildStatus, JavaLaunchInfo};
+use ide_run::BuildPolicy;
use std::path::PathBuf;
/// Cancellable with `cancel_request(request)`.
@@ -19,12 +20,12 @@ pub async fn java_resolve_launch(
window: &str,
module: PathBuf,
test: bool,
- build: bool,
+ policy: BuildPolicy,
request: RequestId,
) -> IdeResult<JavaLaunchInfo> {
host.require_trust(window)?;
let cancel = host.begin_project_request(window, request);
- let result = resolve_launch(host, window, module, test, build, &cancel).await;
+ let result = resolve_launch(host, window, module, test, policy, &cancel).await;
host.end_request(request);
result
}
@@ -34,13 +35,17 @@ async fn resolve_launch(
window: &str,
module: PathBuf,
test: bool,
- build: bool,
+ policy: BuildPolicy,
cancel: &CancellationToken,
) -> IdeResult<JavaLaunchInfo> {
let started = std::time::Instant::now();
let project = host.project(window)?;
let module = project.root.join(module);
let settings = project.settings.effective();
+ // A launch builds incrementally unless the configuration asks for Rebuild or NoBuild.
+ let build = policy != BuildPolicy::NoBuild;
+ let full = policy == BuildPolicy::Rebuild;
+ let build_kind = if full { compile::BuildKind::Rebuild } else { compile::BuildKind::Build };
let (model, external, delegated) = {
let project = project.clone();
let settings = settings.clone();
@@ -59,7 +64,7 @@ async fn resolve_launch(
.map_err(|e| IdeError::internal(e.to_string()))?
};
let external_build = if delegated { Some(project.lsp.java_external_build(&module, cancel).await?) } else { None };
- let mut info = project.lsp.java_launch(&module, test, build && !delegated, delegated, cancel).await?;
+ let mut info = project.lsp.java_launch(&module, test, build && !delegated, full, delegated, cancel).await?;
let lsp_ms = started.elapsed().as_millis();
let data_dir = host.local_data_dir.clone();
let cancel = cancel.clone();
@@ -70,17 +75,23 @@ async fn resolve_launch(
&project.root,
&model,
&module,
- test,
+ cache::BuildOptions { test, policy },
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;
+ apply_external_build_result(&mut info, outputs.failure);
copies
} else if external {
- compile::build_for_launch(&project.root, &model, &module, test, &cancel)?
+ let built = compile::build_for_launch(&project.root, &model, &module, test, build_kind, &cancel)?;
+ if let Some(failure) = built.failure {
+ if policy != BuildPolicy::MakeAndContinueOnErrors {
+ return Err(IdeError::internal(failure));
+ }
+ info.build = Some(JavaBuildStatus::Failed);
+ info.hints.push(failure);
+ }
+ built.class_dirs
} else {
Vec::new()
};
@@ -138,6 +149,18 @@ async fn resolve_launch(
.map_err(|e| IdeError::internal(e.to_string()))?
}
+fn apply_external_build_result(info: &mut JavaLaunchInfo, failure: Option<String>) {
+ info.build = Some(if let Some(failure) = failure {
+ info.hints.push(failure);
+ JavaBuildStatus::Failed
+ } else if info.error_count > 0 {
+ // Incremental Maven compilation can accept error-stub classes written by JDT.
+ JavaBuildStatus::WithErrors
+ } else {
+ JavaBuildStatus::Succeeded
+ });
+}
+
/// A classpath entry as a comparable key. Entries come from JDT LS and from our own
/// build model, which spell one directory differently on Windows (`\\?\` prefix,
/// `/` or `\\`, drive-letter case); compared as text, a module output stayed on the
@@ -242,7 +265,7 @@ pub async fn java_build_workspace(
let module = project.root.join(module);
// HotSwap may cancel the compile (the request id is allocated by the caller).
let cancel = request.map_or_else(CancellationToken::new, |id| host.begin_request(id));
- let result = project.lsp.java_build(&module, &cancel).await;
+ let result = project.lsp.java_build(&module, false, &cancel).await;
if let Some(id) = request {
host.end_request(id);
}
@@ -252,7 +275,7 @@ pub async fn java_build_workspace(
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("java_resolve_launch", |c| async move {
- java_resolve_launch(&c.host, &c.window, c.arg("module")?, c.arg("test")?, c.arg("build")?, c.arg("request")?)
+ java_resolve_launch(&c.host, &c.window, c.arg("module")?, c.arg("test")?, c.arg("policy")?, c.arg("request")?)
.await
});
d.add("java_debug_server", |c| async move { java_debug_server(&c.host, &c.window, c.arg("module")?).await });
@@ -265,6 +288,33 @@ pub(crate) fn register(d: &mut Dispatcher) {
mod tests {
use super::*;
+ #[test]
+ fn successful_external_compilation_does_not_erase_scoped_jdt_errors() {
+ for (failure, expected) in
+ [(None, JavaBuildStatus::WithErrors), (Some("compile failed"), JavaBuildStatus::Failed)]
+ {
+ let mut info = JavaLaunchInfo {
+ error_count: 1,
+ errors: vec![ide_lsp::jdtls::JavaCompileError {
+ path: "src/main/java/Main.java".into(),
+ line: 4,
+ column: 28,
+ message: "missingName cannot be resolved to a variable".into(),
+ }],
+ ..Default::default()
+ };
+ let errors = info.errors.clone();
+ apply_external_build_result(&mut info, failure.map(str::to_owned));
+ assert_eq!(info.build, Some(expected));
+ assert_eq!(info.error_count, 1);
+ assert_eq!(info.errors, errors);
+ assert_eq!(info.hints, failure.into_iter().collect::<Vec<_>>());
+ }
+ let mut info = JavaLaunchInfo::default();
+ apply_external_build_result(&mut info, None);
+ assert_eq!(info.build, Some(JavaBuildStatus::Succeeded));
+ }
+
#[test]
fn library_scopes_filter_jdt_classpaths_and_module_paths() {
use ide_core::settings::{DependencyScope, ProjectLibrary};
diff --git a/crates/ide-host/src/ops/java/cache.rs b/crates/ide-host/src/ops/java/cache.rs
index 3f169c620..dc76873ac 100644
--- a/crates/ide-host/src/ops/java/cache.rs
+++ b/crates/ide-host/src/ops/java/cache.rs
@@ -1,6 +1,7 @@
//! 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 ide_run::BuildPolicy;
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
use std::fs;
@@ -11,6 +12,8 @@ pub(super) struct Outputs {
fingerprint: Option<LaunchFingerprint>,
pub snapshot: PathBuf,
pub originals: Vec<PathBuf>,
+ #[serde(skip)]
+ pub failure: Option<String>,
}
impl Outputs {
@@ -35,6 +38,12 @@ 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()))
}
+#[derive(Default)]
+pub(super) struct BuildOptions {
+ pub test: bool,
+ pub policy: BuildPolicy,
+}
+
/// Owned by Project: running JVMs may still load superseded outputs until it drops.
pub(crate) struct Session {
cache: PathBuf,
@@ -61,11 +70,12 @@ impl Session {
root: &Path,
model: &ide_build::BuildModel,
module: &Path,
- test: bool,
+ options: BuildOptions,
local_repo: Option<PathBuf>,
cancel: &CancellationToken,
) -> IdeResult<Outputs> {
self.initialize();
+ let BuildOptions { test, policy } = options;
let cache = &self.cache;
let record =
record_path(root, cache, module, test).ok_or_else(|| IdeError::internal("launch outside project"))?;
@@ -81,6 +91,7 @@ impl Session {
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()
+ && policy != BuildPolicy::Rebuild
&& outputs.reusable(&before, &snapshots)
{
tracing::info!(module = %module.display(), test, "Reusing Maven launch snapshot");
@@ -90,10 +101,27 @@ impl Session {
// 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);
+ if let Some(previous) = &previous {
+ self.unreferenced.push(previous.snapshot.clone());
}
- let originals = compile::build_for_launch(root, model, module, test, cancel)?;
+ let kind = if policy == BuildPolicy::Rebuild { compile::BuildKind::Rebuild } else { compile::BuildKind::Build };
+ let built = compile::build_for_launch(root, model, module, test, kind, cancel)?;
+ if let Some(failure) = &built.failure {
+ if policy != BuildPolicy::MakeAndContinueOnErrors {
+ return Err(IdeError::internal(failure.clone()));
+ }
+ if let Some(mut previous) =
+ previous.filter(|p| (0..p.originals.len()).all(|i| p.snapshot.join(i.to_string()).is_dir()))
+ {
+ previous.fingerprint = None;
+ previous.failure = built.failure;
+ let mut file = tempfile::NamedTempFile::new_in(record.parent().unwrap())?;
+ serde_json::to_writer(file.as_file_mut(), &previous).map_err(|e| IdeError::internal(e.to_string()))?;
+ file.persist(&record).map_err(|e| IdeError::from(e.error))?;
+ return Ok(previous);
+ }
+ }
+ let originals = built.class_dirs;
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.
@@ -108,8 +136,8 @@ impl Session {
if cancel.is_cancelled() {
return Err(IdeError::cancelled());
}
- let mut outputs = Outputs { fingerprint: None, snapshot, originals };
- if before.is_some() && before == after {
+ let mut outputs = Outputs { fingerprint: None, snapshot, originals, failure: built.failure };
+ if outputs.failure.is_none() && 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())?;
@@ -199,13 +227,77 @@ mod tests {
)
.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::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 rebuild_bypasses_snapshots_and_error_continuation_retains_previous_classes() {
+ let dir = tempfile::tempdir().unwrap();
+ let root = dir.path();
+ let model = fixture(root);
+ let cancel = CancellationToken::new();
+ let mut session = Session::new(root.join("cache"));
+ let first = session.build(root, &model, root, BuildOptions::default(), None, &cancel).unwrap();
+ let rebuilt = session
+ .build(
+ root,
+ &model,
+ root,
+ BuildOptions { policy: BuildPolicy::Rebuild, ..Default::default() },
+ None,
+ &cancel,
+ )
+ .unwrap();
+ assert_ne!(first.snapshot, rebuilt.snapshot);
+ assert_eq!(fs::read_to_string(root.join("calls")).unwrap().lines().count(), 2);
+ assert!(fs::read_to_string(root.join("calls")).unwrap().lines().last().unwrap().contains("clean"));
+ fs::write(root.join("src/main/kotlin/broken"), "broken").unwrap();
+ let continued = session
+ .build(
+ root,
+ &model,
+ root,
+ BuildOptions { policy: BuildPolicy::MakeAndContinueOnErrors, ..Default::default() },
+ None,
+ &cancel,
+ )
+ .unwrap();
+ assert_eq!(continued.snapshot, rebuilt.snapshot);
+ assert!(continued.failure.unwrap().contains("Build failed"));
+ assert_eq!(fs::read_to_string(continued.snapshot.join("0/Main.class")).unwrap(), "first");
+ let again = session
+ .build(
+ root,
+ &model,
+ root,
+ BuildOptions { policy: BuildPolicy::MakeAndContinueOnErrors, ..Default::default() },
+ None,
+ &cancel,
+ )
+ .unwrap();
+ assert_eq!(again.snapshot, rebuilt.snapshot);
+ assert!(again.failure.is_some());
+ cancel.cancel();
+ assert_eq!(
+ session
+ .build(
+ root,
+ &model,
+ root,
+ BuildOptions { policy: BuildPolicy::MakeAndContinueOnErrors, ..Default::default() },
+ None,
+ &cancel
+ )
+ .unwrap_err()
+ .kind,
+ ide_core::error::ErrorKind::Cancelled
+ );
+ }
+
#[test]
fn successful_snapshots_reuse_across_close_and_rebuild_for_changes_missing_outputs_or_failure() {
let dir = tempfile::tempdir().unwrap();
@@ -214,7 +306,7 @@ mod tests {
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 mut build = || session.build(root, &model, root, BuildOptions::default(), None, &cancel);
let first = build().unwrap();
let snapshot = first.snapshot.clone();
drop(first);
@@ -253,14 +345,14 @@ mod tests {
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();
+ let first = session.build(root, &model, root, BuildOptions::default(), None, &cancel).unwrap();
assert_eq!(fs::read_to_string(first.snapshot.join("0/Main.class")).unwrap(), "first");
let source = root.join("src/main/kotlin/Main.kt");
let mtime = fs::metadata(&source).unwrap().modified().unwrap();
fs::write(&source, "other").unwrap(); // 5 bytes, same length as "first"
fs::File::options().write(true).open(&source).unwrap().set_modified(mtime).unwrap();
- let rebuilt = session.build(root, &model, root, false, None, &cancel).unwrap();
+ let rebuilt = session.build(root, &model, root, BuildOptions::default(), None, &cancel).unwrap();
assert_ne!(rebuilt.snapshot, first.snapshot, "a same-length, same-mtime content change must rebuild");
assert_eq!(fs::read_to_string(rebuilt.snapshot.join("0/Main.class")).unwrap(), "other");
}
@@ -273,9 +365,9 @@ mod tests {
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();
+ let first = session.build(root, &model, root, BuildOptions::default(), 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();
+ let second = session.build(root, &model, root, BuildOptions::default(), None, &cancel).unwrap();
assert!(first.snapshot.is_dir());
assert!(second.snapshot.is_dir());
// Another mode can keep a superseded snapshot alive.
@@ -286,10 +378,10 @@ mod tests {
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();
+ let reused = session.build(root, &model, root, BuildOptions::default(), 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();
+ let third = session.build(root, &model, root, BuildOptions::default(), None, &cancel).unwrap();
assert!(second.snapshot.is_dir());
drop(session);
assert!(!second.snapshot.exists());
@@ -316,7 +408,7 @@ mod tests {
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() };
+ let outputs = Outputs { fingerprint: None, snapshot: retained.clone(), originals: Vec::new(), failure: None };
fs::write(record, serde_json::to_vec(&outputs).unwrap()).unwrap();
let mut session = Session::new(cache);
session.initialize();
@@ -347,7 +439,7 @@ mod tests {
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!(session.build(root, &model, root, BuildOptions::default(), 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());
@@ -366,7 +458,8 @@ mod tests {
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();
+ let outputs =
+ session.build(root, &model, root, BuildOptions::default(), 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());
@@ -381,14 +474,14 @@ mod tests {
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();
+ let first = session.build(root, &model, root, BuildOptions::default(), 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!(session.build(root, &model, root, BuildOptions::default(), 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();
+ let restored = session.build(root, &model, root, BuildOptions::default(), None, &cancel).unwrap();
assert_ne!(first.snapshot, restored.snapshot);
}
}
diff --git a/crates/ide-lsp/src/jdtls.rs b/crates/ide-lsp/src/jdtls.rs
index 021ade51a..c9603e48b 100644
--- a/crates/ide-lsp/src/jdtls.rs
+++ b/crates/ide-lsp/src/jdtls.rs
@@ -788,10 +788,11 @@ impl LspManager {
/// Incremental build of the jdtls workspace (`java/buildWorkspace`), so
/// class files are up to date before a launch.
- pub async fn java_build(&self, path: &Path, cancel: &CancellationToken) -> IdeResult<JavaBuildStatus> {
+ /// `full` asks jdtls for a clean build (`java/buildWorkspace(true)`, IDEA's Rebuild).
+ pub async fn java_build(&self, path: &Path, full: bool, cancel: &CancellationToken) -> IdeResult<JavaBuildStatus> {
let (server, _) = self.jdtls(path, cancel).await?;
let _lock = cancellable_wait(cancel, server.java_build_lock.lock()).await?;
- let mut v = self.jdtls_request(path, "java/buildWorkspace", json!(false), BUILD_TIMEOUT, cancel).await?;
+ let mut v = self.jdtls_request(path, "java/buildWorkspace", json!(full), BUILD_TIMEOUT, cancel).await?;
// The first build can finish the Maven import before ServiceReady is handled.
let (server, run) = self.jdtls(path, cancel).await?;
let changed = cancellable_wait(cancel, self.java_configure_compiler(&server, &run)).await??;
@@ -799,7 +800,7 @@ impl LspManager {
let recheck = v.as_i64() == Some(2)
&& compiler_defaults(&server.effective_config()).as_object().is_some_and(|o| !o.is_empty());
if changed || recheck {
- v = self.jdtls_request(path, "java/buildWorkspace", json!(false), BUILD_TIMEOUT, cancel).await?;
+ v = self.jdtls_request(path, "java/buildWorkspace", json!(full), BUILD_TIMEOUT, cancel).await?;
}
Ok(JavaBuildStatus::from_code(v.as_i64().unwrap_or(0)))
}
@@ -842,10 +843,11 @@ impl LspManager {
module: &Path,
test: bool,
build: bool,
+ full_build: bool,
build_lock_held: bool,
cancel: &CancellationToken,
) -> IdeResult<JavaLaunchInfo> {
- let build = if build { Some(self.java_build(module, cancel).await?) } else { None };
+ let build = if build { Some(self.java_build(module, full_build, cancel).await?) } else { None };
if build == Some(JavaBuildStatus::Cancelled) {
return Err(IdeError::cancelled());
}
@@ -875,8 +877,8 @@ impl LspManager {
};
(cp, java_home)
};
- let (errors, error_count, scoped) = match build {
- Some(JavaBuildStatus::WithErrors | JavaBuildStatus::Failed) => {
+ let (errors, error_count, scoped) = match (build, build_lock_held) {
+ (Some(JavaBuildStatus::WithErrors | JavaBuildStatus::Failed), _) | (None, true) => {
let scope_module = module.to_path_buf();
let cp = cp.clone();
let scope = tokio::task::spawn_blocking(move || LaunchScope::new(&scope_module, test, cp.as_ref()))
@@ -888,7 +890,9 @@ impl LspManager {
}
_ => (Vec::new(), 0, false),
};
- let build = if build == Some(JavaBuildStatus::WithErrors) && error_count == 0 && scoped {
+ let build = if build.is_none() && build_lock_held && error_count > 0 {
+ Some(JavaBuildStatus::WithErrors)
+ } else if build == Some(JavaBuildStatus::WithErrors) && error_count == 0 && scoped {
Some(JavaBuildStatus::Succeeded)
} else {
build
diff --git a/crates/ide-lsp/tests/mock_server.rs b/crates/ide-lsp/tests/mock_server.rs
index 06b730de8..4abe3d289 100644
--- a/crates/ide-lsp/tests/mock_server.rs
+++ b/crates/ide-lsp/tests/mock_server.rs
@@ -1752,7 +1752,7 @@ async fn java_source_paths_reach_initialization_live_configuration_and_builds()
assert_eq!(state.launches.load(Ordering::SeqCst), 1);
state.respond("java/buildWorkspace", json!(1));
assert_eq!(
- h.mgr.java_build(&h.root, &Default::default()).await.unwrap(),
+ h.mgr.java_build(&h.root, false, &Default::default()).await.unwrap(),
ide_lsp::jdtls::JavaBuildStatus::Succeeded
);
assert_eq!(state.requested("java/buildWorkspace"), vec![json!(false)]);
@@ -1768,6 +1768,18 @@ async fn java_source_paths_reach_initialization_live_configuration_and_builds()
assert_eq!(init["initializationOptions"]["triggerFiles"], json!([uri_of(&file)]));
}
+#[tokio::test(flavor = "multi_thread")]
+async fn java_build_asks_for_a_full_build_when_rebuilding() {
+ let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);
+ let state = h.launcher.state("jdtls");
+ state.respond("java/buildWorkspace", json!(1));
+ assert_eq!(
+ h.mgr.java_build(&h.root, true, &Default::default()).await.unwrap(),
+ ide_lsp::jdtls::JavaBuildStatus::Succeeded
+ );
+ assert_eq!(state.requested("java/buildWorkspace"), vec![json!(true)]);
+}
+
#[tokio::test(flavor = "multi_thread")]
async fn unmanaged_java_run_imports_sources_without_an_open_editor() {
let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);
@@ -1780,7 +1792,7 @@ async fn unmanaged_java_run_imports_sources_without_an_open_editor() {
let state = h.launcher.state("jdtls");
state.respond("java/buildWorkspace", json!(1));
assert_eq!(
- h.mgr.java_build(&h.root, &Default::default()).await.unwrap(),
+ h.mgr.java_build(&h.root, false, &Default::default()).await.unwrap(),
ide_lsp::jdtls::JavaBuildStatus::Succeeded
);
assert_eq!(state.requested("initialize")[0]["initializationOptions"]["triggerFiles"], json!([uri_of(&file)]));
@@ -1798,7 +1810,7 @@ async fn java_launch_serializes_the_classpath_with_the_build_lock() {
// A launch with a build re-takes the lock after java_build has released it.
let info = tokio::time::timeout(
Duration::from_secs(30),
- h.mgr.java_launch(&h.root, false, true, false, &Default::default()),
+ h.mgr.java_launch(&h.root, false, true, false, false, &Default::default()),
)
.await
.expect("java_launch deadlocked on the build lock")
@@ -1808,10 +1820,13 @@ async fn java_launch_serializes_the_classpath_with_the_build_lock() {
// The delegated external build holds the lock while java_launch resolves the
// classpath; java_launch must not re-take it, or the launch would deadlock.
let guard = h.mgr.java_external_build(&h.root, &Default::default()).await.unwrap();
- tokio::time::timeout(Duration::from_secs(30), h.mgr.java_launch(&h.root, false, false, true, &Default::default()))
- .await
- .expect("java_launch deadlocked on the delegated external build's lock")
- .unwrap();
+ tokio::time::timeout(
+ Duration::from_secs(30),
+ h.mgr.java_launch(&h.root, false, false, false, true, &Default::default()),
+ )
+ .await
+ .expect("java_launch deadlocked on the delegated external build's lock")
+ .unwrap();
drop(guard);
let commands: Vec<_> = state
.requested("workspace/executeCommand")
@@ -1858,7 +1873,7 @@ async fn java_launch_scopes_build_status_and_does_not_wait_for_unrelated_errors(
eventually(|| diagnostics_for(&h, &file) == 1).await;
let info = tokio::time::timeout(
Duration::from_secs(1),
- h.mgr.java_launch(&web, test, true, false, &Default::default()),
+ h.mgr.java_launch(&web, test, true, false, false, &Default::default()),
)
.await
.expect("an already-published error must not incur the diagnostics wait")
@@ -1874,6 +1889,55 @@ async fn java_launch_scopes_build_status_and_does_not_wait_for_unrelated_errors(
}
}
+#[tokio::test(flavor = "multi_thread")]
+async fn delegated_java_launch_retains_scoped_errors_without_a_jdt_build() {
+ use ide_lsp::jdtls::JavaBuildStatus;
+
+ let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);
+ h.open("Main.java", "class Main {}");
+ h.wait_status("jdtls", ServerStatus::Ready).await;
+ let state = h.launcher.state("jdtls");
+ let web = h.root.join("web");
+ state.respond(
+ "workspace/executeCommand",
+ json!({"classpaths": [web.join("target/classes"), h.root.join("service/target/classes")]}),
+ );
+ for (path, test, errors) in [
+ ("web/src/main/java/Main.java", false, 1),
+ ("web/src/test/java/MainTest.java", false, 0),
+ ("web/src/test/java/MainTest.java", true, 1),
+ ("service/src/main/java/Service.java", false, 1),
+ ("service/src/test/java/ServiceTest.java", true, 0),
+ ("other/src/main/java/Other.java", false, 0),
+ ] {
+ let file = h.root.join(path);
+ std::fs::create_dir_all(file.parent().unwrap()).unwrap();
+ std::fs::write(&file, "System.out.println(missingName);").unwrap();
+ let diag = json!({"range": {"start":{"line":0,"character":19},"end":{"line":0,"character":30}},
+ "severity": 1, "message": "missingName cannot be resolved to a variable"});
+ state
+ .peer()
+ .notify("textDocument/publishDiagnostics", json!({"uri": uri_of(&file), "diagnostics": [diag]}))
+ .unwrap();
+ eventually(|| diagnostics_for(&h, &file) == 1).await;
+ let guard = h.mgr.java_external_build(&web, &Default::default()).await.unwrap();
+ let info = h.mgr.java_launch(&web, test, false, false, true, &Default::default()).await.unwrap();
+ drop(guard);
+ assert_eq!(info.error_count, errors, "{path}, test={test}");
+ assert_eq!(info.build, (errors > 0).then_some(JavaBuildStatus::WithErrors));
+ if errors > 0 {
+ assert_eq!(info.errors[0].message, "missingName cannot be resolved to a variable");
+ }
+ state
+ .peer()
+ .notify("textDocument/publishDiagnostics", json!({"uri": uri_of(&file), "diagnostics": []}))
+ .unwrap();
+ eventually(|| diagnostics_for(&h, &file) == 2).await;
+ h.events.lock().clear();
+ }
+ assert!(state.requested("java/buildWorkspace").is_empty());
+}
+
#[tokio::test(flavor = "multi_thread")]
async fn open_java_files_are_checked_again_after_a_project_update() {
let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);
diff --git a/crates/ide-lsp/tests/real_servers.rs b/crates/ide-lsp/tests/real_servers.rs
index 6846f1060..8df943d60 100644
--- a/crates/ide-lsp/tests/real_servers.rs
+++ b/crates/ide-lsp/tests/real_servers.rs
@@ -156,7 +156,7 @@ async fn java_searches_skip_indexed_sources_but_keep_exclusions_outside_scope()
let (mgr, _) = manager(&root, LanguageRegistry::from_configs(vec![java]));
let doc = DocId::next();
mgr.did_open(doc, &path, &LanguageId::new("java"), 1, source);
- mgr.java_build(&path, &Default::default()).await.unwrap();
+ mgr.java_build(&path, false, &Default::default()).await.unwrap();
let uri = ide_lsp::path_to_uri_string;
let covered = retry("imported source scope", Duration::from_secs(120), || async {
mgr.jdtls_command(
diff --git a/crates/ide-run/src/config.rs b/crates/ide-run/src/config.rs
index 60616c60a..cf40ffc93 100644
--- a/crates/ide-run/src/config.rs
+++ b/crates/ide-run/src/config.rs
@@ -30,6 +30,7 @@
//! Configurations not stored as project files live in the same format in the
//! workspace-local, git-ignored `run.local.toml`.
+use crate::BuildPolicy;
use crate::{BeforeLaunchTask, RunConfig, RunExtras};
use ide_core::{IdeError, IdeResult, project_dir};
use serde::Deserialize;
@@ -100,6 +101,8 @@ struct FileConfig {
output_file: Option<String>,
#[serde(default, alias = "beforeLaunch")]
before_launch: Vec<BeforeLaunchTask>,
+ #[serde(alias = "buildPolicy")]
+ build_policy: Option<BuildPolicy>,
#[serde(default)]
compound: Vec<String>,
#[serde(default, alias = "showOnStdout")]
@@ -171,6 +174,7 @@ fn convert(configs: Vec<FileConfig>, local: bool) -> Vec<RunConfig> {
stdin_file: non_empty(c.stdin_file),
output_file: non_empty(c.output_file),
before_launch: c.before_launch.into_iter().filter(|t| !t.kind.is_empty()).collect(),
+ build_policy: c.build_policy,
compound: c.compound,
show_on_stdout: c.show_on_stdout,
show_on_stderr: c.show_on_stderr,
@@ -269,6 +273,9 @@ fn to_table(c: &RunConfig) -> Table {
}
t.insert("before-launch", value(tasks));
}
+ if let Some(policy) = x.build_policy {
+ t.insert("build-policy", value(policy.key()));
+ }
if !x.compound.is_empty() {
t.insert("compound", value(x.compound.iter().collect::<Array>()));
}
diff --git a/crates/ide-run/src/lib.rs b/crates/ide-run/src/lib.rs
index f54bbc46f..6b3845db4 100644
--- a/crates/ide-run/src/lib.rs
+++ b/crates/ide-run/src/lib.rs
@@ -56,6 +56,37 @@ pub struct RunConfig {
pub extras: RunExtras,
}
+/// How a Java launch builds the project before starting (IDEA's Before launch › Build).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub enum BuildPolicy {
+ /// Build the way this project's backend does it: incremental when possible.
+ #[default]
+ Automatic,
+ /// Incremental build (IDEA's "Build"/Make).
+ Make,
+ /// Clean the output, then build (IDEA's Rebuild).
+ Rebuild,
+ /// Do not build; still resolve the module, JDK and classpath.
+ NoBuild,
+ /// Incremental build; a project with compile errors may still start with its last
+ /// successfully compiled classes (IDEA's "Build, no error check").
+ MakeAndContinueOnErrors,
+}
+
+impl BuildPolicy {
+ /// The spelling used in `run.toml` and the run configuration dialog.
+ pub fn key(self) -> &'static str {
+ match self {
+ Self::Automatic => "automatic",
+ Self::Make => "make",
+ Self::Rebuild => "rebuild",
+ Self::NoBuild => "noBuild",
+ Self::MakeAndContinueOnErrors => "makeAndContinueOnErrors",
+ }
+ }
+}
+
/// A step run before a configuration launches; a failing step aborts the launch.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -115,6 +146,10 @@ pub struct RunExtras {
#[serde(default, skip_serializing_if = "Vec::is_empty")]
#[specta(optional)]
pub before_launch: Vec<BeforeLaunchTask>,
+ /// Before launch build for JVM launches; unset keeps the project's default (incremental).
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ #[specta(optional)]
+ pub build_policy: Option<BuildPolicy>,
/// Compound configurations: ids of the configurations started together.
#[serde(default, skip_serializing_if = "Vec::is_empty")]
#[specta(optional)]
@@ -160,6 +195,7 @@ impl Default for RunExtras {
stdin_file: None,
output_file: None,
before_launch: Vec::new(),
+ build_policy: None,
compound: Vec::new(),
show_on_stdout: false,
show_on_stderr: false,
diff --git a/crates/ide-run/tests/config.rs b/crates/ide-run/tests/config.rs
index 7ba18d86e..ef565b4f0 100644
--- a/crates/ide-run/tests/config.rs
+++ b/crates/ide-run/tests/config.rs
@@ -262,3 +262,27 @@ cwd = "sibling"
assert_eq!(loaded[0].cwd.as_deref(), Some(std::path::Path::new("sibling")));
}
}
+
+#[test]
+fn java_config_without_build_policy_loads_and_saves_unchanged() {
+ let dir = tempfile::tempdir().unwrap();
+ let path = user_configs_path(dir.path());
+ fs::create_dir_all(path.parent().unwrap()).unwrap();
+ fs::write(
+ &path,
+ r#"[[configurations]]
+id = "user:main"
+name = "Main"
+kind = "application"
+command = "java"
+args = ["-cp", "${classpath}", "demo.Main"]
+"#,
+ )
+ .unwrap();
+ let configs = load_user_configs(dir.path()).unwrap();
+ assert_eq!(configs.len(), 1);
+ assert_eq!(configs[0].extras.build_policy, None);
+ save_user_configs(dir.path(), &configs).unwrap();
+ assert!(!fs::read_to_string(path).unwrap().contains("build-policy"));
+ assert_eq!(load_user_configs(dir.path()).unwrap(), configs);
+}
diff --git a/src-tauri/src/commands/java.rs b/src-tauri/src/commands/java.rs
index cc148d4fc..1cebd1316 100644
--- a/src-tauri/src/commands/java.rs
+++ b/src-tauri/src/commands/java.rs
@@ -5,11 +5,12 @@ use ide_core::{IdeResult, RequestId};
#[allow(unused_imports)]
pub use ide_host::ops::java::*;
use ide_lsp::jdtls::JavaLaunchInfo;
+use ide_run::BuildPolicy;
use std::path::PathBuf;
use tauri::{State, Window};
/// Cancellable with `cancel_request(request)`.
-/// Builds the workspace (when `build`), then resolves the runtime (or test)
+/// Builds according to `policy`, then resolves the runtime (or test)
/// classpath and the JDK of the module at `module` (absolute, or relative to the project root).
/// A module with Kotlin / Groovy / Scala sources is built by its build system, whose class directories come first.
#[tauri::command]
@@ -19,10 +20,10 @@ pub async fn java_resolve_launch(
state: State<'_, AppState>,
module: PathBuf,
test: bool,
- build: bool,
+ policy: BuildPolicy,
request: RequestId,
) -> IdeResult<JavaLaunchInfo> {
- ide_host::ops::java::java_resolve_launch(&state.host, window.label(), module, test, build, request).await
+ ide_host::ops::java::java_resolve_launch(&state.host, window.label(), module, test, policy, request).await
}
/// Port of java-debug's DAP server inside the jdtls serving `module` (started on demand).
diff --git a/src/bindings.ts b/src/bindings.ts
index 412365a3e..7ab772183 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -772,11 +772,11 @@ export const commands = {
buildRun: (kind: BuildKind, file: string | null, cmake: string | null, request: RequestId, clear: string[], onEvent: Channel<BuildEvent>) => typedError<BuildResult, IdeError>(__TAURI_INVOKE("build_run", { kind, file, cmake, request, clear, onEvent })),
/**
* Cancellable with `cancel_request(request)`.
- * Builds the workspace (when `build`), then resolves the runtime (or test)
+ * Builds according to `policy`, then resolves the runtime (or test)
* classpath and the JDK of the module at `module` (absolute, or relative to the project root).
* A module with Kotlin / Groovy / Scala sources is built by its build system, whose class directories come first.
*/
- javaResolveLaunch: (module: string, test: boolean, build: boolean, request: RequestId) => typedError<JavaLaunchInfo, IdeError>(__TAURI_INVOKE("java_resolve_launch", { module, test, build, request })),
+ javaResolveLaunch: (module: string, test: boolean, policy: BuildPolicy, request: RequestId) => typedError<JavaLaunchInfo, IdeError>(__TAURI_INVOKE("java_resolve_launch", { module, test, policy, request })),
/** Port of java-debug's DAP server inside the jdtls serving `module` (started on demand). */
javaDebugServer: (module: string) => typedError<number, IdeError>(__TAURI_INVOKE("java_debug_server", { module })),
/** Incremental build of the jdtls workspace serving `module` (e.g. before HotSwap). */
@@ -2131,6 +2131,22 @@ export type BuildModel = {
gradle?: GradleModel[],
};
+/** How a Java launch builds the project before starting (IDEA's Before launch › Build). */
+export type BuildPolicy =
+/** Build the way this project's backend does it: incremental when possible. */
+"automatic" |
+/** Incremental build (IDEA's "Build"/Make). */
+"make" |
+/** Clean the output, then build (IDEA's Rebuild). */
+"rebuild" |
+/** Do not build; still resolve the module, JDK and classpath. */
+"noBuild" |
+/**
+ * Incremental build; a project with compile errors may still start with its last
+ * successfully compiled classes (IDEA's "Build, no error check").
+ */
+"makeAndContinueOnErrors";
+
export type BuildResult = {
system: BuildSystem,
title: string,
@@ -7038,6 +7054,8 @@ export type RunExtras_Deserialize = {
/** "Save console output to file" (overwritten on each run). */
outputFile?: string | null,
beforeLaunch?: BeforeLaunchTask[],
+ /** Before launch build for JVM launches; unset keeps the project's default (incremental). */
+ buildPolicy?: BuildPolicy | null,
/** Compound configurations: ids of the configurations started together. */
compound?: string[],
showOnStdout?: boolean,
@@ -7080,6 +7098,8 @@ export type RunExtras_Serialize = {
/** "Save console output to file" (overwritten on each run). */
outputFile?: string | null,
beforeLaunch?: BeforeLaunchTask[],
+ /** Before launch build for JVM launches; unset keeps the project's default (incremental). */
+ buildPolicy?: BuildPolicy | null,
/** Compound configurations: ids of the configurations started together. */
compound?: string[],
showOnStdout?: boolean,
diff --git a/src/features/debugger/__tests__/actions.test.ts b/src/features/debugger/__tests__/actions.test.ts
index 679715b4f..e9d9dd08d 100644
--- a/src/features/debugger/__tests__/actions.test.ts
+++ b/src/features/debugger/__tests__/actions.test.ts
@@ -40,6 +40,7 @@ vi.mock("@/platform/ipc", async (importOriginal) => {
return { ...real, commands: { ...real.commands, ...cmds } };
});
+const saveAll = vi.hoisted(() => vi.fn(async () => undefined));
const editor = vi.hoisted(() => ({
current: null as null | { ctx: { path: string; language: string }; view: { state: unknown } },
}));
@@ -55,7 +56,7 @@ vi.mock("@/workbench/contributions", async (importOriginal) => {
...real,
maybeEditorService: () => ({
openFile: async (path: string, o?: { focus?: boolean }) => void opened.push({ path, focus: o?.focus }),
- saveAll: async () => undefined,
+ saveAll,
}),
};
});
@@ -438,3 +439,26 @@ it("stops the waiting Python container if attaching fails", async () => {
});
expect(ipc.runStop).toHaveBeenCalledWith(9);
});
+
+it("reports Java Debug save failures and does not start the adapter", async () => {
+ const notify = vi.fn();
+ provideNotificationService({ notify });
+ useProject.setState({ project: { root: "/p" } as never });
+ saveAll.mockRejectedValueOnce(new Error("save failed"));
+ await executeAction("debug.startConfig", {
+ id: "main",
+ name: "Main",
+ kind: "application",
+ command: "java",
+ args: ["a.Main"],
+ cwd: null,
+ module: "",
+ env: {},
+ detected: false,
+ isTest: false,
+ debugAdapter: "java-debug",
+ });
+ expect(ipc.debugStart).not.toHaveBeenCalled();
+ expect(notify).toHaveBeenCalledWith(expect.objectContaining({ level: "error", body: "save failed" }));
+ useProject.setState({ project: null });
+});
diff --git a/src/features/debugger/__tests__/java.test.ts b/src/features/debugger/__tests__/java.test.ts
index 1f6801231..dfa91e832 100644
--- a/src/features/debugger/__tests__/java.test.ts
+++ b/src/features/debugger/__tests__/java.test.ts
@@ -78,7 +78,7 @@ describe("Java debugging (java-debug through jdtls)", () => {
expect(isJavaDebuggable({ ...app, kind: "maven" })).toBe(false);
const l = await javaLaunchConfig(app, "/p");
expect(invoked).toEqual([
- ["javaResolveLaunch", ["api", false, true, expect.any(Number)]],
+ ["javaResolveLaunch", ["api", false, "automatic", expect.any(Number)]],
["javaDebugServer", ["api"]],
]);
expect(l).toMatchObject({ adapter: "java-debug", request: "launch", cwd: "/p/api", args: [], env: { A: "1" } });
@@ -178,7 +178,7 @@ it.each(["sibling", "/outside/modules"])("debugs from %s with the main class mod
for (const module of ["api", undefined]) {
invoked.length = 0;
const launch = await javaLaunchConfig({ ...app, module, cwd }, "/p");
- expect(invoked).toContainEqual(["javaResolveLaunch", ["api", false, true, expect.any(Number)]]);
+ expect(invoked).toContainEqual(["javaResolveLaunch", ["api", false, "automatic", expect.any(Number)]]);
expect(invoked).toContainEqual(["javaDebugServer", ["api"]]);
expect(launch.cwd).toBe(cwd.startsWith("/") ? cwd : `/p/${cwd}`);
}
@@ -208,3 +208,16 @@ describe("naming the Java project jdtls imported", () => {
expect(await javaProjectName("/p")).toBe("p");
});
});
+
+it("reports a save failure before starting Java Debug", async () => {
+ invoked.length = 0;
+ const saveAll = vi.fn().mockRejectedValue(new Error("save failed"));
+ await expect(
+ javaLaunchConfig(app, "/p", {
+ request: 1,
+ signal: new AbortController().signal,
+ saveAll,
+ }),
+ ).rejects.toThrow("save failed");
+ expect(invoked).toEqual([]);
+});
diff --git a/src/features/debugger/actions.ts b/src/features/debugger/actions.ts
index c7d1ccddb..a87e18827 100644
--- a/src/features/debugger/actions.ts
+++ b/src/features/debugger/actions.ts
@@ -266,11 +266,14 @@ async function startJavaConfig(config: RunConfig, root: string, origin: RunConfi
};
signal.addEventListener("abort", cancel, { once: true });
try {
- await maybeEditorService()
- ?.saveAll()
- .catch(() => undefined);
- signal.throwIfAborted();
- return await javaLaunchConfig(config, root, { request, signal, report });
+ return await javaLaunchConfig(config, root, {
+ request,
+ signal,
+ report,
+ saveAll: async () => {
+ await maybeEditorService()?.saveAll();
+ },
+ });
} finally {
signal.removeEventListener("abort", cancel);
}
diff --git a/src/features/debugger/java.ts b/src/features/debugger/java.ts
index 35873c67d..37f91d5bb 100644
--- a/src/features/debugger/java.ts
+++ b/src/features/debugger/java.ts
@@ -15,7 +15,7 @@ import {
prepareJavaLaunch,
type JavaPreparation,
} from "@/platform/javaLaunch";
-import { notifications } from "@/workbench/contributions";
+import { maybeEditorService, notifications } from "@/workbench/contributions";
export const JAVA_ADAPTER = "java-debug";
export const KOTLIN_ADAPTER = "kotlin-debug-adapter";
@@ -119,6 +119,9 @@ export async function javaLaunchConfig(
preparation ?? {
request: nextRequestId(),
signal: new AbortController().signal,
+ saveAll: async () => {
+ await maybeEditorService()?.saveAll();
+ },
},
);
if (info.errorCount > 0 && !preparation?.report)
diff --git a/src/features/run/ConfigForm.tsx b/src/features/run/ConfigForm.tsx
index 51ef2ebe4..61989a47c 100644
--- a/src/features/run/ConfigForm.tsx
+++ b/src/features/run/ConfigForm.tsx
@@ -3,10 +3,10 @@
* common ones, the options added through "Modify options" (⌥M) and the
* Before launch list.
*/
-import { parseJavaArgs } from "@/platform/javaLaunch";
+import { isJvmApplication, parseJavaArgs } from "@/platform/javaLaunch";
import { useEffect, useMemo, useRef, useState, type KeyboardEvent, type ReactNode, type RefObject } from "react";
import clsx from "clsx";
-import { isTauri, type BeforeLaunchTask, type RunConfig } from "@/platform/ipc";
+import { isTauri, type BeforeLaunchTask, type BuildPolicy, type RunConfig } from "@/platform/ipc";
import { useWorkflowSettings } from "@/platform/workflowSettings";
import { relativePath, useProject } from "@/platform/project";
import { isRemoteWindow } from "@/platform/remote";
@@ -42,7 +42,9 @@ import {
parseEnv,
type ConfigErrors,
} from "./configs";
+import { gradleContainsModule } from "./gradleRun";
import { EnvDialog } from "./EnvDialog";
+import { useBuildModel } from "@/platform/buildModel";
import { withTarget } from "./remote";
import { COMPOUND, formParams, terminalApplies, withParams } from "./types";
import { TomcatSettings } from "./TomcatSettings";
@@ -76,12 +78,19 @@ export type OptionId =
| "showOnStdout"
| "showOnStderr"
| "beforeLaunch"
+ | "buildPolicy"
| "openToolWindow"
| "focusToolWindow"
| "isTest"
| "emulateTerminal";
-const VALUE_OPTIONS: ReadonlySet<OptionId> = new Set(["stdinFile", "envFiles", "outputFile", "beforeLaunch"]);
+const VALUE_OPTIONS: ReadonlySet<OptionId> = new Set([
+ "stdinFile",
+ "envFiles",
+ "outputFile",
+ "beforeLaunch",
+ "buildPolicy",
+]);
const OPTION_LABELS: Record<OptionId, string> = {
allowParallel: "Allow multiple instances",
@@ -91,6 +100,7 @@ const OPTION_LABELS: Record<OptionId, string> = {
showOnStdout: "Show console when a message is printed to stdout",
showOnStderr: "Show console when a message is printed to stderr",
beforeLaunch: "Add before launch task",
+ buildPolicy: "Build",
openToolWindow: "Open run/debug tool window when started",
focusToolWindow: "Focus run/debug tool window when started",
isTest: "Show results in the test runner",
@@ -101,7 +111,11 @@ const OPTION_GROUPS: ReadonlyArray<{ label: string; options: OptionId[]; process
{ label: "Operating System", options: ["allowParallel", "stdinFile", "envFiles", "emulateTerminal"], process: true },
{ label: "Logs", options: ["outputFile", "showOnStdout", "showOnStderr"], process: true },
{ label: "Test", options: ["isTest"], process: true },
- { label: "Before Launch", options: ["beforeLaunch", "openToolWindow", "focusToolWindow"], process: false },
+ {
+ label: "Before Launch",
+ options: ["buildPolicy", "beforeLaunch", "openToolWindow", "focusToolWindow"],
+ process: false,
+ },
];
/** Whether the option currently has a (non-default) value. */
@@ -121,6 +135,8 @@ export function optionSet(config: RunConfig, id: OptionId, openByDefault: boolea
return !!config.showOnStderr;
case "beforeLaunch":
return !!config.beforeLaunch?.length;
+ case "buildPolicy":
+ return (config.buildPolicy ?? "automatic") !== "automatic";
case "openToolWindow":
return config.openToolWindow ?? openByDefault;
case "focusToolWindow":
@@ -145,6 +161,8 @@ export function optionPatch(id: OptionId, on: boolean): Partial<RunConfig> {
return { outputFile: null };
case "beforeLaunch":
return { beforeLaunch: [] };
+ case "buildPolicy":
+ return { buildPolicy: on ? "automatic" : null };
case "showOnStdout":
return { showOnStdout: on };
case "showOnStderr":
@@ -160,6 +178,14 @@ export function optionPatch(id: OptionId, on: boolean): Partial<RunConfig> {
}
}
+const BUILD_POLICY_OPTIONS: SelectOption[] = [
+ { value: "automatic", label: "Automatic (incremental)" },
+ { value: "make", label: "Build (Make)" },
+ { value: "rebuild", label: "Rebuild" },
+ { value: "noBuild", label: "No build" },
+ { value: "makeAndContinueOnErrors", label: "Build, no error check" },
+];
+
export interface ConfigFormProps {
config: RunConfig;
/** Every configuration of the dialog (compound members, before launch targets, name checks). */
@@ -222,6 +248,17 @@ export function ConfigForm({ config, all, type, errors, template, onChange, modi
const tx = useTx();
const txTemplate = useTxTemplate();
const root = useProject((s) => s.project?.root ?? null);
+ const gradle = useBuildModel((s) => s.model?.gradle);
+ const runUsing = useProject((s) => s.settings?.languages?.java?.gradle?.runUsing);
+ const delegated =
+ isJvmApplication(config) &&
+ runUsing !== "ide" &&
+ gradle?.some((g) => config.module == null || gradleContainsModule(g, root ?? "", config.module));
+ const buildPolicyOptions = BUILD_POLICY_OPTIONS.filter((option) => {
+ if (config.kind === "gradle" || delegated)
+ return option.value !== "noBuild" && option.value !== "makeAndContinueOnErrors";
+ return config.kind !== "maven" || option.value !== "noBuild";
+ });
const [shown, setShown] = useState<ReadonlySet<OptionId>>(() => new Set());
const [argsText, setArgsText] = useState<string | null>(null);
const [envText, setEnvText] = useState<string | null>(null);
@@ -239,6 +276,7 @@ export function ConfigForm({ config, all, type, errors, template, onChange, modi
}
const compound = config.kind === COMPOUND;
+ const buildPolicyApplies = (c: RunConfig) => isJvmApplication(c) || c.kind === "maven" || c.kind === "gradle";
// Compound and debug-only types (Remote JVM Debug) start no process of their own.
const noProcess = compound || !!type?.debugOnly;
const params = compound ? {} : formParams(config, type);
@@ -275,7 +313,9 @@ export function ConfigForm({ config, all, type, errors, template, onChange, modi
...g.options
.filter(
(id) =>
- (!compound || id === "beforeLaunch") && (id !== "emulateTerminal" || terminal || !!config.emulateTerminal),
+ (!compound || id === "beforeLaunch") &&
+ (id !== "emulateTerminal" || terminal || !!config.emulateTerminal) &&
+ (id !== "buildPolicy" || buildPolicyApplies(config)),
)
.map((id): MenuItem => ({
label: OPTION_LABELS[id],
@@ -629,6 +669,17 @@ export function ConfigForm({ config, all, type, errors, template, onChange, modi
</>
)}
+ {isShown("buildPolicy") && buildPolicyApplies(config) && (
+ <Field label="Build" hint="Before launch build for this Java configuration">
+ <Select
+ value={config.buildPolicy ?? "automatic"}
+ options={buildPolicyOptions}
+ onChange={(v) => update({ buildPolicy: v === "automatic" ? null : (v as BuildPolicy) })}
+ aria-label="Build"
+ />
+ </Field>
+ )}
+
{isShown("beforeLaunch") && (
<Field label="Before launch" error={errors.beforeLaunch} top>
<div className={styles.taskList} role="list" aria-label={tx("Before launch tasks")}>
diff --git a/src/features/run/applicationUpdate.test.ts b/src/features/run/applicationUpdate.test.ts
index 437a669b6..441873e8f 100644
--- a/src/features/run/applicationUpdate.test.ts
+++ b/src/features/run/applicationUpdate.test.ts
@@ -131,7 +131,7 @@ const boot = {
describe("Spring Boot application updates", () => {
it("processes resources and publishes them to the resolved runtime output", async () => {
await updateTomcat(boot, "resources");
- expect(mocks.resolve).toHaveBeenCalledWith("app", false, false, 1);
+ expect(mocks.resolve).toHaveBeenCalledWith("app", false, "noBuild", 1);
expect(mocks.runBuild).toHaveBeenCalledWith({ id: "build" });
expect(mocks.publish).toHaveBeenCalledWith(boot.config, ["/p/app/bin/main"], "a.Main");
expect(mocks.update).not.toHaveBeenCalled();
@@ -139,7 +139,7 @@ describe("Spring Boot application updates", () => {
});
it("compiles and invokes the existing scoped HotSwap action in debug", async () => {
await updateTomcat(boot, "classes");
- expect(mocks.resolve).toHaveBeenCalledWith("app", false, true, 1);
+ expect(mocks.resolve).toHaveBeenCalledWith("app", false, "make", 1);
expect(mocks.action).toHaveBeenCalledWith("debug.reloadChangedClasses", { configId: "boot" });
});
it("explains compiled classes require restart without a debugger", async () => {
diff --git a/src/features/run/applicationUpdate.ts b/src/features/run/applicationUpdate.ts
index 6b8482a86..d6c969c2b 100644
--- a/src/features/run/applicationUpdate.ts
+++ b/src/features/run/applicationUpdate.ts
@@ -43,7 +43,12 @@ async function updateSpringBoot(config: RunConfig, mode: UpdateMode, debugging:
const parsed = parseJavaArgs(config.args);
if (!parsed.mainClass) throw new Error(tx("The Spring Boot configuration has no main class"));
const info = await call(
- commands.javaResolveLaunch(module, parsed.classpath === "test", mode === "classes", nextRequestId()),
+ commands.javaResolveLaunch(
+ module,
+ parsed.classpath === "test",
+ mode === "classes" ? "make" : "noBuild",
+ nextRequestId(),
+ ),
);
if (info.build === "failed" || info.build === "withErrors" || info.build === "cancelled")
throw new Error(tx("Application update build failed"));
diff --git a/src/features/run/beforeLaunch.ts b/src/features/run/beforeLaunch.ts
index 686403f82..2e150d346 100644
--- a/src/features/run/beforeLaunch.ts
+++ b/src/features/run/beforeLaunch.ts
@@ -2,9 +2,9 @@
* Before launch tasks (IDEA's "Before launch" list): run in order before a
* configuration starts; the first failure aborts the launch.
*/
+import { useProject } from "@/platform/project";
import { buildCMake, isCMakeBuild } from "./cmake";
import { dotnetBuildConfig } from "./dotnetTypes";
-import { useProject } from "@/platform/project";
import { useBuildPresentation } from "@/platform/projectPresentation";
import { buildTask } from "./buildTask";
import { moduleTaskError } from "./configs";
@@ -88,7 +88,9 @@ async function runTask(
return (await runToEnd(dotnetBuildConfig(config), chain, show)) ? null : "Build failed";
case "build": {
if (target) return buildCMake(target, show === true);
- return buildTask(BUILD_ACTION, { activate: false });
+ const error = await buildTask(BUILD_ACTION, { activate: false });
+ if (error) return error;
+ return null;
}
case "buildModule": {
const error = moduleTaskError(config, target);
diff --git a/src/features/run/buildCommand.test.ts b/src/features/run/buildCommand.test.ts
new file mode 100644
index 000000000..910bbad04
--- /dev/null
+++ b/src/features/run/buildCommand.test.ts
@@ -0,0 +1,44 @@
+import { describe, expect, it } from "vitest";
+import type { RunConfig } from "@/platform/ipc";
+import { applyBuildPolicyToCommand } from "./buildCommand";
+
+const cfg = (extra: Partial<RunConfig>): RunConfig => ({
+ id: "m",
+ name: "m",
+ kind: "maven",
+ command: "mvn",
+ args: ["-B", "spring-boot:run"],
+ cwd: null,
+ env: {},
+ detected: false,
+ isTest: false,
+ debugAdapter: null,
+ ...extra,
+});
+
+describe("build policy for build-tool commands", () => {
+ it("puts clean first for Maven and Gradle Rebuild", () => {
+ expect(applyBuildPolicyToCommand({ ...cfg({ buildPolicy: "rebuild" }), kind: "maven" }).args).toEqual([
+ "clean",
+ "-B",
+ "spring-boot:run",
+ ]);
+ expect(
+ applyBuildPolicyToCommand({ ...cfg({ kind: "gradle", args: ["bootRun"] }), buildPolicy: "rebuild" }).args,
+ ).toEqual(["clean", "bootRun"]);
+ });
+
+ it("lets Maven continue on compile errors only when asked", () => {
+ expect(applyBuildPolicyToCommand({ ...cfg({ buildPolicy: "makeAndContinueOnErrors" }) }).args).toContain(
+ "-Dmaven.compiler.failOnError=false",
+ );
+ expect(applyBuildPolicyToCommand({ ...cfg({ buildPolicy: "make" }) }).args).not.toContain(
+ "-Dmaven.compiler.failOnError=false",
+ );
+ });
+
+ it("leaves Automatic and NoBuild commands alone", () => {
+ for (const buildPolicy of ["automatic", "noBuild"] as const)
+ expect(applyBuildPolicyToCommand(cfg({ buildPolicy }))).toEqual(cfg({ buildPolicy }));
+ });
+});
diff --git a/src/features/run/buildCommand.ts b/src/features/run/buildCommand.ts
new file mode 100644
index 000000000..cd73142f9
--- /dev/null
+++ b/src/features/run/buildCommand.ts
@@ -0,0 +1,22 @@
+/**
+ * Build policies for configurations whose command is itself a build tool (Maven,
+ * Gradle). Application/Spring Boot configurations build through `prepareJavaLaunch`
+ * instead; this only rewrites the command of an already chosen build-tool launch.
+ */
+import type { RunConfig } from "@/platform/ipc";
+
+const MAVEN = new Set(["maven"]);
+const GRADLE = new Set(["gradle"]);
+
+export function applyBuildPolicyToCommand(config: RunConfig): RunConfig {
+ const rebuild = config.buildPolicy === "rebuild";
+ if (rebuild && !config.args.includes("clean") && (MAVEN.has(config.kind) || GRADLE.has(config.kind))) {
+ // Maven and Gradle both accept the clean task before their other goals.
+ return { ...config, args: ["clean", ...config.args] };
+ }
+ if (config.buildPolicy === "makeAndContinueOnErrors" && MAVEN.has(config.kind)) {
+ const flag = "-Dmaven.compiler.failOnError=false";
+ return config.args.includes(flag) ? config : { ...config, args: [...config.args, flag] };
+ }
+ return config;
+}
diff --git a/src/features/run/gradleRun.test.ts b/src/features/run/gradleRun.test.ts
index c085ffcdb..5e46a845c 100644
--- a/src/features/run/gradleRun.test.ts
+++ b/src/features/run/gradleRun.test.ts
@@ -265,3 +265,15 @@ describe("delegation across independent builds", () => {
expect(run!.args.at(-1)).toBe(":app:openideaRun");
});
});
+
+it("uses the same Rebuild preparation for delegated Run and Debug", () => {
+ const app = {
+ ...applicationConfig({ className: "a.Main" }, "app/src/main/java/a/Main.java", []),
+ buildPolicy: "rebuild" as const,
+ };
+ const run = delegatedGradleConfig(app, "app", ctx)!;
+ expect(run.args[0]).toBe("clean");
+ const debug = jdwpLaunch(run)!;
+ expect(debug.args.filter((a) => a === "clean")).toHaveLength(1);
+ expect(debug.args).toContain(DELEGATED_DEBUG);
+});
diff --git a/src/features/run/gradleRun.ts b/src/features/run/gradleRun.ts
index ce906c06c..818810cbe 100644
--- a/src/features/run/gradleRun.ts
+++ b/src/features/run/gradleRun.ts
@@ -10,8 +10,10 @@ import TESTS_SCRIPT from "./gradleTests.gradle?raw";
import BOOT_SCRIPT from "./gradleBoot.gradle?raw";
import { useBuildModel } from "@/platform/buildModel";
import { call, commands, isTauri, type GradleModel, type RunConfig } from "@/platform/ipc";
-import { findJavaModule, isJvmApplication, parseJavaArgs } from "@/platform/javaLaunch";
+import { isJvmApplication, parseJavaArgs, prepareJavaModule } from "@/platform/javaLaunch";
import { useProject } from "@/platform/project";
+import { maybeEditorService } from "@/workbench/contributions";
+import { applyBuildPolicyToCommand } from "./buildCommand";
/** System property that marks a delegated run (read by `jdwpLaunch` to add the debug flag). */
export const DELEGATED_MAIN = "-Dopenidea.run.main=";
@@ -21,6 +23,10 @@ const TASK = "openideaRun";
const isAbsolute = (p: string) => p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p);
const absolute = (root: string, p: string) => (isAbsolute(p) ? p : p ? `${root}/${p}` : root);
+export function gradleContainsModule(gradle: GradleModel, root: string, module: string): boolean {
+ return gradle.projects.some((p) => absolute(root, p.dir) === absolute(root, module));
+}
+
export interface DelegationContext {
/** Project root. */
root: string;
@@ -74,7 +80,7 @@ export function delegatedGradleConfig(config: RunConfig, module: string, ctx: De
// A Gradle run from here on: not an Application again (it would be delegated twice), and
// without the Application's params (Gradle's own VM-options init script would repeat them).
const { params: _params, ...rest } = config;
- return {
+ return applyBuildPolicyToCommand({
...rest,
kind: "gradle",
command: ctx.gradle.command,
@@ -83,7 +89,7 @@ export function delegatedGradleConfig(config: RunConfig, module: string, ctx: De
// The Gradle JVM's JAVA_HOME first; the configuration's own environment wins.
env: { ...ctx.gradle.env, ...config.env },
module: module,
- };
+ });
}
/**
@@ -148,8 +154,9 @@ export async function gradleDelegation(config: RunConfig): Promise<RunConfig | n
if (!project?.root || settings?.languages?.java?.gradle?.runUsing === "ide") return null;
const { model, gradleOffline } = useBuildModel.getState();
if (!model?.gradle?.length) return null;
- const module = config.module ?? (await findJavaModule(config));
- if (module === null) return null;
+ const module = await prepareJavaModule(config, async () => {
+ await maybeEditorService()?.saveAll();
+ });
const dir = absolute(project.root, module);
// A composite can report a sibling's module; prefer a linked root that contains it.
const ownerDepth = (g: GradleModel) => {
@@ -158,7 +165,7 @@ export async function gradleDelegation(config: RunConfig): Promise<RunConfig | n
return path === root || path.startsWith(`${root}/`) ? root.split("/").length : 0;
};
const gradle = model.gradle
- .filter((g) => g.projects.some((p) => absolute(project.root, p.dir) === dir))
+ .filter((g) => gradleContainsModule(g, project.root, module))
.sort((a, b) => ownerDepth(b) - ownerDepth(a))[0];
if (!gradle) return null;
const ctx = {
diff --git a/src/features/run/index.ts b/src/features/run/index.ts
index 2e13d07d2..86884df1b 100644
--- a/src/features/run/index.ts
+++ b/src/features/run/index.ts
@@ -137,7 +137,18 @@ async function debugConfig(config: RunConfig, chain: readonly string[] = [], sho
return;
}
// "Build and run using: Gradle": the JavaExec JVM gets the agent, the debugger attaches to it.
- const delegated = getAction("debug.attach") ? await gradleDelegation(config) : null;
+ let delegated: RunConfig | null;
+ try {
+ delegated = getAction("debug.attach") ? await gradleDelegation(config) : null;
+ } catch (error) {
+ notifications().notify({
+ group: "run",
+ level: "error",
+ title: `Cannot run '${config.name}'`,
+ body: error instanceof Error ? error.message : String(error),
+ });
+ return;
+ }
if (delegated) {
await debugWithAgent(delegated, show);
return;
diff --git a/src/features/run/java.test.ts b/src/features/run/java.test.ts
index 83ca8226f..bf6864059 100644
--- a/src/features/run/java.test.ts
+++ b/src/features/run/java.test.ts
@@ -366,6 +366,12 @@ describe("debugging build tool configurations", () => {
expect(out.env.MAVEN_OPTS).toMatch(AGENT);
});
+ it("honours Rebuild on a Maven debug command", () => {
+ const out = jdwpLaunch(cfg({ id: "r", kind: "maven", args: ["spring-boot:run"], buildPolicy: "rebuild" }))!;
+ expect(out.args[0]).toBe("clean");
+ expect(out.args.at(-1)).toMatch(/^-Dspring-boot\.run\.jvmArguments=-agentlib:jdwp=/);
+ });
+
it("keeps plain Maven builds out of the debugger unless set to the Java debugger", () => {
expect(jdwpLaunch(cfg({ id: "p", kind: "maven", args: ["exec:exec"] }))).toBeNull();
const chosen = jdwpLaunch(cfg({ id: "p", kind: "maven", args: ["package"], debugAdapter: "java-debug" }))!;
diff --git a/src/features/run/javaDebug.ts b/src/features/run/javaDebug.ts
index 2eb636ad3..fa8a1ed3f 100644
--- a/src/features/run/javaDebug.ts
+++ b/src/features/run/javaDebug.ts
@@ -11,6 +11,7 @@
import { executeAction } from "@/platform/actions";
import type { RunConfig } from "@/platform/ipc";
import { isJvmApplication, JDWP_AGENT, jdwpListeningPort } from "@/platform/javaLaunch";
+import { applyBuildPolicyToCommand } from "./buildCommand";
import { startRun, useRun } from "./store";
import { DELEGATED_DEBUG, DELEGATED_MAIN } from "./gradleRun";
@@ -38,6 +39,7 @@ function withProperty(args: readonly string[], key: string, value: string): stri
/** The configuration with a waiting JDWP agent, or null when it starts no debuggable JVM. */
export function jdwpLaunch(config: RunConfig): RunConfig | null {
+ config = applyBuildPolicyToCommand(config);
if (config.kind === "tomcat") return { ...config, params: { ...config.params, tomcatDebug: "true" } };
const args = config.args;
// A single source file (`java Hi.java`): the agent goes before the file. Compiled first
diff --git a/src/features/run/javaModule.test.ts b/src/features/run/javaModule.test.ts
index e5b270f67..fd839dd88 100644
--- a/src/features/run/javaModule.test.ts
+++ b/src/features/run/javaModule.test.ts
@@ -1,6 +1,7 @@
import { afterEach, beforeEach, expect, it, vi } from "vitest";
import { IpcError, type RunConfig } from "@/platform/ipc";
-import { findJavaModule, prepareJavaLaunch } from "@/platform/javaLaunch";
+import { useProject } from "@/platform/project";
+import { findJavaModule, prepareJavaLaunch, prepareJavaModule } from "@/platform/javaLaunch";
import { _resetI18nForTests, setLocale } from "@/platform/i18n";
import { provideNotificationService } from "@/workbench/contributions";
import { applicationConfig } from "./application";
@@ -72,7 +73,7 @@ afterEach(() => {
it.each(["sibling", "/outside/modules"])("runs from %s using the stored module's classpath", async (cwd) => {
const session = await startRun({ ...config, module: "app", cwd });
expect(session?.status).toBe("running");
- expect(ipc.javaResolveLaunch).toHaveBeenCalledWith("app", false, true, expect.any(Number));
+ expect(ipc.javaResolveLaunch).toHaveBeenCalledWith("app", false, "automatic", expect.any(Number));
expect(ipc.runStart).toHaveBeenCalledWith(
expect.objectContaining({ cwd, args: ["-cp", "/p/app/target/classes", "a.Main"] }),
expect.anything(),
@@ -80,10 +81,59 @@ it.each(["sibling", "/outside/modules"])("runs from %s using the stored module's
expect(ipc.findFiles).not.toHaveBeenCalled();
});
+const launchInfo = (build: "succeeded" | "failed" | "withErrors") => ({
+ build,
+ projectRoot: "/p",
+ classPaths: ["/p/app/target/classes"],
+ modulePaths: [],
+ javaHome: null,
+ javaExec: "java",
+ shortenCommandLine: null,
+ errors: build === "succeeded" ? [] : [{ path: "/p/app/src/Main.java", line: 1, column: 1, message: "boom" }],
+ errorCount: build === "succeeded" ? 0 : 1,
+ hints: [],
+});
+
+it.each(["noBuild", "rebuild"] as const)("passes the %s build policy to the resolver", async (buildPolicy) => {
+ await startRun({ ...config, module: "app", buildPolicy });
+ expect(ipc.javaResolveLaunch).toHaveBeenCalledWith("app", false, buildPolicy, expect.any(Number));
+});
+
+it("always applies the launch policy after a Before launch Build Project", async () => {
+ useProject.setState({ project: { root: "/p" } as never });
+ await startRun({ ...config, module: "app" });
+ expect(ipc.javaResolveLaunch).toHaveBeenCalledWith("app", false, "automatic", expect.any(Number));
+ useProject.setState({ project: null });
+});
+
+it("does not start a configuration whose build failed", async () => {
+ ipc.javaResolveLaunch.mockResolvedValueOnce({ status: "ok", data: launchInfo("failed") });
+ const session = await startRun({ ...config, module: "app", buildPolicy: "make" });
+ expect(session?.status).toBe("failed");
+ expect(ipc.runStart).not.toHaveBeenCalled();
+});
+
+it("starts with the last compiled classes for makeAndContinueOnErrors", async () => {
+ ipc.javaResolveLaunch.mockResolvedValueOnce({ status: "ok", data: launchInfo("withErrors") });
+ const session = await startRun({ ...config, module: "app", buildPolicy: "makeAndContinueOnErrors" });
+ expect(session?.status).toBe("running");
+ expect(ipc.runStart).toHaveBeenCalled();
+});
+
+it.each([undefined, "automatic", "make", "rebuild"] as const)(
+ "does not launch scoped compilation-error bytecode under %s",
+ async (buildPolicy) => {
+ ipc.javaResolveLaunch.mockResolvedValueOnce({ status: "ok", data: launchInfo("withErrors") });
+ const session = await startRun({ ...config, module: "app", buildPolicy });
+ expect(session?.status).toBe("failed");
+ expect(ipc.runStart).not.toHaveBeenCalled();
+ },
+);
+
it("finds the source module for an old saved configuration without a module", async () => {
await startRun({ ...config, cwd: "/outside/modules" });
expect(ipc.findFiles).toHaveBeenCalledWith("Main.java", 1000);
- expect(ipc.javaResolveLaunch).toHaveBeenCalledWith("app", false, true, expect.any(Number));
+ expect(ipc.javaResolveLaunch).toHaveBeenCalledWith("app", false, "automatic", expect.any(Number));
expect(ipc.runStart).toHaveBeenCalledWith(expect.objectContaining({ cwd: "/outside/modules" }), expect.anything());
});
@@ -96,7 +146,7 @@ it.each([["-cp", "lib/*"], []])("colours Spring Boot runs without classpath reso
expect.objectContaining({ args: ["-Dspring.output.ansi.enabled=always", ...args] }),
expect.anything(),
);
- expect(ipc.javaResolveLaunch).not.toHaveBeenCalled();
+ expect(ipc.javaResolveLaunch).toHaveBeenCalledWith("app", false, "automatic", expect.any(Number));
expect(boot.args).toBe(args);
expect(args).not.toContain("-Dspring.output.ansi.enabled=always");
});
@@ -105,14 +155,14 @@ it.each(["never", "detect", "always"])("preserves an explicit Spring Boot consol
const args = [`-Dspring.output.ansi.enabled=${value}`, "-cp", "lib/*", "a.Main"];
await startRun({ ...config, kind: "spring-boot", args });
expect(ipc.runStart).toHaveBeenCalledWith(expect.objectContaining({ args }), expect.anything());
- expect(ipc.javaResolveLaunch).not.toHaveBeenCalled();
+ expect(ipc.javaResolveLaunch).toHaveBeenCalledWith("app", false, "automatic", expect.any(Number));
});
it("keeps plain Java runs with an explicit classpath free of Spring Boot options", async () => {
const args = ["-cp", "lib/*", "a.Main"];
await startRun({ ...config, args });
expect(ipc.runStart).toHaveBeenCalledWith(expect.objectContaining({ args }), expect.anything());
- expect(ipc.javaResolveLaunch).not.toHaveBeenCalled();
+ expect(ipc.javaResolveLaunch).toHaveBeenCalledWith("app", false, "automatic", expect.any(Number));
});
it("adds the Spring Boot console option once when resolving the module classpath", async () => {
@@ -197,3 +247,17 @@ it("translates import recovery guidance for a root Spring Boot configuration", a
),
).rejects.toThrow("Java 模块 '.' 尚未导入");
});
+
+it("does not resolve or launch when saving fails", async () => {
+ const saveAll = vi.fn().mockRejectedValue(new Error("save failed"));
+ await expect(
+ prepareJavaLaunch(config, {
+ request: 1,
+ signal: new AbortController().signal,
+ saveAll,
+ }),
+ ).rejects.toThrow("save failed");
+ await expect(prepareJavaModule(config, saveAll)).rejects.toThrow("save failed");
+ expect(ipc.javaResolveLaunch).not.toHaveBeenCalled();
+ expect(ipc.runStart).not.toHaveBeenCalled();
+});
diff --git a/src/features/run/runConfigTypes.test.tsx b/src/features/run/runConfigTypes.test.tsx
index 4cfe6ac65..c6e4929dd 100644
--- a/src/features/run/runConfigTypes.test.tsx
+++ b/src/features/run/runConfigTypes.test.tsx
@@ -1,3 +1,4 @@
+import { useBuildModel } from "@/platform/buildModel";
import { useBuildPresentation } from "@/platform/projectPresentation";
import { useProject } from "@/platform/project";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
@@ -116,6 +117,22 @@ describe("configuration types", () => {
expect(formParams(saved)).toMatchObject({ mainClass: "a.Main", module: "." });
});
+ it("sets the before launch build policy of a Java configuration", async () => {
+ const type = typeFor("application")!;
+ const config = withParams(newConfigOfType(type, []), {
+ ...newConfigOfType(type, []).params,
+ mainClass: "a.Main",
+ });
+ const changed = vi.fn();
+ render(<ConfigForm config={config} all={[config]} type={type} errors={{}} onChange={changed} modifyRequest={0} />);
+ fireEvent.click(screen.getByRole("button", { name: /Modify options/ }));
+ fireEvent.click(await screen.findByText("Build"));
+ expect(screen.getByRole("button", { name: "Build" }).textContent).toContain("Automatic");
+ fireEvent.click(screen.getByRole("button", { name: "Build" }));
+ fireEvent.click(await screen.findByRole("option", { name: "Rebuild" }));
+ expect(changed).toHaveBeenCalledWith(expect.objectContaining({ buildPolicy: "rebuild" }));
+ });
+
it.each(["spring-boot", "tomcat"])("edits shared update policies in the %s form", async (kind) => {
const type = typeFor(kind)!;
const original = newConfigOfType(type, []);
@@ -700,6 +717,16 @@ describe("before launch tasks", () => {
useBuildPresentation.setState({ modules: new Map() });
disposeBuild();
});
+
+ it("shows the build policy for a Maven configuration", async () => {
+ const type = typeFor("maven")!;
+ const config = newConfigOfType(type, []);
+ const changed = vi.fn();
+ render(<ConfigForm config={config} all={[config]} type={type} errors={{}} onChange={changed} modifyRequest={0} />);
+ fireEvent.click(screen.getByRole("button", { name: /Modify options/ }));
+ fireEvent.click(await screen.findByText("Build"));
+ expect(screen.getByRole("button", { name: "Build" })).toBeTruthy();
+ });
});
describe("environment variables", () => {
@@ -866,3 +893,37 @@ describe("new Gradle wrapper default", () => {
},
);
});
+
+it.each(["maven", "gradle", "delegated", "absolute", "legacy"])(
+ "offers only supported build policies for %s",
+ (tool) => {
+ const kind = tool === "maven" || tool === "gradle" ? tool : "application";
+ const config = cfg("main", { kind, module: tool === "legacy" ? null : "app", buildPolicy: "make" });
+ const previous = useProject.getState();
+ if (kind === "application") {
+ useProject.setState({ project: { root: "/work" } as never, settings: null });
+ useBuildModel.setState({
+ model: { gradle: [{ projects: [{ dir: tool === "absolute" ? "/work/app" : "app" }] }] } as never,
+ });
+ }
+ try {
+ render(
+ <ConfigForm
+ config={config}
+ all={[config]}
+ type={typeFor(kind)}
+ errors={{}}
+ onChange={vi.fn()}
+ modifyRequest={0}
+ />,
+ );
+ fireEvent.click(screen.getByRole("button", { name: "Build" }));
+ expect(screen.queryByRole("option", { name: "No build" })).toBeNull();
+ expect(screen.queryByRole("option", { name: "Build, no error check" }) !== null).toBe(tool === "maven");
+ expect(screen.getByRole("option", { name: "Rebuild" })).toBeTruthy();
+ } finally {
+ useBuildModel.setState({ model: null });
+ useProject.setState(previous);
+ }
+ },
+);
diff --git a/src/features/run/store.ts b/src/features/run/store.ts
index 7e393e8df..e2f87a2aa 100644
--- a/src/features/run/store.ts
+++ b/src/features/run/store.ts
@@ -19,9 +19,9 @@ import {
type TestCaseReport,
} from "@/platform/ipc";
import {
- consoleVmArgs,
findJavaModule,
isJvmApplication,
+ JavaBuildFailedError,
parseJavaArgs,
prepareJavaLaunch,
} from "@/platform/javaLaunch";
@@ -30,6 +30,7 @@ import { useProject } from "@/platform/project";
import { executeAction } from "@/platform/actions";
import { workflowSettings } from "@/platform/workflowSettings";
import { maybeEditorService, notifications, toolWindowService, useDebugRunSessions } from "@/workbench/contributions";
+import { applyBuildPolicyToCommand } from "./buildCommand";
import { ConsoleModel } from "./console";
import { jvmFrameTarget } from "./links";
import { confirmRerun, confirmTerminate } from "./dialogs";
@@ -851,6 +852,8 @@ export async function startRun(
};
try {
let launch = options.launch ?? config;
+ // A Maven/Gradle configuration's own command is its build; Rebuild adds clean.
+ if (!options.launch) launch = applyBuildPolicyToCommand(launch);
// "Build and run using: Gradle": the module's Gradle build compiles and launches it.
const delegated = isJvmApplication(launch) ? await gradleDelegation(launch) : null;
if (runtimes.get(sessionId)?.generation !== generation) return getSession(sessionId) ?? null;
@@ -931,7 +934,8 @@ async function resolveJvmApplication(sessionId: string, config: RunConfig): Prom
say(`No main class in '${config.name}': expected java [options] -cp \${classpath} <main class> [args]\n`, "stderr");
return null;
}
- if (!parsed.classpath) return { ...config, args: [...consoleVmArgs(config), ...config.args] };
+ // Always prepare, exactly like Debug: even an explicit classpath needs the module, the
+ // project JDK and the selected build, and both modes must share the same result.
const rt = runtime(sessionId)!;
const request = { id: nextRequestId(), controller: new AbortController() };
rt.resolveRequest = request;
@@ -940,6 +944,9 @@ async function resolveJvmApplication(sessionId: string, config: RunConfig): Prom
request: request.id,
signal: request.controller.signal,
report: say,
+ saveAll: async () => {
+ await maybeEditorService()?.saveAll();
+ },
});
// No installed JDK is new enough for the module: offer to download one.
const jdkHint = info.hints.find((h) => downloadJdkActions(h).length);
@@ -959,7 +966,7 @@ async function resolveJvmApplication(sessionId: string, config: RunConfig): Prom
if (runtimes.get(sessionId) === rt && rt.resolveRequest === request) patchSession(sessionId, { stopped: true });
return null;
}
- say(`Cannot resolve the classpath: ${message}\n`, "stderr");
+ say(e instanceof JavaBuildFailedError ? `${message}\n` : `Cannot resolve the classpath: ${message}\n`, "stderr");
// jdtls can't start without a newer JDK: "Download JDK 25".
const actions = downloadJdkActions(message);
notifications().notify({
diff --git a/src/features/run/tomcat.test.tsx b/src/features/run/tomcat.test.tsx
index a2599e484..775672a69 100644
--- a/src/features/run/tomcat.test.tsx
+++ b/src/features/run/tomcat.test.tsx
@@ -278,7 +278,7 @@ describe("updating a running Tomcat deployment", () => {
it("compiles the selected WAR module and copies its outputs instead of rebuilding the WAR", async () => {
const c = config({ deployment: "artifact", artifact: "maven:web/pom.xml" });
expect(await syncTomcatOutputs(c, false)).toBe(true);
- expect(commands.javaResolveLaunch).toHaveBeenCalledWith("web", false, true, expect.anything());
+ expect(commands.javaResolveLaunch).toHaveBeenCalledWith("web", false, "make", expect.anything());
expect(commands.runTomcatSync).toHaveBeenCalledWith(c, "web", ["/p/web/target/classes", "/m2/lib.jar"], false);
});
diff --git a/src/features/run/tomcat.ts b/src/features/run/tomcat.ts
index 64cba9d5a..3a45afd82 100644
--- a/src/features/run/tomcat.ts
+++ b/src/features/run/tomcat.ts
@@ -161,7 +161,9 @@ export async function syncTomcatOutputs(config: RunConfig, resourcesOnly: boolea
const artifacts = await call(commands.runTomcatArtifacts());
const artifact = p.artifact ? artifacts.find((a) => a.id === p.artifact) : artifacts[0];
if (!artifact) return false;
- const info = await call(commands.javaResolveLaunch(artifact.module, false, true, nextRequestId())).catch(() => null);
+ const info = await call(commands.javaResolveLaunch(artifact.module, false, "make", nextRequestId())).catch(
+ () => null,
+ );
if (!info) return false;
if (info.build === "failed" || info.build === "withErrors" || info.build === "cancelled")
throw new Error(tx("Application update build failed"));
diff --git a/src/platform/i18n.test.ts b/src/platform/i18n.test.ts
index 4a6e565ca..dbe04e01e 100644
--- a/src/platform/i18n.test.ts
+++ b/src/platform/i18n.test.ts
@@ -243,6 +243,34 @@ describe("catalogs", () => {
const COMPLETE = ["zh"];
/** Written in another script, so a text equal to its English source was not translated. */
const OWN_SCRIPT = new Set(["zh", "ko"]);
+ /** Product names intentionally kept as written in every locale. */
+ const SAME_AS_ENGLISH = new Set([
+ "Docker",
+ "Shell",
+ "Java",
+ "Python",
+ "C/C++",
+ "C#",
+ "Go",
+ "Rust",
+ "Kotlin",
+ "PHP",
+ "SQL",
+ "JavaScript",
+ "TypeScript",
+ "HTML",
+ "CSS",
+ "JSON",
+ "YAML",
+ "XML",
+ "Maven",
+ "Gradle",
+ "npm",
+ "pnpm",
+ "Yarn",
+ "Cargo",
+ "CMake",
+ ]);
const translated = SUPPORTED_LOCALES.filter((locale) => locale !== "en").sort();
it("exist for exactly the supported locales", () => {
@@ -259,7 +287,8 @@ describe("catalogs", () => {
it("translate source text into text different from English, in locales with another script", () => {
for (const [locale, catalog] of Object.entries(texts))
if (OWN_SCRIPT.has(locale))
- for (const [source, text] of Object.entries(catalog)) expect(text, `${locale}:${source}`).not.toBe(source);
+ for (const [source, text] of Object.entries(catalog))
+ if (!SAME_AS_ENGLISH.has(source)) expect(text, `${locale}:${source}`).not.toBe(source);
});
it("keep the placeholders of source-text templates", () => {
diff --git a/src/platform/javaLaunch.ts b/src/platform/javaLaunch.ts
index e35f8b245..fb1e50408 100644
--- a/src/platform/javaLaunch.ts
+++ b/src/platform/javaLaunch.ts
@@ -4,7 +4,15 @@
* `${classpath}` (or `${testClasspath}`) and the `java` launcher are resolved
* through jdtls when the configuration starts.
*/
-import { call, commands, IpcError, type JavaLaunchInfo, type RunConfig, type RequestId } from "@/platform/ipc";
+import {
+ call,
+ commands,
+ IpcError,
+ type BuildPolicy,
+ type JavaLaunchInfo,
+ type RunConfig,
+ type RequestId,
+} from "@/platform/ipc";
import { tx } from "@/platform/i18n";
import { useBuildPresentation } from "@/platform/projectPresentation";
@@ -170,25 +178,47 @@ export async function resolveJavaModule(config: RunConfig): Promise<string> {
return module;
}
+/** Saves before resolving the module, for direct and delegated Run and Debug. */
+export async function prepareJavaModule(config: RunConfig, saveAll?: () => Promise<void>, signal?: AbortSignal) {
+ signal?.throwIfAborted();
+ await saveAll?.();
+ signal?.throwIfAborted();
+ const module = await resolveJavaModule(config);
+ signal?.throwIfAborted();
+ return module;
+}
+
/** Shared, cancellable build and classpath preparation for Run and Debug. */
export interface JavaPreparation {
request: RequestId;
signal: AbortSignal;
report?: (text: string, kind?: "system" | "stderr") => void;
+ /** Before launch build; unset reads the run configuration (default: automatic/incremental). */
+ policy?: BuildPolicy;
+ /** Saves open documents first, as IDEA's Before launch does. */
+ saveAll?: () => Promise<void>;
+}
+
+/** The build the launch would do: the configuration's policy, else incremental. */
+export function buildPolicyOf(config: RunConfig): BuildPolicy {
+ return config.buildPolicy ?? "automatic";
}
+/** A build stopped the launch: the message is ready for the console and the notification. */
+export class JavaBuildFailedError extends Error {}
+
export async function prepareJavaLaunch(config: RunConfig, preparation: JavaPreparation) {
const { signal, report } = preparation;
+ const policy = preparation.policy ?? buildPolicyOf(config);
signal.throwIfAborted();
const parsed = parseJavaArgs(config.args);
if (!parsed.mainClass) throw new Error(`No main class in '${config.name}'`);
report?.(tx`Building and resolving the classpath of ${parsed.mainClass}…` + "\n");
const started = performance.now();
- const module = await resolveJavaModule(config);
- signal.throwIfAborted();
+ const module = await prepareJavaModule(config, preparation.saveAll, signal);
const moduleMs = performance.now() - started;
const info = await call(
- commands.javaResolveLaunch(module, parsed.classpath === "test", true, preparation.request),
+ commands.javaResolveLaunch(module, parsed.classpath === "test", policy, preparation.request),
).catch((error: unknown) => {
if (
error instanceof IpcError &&
@@ -204,11 +234,17 @@ export async function prepareJavaLaunch(config: RunConfig, preparation: JavaPrep
});
signal.throwIfAborted();
console.info("Java launch preparation", { module, moduleMs, resolveMs: performance.now() - started - moduleMs });
- if (info.build === "withErrors")
- report?.(tx("Build completed with errors; launching with the last compiled classes.") + "\n", "stderr");
- if (info.build === "failed") report?.(tx("Build failed; launching with the last compiled classes.") + "\n", "stderr");
const errors = formatCompileErrors(info);
if (errors) report?.(errors, "stderr");
+ // IDEA's default: a failed build (or one with compile errors) does not start the program;
+ // only "Build, no error check" continues with the last compiled classes.
+ if ((info.build === "failed" || info.build === "withErrors") && policy !== "makeAndContinueOnErrors") {
+ const reason =
+ info.build === "failed"
+ ? tx`Build failed; '${config.name}' was not started.`
+ : tx`Build has compile errors; '${config.name}' was not started.`;
+ throw new JavaBuildFailedError(reason);
+ }
if (parsed.classpath && !info.classPaths.length)
throw new Error(tx("The classpath is empty: is the module imported by the Java language server?"));
return { module, info, resolved: resolveJavaCommand(config, info) };
diff --git a/src/platform/locales/text/en.json b/src/platform/locales/text/en.json
index dd6aee814..71f024e3f 100644
--- a/src/platform/locales/text/en.json
+++ b/src/platform/locales/text/en.json
@@ -540,5 +540,13 @@
"dev,integration": "dev,integration",
"Comma-separated profiles (-P), combined with Maven tool window choices; !id excludes a profile. A run configuration’s own -P replaces these profiles.": "Comma-separated profiles (-P), combined with Maven tool window choices; !id excludes a profile. A run configuration’s own -P replaces these profiles.",
"Active profiles": "Active profiles",
+ "Build failed; '{name}' was not started.": "Build failed; '{name}' was not started.",
+ "Build has compile errors; '{name}' was not started.": "Build has compile errors; '{name}' was not started.",
+ "Automatic (incremental)": "Automatic (incremental)",
+ "Build (Make)": "Build (Make)",
+ "Rebuild": "Rebuild",
+ "No build": "No build",
+ "Build, no error check": "Build, no error check",
+ "Before launch build for this Java configuration": "Before launch build for this Java configuration",
"the bundle of {gemfile} has no `debug` gem. Add `gem \"debug\"` to the Gemfile and run `bundle install`": "the bundle of {gemfile} has no `debug` gem. Add `gem \"debug\"` to the Gemfile and run `bundle install`"
}
diff --git a/src/platform/locales/text/es.json b/src/platform/locales/text/es.json
index abbcfd6e6..e3eb28e6b 100644
--- a/src/platform/locales/text/es.json
+++ b/src/platform/locales/text/es.json
@@ -3488,8 +3488,6 @@
"What should the agent do?": "¿Qué debe hacer el agente?",
"New worktree": "Nuevo árbol de trabajo",
"Building and resolving the classpath of {name}…": "Compilando y resolviendo el classpath de {name}…",
- "Build completed with errors; launching with the last compiled classes.": "La compilación terminó con errores; iniciando con las últimas clases compiladas.",
- "Build failed; launching with the last compiled classes.": "La compilación falló; iniciando con las últimas clases compiladas.",
"The classpath is empty: is the module imported by the Java language server?": "El classpath está vacío: ¿el servidor de lenguaje Java importó el módulo?",
"Launch cancelled.": "Inicio cancelado.",
"Starting debugger for {name}…": "Iniciando depurador para {name}…",
diff --git a/src/platform/locales/text/fr.json b/src/platform/locales/text/fr.json
index fcb68c1de..34952281b 100644
--- a/src/platform/locales/text/fr.json
+++ b/src/platform/locales/text/fr.json
@@ -3354,8 +3354,6 @@
"What should the agent do?": "Que doit faire l'agent ?",
"New worktree": "Nouveau worktree",
"Building and resolving the classpath of {name}…": "Compilation et résolution du classpath de {name}…",
- "Build completed with errors; launching with the last compiled classes.": "Build terminé avec des erreurs ; lancement avec les dernières classes compilées.",
- "Build failed; launching with the last compiled classes.": "Échec du build ; lancement avec les dernières classes compilées.",
"The classpath is empty: is the module imported by the Java language server?": "Le classpath est vide : le module est-il importé par le serveur de langage Java ?",
"Launch cancelled.": "Lancement annulé.",
"Starting debugger for {name}…": "Démarrage du débogueur pour {name}…",
diff --git a/src/platform/locales/text/ko.json b/src/platform/locales/text/ko.json
index ae7f94cf6..503b64a96 100644
--- a/src/platform/locales/text/ko.json
+++ b/src/platform/locales/text/ko.json
@@ -3543,8 +3543,6 @@
"What should the agent do?": "에이전트가 무엇을 해야 하나요?",
"New worktree": "새 워크트리",
"Building and resolving the classpath of {name}…": "{name}의 클래스 경로를 빌드하고 해결하는 중…",
- "Build completed with errors; launching with the last compiled classes.": "빌드가 오류와 함께 완료되었습니다. 마지막으로 컴파일된 클래스로 실행합니다.",
- "Build failed; launching with the last compiled classes.": "빌드에 실패했습니다. 마지막으로 컴파일된 클래스로 실행합니다.",
"The classpath is empty: is the module imported by the Java language server?": "클래스 경로가 비어 있습니다. Java 언어 서버에서 모듈을 가져왔습니까?",
"Launch cancelled.": "실행이 취소되었습니다.",
"Starting debugger for {name}…": "{name}의 디버거 시작 중…",
diff --git a/src/platform/locales/text/pl.json b/src/platform/locales/text/pl.json
index 326d62f60..c63f50b28 100644
--- a/src/platform/locales/text/pl.json
+++ b/src/platform/locales/text/pl.json
@@ -3460,8 +3460,6 @@
"What should the agent do?": "Co agent powinien zrobić?",
"New worktree": "Nowe worktree",
"Building and resolving the classpath of {name}…": "Kompilowanie i ustalanie ścieżki klas (classpath) dla {name}…",
- "Build completed with errors; launching with the last compiled classes.": "Kompilacja zakończona z błędami; uruchamianie z ostatnio skompilowanymi klasami.",
- "Build failed; launching with the last compiled classes.": "Kompilacja nie powiodła się; uruchamianie z ostatnio skompilowanymi klasami.",
"The classpath is empty: is the module imported by the Java language server?": "Ścieżka klas jest pusta: czy moduł został zaimportowany przez serwer językowy Java?",
"Launch cancelled.": "Uruchomienie anulowane.",
"Starting debugger for {name}…": "Uruchamianie debugera dla {name}…",
diff --git a/src/platform/locales/text/pt.json b/src/platform/locales/text/pt.json
index 8cabbd1bb..6288ee8e8 100644
--- a/src/platform/locales/text/pt.json
+++ b/src/platform/locales/text/pt.json
@@ -3461,8 +3461,6 @@
"What should the agent do?": "O que o agente deve fazer?",
"New worktree": "Novo worktree",
"Building and resolving the classpath of {name}…": "Compilando e resolvendo o classpath de {name}…",
- "Build completed with errors; launching with the last compiled classes.": "Build concluído com erros; iniciando com as últimas classes compiladas.",
- "Build failed; launching with the last compiled classes.": "Falha no build; iniciando com as últimas classes compiladas.",
"The classpath is empty: is the module imported by the Java language server?": "O classpath está vazio: o módulo foi importado pelo servidor de linguagem Java?",
"Launch cancelled.": "Inicialização cancelada.",
"Starting debugger for {name}…": "Iniciando o depurador para {name}…",
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index 7b3531908..6cd919a81 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -1581,7 +1581,6 @@
"Open in New Window": "在新窗口中打开",
"Open in Terminal": "在终端中打开",
"Open in editor": "在编辑器中打开",
- "Open main menu with a lone Alt press": "单独按下 Alt 打开主菜单",
"Open moved files in editor": "在编辑器中打开已移动的文件",
"Open new tabs at the end": "在末尾打开新标签页",
"Open on GitHub": "在 GitHub 上打开",
@@ -3768,8 +3767,6 @@
"What should the agent do?": "让 agent 做点什么?",
"New worktree": "新 worktree",
"Building and resolving the classpath of {name}…": "正在构建并解析 {name} 的类路径…",
- "Build completed with errors; launching with the last compiled classes.": "构建完成但存在错误;使用上次编译的类启动。",
- "Build failed; launching with the last compiled classes.": "构建失败;使用上次编译的类启动。",
"The classpath is empty: is the module imported by the Java language server?": "类路径为空:Java 语言服务器是否已导入此模块?",
"Launch cancelled.": "启动已取消。",
"Starting debugger for {name}…": "正在启动 {name} 的调试器…",
@@ -5088,7 +5085,6 @@
"Only one of these runs at a time. Automatic uses the first one available: {order}.": "这些服务器同一时间只运行一个。自动模式使用第一个可用的:{order}。",
"Configure the settings related to version control used in your project": "配置项目中使用的版本控制相关设置",
"Use non-modal commit interface": "使用非模态提交界面",
- "When off, Alt key combinations still work but pressing Alt alone does not focus the main menu": "关闭后,Alt 组合键仍然可用,但单独按下 Alt 不会聚焦主菜单",
"When off, Local Changes and Stash are tabs of the Git tool window and Commit opens a dialog.": "关闭时,本地更改和贮藏作为 Git 工具窗口的标签页显示,提交时打开对话框。",
"Clear initial commit message": "清除初始提交消息",
"Show options before Update": "更新前显示选项",
@@ -6876,5 +6872,26 @@
"Select Maven toolchains.xml": "选择 Maven toolchains.xml",
"dev,integration": "开发,集成",
"Comma-separated profiles (-P), combined with Maven tool window choices; !id excludes a profile. A run configuration’s own -P replaces these profiles.": "以逗号分隔的 profiles(-P),与 Maven 工具窗口中的选择合并;!id 排除指定 profile。运行配置自身的 -P 会替代这些 profiles。",
+ "Build failed; '{name}' was not started.": "构建失败;'{name}' 未启动。",
+ "Build has compile errors; '{name}' was not started.": "构建存在编译错误;'{name}' 未启动。",
+ "Automatic (incremental)": "自动(增量)",
+ "Build (Make)": "构建(Make)",
+ "Rebuild": "重新构建",
+ "No build": "不构建",
+ "Build, no error check": "构建,不检查错误",
+ "Before launch build for this Java configuration": "此 Java 配置启动前的构建方式",
+ "Docker": "Docker",
+ "Shell": "Shell",
+ "C/C++": "C/C++",
+ "Go": "Go",
+ "Rust": "Rust",
+ "Python": "Python",
+ "JavaScript": "JavaScript",
+ "Java": "Java",
+ "Add Service ({kind})": "添加服务({kind})",
+ "Others": "其他",
+ "Servers": "服务器",
+ "Open main menu with a lone Alt press": "单独按下 Alt 打开主菜单",
+ "When off, Alt key combinations still work but pressing Alt alone does not focus the main menu": "关闭后,Alt 组合键仍然可用,但单独按下 Alt 不会聚焦主菜单",
"the bundle of {gemfile} has no `debug` gem. Add `gem \"debug\"` to the Gemfile and run `bundle install`": "{gemfile} 的 bundle 中没有 `debug` gem。请在 Gemfile 中添加 `gem \"debug\"`,然后运行 `bundle install`"
}