The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(java): preserve mapped toolchain paths and refresh Maven run settings (#1147)
l0ng-ai60969eccb673
diff --git a/crates/ide-host/src/ops/run.rs b/crates/ide-host/src/ops/run.rsindex 511846bfb..ae24f9f88 100644--- a/crates/ide-host/src/ops/run.rs+++ b/crates/ide-host/src/ops/run.rs@@ -41,7 +41,7 @@ pub fn configs(host: &Host, window: &str) -> IdeResult<Vec<RunConfig>> {}/// A project's detected configurations (minus removed ones and unlinked Maven projects), then-/// its saved ones; toolchains from Languages & Frameworks applied. Gradle choices stay as saved:+/// its saved ones; toolchains from Languages & Frameworks applied. Build-tool choices stay as saved:/// derived defaults must not be written back as explicit environment.fn detected_and_saved(root: &std::path::Path,@@ -56,7 +56,7 @@ fn detected_and_saved(.filter(|d| !suppressed.contains(&d.id) && !saved.iter().any(|u| u.id == d.id)).collect();all.extend(saved.iter().cloned());- for config in all.iter_mut().filter(|c| c.kind != "gradle") {+ for config in all.iter_mut().filter(|c| !matches!(c.kind.as_str(), "gradle" | "maven")) {ide_sdk::apply::apply_to_run_configs(std::slice::from_mut(config), root, settings);}all@@ -75,7 +75,7 @@ pub fn save_configs(let configs: Vec<RunConfig> = configs.iter().map(|c| match c.kind.as_str() {- "gradle" => c.clone(),+ "gradle" | "maven" => c.clone(),_ => ide_sdk::apply::without_derived(c, &project.root, &settings),}).collect();@@ -156,7 +156,9 @@ pub async fn start(host: &Host, window: &str, config: RunConfig, on_output: Emitlet root = &root;// Configurations made in the UI name bare tools (`godot`) that may live outside PATH.let mut config = config;- if matches!(config.kind.as_str(), "gradle" | "tomcat") {+ if config.kind == "maven" {+ ide_sdk::apply::prepare_maven_run(&mut config, root, &settings);+ } else if matches!(config.kind.as_str(), "gradle" | "tomcat") {ide_sdk::apply::apply_to_run_configs(std::slice::from_mut(&mut config), root, &settings);} else {ide_sdk::apply::resolve_run_command(&mut config, root, &settings);diff --git a/crates/ide-host/tests/run_configs.rs b/crates/ide-host/tests/run_configs.rsindex 9313c7569..c45bccdaf 100644--- a/crates/ide-host/tests/run_configs.rs+++ b/crates/ide-host/tests/run_configs.rs@@ -81,6 +81,46 @@ async fn gradle_defaults_are_not_saved_as_explicit_run_choices() {assert_eq!(saved.command, gradle.command);}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn maven_defaults_are_resolved_at_launch_and_explicit_choices_survive_reload() {+ let tmp = tempfile::tempdir().unwrap();+ let root = dunce::canonicalize(tmp.path()).unwrap();+ std::fs::write(root.join("pom.xml"), "<project/>").unwrap();+ let home = root.join("maven");+ std::fs::create_dir_all(home.join("bin")).unwrap();+ let launcher = home.join("bin").join(if cfg!(windows) { "mvn.cmd" } else { "mvn" });+ std::fs::write(&launcher, "").unwrap();+ let host = host(&root.join("app"));+ host.trust.decide(&root, true, false).unwrap();+ host.open_project("main", &root).unwrap();+ for (key, value) in [+ ("languages.java.maven.home", home.to_string_lossy().into_owned()),+ ("languages.java.maven.userSettings", "settings.xml".into()),+ ] {+ ops::project::set_settings(+ &host,+ "main",+ ide_workspace::settings::SettingsScope::Project,+ key,+ &serde_json::to_string(&value).unwrap(),+ )+ .unwrap();+ }+ let mut config = ops::run::configs(&host, "main").unwrap().into_iter().find(|c| c.id == "maven:test").unwrap();+ assert_eq!(config.command, "mvn");+ assert_eq!(config.args, ["test"]);+ assert!(config.env.is_empty());+ config.command = launcher.to_string_lossy().into_owned();+ config.args = vec!["-s".into(), "own-settings.xml".into(), "test".into()];+ config.env.insert("JAVA_HOME".into(), "own-jdk".into());+ config.detected = false;+ ops::run::save_configs(&host, "main", &[config.clone()], &[]).unwrap();+ let saved = ops::run::configs(&host, "main").unwrap().into_iter().find(|c| c.id == config.id).unwrap();+ assert_eq!(saved.command, config.command);+ assert_eq!(saved.args, config.args);+ assert_eq!(saved.env, config.env);+}+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]async fn workspace_cmake_before_launch_tasks_resolve_in_the_member() {let tmp = tempfile::tempdir().unwrap();diff --git a/crates/ide-sdk/src/apply.rs b/crates/ide-sdk/src/apply.rsindex 7ff5e54c1..a496a4333 100644--- a/crates/ide-sdk/src/apply.rs+++ b/crates/ide-sdk/src/apply.rs@@ -192,6 +192,88 @@ pub fn maven_options(root: &Path, s: &Settings) -> Vec<String> {out}+fn maven_settings_prefixes(args: &[String]) -> Vec<usize> {+ let mut prefixes = vec![0];+ let mut i = 0;+ while let Some(arg) = args.get(i) {+ if arg == "-s" && args.get(i + 1).is_some() {+ i += 2;+ } else if arg.starts_with("-Dmaven.repo.local=") {+ i += 1;+ } else {+ break;+ }+ prefixes.push(i);+ }+ prefixes+}++fn generated_maven_goal(config: &RunConfig) -> bool {+ config.id.starts_with("maven:goal:") && config.extras.params.is_empty()+}++fn maven_goal_prefix(config: &RunConfig) -> Option<usize> {+ let (_, goals) = config.id.split_once(".xml:")?;+ maven_settings_prefixes(&config.args)+ .into_iter()+ .find(|&start| (start + 1..=config.args.len()).any(|end| config.args[start..end].join(" ") == goals))+}++/// Applies the current Maven settings at launch, including temporary configurations+/// made before build-tool defaults stopped being stored in their command and arguments.+pub fn prepare_maven_run(config: &mut RunConfig, root: &Path, s: &Settings) {+ let mut detected = config.detected;+ if generated_maven_goal(config) {+ // The id records the user's original goals; only the settings prefix before them is derived.+ if let Some(prefix) = maven_goal_prefix(config) {+ config.args.drain(..prefix);+ }+ let name = config.command.rsplit(['/', '\\']).next().unwrap_or_default().to_ascii_lowercase();+ if !matches!(name.as_str(), "mvnw" | "mvnw.cmd" | "mvnw.bat") {+ config.command = "mvn".into();+ if maven_command(root, s).is_none() {+ let cwd = config.cwd.as_ref().map_or_else(|| root.to_path_buf(), |dir| root.join(dir.as_ref()));+ for dir in cwd.ancestors().take_while(|dir| dir.starts_with(root)) {+ let wrapper = dir.join(if cfg!(windows) { "mvnw.cmd" } else { "mvnw" });+ if wrapper.is_file() {+ config.command = wrapper.to_string_lossy().into_owned();+ break;+ }+ }+ }+ }+ } else if config.detected || config.id.starts_with("context:") {+ let saved = ide_run::load_user_configs(root).unwrap_or_default();+ let id = config+ .id+ .strip_prefix("context:target:context:")+ .or_else(|| config.id.strip_prefix("context:"))+ .unwrap_or(&config.id);+ let id = id.strip_prefix("workspace:").and_then(|id| id.split_once(':')).map_or(id, |(_, id)| id);+ let source = ide_run::detect(root)+ .into_iter()+ .chain(saved.iter().cloned())+ .filter(|base| base.kind == "maven" && (id == base.id || id.starts_with(&format!("{}:", base.id))))+ .max_by_key(|base| base.id.len())+ .filter(|base| !saved.iter().any(|user| user.id == base.id));+ if let Some(base) = source.filter(|_| config.extras.params.is_empty()) {+ if let Some(prefix) = maven_settings_prefixes(&config.args)+ .into_iter()+ .find(|&start| config.args[start..].starts_with(&base.args))+ {+ config.args.drain(..prefix);+ }+ config.command = base.command;+ } else {+ detected = false;+ }+ }+ let original = config.detected;+ config.detected = detected;+ apply_to_run_configs(std::slice::from_mut(config), root, s);+ config.detected = original;+}+/// The Maven local repository from settings: the configured one, else/// `<localRepository>` of the configured user `settings.xml`; `None` = Maven's default.pub fn maven_local_repository(root: &Path, s: &Settings) -> Option<PathBuf> {@@ -666,6 +748,9 @@ fn sets_maven_option(args: &[String], group: &[String]) -> bool {Some(flag) => {let key = flag.split_once('=').map_or(flag, |(k, _)| k);args.iter().any(|a| a.split_once('=').map_or(a.as_str(), |(k, _)| k) == key)+ || args+ .windows(2)+ .any(|a| a[0] == "-D" && format!("-D{}", a[1].split('=').next().unwrap_or_default()) == key)}None => true,}@@ -815,11 +900,10 @@ pub fn apply_to_run_configs(configs: &mut [RunConfig], root: &Path, s: &Settingsc.env.entry("JAVA_HOME".into()).or_insert_with(|| jdk.home.to_string_lossy().into_owned());}if c.kind == "maven" {- // A configuration made or saved in the UI names the literal `mvn` /- // `mvn.cmd`; without a wrapper it cannot start when Maven lives on a- // version manager's shims or a configured home (#328).if let Some(mvn) = &mvn- && (c.detected || matches!(c.command.as_str(), "mvn" | "mvn.cmd" | "mvn.bat"))+ && (c.detected+ || generated_maven_goal(c)+ || matches!(c.command.as_str(), "mvn" | "mvn.cmd" | "mvn.bat")){c.command = mvn.to_string_lossy().into_owned();}@@ -870,9 +954,15 @@ pub fn without_derived(config: &RunConfig, root: &Path, s: &Settings) -> RunConfif out.kind == "maven" {let options = maven_options(root, s);let mut probe = out.clone();+ let mut prefix = generated_maven_goal(&out).then(|| maven_goal_prefix(&out)).flatten();for group in maven_option_groups(&options) {- if let Some(at) = probe.args.windows(group.len()).position(|w| w == group) {+ if let Some(at) = probe.args.windows(group.len()).position(|w| w == group)+ && prefix.is_none_or(|limit| at + group.len() <= limit)+ {probe.args.drain(at..at + group.len());+ if let Some(limit) = &mut prefix {+ *limit -= group.len();+ }}}if applied(&probe).args == out.args {diff --git a/crates/ide-sdk/src/discover.rs b/crates/ide-sdk/src/discover.rsindex 92b58a237..c0de0540d 100644--- a/crates/ide-sdk/src/discover.rs+++ b/crates/ide-sdk/src/discover.rs@@ -545,7 +545,7 @@ fn jdk() -> Vec<Sdk> {/// A JDK as the SDK pickers list it (`Eclipse Adoptium 25.0.1`).pub fn jdk_sdk(j: &crate::java::Jdk) -> Sdk {- let java_home = std::env::var_os("JAVA_HOME").and_then(|h| dunce::canonicalize(h).ok());+ let java_home = std::env::var_os("JAVA_HOME").and_then(|h| crate::launch_path(Path::new(&h)).ok());let release = std::fs::read_to_string(j.home.join("release")).unwrap_or_default();let version = release_value(&release, "JAVA_VERSION").unwrap_or_else(|| j.major.to_string());let name = match release_value(&release, "IMPLEMENTOR") {@@ -595,7 +595,7 @@ fn maven() -> Vec<Sdk> {} else {which("mvn")};- if let Some(mvn) = on_path.and_then(|p| dunce::canonicalize(p).ok())+ if let Some(mvn) = on_path.and_then(|p| crate::launch_path(&p).ok())&& let Some(home) = mvn.parent().and_then(Path::parent){found.push((home.to_path_buf(), "path"));@@ -629,7 +629,7 @@ fn maven() -> Vec<Sdk> {let mut out = Vec::new();for (dir, source) in found {let Some(home) = maven_home(&dir) else { continue };- let home = dunce::canonicalize(&home).unwrap_or(home);+ let home = crate::launch_path(&home).unwrap_or(home);if !seen.insert(home.clone()) {continue;}@@ -645,3 +645,84 @@ fn maven() -> Vec<Sdk> {}out}++#[cfg(all(test, windows))]+mod maven_path_tests {+ use super::*;+ use crate::launch_path;+ use std::process::Command;++ struct Subst {+ name: String,+ root: PathBuf,+ }++ impl Subst {+ fn new(target: &Path) -> Self {+ for letter in (b'D'..=b'Z').rev() {+ let name = format!("{}:", char::from(letter));+ let root = PathBuf::from(format!("{name}\\"));+ if root.exists() {+ continue;+ }+ let output = Command::new("subst").arg(&name).arg(target).output().unwrap();+ if output.status.success() {+ return Self { name, root };+ }+ }+ panic!("no free drive for Maven path verification");+ }+ }++ impl Drop for Subst {+ fn drop(&mut self) {+ let _ = Command::new("subst").args([&self.name, "/D"]).output();+ }+ }++ fn install(home: &Path) {+ std::fs::create_dir_all(home.join("bin")).unwrap();+ std::fs::create_dir_all(home.join("lib")).unwrap();+ std::fs::write(home.join("bin/mvn.cmd"), "@echo off\n").unwrap();+ std::fs::write(home.join("lib/maven-core-3.9.16.jar"), "").unwrap();+ }++ #[test]+ fn mapped_maven_home_and_launcher_keep_their_drive() {+ let mapped = tempfile::tempdir().unwrap();+ install(&mapped.path().join("apache-maven"));+ let drive = Subst::new(mapped.path());+ let home = drive.root.join("apache-maven");+ let launcher = home.join("bin/mvn.cmd");+ assert_ne!(dunce::canonicalize(&home).unwrap(), home);+ assert_eq!(launch_path(&home).unwrap(), home);+ assert_eq!(launch_path(&launcher).unwrap(), launcher);+ assert_eq!(maven_home(&home), Some(home.clone()));+ assert_eq!(maven_version(&home).as_deref(), Some("3.9.16"));+ let jdk = drive.root.join("jdk");+ std::fs::create_dir_all(jdk.join("bin")).unwrap();+ std::fs::write(jdk.join("bin/java.exe"), "").unwrap();+ std::fs::write(jdk.join("release"), "JAVA_VERSION=\"17.0.9\"\n").unwrap();+ assert_eq!(crate::java::jdk_at(&jdk).unwrap().home, jdk);+ }++ #[test]+ fn a_launcher_link_outside_the_mapped_root_still_finds_its_install() {+ let mapped = tempfile::tempdir().unwrap();+ let real = tempfile::tempdir().unwrap();+ install(real.path());+ let drive = Subst::new(mapped.path());+ let link = mapped.path().join("shims");+ let output = Command::new(std::env::var_os("COMSPEC").unwrap_or_else(|| "cmd.exe".into()))+ .args(["/D", "/C", "mklink", "/J"])+ .arg(&link)+ .arg(real.path().join("bin"))+ .output()+ .unwrap();+ assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr));+ let launcher = launch_path(&drive.root.join("shims/mvn.cmd")).unwrap();+ assert_eq!(launcher, dunce::canonicalize(real.path().join("bin/mvn.cmd")).unwrap());+ let home = launcher.parent().and_then(Path::parent).and_then(maven_home).unwrap();+ assert_eq!(home, dunce::canonicalize(real.path()).unwrap());+ }+}diff --git a/crates/ide-sdk/src/java.rs b/crates/ide-sdk/src/java.rsindex a2f60063d..05f89fc93 100644--- a/crates/ide-sdk/src/java.rs+++ b/crates/ide-sdk/src/java.rs@@ -38,10 +38,7 @@ pub fn jdk_at(home: &Path) -> Option<Jdk> {if !home.join("bin").join(crate::exe("java")).is_file() {return None;}- Some(Jdk {- major: parse_release(&release)?,- home: dunce::canonicalize(home).unwrap_or_else(|_| home.to_path_buf()),- })+ Some(Jdk { major: parse_release(&release)?, home: crate::launch_path(home).unwrap_or_else(|_| home.to_path_buf()) })}fn children(dir: &Path) -> Vec<PathBuf> {@@ -90,7 +87,7 @@ fn scan() -> Vec<Jdk> {let path = std::env::var_os("PATH").unwrap_or_default();if let Some(java) = std::env::split_paths(&path).map(|d| d.join(crate::exe("java"))).find(|j| j.is_file()) {// Through symlinks (`/usr/bin/java`, Homebrew, SDKMAN `current`) to `<home>/bin/java`.- if let Some(home) = dunce::canonicalize(java).ok().and_then(|j| j.parent()?.parent().map(Path::to_path_buf)) {+ if let Some(home) = crate::launch_path(&java).ok().and_then(|j| j.parent()?.parent().map(Path::to_path_buf)) {homes.push(home);}}diff --git a/crates/ide-sdk/src/lib.rs b/crates/ide-sdk/src/lib.rsindex ef4efaf66..ac8c34eb8 100644--- a/crates/ide-sdk/src/lib.rs+++ b/crates/ide-sdk/src/lib.rs@@ -82,6 +82,36 @@ pub(crate) fn exe(name: &str) -> String {if cfg!(windows) { format!("{name}.exe") } else { name.to_owned() }}+/// `path` with symlinks resolved (Homebrew's `bin/mvn` → its Cellar), except that a Windows+/// mapped drive letter is kept when the target stays inside that drive: canonicalizing gives+/// `\\?\UNC\server\share\…` or another drive, and cmd.exe can't start a script from a+/// `\\?\` path (`mvn.cmd`, or `mvn.cmd` with such a `JAVA_HOME`), nor is it the path the user knows.+pub(crate) fn launch_path(path: &Path) -> std::io::Result<PathBuf> {+ let real = dunce::canonicalize(path)?;+ #[cfg(windows)]+ {+ use std::path::{Component, Prefix};+ let drive = |p: &Path| match p.components().next() {+ Some(Component::Prefix(x)) => match x.kind() {+ Prefix::Disk(d) | Prefix::VerbatimDisk(d) => Some(d.to_ascii_uppercase()),+ _ => None,+ },+ _ => None,+ };+ if let Some(d) = drive(path)+ && drive(&real) != Some(d)+ {+ let root = PathBuf::from(format!("{}:\\", char::from(d)));+ if let Ok(mapped) = dunce::canonicalize(&root)+ && let Ok(relative) = real.strip_prefix(mapped)+ {+ return Ok(root.join(relative));+ }+ }+ }+ Ok(real)+}+pub(crate) fn home_dir() -> Option<PathBuf> {std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")).map(PathBuf::from)}diff --git a/crates/ide-sdk/src/tests.rs b/crates/ide-sdk/src/tests.rsindex af8bae61b..4a61ad1d5 100644--- a/crates/ide-sdk/src/tests.rs+++ b/crates/ide-sdk/src/tests.rs@@ -284,6 +284,129 @@ fn saved_maven_goal_configs_take_the_configured_launcher() {assert_eq!(configs[2].command, "./mvnw");}+#[test]+fn maven_launch_refreshes_legacy_defaults_but_keeps_user_overrides() {+ use crate::apply::prepare_maven_run;++ let tmp = tempfile::tempdir().unwrap();+ std::fs::write(tmp.path().join("pom.xml"), "<project/>").unwrap();+ let home = tmp.path().join("new-maven");+ std::fs::create_dir_all(home.join("bin")).unwrap();+ let launcher = home.join("bin").join(if cfg!(windows) { "mvn.cmd" } else { "mvn" });+ std::fs::write(&launcher, "").unwrap();+ let mut s = Settings::default();+ s.languages.java.maven.home = home.to_string_lossy().into_owned();+ s.languages.java.maven.user_settings = "new-settings.xml".into();+ s.languages.java.maven.local_repository = "new-repo".into();+ let options = maven_options(tmp.path(), &s);++ for id in [+ "maven:goal:pom.xml:test",+ "maven:test",+ "context:maven:test:src/test/java/ExampleTest.java",+ "context:target:context:maven:test:src/test/java/ExampleTest.java:ExampleTest#example",+ "workspace:abc:maven:test",+ "context:target:context:workspace:abc:maven:test:src/test/java/ExampleTest.java:ExampleTest#example",+ ] {+ let mut config = run(+ "maven",+ "//?/UNC/server/old-maven/bin/mvn.cmd",+ &["-s", "old-settings.xml", "-Dmaven.repo.local=old-repo", "test", "-Dtest=ExampleTest#example"],+ );+ config.id = id.into();+ config.detected = !id.starts_with("maven:goal:");+ let original = config.clone();+ prepare_maven_run(&mut config, tmp.path(), &s);+ assert_eq!(config.command, launcher.to_string_lossy(), "{id}");+ assert_eq!(+ config.args,+ [options.clone(), vec!["test".into(), "-Dtest=ExampleTest#example".into()]].concat(),+ "{id}"+ );+ // Rerunning the stored configuration reads settings again, without changing the stored input.+ s.languages.java.maven.local_repository = "other-repo".into();+ let mut rerun = original;+ prepare_maven_run(&mut rerun, tmp.path(), &s);+ assert!(rerun.args.contains(&format!("-Dmaven.repo.local={}", tmp.path().join("other-repo").display())));+ s.languages.java.maven.local_repository = "new-repo".into();+ }++ for args in [+ vec!["-s", "own-settings.xml", "-Dmaven.repo.local=own-repo", "test"],+ vec!["--settings=own-settings.xml", "-D", "maven.repo.local=own-repo", "test"],+ ] {+ let mut config = run("maven", "mvn", &args);+ config.detected = false;+ prepare_maven_run(&mut config, tmp.path(), &s);+ assert_eq!(config.command, launcher.to_string_lossy());+ assert_eq!(config.args, args);+ }++ let mut explicit = run("maven", "/custom/mvn", &["-s", "own-settings.xml", "-Dmaven.repo.local=own-repo", "test"]);+ explicit.detected = false;+ prepare_maven_run(&mut explicit, tmp.path(), &s);+ assert_eq!(explicit.command, "/custom/mvn");+ assert_eq!(explicit.args, ["-s", "own-settings.xml", "-Dmaven.repo.local=own-repo", "test"]);++ // A gutter configuration derived from a user-edited default must keep that user's choices.+ let mut saved = explicit.clone();+ saved.id = "maven:test".into();+ ide_run::save_user_configs(tmp.path(), &[saved]).unwrap();+ explicit.id = "context:maven:test:src/test/java/ExampleTest.java".into();+ explicit.detected = true;+ prepare_maven_run(&mut explicit, tmp.path(), &s);+ assert_eq!(explicit.command, "/custom/mvn");+ assert_eq!(explicit.args, ["-s", "own-settings.xml", "-Dmaven.repo.local=own-repo", "test"]);++ std::fs::create_dir(tmp.path().join("child")).unwrap();+ std::fs::write(tmp.path().join("child/pom.xml"), "<project/>").unwrap();+ let mut nested = explicit.clone();+ nested.id = "maven:test:child".into();+ nested.detected = false;+ ide_run::save_user_configs(tmp.path(), &[nested]).unwrap();+ explicit.id = "context:maven:test:child:src/test/java/ExampleTest.java".into();+ prepare_maven_run(&mut explicit, tmp.path(), &s);+ assert_eq!(explicit.command, "/custom/mvn", "an edited child must not fall back to the parent's defaults");+ assert_eq!(explicit.args, ["-s", "own-settings.xml", "-Dmaven.repo.local=own-repo", "test"]);+}++#[test]+fn maven_goal_keeps_explicit_settings_and_nested_wrapper() {+ use crate::apply::prepare_maven_run;++ let tmp = tempfile::tempdir().unwrap();+ std::fs::create_dir(tmp.path().join("child")).unwrap();+ let wrapper = tmp.path().join("child").join(if cfg!(windows) { "mvnw.cmd" } else { "mvnw" });+ std::fs::write(&wrapper, "").unwrap();+ let mut config = run("maven", "old-maven", &["-s", "old-settings.xml", "-s", "own-settings.xml", "test"]);+ config.id = "maven:goal:child/pom.xml:-s own-settings.xml test".into();+ config.cwd = Some("child".into());+ config.detected = false;+ let mut s = Settings::default();+ s.languages.java.maven.user_settings = "new-settings.xml".into();+ prepare_maven_run(&mut config, tmp.path(), &s);+ assert_eq!(config.command, wrapper.to_string_lossy());+ assert_eq!(config.args, ["-s", "own-settings.xml", "test"]);+}++#[test]+fn persisting_a_maven_goal_keeps_explicit_options_equal_to_the_defaults() {+ let tmp = tempfile::tempdir().unwrap();+ let mut s = Settings::default();+ s.languages.java.maven.user_settings = tmp.path().join("settings.xml").to_string_lossy().into_owned();+ s.languages.java.maven.local_repository = tmp.path().join("repo").to_string_lossy().into_owned();+ let options = maven_options(tmp.path(), &s);+ for goals in [vec![options[2].clone(), "test".into()], [options.clone(), vec!["test".into()]].concat()] {+ let mut config = run("maven", "mvn", &[]);+ config.id = format!("maven:goal:pom.xml:{}", goals.join(" "));+ config.detected = false;+ config.args = goals.clone();+ apply_to_run_configs(std::slice::from_mut(&mut config), tmp.path(), &s);+ let kept = without_derived(&config, tmp.path(), &s);+ assert_eq!(kept.args, goals);+ }+}+#[test]fn language_server_settings_disable_add_and_override() {use crate::apply::{language_servers, server_launch_overrides, server_protocol_overrides, with_custom_servers};diff --git a/src/features/build-tools/model.test.ts b/src/features/build-tools/model.test.tsindex 07fedfb82..40754abc2 100644--- a/src/features/build-tools/model.test.ts+++ b/src/features/build-tools/model.test.ts@@ -210,11 +210,25 @@ describe("Maven runs", () => {});expect(root.cwd).toBeNull();expect(root.isTest).toBe(false);- // Settings › Maven options go before the goals.- const configured = { ...core, options: ["-s", "/m2/settings.xml"] };+ const configured = {+ ...core,+ command: "//?/UNC/server/share/maven/bin/mvn.cmd",+ options: ["-s", "/old/settings.xml", "-Dmaven.repo.local=/old/repository"],+ };+ const goal = mavenGoalConfig(configured, ["test"], maven, {+ offline: false,+ skipTests: true,+ profiles: {},+ });+ expect(goal.command).toBe("mvn");+ expect(goal.args).toEqual(["test", "-DskipTests"]);expect(- mavenGoalConfig(configured, ["test"], maven, { offline: false, skipTests: true, profiles: {} }).args,- ).toEqual(["-s", "/m2/settings.xml", "test", "-DskipTests"]);+ mavenGoalConfig(configured, ["-s", "/own/settings.xml", "test"], maven, {+ offline: false,+ skipTests: false,+ profiles: {},+ }).args,+ ).toEqual(["-s", "/own/settings.xml", "test"]);});it("parses typed command lines", () => {diff --git a/src/features/build-tools/model.ts b/src/features/build-tools/model.tsindex 51957d283..c448ee943 100644--- a/src/features/build-tools/model.ts+++ b/src/features/build-tools/model.ts@@ -426,12 +426,12 @@ export function mavenGoalConfig(model: Pick<MavenModel, "profiles">,options: MavenRunOptions,): RunConfig {- const args = [...project.options, ...mavenArgs(goals, model, options)];+ const args = mavenArgs(goals, model, options);return {id: `maven:goal:${project.pom}:${goals.join(" ")}`,name: mavenConfigName(project, goals),kind: "maven",- command: project.command,+ command: /(?:^|[/\\])mvnw(?:\.cmd|\.bat)?$/i.test(project.command) ? project.command : "mvn",args,cwd: project.dir || null,env: { ...project.env },