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): resolve Maven projects with the profiles chosen in the Maven tool window (#1044)
l0ng-aiae406ca2fb7b
diff --git a/crates/ide-build/src/lib.rs b/crates/ide-build/src/lib.rsindex 96358419f..230ea671f 100644--- a/crates/ide-build/src/lib.rs+++ b/crates/ide-build/src/lib.rs@@ -18,7 +18,7 @@ mod xml;pub use gradle::{GradleModel, GradleProject, GradleTask};pub use maven::{MavenDependency, MavenModel, MavenPlugin, MavenProfile, MavenProject, Omission};-pub use sync::{SyncOptions, SyncProgress, sync_gradle, sync_maven};+pub use sync::{SyncOptions, SyncProgress, maven_profiles, save_maven_profiles, sync_gradle, sync_maven};use serde::{Deserialize, Serialize};use specta::Type;diff --git a/crates/ide-build/src/sync.rs b/crates/ide-build/src/sync.rsindex 815c46313..dec09289f 100644--- a/crates/ide-build/src/sync.rs+++ b/crates/ide-build/src/sync.rs@@ -88,6 +88,24 @@ fn maven_sync_goals(effective: &Path, offline: bool) -> Vec<String> {]}const GRADLE_CACHE: &str = "gradle.json";+const MAVEN_PROFILES: &str = "maven-profiles.json";++/// The Maven profiles (`-P` entries, `!id` deactivates) the project was last synced+/// with: what the IDE resolves it with besides `mvn` (the Java language server, Build Project).+pub fn maven_profiles(cache_dir: &Path) -> Vec<String> {+ read_cache(cache_dir, MAVEN_PROFILES).unwrap_or_default()+}++/// Records the profiles of a sync for [`maven_profiles`]; `true` when they changed.+pub fn save_maven_profiles(cache_dir: &Path, profiles: &[String]) -> IdeResult<bool> {+ if maven_profiles(cache_dir) == profiles {+ return Ok(false);+ }+ std::fs::create_dir_all(cache_dir)?;+ let json = serde_json::to_vec(profiles).map_err(|e| IdeError::internal(e.to_string()))?;+ std::fs::write(cache_dir.join(MAVEN_PROFILES), json)?;+ Ok(true)+}fn read_cache<T: DeserializeOwned>(dir: &Path, name: &str) -> Option<T> {serde_json::from_slice(&std::fs::read(dir.join(name)).ok()?).ok()diff --git a/crates/ide-host/src/ops/build.rs b/crates/ide-host/src/ops/build.rsindex 6ae0b0bd0..03bf903d2 100644--- a/crates/ide-host/src/ops/build.rs+++ b/crates/ide-host/src/ops/build.rs@@ -74,6 +74,18 @@ pub fn load(root: &Path, cache: &Path, settings: &Settings) -> BuildModel {model}+/// `model` building with the Maven profiles of the last sync (`-P`), as Maven runs from+/// the tool window do.+fn with_profiles(mut model: BuildModel, cache: &Path) -> BuildModel {+ let profiles = ide_build::maven_profiles(cache);+ if let (Some(m), false) = (&mut model.maven, profiles.is_empty()) {+ for p in &mut m.projects {+ p.options.push(format!("-P{}", profiles.join(",")));+ }+ }+ model+}+/// Maven and Gradle projects of the window's project, from the build files plus the last sync.pub async fn build_model(host: &Host, window: &str) -> IdeResult<BuildModel> {host.require_trust(window)?;@@ -98,6 +110,12 @@ pub async fn build_sync(let project = host.project(window)?;let (root, cache, settings) = (project.root.clone(), project.build_cache_dir(), project.settings.effective());let bridge_profiles = profiles.clone();+ // What the Java language server and Build Project resolve the project with from now on.+ let profiles_changed = tool == BuildTool::Maven+ && ide_build::save_maven_profiles(&cache, &profiles).unwrap_or_else(|e| {+ tracing::warn!("Maven profiles not saved: {e}");+ false+ });let token = host.begin_project_request(window, request);let result = tokio::task::spawn_blocking(move || {let current = load(&root, &cache, &settings);@@ -152,6 +170,10 @@ pub async fn build_sync(let lsp = project.lsp.clone();let uris = build_files.iter().map(|f| ide_lsp::path_to_uri_string(&project.root.join(f))).collect();tokio::spawn(async move {+ if profiles_changed {+ // jdtls takes the profiles from its Maven settings (see `ide_sdk::maven_profiles`).+ lsp.reconfigure().await;+ }if let Err(e) = lsp.java_update_project_configs(&project.root, uris).await {tracing::debug!("java/projectConfigurationsUpdate: {e}");}@@ -257,7 +279,8 @@ pub async fn build_run(for member in workspace.projects.iter().filter(|p| file.as_ref().is_none_or(|f| f.starts_with(p))) {let settings = ide_workspace::SettingsStore::load(&config_dir, Some(member)).effective();let member_cache = cache.join(crate::project::project_key(member));- let plan = compile::plan(member, &load(member, &member_cache, &settings), kind, file.as_deref())?;+ let model = with_profiles(load(member, &member_cache, &settings), &member_cache);+ let plan = compile::plan(member, &model, kind, file.as_deref())?;match &mut combined {Some(combined) => combined.steps.extend(plan.steps),None => combined = Some(plan),@@ -267,7 +290,7 @@ pub async fn build_run(plan.title = workspace.name;plan} else {- compile::plan(&root, &load(&root, &cache, &settings), kind, file.as_deref())?+ compile::plan(&root, &with_profiles(load(&root, &cache, &settings), &cache), kind, file.as_deref())?};let result = compile::run(&root, &plan, &token, &|e| {let _ = on_event.send(e);diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rsindex e7d26808c..63d69ae8c 100644--- a/crates/ide-host/src/project.rs+++ b/crates/ide-host/src/project.rs@@ -129,6 +129,7 @@ impl Host {let root = root.clone();let data_dir = self.local_data_dir.clone();let config_dir = self.config_dir.clone();+ let build_cache = self.local_data_dir.join("cache").join(&project_key).join("build");let sink = sink.clone();let formatter_problem = std::sync::Mutex::new(None);lsp.set_config_hook(Box::new(move |cfg, server_root| {@@ -142,6 +143,15 @@ impl Host {let root = member.as_ref().unwrap_or(&root);ide_sdk::apply::server_launch_overrides(cfg, &effective);ide_sdk::apply::configure_server(cfg, root, server_root, &effective);+ if cfg.name == "jdtls" {+ // A workspace member keeps its build model under its own key (Build Project).+ let cache = match &member {+ Some(member) => build_cache.join(crate::project::project_key(member)),+ None => build_cache.clone(),+ };+ let profiles = ide_build::maven_profiles(&cache);+ ide_sdk::maven_profiles::configure_jdtls(cfg, root, &effective, &profiles, &cache);+ }ide_sdk::java::cap_java_home(cfg, &ide_sdk::java::installed_jdks());if cfg.name == "jdtls" {let problem = ide_lsp::jdtls::configure_formatter(diff --git a/crates/ide-lsp/src/handler.rs b/crates/ide-lsp/src/handler.rsindex fec8a9a78..4e0237986 100644--- a/crates/ide-lsp/src/handler.rs+++ b/crates/ide-lsp/src/handler.rs@@ -241,6 +241,9 @@ impl Handler for ClientHandler {"language/status" if self.server.name == "jdtls" && params["type"] == "ServiceReady" => {mgr.java_import_ready(self.server.clone(), self.generation);}+ "language/status" if self.server.name == "jdtls" && params["type"] == "ProjectStatus" => {+ mgr.java_projects_updated(self.server.clone(), self.generation);+ }// The Angular server's project loading, shown like `$/progress`; one// task while several projects load."angular/projectLoadingStart" if !self.server.progress.lock().contains_key(ANGULAR_LOADING) => selfdiff --git a/crates/ide-lsp/src/jdtls.rs b/crates/ide-lsp/src/jdtls.rsindex fab72d9eb..5852f53e4 100644--- a/crates/ide-lsp/src/jdtls.rs+++ b/crates/ide-lsp/src/jdtls.rs@@ -336,6 +336,35 @@ impl LspManager {});}+ /// jdtls reports `ProjectStatus` when an import or project update ends (a POM+ /// change, a Maven sync, other Maven profiles), but does not check open documents+ /// again against the new classpath: their errors would stay until the next edit.+ pub(crate) fn java_projects_updated(self: &Arc<Self>, server: Arc<Server>, generation: u64) {+ let uris: Vec<String> = self+ .docs+ .lock()+ .values()+ .filter(|d| d.language.as_str() == "java" && d.path.starts_with(&server.root))+ .map(|d| crate::uri::path_to_uri_string(&d.path))+ .collect();+ if uris.is_empty() {+ return;+ }+ self.runtime.spawn(async move {+ let Some(run) = server.running_gen(generation) else { return };+ for uri in uris {+ let params =+ json!({ "command": "java.project.refreshDiagnostics", "arguments": [uri, "thisFile", false] });+ let request = run.peer.request::<_, Value>("workspace/executeCommand", params, None);+ if let Ok(Err(e)) | Err(e) =+ tokio::time::timeout(COMMAND_TIMEOUT, request).await.map_err(|_| ide_jsonrpc::RpcError::Timeout)+ {+ tracing::debug!("jdtls: java.project.refreshDiagnostics {uri}: {e}");+ }+ }+ });+ }+/// The jdtls instance serving `path` (a module directory or source file),/// started if needed and waited for.async fn jdtls(&self, path: &Path, cancel: &CancellationToken) -> IdeResult<(Arc<Server>, Running)> {diff --git a/crates/ide-lsp/tests/mock_server.rs b/crates/ide-lsp/tests/mock_server.rsindex 147d63517..7b46a9d6c 100644--- a/crates/ide-lsp/tests/mock_server.rs+++ b/crates/ide-lsp/tests/mock_server.rs@@ -1200,6 +1200,40 @@ async fn java_launch_serializes_the_classpath_with_the_build_lock() {assert!(commands.contains(&"java.project.getClasspaths".to_owned()));}+#[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())], &[]);+ let (_, a) = h.open("A.java", "class A {}");+ let (_, b) = h.open("B.java", "class B {}");+ h.wait_status("jdtls", ServerStatus::Ready).await;+ let state = h.launcher.state("jdtls");+ let refreshed = || {+ let mut uris: Vec<Value> = state+ .requested("workspace/executeCommand")+ .iter()+ .filter(|p| p["command"] == "java.project.refreshDiagnostics")+ .map(|p| {+ assert_eq!(p["arguments"][1], "thisFile");+ p["arguments"][0].clone()+ })+ .collect();+ uris.sort_by_key(|u| u.to_string());+ uris+ };+ // Other status messages leave the documents alone.+ state+ .peer()+ .notify("language/status", json!({ "type": "Message", "message": "Updating project configurations..." }))+ .unwrap();+ tokio::time::sleep(Duration::from_millis(200)).await;+ assert!(refreshed().is_empty());++ state.peer().notify("language/status", json!({ "type": "ProjectStatus", "message": "OK" })).unwrap();+ let mut expected = vec![json!(uri_of(&a)), json!(uri_of(&b))];+ expected.sort_by_key(|u| u.to_string());+ eventually(|| refreshed() == expected).await;+}+#[tokio::test(flavor = "multi_thread")]async fn fallback_servers_only_run_when_the_preferred_one_is_missing() {// Preferred installed: the alternative is never started.diff --git a/crates/ide-sdk/src/lib.rs b/crates/ide-sdk/src/lib.rsindex 79ccfda67..2d90ad2a5 100644--- a/crates/ide-sdk/src/lib.rs+++ b/crates/ide-sdk/src/lib.rs@@ -16,6 +16,7 @@ pub mod jdtls;pub mod libraries;pub mod locate;pub mod lombok;+pub mod maven_profiles;mod npm;pub mod pinned;pub mod python;diff --git a/crates/ide-sdk/src/maven_profiles.rs b/crates/ide-sdk/src/maven_profiles.rsnew file mode 100644index 000000000..b5eeed576--- /dev/null+++ b/crates/ide-sdk/src/maven_profiles.rs@@ -0,0 +1,239 @@+//! Maven profiles for the Java language server. jdtls (m2e) has no setting for the+//! profiles a project is imported with; it takes them from `<activeProfiles>` of the+//! user `settings.xml`. The profiles chosen in the Maven tool window are therefore+//! passed as a copy of the user's settings with those profiles activated.++use crate::apply::setting_path;+use ide_core::settings::Settings;+use ide_language::LanguageServerConfig;+use serde_json::{Value, json};+use std::path::{Path, PathBuf};++const PREFIX: &str = "jdtls-maven-settings-";++/// Points jdtls at a user `settings.xml` activating `profiles` (`-P` entries of the+/// last Maven sync), written to `dir`. Through `settings`, so a running server+/// re-imports its Maven projects instead of restarting. `!id` entries can't be+/// expressed in `settings.xml` and are left to the POMs' own activation.+pub fn configure_jdtls(cfg: &mut LanguageServerConfig, root: &Path, s: &Settings, profiles: &[String], dir: &Path) {+ if cfg.name != "jdtls" {+ return;+ }+ let active: Vec<&str> =+ profiles.iter().map(|p| p.trim()).filter(|p| !p.is_empty() && !p.starts_with('!')).collect();+ let Some(file) = (!active.is_empty()).then(|| write_settings(root, s, &active, dir)).flatten() else {+ remove_generated(dir, None);+ return;+ };+ let layer = json!({ "java": { "configuration": { "maven": { "userSettings": file.to_string_lossy() } } } });+ match &mut cfg.settings {+ Some(settings) => merge(settings, layer),+ None => cfg.settings = Some(layer),+ }+}++/// The user's settings (Settings › Maven, else `~/.m2/settings.xml`) with `active`+/// added to `<activeProfiles>`. Named after its content: m2e reloads a settings file+/// only when the configured path changes.+fn write_settings(root: &Path, s: &Settings, active: &[&str], dir: &Path) -> Option<PathBuf> {+ let user = setting_path(root, &s.languages.java.maven.user_settings)+ .or_else(|| crate::home_dir().map(|h| h.join(".m2").join("settings.xml")));+ let base = user.and_then(|f| std::fs::read_to_string(f).ok()).unwrap_or_else(|| "<settings>\n</settings>\n".into());+ let Some(text) = with_active_profiles(&base, active) else {+ tracing::warn!("Maven profiles not passed to jdtls: the user settings.xml has no <settings> element");+ return None;+ };+ let mut hash = 0xcbf29ce484222325u64;+ for byte in text.bytes() {+ hash = (hash ^ u64::from(byte)).wrapping_mul(0x100000001b3);+ }+ let file = dir.join(format!("{PREFIX}{hash:016x}.xml"));+ if !file.is_file() {+ let written = std::fs::create_dir_all(dir).and_then(|()| std::fs::write(&file, &text));+ if let Err(e) = written {+ tracing::warn!("Maven profiles not passed to jdtls: {}: {e}", file.display());+ return None;+ }+ }+ remove_generated(dir, Some(&file));+ Some(file)+}++/// Deletes the settings files written for earlier profile choices.+fn remove_generated(dir: &Path, keep: Option<&Path>) {+ let Ok(entries) = std::fs::read_dir(dir) else { return };+ for entry in entries.flatten() {+ let path = entry.path();+ let generated = path.file_name().and_then(|n| n.to_str()).is_some_and(|n| n.starts_with(PREFIX));+ if generated && Some(path.as_path()) != keep {+ let _ = std::fs::remove_file(path);+ }+ }+}++/// `text` (a `settings.xml`) with `ids` appended to its `<activeProfiles>`, created+/// when missing; `None` when there is no `<settings>` element to add it to.+pub fn with_active_profiles(text: &str, ids: &[&str]) -> Option<String> {+ let entries: String = ids.iter().map(|id| format!(" <activeProfile>{}</activeProfile>\n", escape(id))).collect();+ let masked = mask_comments(text);+ if let Some(start) = find_tag(&masked, "<activeProfiles", 0) {+ let end = start + masked[start..].find('>')?;+ if masked[..end].ends_with('/') {+ let element = format!("<activeProfiles>\n{entries} </activeProfiles>");+ return Some(format!("{}{element}{}", &text[..start], &text[end + 1..]));+ }+ let close = end + masked[end..].find("</activeProfiles")?;+ return Some(format!("{}\n{entries} {}", text[..close].trim_end(), &text[close..]));+ }+ let close = masked.rfind("</settings")?;+ let element = format!(" <activeProfiles>\n{entries} </activeProfiles>\n");+ Some(format!("{}\n{element}{}", text[..close].trim_end(), &text[close..]))+}++/// Start of the element `open` (`<name`), not a longer name sharing its prefix.+fn find_tag(masked: &str, open: &str, from: usize) -> Option<usize> {+ let mut at = from;+ while let Some(i) = masked[at..].find(open) {+ let start = at + i;+ let next = masked[start + open.len()..].chars().next();+ if next.is_some_and(|c| c == '>' || c == '/' || c.is_whitespace()) {+ return Some(start);+ }+ at = start + open.len();+ }+ None+}++/// `text` with comments and CDATA blanked out, byte offsets unchanged.+fn mask_comments(text: &str) -> String {+ let mut out = text.as_bytes().to_vec();+ let mut at = 0;+ while at < text.len() {+ let rest = &text[at..];+ let (open, close) = match (rest.find("<!--"), rest.find("<![CDATA[")) {+ (Some(c), Some(d)) if d < c => (d, "]]>"),+ (Some(c), _) => (c, "-->"),+ (None, Some(d)) => (d, "]]>"),+ (None, None) => break,+ };+ let start = at + open;+ let end = text[start..].find(close).map_or(text.len(), |i| start + i + close.len());+ out[start..end].fill(b' ');+ at = end;+ }+ String::from_utf8(out).unwrap_or_default()+}++fn escape(s: &str) -> String {+ s.replace('&', "&").replace('<', "<").replace('>', ">")+}++fn merge(base: &mut Value, layer: Value) {+ match (base, layer) {+ (Value::Object(base), Value::Object(layer)) => {+ for (k, v) in layer {+ match base.get_mut(&k) {+ Some(existing) => merge(existing, v),+ None => {+ base.insert(k, v);+ }+ }+ }+ }+ (base, layer) => *base = layer,+ }+}++#[cfg(test)]+mod tests {+ use super::*;++ fn jdtls() -> LanguageServerConfig {+ serde_json::from_value(json!({ "name": "jdtls", "command": "jdtls" })).unwrap()+ }++ fn user_settings(cfg: &LanguageServerConfig) -> Option<String> {+ cfg.settings.as_ref()?.pointer("/java/configuration/maven/userSettings")?.as_str().map(Into::into)+ }++ #[test]+ fn adds_profiles_to_every_shape_of_settings_xml() {+ let ids = ["native", "本地"];+ let added = "<activeProfile>native</activeProfile>\n <activeProfile>本地</activeProfile>";+ for (text, keeps) in [+ ("<settings>\n</settings>\n", ""),+ ("<settings><mirrors><mirror><id>m</id></mirror></mirrors></settings>", "<mirror><id>m</id></mirror>"),+ (+ "<settings>\n <activeProfiles>\n <activeProfile>nexus</activeProfile>\n </activeProfiles>\n</settings>",+ "<activeProfile>nexus</activeProfile>",+ ),+ ("<settings><activeProfiles/></settings>", ""),+ ("<settings><activeProfiles /></settings>", ""),+ // Commented-out elements are not where the profiles go.+ (+ "<settings>\n<!-- <activeProfiles></activeProfiles> </settings> -->\n</settings>",+ "<!-- <activeProfiles></activeProfiles> </settings> -->",+ ),+ (+ "<?xml version=\"1.0\"?>\n<settings xmlns=\"http://maven.apache.org/SETTINGS/1.0.0\"><activeProfilesX/></settings>",+ "<activeProfilesX/>",+ ),+ ] {+ let out = with_active_profiles(text, &ids).unwrap_or_else(|| panic!("{text}"));+ assert!(out.contains(added), "{text}\n→\n{out}");+ assert!(out.contains(keeps), "{text}\n→\n{out}");+ let out = if keeps.starts_with("<!--") { out.replace(keeps, "") } else { out };+ assert_eq!(out.matches("<activeProfiles>").count(), 1, "{text}\n→\n{out}");+ let close = out.find("</activeProfiles>").unwrap();+ assert!(close < out.rfind("</settings>").unwrap(), "{out}");+ assert!(out.find(added).unwrap() < close, "{out}");+ }+ assert_eq!(with_active_profiles("<settings/>", &ids), None);+ assert!(with_active_profiles("<settings></settings>", &["a&b"]).unwrap().contains("a&b"));+ }++ #[test]+ fn jdtls_imports_with_the_synced_profiles() {+ let tmp = tempfile::tempdir().unwrap();+ let user = tmp.path().join("user-settings.xml");+ std::fs::write(&user, "<settings><localRepository>/repo</localRepository></settings>").unwrap();+ let mut s = Settings::default();+ s.languages.java.maven.user_settings = user.to_string_lossy().into_owned();+ let dir = tmp.path().join("build");+ let profiles = |p: &[&str]| p.iter().map(|s| s.to_string()).collect::<Vec<_>>();++ let mut cfg = jdtls();+ configure_jdtls(&mut cfg, tmp.path(), &s, &profiles(&["native", "!dev", "本地"]), &dir);+ let first = user_settings(&cfg).expect("generated settings");+ let text = std::fs::read_to_string(&first).unwrap();+ assert!(text.contains("<localRepository>/repo</localRepository>"), "{text}");+ assert!(+ text.contains("<activeProfile>native</activeProfile>")+ && text.contains("<activeProfile>本地</activeProfile>")+ );+ assert!(!text.contains("dev"), "deactivations are not activations: {text}");++ // Same choice → same file; another choice → another path (m2e reloads on a new path).+ let mut again = jdtls();+ configure_jdtls(&mut again, tmp.path(), &s, &profiles(&["native", "本地"]), &dir);+ assert_eq!(user_settings(&again).as_deref(), Some(first.as_str()));+ let mut other = jdtls();+ configure_jdtls(&mut other, tmp.path(), &s, &profiles(&["pro"]), &dir);+ let second = user_settings(&other).unwrap();+ assert_ne!(second, first);+ assert!(!Path::new(&first).exists(), "the previous file is removed");++ // No profile (or only deactivations) → the user's settings as configured.+ for none in [&[][..], &["!dev"][..]] {+ let mut plain = jdtls();+ configure_jdtls(&mut plain, tmp.path(), &s, &profiles(none), &dir);+ assert_eq!(user_settings(&plain), None);+ }+ assert!(!Path::new(&second).exists());++ let mut other_server: LanguageServerConfig =+ serde_json::from_value(json!({ "name": "kotlin-lsp", "command": "kotlin-lsp" })).unwrap();+ configure_jdtls(&mut other_server, tmp.path(), &s, &profiles(&["native"]), &dir);+ assert_eq!(other_server.settings, None);+ }+}diff --git a/src/features/build-tools/profileReload.test.ts b/src/features/build-tools/profileReload.test.tsnew file mode 100644index 000000000..6f2bf0d13--- /dev/null+++ b/src/features/build-tools/profileReload.test.ts@@ -0,0 +1,92 @@+import { afterEach, beforeEach, expect, it, vi } from "vitest";+import type { BuildModel, MavenModel, ProjectInfo } from "@/platform/ipc";+import { useProject } from "@/platform/project";+import { loadModel, PROFILE_RELOAD_DELAY_MS, resetBuild, setProfile, useBuild } from "./store";++const mocks = vi.hoisted(() => ({ model: vi.fn(), sync: vi.fn() }));+vi.mock("@/platform/ipc", async (original) => {+ const real = await original<typeof import("@/platform/ipc")>();+ return {+ ...real,+ isTauri: () => true,+ call: (value: unknown) => value,+ commands: {+ ...real.commands,+ buildModel: mocks.model,+ runConfigs: () => Promise.resolve([]),+ buildSync: mocks.sync,+ cancelRequest: () => Promise.resolve(),+ },+ };+});+vi.mock("@tauri-apps/api/core", async (original) => ({+ ...(await original<typeof import("@tauri-apps/api/core")>()),+ Channel: class {+ onmessage: unknown = null;+ },+}));++const maven = {+ syncedAt: 1,+ stale: false,+ syncError: null,+ profiles: [+ { id: "native", activeByDefault: false },+ { id: "local", activeByDefault: false },+ { id: "dev", activeByDefault: true },+ ],+ projects: [],+} as unknown as MavenModel;+const model: BuildModel = { maven, gradle: null };++/** The `-P` entries each sync was started with. */+const syncedProfiles = () => mocks.sync.mock.calls.map((c) => c[3] as string[]);++beforeEach(async () => {+ vi.clearAllMocks();+ localStorage.clear();+ resetBuild();+ useBuild.setState({ syncing: {} });+ useProject.setState({ project: { root: "/p", trusted: true } as ProjectInfo });+ mocks.model.mockResolvedValue(model);+ await loadModel();+ vi.useFakeTimers();+});++afterEach(() => {+ vi.useRealTimers();+});++it("reloads Maven once with the new profiles after a few toggles", async () => {+ let finish = () => {};+ mocks.sync.mockImplementation(() => new Promise((resolve) => (finish = () => resolve(model))));+ setProfile("native", true);+ setProfile("local", true);+ setProfile("dev", false);+ expect(mocks.sync).not.toHaveBeenCalled();+ await vi.advanceTimersByTimeAsync(PROFILE_RELOAD_DELAY_MS);+ expect(syncedProfiles()).toEqual([["native", "local", "!dev"]]);+ finish();+ await vi.runAllTimersAsync();+ expect(mocks.sync).toHaveBeenCalledTimes(1);+});++it("reloads again after a sync that started with the previous profiles", async () => {+ const finishes: (() => void)[] = [];+ mocks.sync.mockImplementation(() => new Promise((resolve) => finishes.push(() => resolve(model))));+ setProfile("native", true);+ await vi.advanceTimersByTimeAsync(PROFILE_RELOAD_DELAY_MS);+ setProfile("local", true);+ await vi.advanceTimersByTimeAsync(PROFILE_RELOAD_DELAY_MS);+ expect(syncedProfiles()).toEqual([["native"]]);+ finishes[0]!();+ await vi.runAllTimersAsync();+ expect(syncedProfiles()).toEqual([["native"], ["native", "local"]]);+});++it("does not reload a project closed before the delay ran out", async () => {+ setProfile("native", true);+ resetBuild();+ await vi.advanceTimersByTimeAsync(PROFILE_RELOAD_DELAY_MS);+ expect(mocks.sync).not.toHaveBeenCalled();+});diff --git a/src/features/build-tools/store.ts b/src/features/build-tools/store.tsindex f3555e4c6..936fbb117 100644--- a/src/features/build-tools/store.ts+++ b/src/features/build-tools/store.ts@@ -114,8 +114,19 @@ export const toggleSkipTests = () =>export const toggleGradleOffline = () =>updateSettings((s) => ({ ...s, gradle: { ...s.gradle, offline: !s.gradle.offline } }));+/** Delay before reloading Maven after a profile toggle, so a few toggles in a row reload once. */+export const PROFILE_RELOAD_DELAY_MS = 800;+let profileReload: ReturnType<typeof setTimeout> | undefined;+export function setProfile(id: string, checked: boolean) {updateSettings((s) => ({ ...s, maven: { ...s.maven, profiles: { ...s.maven.profiles, [id]: checked } } }));+ // The Java language server and Build Project resolve the project with the profiles of the+ // last sync, so a new choice reloads it (IDEA re-imports on a profile change too).+ clearTimeout(profileReload);+ profileReload = setTimeout(() => {+ profileReload = undefined;+ requestSync("maven");+ }, PROFILE_RELOAD_DELAY_MS);}export function readHistory(tool: BuildTool): string[] {@@ -269,6 +280,15 @@ export function initialExpanded(tool: BuildTool, model: BuildModel): Set<string>const TITLES: Record<BuildTool, string> = { maven: "Syncing Maven projects", gradle: "Syncing Gradle projects" };+/** Tools to sync again once their running sync ends: its options changed meanwhile. */+const queuedSyncs = new Set<BuildTool>();++/** Syncs `tool` now, or right after the sync in progress (which used the previous options). */+export function requestSync(tool: BuildTool) {+ if (useBuild.getState().syncing[tool]) queuedSyncs.add(tool);+ else void syncTool(tool);+}+/** Reloads all projects of `tool` from the build tool itself (effective POM, dependency tree, task list). */export async function syncTool(tool: BuildTool): Promise<void> {const state = useBuild.getState();@@ -317,6 +337,7 @@ export async function syncTool(tool: BuildTool): Promise<void> {} finally {if (useBuild.getState().syncing[tool]?.request === request) setSync(undefined);upsertTask({ id: taskId, title: TITLES[tool], message: null, fraction: 1, done: true });+ if (queuedSyncs.delete(tool) && gen === generation) void syncTool(tool);}}@@ -330,6 +351,9 @@ export function cancelSync(tool: BuildTool) {export function resetBuild() {generation++;+ clearTimeout(profileReload);+ profileReload = undefined;+ queuedSyncs.clear();useAnalyzer.setState({ pom: null });for (const tool of ["maven", "gradle"] as const) {cancelSync(tool);