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(gradle): import modules from Gradle itself (includeFlat, included builds, computed includes) (#715)

ntbang0901bd424a3805fd
diff --git a/crates/ide-build/src/gradle-model.gradle b/crates/ide-build/src/gradle-model.gradle
new file mode 100644
index 000000000..601d2d283
--- /dev/null
+++ b/crates/ide-build/src/gradle-model.gradle
@@ -0,0 +1,40 @@
+// OpenIDEA Gradle sync: prints each project as Gradle evaluated it, one JSON line per project.
+// Read by `ide_build::gradle::parse_reported_projects`. Dependencies are not resolved: the
+// Java language server reads the classpath itself, and resolving is the slow part of an import.
+import groovy.json.JsonOutput
+
+def canon = { File f -> f.canonicalPath }
+// Init scripts also run in included builds and buildSrc, whose projects reuse `:`, `:core`…:
+// the identity path (`:lib:core`, `:buildSrc`) tells them apart and addresses their tasks
+// from the root build. Internal API, hence the fallback.
+def identity = { Project p -> try { p.identityPath.toString() } catch (ignored) { p.path } }
+
+def describe = { Project p ->
+ def m = [path: identity(p), dir: canon(p.projectDir), buildDir: canon(p.layout.buildDirectory.get().asFile)]
+ if (p.gradle.parent != null) m.build = identity(p.rootProject)
+ def sets = p.extensions.findByName('sourceSets')
+ if (sets != null) {
+ // Test source sets as IDEA classifies them: `test`, test fixtures, JVM test suites,
+ // and sets whose folders the `idea` plugin lists as test sources.
+ def suites = [] as Set
+ try { p.extensions.findByName('testing')?.suites?.each { suites << it.sources.name } } catch (ignored) {}
+ def ideaTests = [] as Set
+ try { p.extensions.findByName('idea')?.module?.testSources?.files?.each { ideaTests << canon(it) } } catch (ignored) {}
+ m.sourceSets = sets.collect { s ->
+ def res = s.resources.srcDirs.collect(canon)
+ def src = s.allSource.srcDirs.collect(canon) - res
+ def test = s.name == 'test' || s.name == 'testFixtures' || suites.contains(s.name) ||
+ s.name.endsWith('Test') || s.name.endsWith('Tests') ||
+ (!src.isEmpty() && src.every { ideaTests.contains(it) })
+ [name: s.name, test: test, src: src, res: res]
+ }
+ }
+ try {
+ def java = p.extensions.findByName('java')
+ def lv = java?.toolchain?.languageVersion?.getOrNull()
+ m.java = lv != null ? lv.asInt() : (java?.targetCompatibility?.majorVersion as Integer)
+ } catch (ignored) {}
+ println '@openidea-model\t' + JsonOutput.toJson(m)
+}
+
+gradle.projectsEvaluated { g -> g.rootProject.allprojects { describe(it) } }
diff --git a/crates/ide-build/src/gradle.rs b/crates/ide-build/src/gradle.rs
index 4acc986e9..2ebf58489 100644
--- a/crates/ide-build/src/gradle.rs
+++ b/crates/ide-build/src/gradle.rs
@@ -32,7 +32,8 @@ pub struct GradleModel {
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct GradleProject {
- /// Gradle path: `:` for the root project, `:app`, `:libs:core`.
+ /// Gradle path: `:` for the root project, `:app`, `:libs:core`; for a project of a
+ /// nested build its identity path (`:lib:core`), which addresses its tasks from the root.
pub path: String,
pub name: String,
/// Project-relative directory.
@@ -40,6 +41,10 @@ pub struct GradleProject {
/// Project-relative build script, if any.
pub build_file: Option<String>,
pub tasks: Vec<GradleTask>,
+ /// Identity path of the nested build holding the project (`:lib` for `includeBuild`,
+ /// `:buildSrc`); null for the opened build.
+ #[serde(default)]
+ pub build: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
@@ -129,35 +134,88 @@ fn include_args(after: &str) -> Vec<String> {
out
}
-/// `(root project name, included project paths)` from a settings script.
-pub fn parse_settings(text: &str) -> (Option<String>, Vec<String>) {
+/// What a settings script declares, read statically.
+#[derive(Debug, Default, PartialEq)]
+pub struct Settings {
+ pub name: Option<String>,
+ /// Included project paths (`:app`), in declaration order.
+ pub includes: Vec<String>,
+ /// Project directories that differ from the default `<path>` under the build
+ /// dir, relative to it: `includeFlat` siblings and literal `projectDir = file(..)`.
+ pub dirs: BTreeMap<String, String>,
+}
+
+/// The included projects, root project name and directory overrides of a settings script.
+/// Interpolated (`"$m"`) names and directories cannot be read without Gradle and are skipped.
+pub fn parse_settings(text: &str) -> Settings {
let text = strip_comments(text);
- let mut name = None;
- let mut includes: Vec<String> = Vec::new();
+ let mut s = Settings::default();
for (i, _) in text.match_indices("rootProject.name") {
let line = text[i + "rootProject.name".len()..].lines().next().unwrap_or_default();
if let Some(n) = literals(line).into_iter().next() {
- name = Some(n);
+ s.name = Some(n);
}
}
let mut from = 0;
while let Some(i) = text[from..].find("include") {
let at = from + i;
from = at + "include".len();
+ let flat = text[from..].starts_with("Flat");
+ if flat {
+ from += "Flat".len();
+ }
let before_ok = at == 0 || !text[..at].ends_with(|c: char| c.is_alphanumeric() || c == '_' || c == '.');
let after = &text[from..];
let after_ok = after.starts_with(|c: char| c == '(' || c.is_whitespace());
if !before_ok || !after_ok {
continue;
}
- for p in include_args(after) {
+ for p in include_args(after).into_iter().filter(|p| !p.contains('$')) {
let path = if p.starts_with(':') { p } else { format!(":{p}") };
- if path.len() > 1 && !includes.contains(&path) {
- includes.push(path);
+ if path.len() <= 1 {
+ continue;
}
+ // `includeFlat 'a'` is the sibling directory `../a` of the root project.
+ if flat {
+ s.dirs.insert(path.clone(), format!("../{}", path.trim_start_matches(':')));
+ }
+ if !s.includes.contains(&path) {
+ s.includes.push(path);
+ }
+ }
+ }
+ // `project(':a').projectDir = file('../a')`; a later assignment wins, as in Gradle.
+ for line in text.lines() {
+ let Some((left, right)) = line.split_once(".projectDir") else { continue };
+ let Some(right) = right.trim_start().strip_prefix('=') else { continue };
+ let Some(arg) = right.trim_start().strip_prefix("file") else { continue };
+ let (Some(path), Some(dir)) = (
+ left.rsplit_once("project").map(|(_, p)| literals(p)).and_then(|l| l.into_iter().next()),
+ literals(arg).into_iter().next(),
+ ) else {
+ continue;
+ };
+ if !path.contains('$') && !dir.contains('$') {
+ let path = if path.starts_with(':') { path } else { format!(":{path}") };
+ s.dirs.insert(path, dir);
}
}
- (name, includes)
+ s
+}
+
+/// `a/b/../c` → `a/c`, without touching the filesystem.
+fn normalize(p: &Path) -> PathBuf {
+ let mut out = PathBuf::new();
+ for c in p.components() {
+ match c {
+ std::path::Component::CurDir => {}
+ std::path::Component::ParentDir if out.file_name().is_some() => {
+ out.pop();
+ }
+ c => out.push(c),
+ }
+ }
+ out
}
/// The directory of the Gradle build under `root`: the root itself, or a direct
@@ -235,31 +293,159 @@ pub fn default_tasks(is_root: bool, script: &str) -> Vec<GradleTask> {
}
/// Reads the Gradle build under `root` (no Gradle run), or `None` when there is none.
+fn read_first(d: &Path, names: &[&str]) -> Option<(String, String)> {
+ names.iter().find_map(|n| std::fs::read_to_string(d.join(n)).ok().map(|t| (n.to_string(), t)))
+}
+
+/// The project `path` in `pdir`, with the default tasks of its build script.
+/// Outside `root` the directory stays absolute (`rel` falls back).
+fn project_at(root: &Path, path: String, name: String, pdir: &Path) -> GradleProject {
+ let script = read_first(pdir, BUILD_FILES);
+ let tasks = default_tasks(path == ":", script.as_ref().map(|(_, t)| t.as_str()).unwrap_or_default());
+ GradleProject {
+ build_file: script.map(|(n, _)| rel(root, &pdir.join(n))),
+ dir: rel(root, pdir),
+ path,
+ name,
+ tasks,
+ build: None,
+ }
+}
+
+/// A project as Gradle evaluated it (the sync's init script, `gradle-model.gradle`).
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ReportedProject {
+ pub path: String,
+ /// Absolute, canonical.
+ pub dir: String,
+ /// Absolute output folder (`layout.buildDirectory`).
+ #[serde(default)]
+ pub build_dir: Option<String>,
+ #[serde(default)]
+ pub source_sets: Vec<ReportedSourceSet>,
+ /// Toolchain language version, else target compatibility.
+ #[serde(default)]
+ pub java: Option<u32>,
+ /// Identity path of the nested build (included build, buildSrc) reporting the project.
+ #[serde(default)]
+ pub build: Option<String>,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+pub struct ReportedSourceSet {
+ pub name: String,
+ pub test: bool,
+ /// Absolute source folders (Java, Kotlin, Groovy, …), which need not exist.
+ #[serde(default)]
+ pub src: Vec<String>,
+ /// Absolute resource folders.
+ #[serde(default)]
+ pub res: Vec<String>,
+}
+
+const MODEL_LINE: &str = "@openidea-model\t";
+
+/// The projects printed by `gradle-model.gradle`; malformed lines are skipped.
+pub fn parse_reported_projects(output: &str) -> Vec<ReportedProject> {
+ output.lines().filter_map(|l| serde_json::from_str(l.trim_end().strip_prefix(MODEL_LINE)?).ok()).collect()
+}
+
+/// Source roots of the reported source sets: `(absolute folder, is test, is resources)`.
+pub fn reported_source_roots(reported: &[ReportedProject]) -> Vec<(PathBuf, ReportedRoot)> {
+ let mut out: Vec<(PathBuf, ReportedRoot)> = Vec::new();
+ for p in reported {
+ for set in &p.source_sets {
+ let (src, res) = if set.test {
+ (ReportedRoot::Test, ReportedRoot::TestResources)
+ } else {
+ (ReportedRoot::Source, ReportedRoot::Resources)
+ };
+ for (dir, kind) in set.src.iter().map(|d| (d, src)).chain(set.res.iter().map(|d| (d, res))) {
+ let dir = PathBuf::from(dir);
+ // A folder shared by `main` and another set is `main`'s, as in IDEA.
+ if !out.iter().any(|(d, _)| *d == dir) {
+ out.push((dir, kind));
+ }
+ }
+ }
+ // IDEA excludes the build folder of every module.
+ if let Some(b) = &p.build_dir {
+ out.push((PathBuf::from(b), ReportedRoot::Excluded));
+ }
+ }
+ out
+}
+
+/// Role of a folder a Gradle sync reported.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ReportedRoot {
+ Source,
+ Test,
+ Resources,
+ TestResources,
+ Excluded,
+}
+
+/// Replaces the statically read projects with the ones Gradle reported (root first):
+/// settings scripts may compute their projects, which no static reading sees.
+pub fn merge_reported_projects(root: &Path, model: &mut GradleModel, reported: &[ReportedProject]) {
+ if reported.is_empty() {
+ return;
+ }
+ let root_name = model.projects.iter().find(|p| p.path == ":").map(|p| p.name.clone());
+ model.projects = reported
+ .iter()
+ .map(|p| {
+ let name = match p.path.as_str() {
+ ":" => root_name.clone().unwrap_or_default(),
+ path => path.rsplit(':').next().unwrap_or_default().to_owned(),
+ };
+ let mut project = project_at(root, p.path.clone(), name, Path::new(&p.dir));
+ // buildSrc is built before the build, never addressable as `:buildSrc:<task>`.
+ if p.build.as_deref().is_some_and(|b| b.ends_with(":buildSrc")) {
+ project.tasks.clear();
+ }
+ project.build = p.build.clone();
+ project
+ })
+ .collect();
+ // Each build reports its projects when it is evaluated (nested builds first).
+ model.projects.sort_by(|a, b| a.path.cmp(&b.path));
+ // One JDK runs the whole build: the newest any module needs.
+ if let Some(v) = reported.iter().filter_map(|p| p.java).max() {
+ model.java_version = Some(v);
+ }
+}
+
+/// Project directories outside `root`, outermost only (`../svc`, not also `../svc/sources/app`):
+/// the folders IDEA shows as extra top-level module roots.
+pub fn external_roots<'a>(root: &Path, dirs: impl IntoIterator<Item = &'a str>) -> Vec<PathBuf> {
+ let mut dirs: Vec<PathBuf> = dirs.into_iter().map(|d| root.join(d)).filter(|d| !d.starts_with(root)).collect();
+ dirs.sort();
+ dirs.dedup();
+ let mut out: Vec<PathBuf> = Vec::new();
+ for d in dirs {
+ if !out.iter().any(|o| d.starts_with(o)) {
+ out.push(d);
+ }
+ }
+ out
+}
+
pub fn load(root: &Path) -> Option<GradleModel> {
let dir = build_dir(root)?;
- let read = |d: &Path, names: &[&str]| {
- names.iter().find_map(|n| std::fs::read_to_string(d.join(n)).ok().map(|t| (n.to_string(), t)))
- };
- let (name, includes) = read(&dir, SETTINGS_FILES).map(|(_, t)| parse_settings(&t)).unwrap_or_default();
+ let settings = read_first(&dir, SETTINGS_FILES).map(|(_, t)| parse_settings(&t)).unwrap_or_default();
let root_name =
- name.unwrap_or_else(|| dir.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default());
- let mut projects = Vec::new();
- let mut add = |path: String, name: String, pdir: PathBuf| {
- let script = read(&pdir, BUILD_FILES);
- let tasks = default_tasks(path == ":", script.as_ref().map(|(_, t)| t.as_str()).unwrap_or_default());
- projects.push(GradleProject {
- build_file: script.map(|(n, _)| rel(root, &pdir.join(n))),
- dir: rel(root, &pdir),
- path,
- name,
- tasks,
- });
- };
- add(":".into(), root_name, dir.clone());
- for path in includes {
- let pdir = dir.join(path.trim_start_matches(':').replace(':', "/"));
+ settings.name.unwrap_or_else(|| dir.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default());
+ let mut projects = vec![project_at(root, ":".into(), root_name, &dir)];
+ for path in settings.includes {
+ let pdir = match settings.dirs.get(&path) {
+ Some(d) => normalize(&dir.join(d)),
+ None => dir.join(path.trim_start_matches(':').replace(':', "/")),
+ };
let name = path.rsplit(':').next().unwrap_or_default().to_owned();
- add(path, name, pdir);
+ projects.push(project_at(root, path, name, &pdir));
}
let java_version = projects
.iter()
@@ -358,9 +544,32 @@ pub fn build_files(root: &Path, model: &GradleModel) -> Vec<PathBuf> {
let dir = root.join(&model.dir);
let mut out: Vec<PathBuf> = SETTINGS_FILES.iter().map(|f| dir.join(f)).filter(|p| p.is_file()).collect();
out.extend(model.projects.iter().filter_map(|p| p.build_file.as_ref().map(|f| root.join(f))));
+ // The settings of each nested build (its root project's folder).
+ for p in model.projects.iter().filter(|p| p.build.as_deref() == Some(p.path.as_str())) {
+ let nested = root.join(&p.dir);
+ out.extend(SETTINGS_FILES.iter().map(|f| nested.join(f)).filter(|f| f.is_file()));
+ }
+ // What IDEA's auto-import also watches: properties, the wrapper and version catalogs.
+ let extra = ["gradle.properties", "gradle/wrapper/gradle-wrapper.properties"].map(|f| dir.join(f));
+ out.extend(extra.into_iter().filter(|p| p.is_file()));
+ if let Ok(entries) = std::fs::read_dir(dir.join("gradle")) {
+ let mut catalogs: Vec<PathBuf> = entries
+ .flatten()
+ .map(|e| e.path())
+ .filter(|p| p.to_string_lossy().ends_with(".versions.toml") && p.is_file())
+ .collect();
+ catalogs.sort();
+ out.extend(catalogs);
+ }
out
}
+/// A build script without comments and with whitespace runs collapsed, so editing a
+/// comment or reformatting does not make a sync stale (IDEA hashes lexer tokens alike).
+pub(crate) fn script_fingerprint(text: &str) -> String {
+ strip_comments(text).split_whitespace().collect::<Vec<_>>().join(" ")
+}
+
/// `(project path, task)` from `gradle tasks --all` console output; tasks listed as
/// `app:run` belong to `:app`, unqualified ones to the root project `:`.
pub fn parse_tasks(output: &str) -> Vec<(String, GradleTask)> {
@@ -451,14 +660,60 @@ dependencies {
/* include("block") */
includeBuild("plugins")
"#;
- let (name, includes) = parse_settings(kts);
- assert_eq!(name.as_deref(), Some("gradle-demo"));
- assert_eq!(includes, [":app", ":lib", ":libs:core"]);
+ let s = parse_settings(kts);
+ assert_eq!(s.name.as_deref(), Some("gradle-demo"));
+ assert_eq!(s.includes, [":app", ":lib", ":libs:core"]);
+ assert!(s.dirs.is_empty());
let groovy = "rootProject.name = 'demo'\ninclude 'a',\n 'b'\ninclude ':c'\nprintln 'x'\n";
- let (name, includes) = parse_settings(groovy);
- assert_eq!(name.as_deref(), Some("demo"));
- assert_eq!(includes, [":a", ":b", ":c"]);
+ let s = parse_settings(groovy);
+ assert_eq!(s.name.as_deref(), Some("demo"));
+ assert_eq!(s.includes, [":a", ":b", ":c"]);
+ }
+
+ #[test]
+ fn settings_include_flat_and_project_dirs() {
+ let groovy = r#"
+ includeFlat 'svc-a'
+ includeFlat 'svc-b', 'svc-c' // trailing comment
+ ['x', 'y'].each { m -> include ":svc-a:$m" }
+ include ':wo'
+ project(':wo').projectDir = file('../svc-a/.worktrees/wo')
+ project(":dyn").projectDir = file("${rootDir}/dyn")
+ includeFlated 'not-a-call'
+ "#;
+ let s = parse_settings(groovy);
+ assert_eq!(s.includes, [":svc-a", ":svc-b", ":svc-c", ":wo"]);
+ assert_eq!(
+ s.dirs.into_iter().collect::<Vec<_>>(),
+ [
+ (":svc-a".into(), "../svc-a".into()),
+ (":svc-b".into(), "../svc-b".into()),
+ (":svc-c".into(), "../svc-c".into()),
+ (":wo".into(), "../svc-a/.worktrees/wo".into()),
+ ]
+ );
+
+ let kts = "includeFlat(\"k\")\nproject(\":k\").projectDir = file(\"../other\")";
+ let s = parse_settings(kts);
+ assert_eq!(s.includes, [":k"]);
+ assert_eq!(s.dirs.get(":k").map(String::as_str), Some("../other"));
+ }
+
+ #[test]
+ fn loads_include_flat_siblings() {
+ let tmp = tempfile::tempdir().unwrap();
+ let ws = tmp.path();
+ std::fs::create_dir_all(ws.join("root")).unwrap();
+ std::fs::create_dir_all(ws.join("svc")).unwrap();
+ std::fs::write(ws.join("root/settings.gradle"), "rootProject.name = 'Root'\nincludeFlat 'svc'").unwrap();
+ std::fs::write(ws.join("svc/build.gradle"), "plugins { id 'java' }").unwrap();
+ let root = ws.join("root");
+ let m = load(&root).unwrap();
+ let svc = m.projects.iter().find(|p| p.path == ":svc").unwrap();
+ assert_eq!(Path::new(&svc.dir), ws.join("svc"));
+ assert_eq!(svc.build_file.as_deref().map(Path::new), Some(ws.join("svc/build.gradle").as_path()));
+ assert!(root.join(svc.build_file.as_ref().unwrap()).is_file());
}
#[test]
@@ -539,4 +794,52 @@ Pattern: clean<TaskName>: Cleans the output files of a task.
let none = tempfile::tempdir().unwrap();
assert!(load(none.path()).is_none());
}
+
+ #[test]
+ fn merges_included_builds_and_build_src_by_identity_path() {
+ let tmp = tempfile::tempdir().unwrap();
+ let ws = tmp.path();
+ for d in ["shop/app", "shop/buildSrc", "lib/core"] {
+ std::fs::create_dir_all(ws.join(d)).unwrap();
+ }
+ std::fs::write(ws.join("shop/settings.gradle"), "rootProject.name = 'shop'\ninclude 'app'").unwrap();
+ std::fs::write(ws.join("lib/settings.gradle"), "include 'core'").unwrap();
+ let root = ws.join("shop");
+ // In evaluation order, as the init script prints it: nested builds first.
+ let line = |path: &str, d: &str, build: Option<&str>| {
+ let project = ReportedProject {
+ path: path.into(),
+ dir: ws.join(d).to_string_lossy().into_owned(),
+ build: build.map(Into::into),
+ ..ReportedProject::default()
+ };
+ format!("{MODEL_LINE}{}\n", serde_json::to_string(&project).unwrap())
+ };
+ let out = [
+ line(":lib", "lib", Some(":lib")),
+ line(":lib:core", "lib/core", Some(":lib")),
+ line(":buildSrc", "shop/buildSrc", Some(":buildSrc")),
+ line(":", "shop", None),
+ line(":app", "shop/app", None),
+ ]
+ .concat();
+ let mut model = load(&root).unwrap();
+ merge_reported_projects(&root, &mut model, &parse_reported_projects(&out));
+ let projects: Vec<_> =
+ model.projects.iter().map(|p| (p.path.as_str(), p.name.as_str(), p.build.as_deref())).collect();
+ assert_eq!(
+ projects,
+ [
+ (":", "shop", None),
+ (":app", "app", None),
+ (":buildSrc", "buildSrc", Some(":buildSrc")),
+ (":lib", "lib", Some(":lib")),
+ (":lib:core", "core", Some(":lib")),
+ ]
+ );
+ let build_src = &model.projects[2];
+ assert!(build_src.tasks.is_empty(), "buildSrc tasks cannot run from the root build");
+ assert!(!model.projects[4].tasks.is_empty());
+ assert!(build_files(&root, &model).contains(&ws.join("lib/settings.gradle")));
+ }
}
diff --git a/crates/ide-build/src/lib.rs b/crates/ide-build/src/lib.rs
index 230ea671f..a362b4808 100644
--- a/crates/ide-build/src/lib.rs
+++ b/crates/ide-build/src/lib.rs
@@ -65,6 +65,18 @@ pub fn load_linked(
BuildModel { maven, gradle }
}
+/// Gradle project folders outside `root` as of the last sync (`includeFlat` siblings):
+/// extra content roots, as IDEA lists module roots beside the project folder.
+/// Reads only the sync's cached projects (no build script), so it is cheap enough for hot paths.
+pub fn gradle_external_roots(root: &Path, cache_dir: &Path) -> Vec<PathBuf> {
+ gradle::external_roots(root, sync::reported_gradle_projects(cache_dir).iter().map(|p| p.dir.as_str()))
+}
+
+/// Source, resource and build folders of the last Gradle sync, absolute.
+pub fn gradle_source_roots(cache_dir: &Path) -> Vec<(PathBuf, gradle::ReportedRoot)> {
+ gradle::reported_source_roots(&sync::reported_gradle_projects(cache_dir))
+}
+
/// A library the project depends on, as `groupId:artifactId:version`.
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct DependencyCoordinate {
diff --git a/crates/ide-build/src/sync.rs b/crates/ide-build/src/sync.rs
index dec09289f..46e058f8d 100644
--- a/crates/ide-build/src/sync.rs
+++ b/crates/ide-build/src/sync.rs
@@ -4,14 +4,16 @@
//! per project (`maven.json`, `gradle.json` in the cache directory) and merged
//! into the static model by [`crate::load`]; a changed build file marks them stale.
-use crate::gradle::{self, GradleModel, GradleTask};
+use crate::gradle::{self, GradleModel, GradleTask, ReportedProject, parse_reported_projects};
use crate::maven::{self, MavenDependency, MavenModel, MavenPlugin};
use crate::process::{self, Output};
use ide_core::{CancellationToken, IdeError, IdeResult};
use serde::{Deserialize, Serialize, de::DeserializeOwned};
use specta::Type;
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap};
use std::path::{Path, PathBuf};
+use std::sync::{Arc, LazyLock, Mutex};
+use std::time::SystemTime;
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -68,8 +70,14 @@ struct GradleCache {
at_ms: f64,
error: Option<String>,
tasks: Vec<(String, GradleTask)>,
+ /// The projects as Gradle evaluated them; empty in caches from before they were read.
+ #[serde(default)]
+ projects: Vec<ReportedProject>,
}
+/// Init script printing every project, its source sets and Java version once configured.
+const MODEL_INIT_SCRIPT: &str = include_str!("gradle-model.gradle");
+
const MAVEN_CACHE: &str = "maven.json";
const MAVEN_CACHE_VERSION: u32 = 1;
@@ -122,6 +130,20 @@ fn write_cache<T: Serialize>(dir: &Path, name: &str, value: &T) -> IdeResult<()>
/// FNV-1a over the paths and contents of `files` (missing files count as empty).
fn hash_files(files: &[PathBuf]) -> String {
+ hash_contents(files, |f| std::fs::read(f).unwrap_or_default())
+}
+
+/// Like IDEA's auto-import CRC: editing a comment or reformatting a build script
+/// does not make the last sync stale.
+fn hash_gradle_files(files: &[PathBuf]) -> String {
+ hash_contents(files, |f| {
+ let text = std::fs::read_to_string(f).unwrap_or_default();
+ let script = f.extension().is_some_and(|e| e == "gradle" || e == "kts");
+ if script { gradle::script_fingerprint(&text) } else { text }.into_bytes()
+ })
+}
+
+fn hash_contents(files: &[PathBuf], read: impl Fn(&Path) -> Vec<u8>) -> String {
let mut h: u64 = 0xcbf29ce484222325;
let mut feed = |bytes: &[u8]| {
for b in bytes {
@@ -132,7 +154,7 @@ fn hash_files(files: &[PathBuf]) -> String {
for f in files {
feed(f.to_string_lossy().as_bytes());
feed(&[0]);
- feed(&std::fs::read(f).unwrap_or_default());
+ feed(&read(f));
feed(&[0]);
}
format!("{h:016x}")
@@ -168,9 +190,33 @@ pub fn apply_maven_cache(root: &Path, cache_dir: &Path, model: &mut MavenModel)
}
}
+/// The projects of the last successful Gradle sync.
+/// Parsed once per change of the cache file (modification time and size): content and source
+/// roots are read on hot paths (every references search, Find in Files, repository scans).
+pub fn reported_gradle_projects(cache_dir: &Path) -> Arc<Vec<ReportedProject>> {
+ type Memo = HashMap<PathBuf, (Option<SystemTime>, u64, Arc<Vec<ReportedProject>>)>;
+ static MEMO: LazyLock<Mutex<Memo>> = LazyLock::new(Default::default);
+ let path = cache_dir.join(GRADLE_CACHE);
+ let Ok(meta) = std::fs::metadata(&path) else {
+ MEMO.lock().unwrap_or_else(|e| e.into_inner()).remove(&path);
+ return Arc::default();
+ };
+ let stamp = (meta.modified().ok(), meta.len());
+ let mut memo = MEMO.lock().unwrap_or_else(|e| e.into_inner());
+ if let Some((modified, len, projects)) = memo.get(&path)
+ && (*modified, *len) == stamp
+ {
+ return projects.clone();
+ }
+ let projects = Arc::new(read_cache::<GradleCache>(cache_dir, GRADLE_CACHE).map(|c| c.projects).unwrap_or_default());
+ memo.insert(path, (stamp.0, stamp.1, projects.clone()));
+ projects
+}
+
/// Merges the cached task list into `model`.
pub fn apply_gradle_cache(root: &Path, cache_dir: &Path, model: &mut GradleModel) {
let Some(cache) = read_cache::<GradleCache>(cache_dir, GRADLE_CACHE) else { return };
+ gradle::merge_reported_projects(root, model, &cache.projects);
if !cache.tasks.is_empty() {
for p in &mut model.projects {
let tasks: Vec<GradleTask> =
@@ -180,9 +226,11 @@ pub fn apply_gradle_cache(root: &Path, cache_dir: &Path, model: &mut GradleModel
}
}
}
+ // A successful sync from before projects were cached has not seen computed includes.
+ let without_projects = cache.error.is_none() && cache.projects.is_empty();
model.synced_at = Some(cache.at_ms);
model.sync_error = cache.error;
- model.stale = cache.hash != hash_files(&gradle::build_files(root, model));
+ model.stale = without_projects || cache.hash != hash_gradle_files(&gradle::build_files(root, model));
}
// ---------------------------------------------------------------- processes
@@ -322,8 +370,18 @@ pub fn sync_gradle(
cancel: &CancellationToken,
progress: &dyn Fn(SyncProgress),
) -> IdeResult<()> {
- let model = gradle::load(root).ok_or_else(|| IdeError::not_found("no Gradle build in this project"))?;
- let mut args: Vec<String> = vec!["--console=plain".into(), "-q".into(), "tasks".into(), "--all".into()];
+ let mut model = gradle::load(root).ok_or_else(|| IdeError::not_found("no Gradle build in this project"))?;
+ std::fs::create_dir_all(cache_dir)?;
+ let init_script = cache_dir.join("openidea-model.gradle");
+ std::fs::write(&init_script, MODEL_INIT_SCRIPT)?;
+ let mut args: Vec<String> = vec![
+ "--console=plain".into(),
+ "-q".into(),
+ "--init-script".into(),
+ init_script.to_string_lossy().into_owned(),
+ "tasks".into(),
+ "--all".into(),
+ ];
if options.offline {
args.push("--offline".into());
}
@@ -336,11 +394,15 @@ pub fn sync_gradle(
cancel,
|_| {},
)?;
+ let projects = if out.success { parse_reported_projects(&out.text) } else { Vec::new() };
+ // Hash the build files of the reported projects, or the model is stale right after the sync.
+ gradle::merge_reported_projects(root, &mut model, &projects);
let cache = GradleCache {
- hash: hash_files(&gradle::build_files(root, &model)),
+ hash: hash_gradle_files(&gradle::build_files(root, &model)),
at_ms: now_ms(),
error: (!out.success).then(|| error_summary(&out.text)),
tasks: if out.success { gradle::parse_tasks(&out.text) } else { Vec::new() },
+ projects,
};
write_cache(cache_dir, GRADLE_CACHE, &cache)
}
@@ -456,6 +518,93 @@ mod tests {
assert!(model.projects[0].dependencies.iter().all(|d| d.artifact_id != "cached"));
}
+ #[test]
+ fn gradle_reported_projects_replace_static_ones() {
+ let tmp = tempfile::tempdir().unwrap();
+ let ws = dunce::canonicalize(tmp.path()).unwrap();
+ let root = ws.join("app");
+ let billing = ws.join("billing");
+ std::fs::create_dir_all(root.join("shared")).unwrap();
+ std::fs::create_dir_all(billing.join("modules/core")).unwrap();
+ // Computed includes: nothing a static reading can see.
+ std::fs::write(root.join("settings.gradle"), "rootProject.name = 'Shop'\n['billing'].each { includeFlat it }")
+ .unwrap();
+ std::fs::write(billing.join("modules/core/build.gradle"), "apply plugin: 'java'").unwrap();
+ // Built with serde: a Windows path holds backslashes, which raw JSON text would leave unescaped.
+ let line = |p: ReportedProject| format!("@openidea-model\t{}\n", serde_json::to_string(&p).unwrap());
+ let (r, b) = (root.display().to_string(), billing.display().to_string());
+ let core_src = |p: &str| format!("{b}/modules/core/src/{p}");
+ let set = |name: &str, test: bool, src: &[&str], res: &[&str]| gradle::ReportedSourceSet {
+ name: name.into(),
+ test,
+ src: src.iter().map(|p| core_src(p)).collect(),
+ res: res.iter().map(|p| core_src(p)).collect(),
+ };
+ // A settings script's own println comes first; task listing lines follow.
+ let out = format!(
+ "configuring billing\n{}{}{}@openidea-model\t{{broken\n\nOther tasks\n-----------\nbilling:core:jar\n",
+ line(ReportedProject { path: ":".into(), dir: r.clone(), ..ReportedProject::default() }),
+ line(ReportedProject {
+ path: ":billing".into(),
+ dir: b.clone(),
+ java: Some(17),
+ ..ReportedProject::default()
+ }),
+ line(ReportedProject {
+ path: ":billing:core".into(),
+ dir: format!("{b}/modules/core"),
+ java: Some(21),
+ source_sets: vec![
+ set("main", false, &["main/java"], &["main/resources"]),
+ set("test", true, &["main/java", "test/java"], &[]),
+ ],
+ ..ReportedProject::default()
+ }),
+ );
+ let projects = parse_reported_projects(&out);
+ assert_eq!(projects.len(), 3, "the malformed line is skipped");
+ let src = |p: &str| PathBuf::from(core_src(p));
+ assert_eq!(
+ gradle::reported_source_roots(&projects),
+ [
+ (src("main/java"), gradle::ReportedRoot::Source),
+ (src("main/resources"), gradle::ReportedRoot::Resources),
+ (src("test/java"), gradle::ReportedRoot::Test),
+ ]
+ );
+ let mut model = gradle::load(&root).unwrap();
+ assert_eq!(model.projects.len(), 1);
+ gradle::merge_reported_projects(&root, &mut model, &projects);
+ let paths: Vec<_> = model.projects.iter().map(|p| (p.path.as_str(), p.name.as_str())).collect();
+ assert_eq!(paths, [(":", "Shop"), (":billing", "billing"), (":billing:core", "core")]);
+ assert_eq!(model.projects[0].dir, "");
+ assert!(root.join(model.projects[2].build_file.as_ref().unwrap()).is_file());
+ assert_eq!(
+ gradle::external_roots(&root, model.projects.iter().map(|p| p.dir.as_str())),
+ std::slice::from_ref(&billing)
+ );
+ assert_eq!(model.java_version, Some(21), "the newest version any module needs");
+ assert_eq!(
+ gradle::parse_tasks(&out),
+ [(":billing:core".into(), GradleTask { name: "jar".into(), group: "other".into(), description: None })]
+ );
+
+ // The cached projects are parsed once per change of the cache file.
+ let cache_dir = ws.join("cache");
+ let write = |projects: &[ReportedProject]| {
+ let cache = GradleCache { projects: projects.to_vec(), ..GradleCache::default() };
+ write_cache(&cache_dir, GRADLE_CACHE, &cache).unwrap();
+ };
+ write(&projects);
+ let first = reported_gradle_projects(&cache_dir);
+ assert!(Arc::ptr_eq(&first, &reported_gradle_projects(&cache_dir)), "unchanged: not parsed again");
+ assert_eq!(crate::gradle_external_roots(&root, &cache_dir), [billing]);
+ write(&projects[..1]);
+ assert_eq!(reported_gradle_projects(&cache_dir).len(), 1, "a new sync is read");
+ std::fs::remove_file(cache_dir.join(GRADLE_CACHE)).unwrap();
+ assert!(reported_gradle_projects(&cache_dir).is_empty());
+ }
+
#[test]
fn gradle_cache_replaces_tasks_per_project() {
let tmp = tempfile::tempdir().unwrap();
@@ -466,16 +615,39 @@ mod tests {
std::fs::write(root.join("app/build.gradle"), "apply plugin: 'java'").unwrap();
let mut model = gradle::load(&root).unwrap();
let cache = GradleCache {
- hash: hash_files(&gradle::build_files(&root, &model)),
+ hash: hash_gradle_files(&gradle::build_files(&root, &model)),
at_ms: 1.0,
error: None,
tasks: vec![(":app".into(), GradleTask { name: "hello".into(), group: "demo".into(), description: None })],
+ projects: [":", ":app"]
+ .iter()
+ .zip([root.clone(), root.join("app")])
+ .map(|(path, dir)| ReportedProject {
+ path: (*path).into(),
+ dir: dir.to_string_lossy().into_owned(),
+ ..Default::default()
+ })
+ .collect(),
};
write_cache(&cache_dir, GRADLE_CACHE, &cache).unwrap();
apply_gradle_cache(&root, &cache_dir, &mut model);
assert_eq!(model.projects[1].tasks.len(), 1);
assert!(model.projects[0].tasks.iter().any(|t| t.name == "wrapper"), "root keeps its defaults");
assert!(!model.stale);
+
+ let stale_after = |script: &str| {
+ std::fs::write(root.join("app/build.gradle"), script).unwrap();
+ let mut m = gradle::load(&root).unwrap();
+ apply_gradle_cache(&root, &cache_dir, &mut m);
+ m.stale
+ };
+ assert!(!stale_after("// a note\napply plugin: 'java'\n"), "comments and spacing don't count");
+ assert!(stale_after("apply plugin: 'groovy'"));
+ std::fs::write(root.join("app/build.gradle"), "apply plugin: 'java'").unwrap();
+ std::fs::write(root.join("gradle.properties"), "org.gradle.jvmargs=-Xmx2g").unwrap();
+ let mut m = gradle::load(&root).unwrap();
+ apply_gradle_cache(&root, &cache_dir, &mut m);
+ assert!(m.stale, "gradle.properties is watched");
}
#[test]
diff --git a/crates/ide-core/src/settings.rs b/crates/ide-core/src/settings.rs
index dd101f248..95ba3f5fd 100644
--- a/crates/ide-core/src/settings.rs
+++ b/crates/ide-core/src/settings.rs
@@ -786,6 +786,19 @@ pub struct GradleSettings {
pub home: String,
/// Empty = Gradle's default user home.
pub user_home: String,
+ /// IDEA's "Build and run using": who builds and launches an Application main.
+ pub run_using: GradleRunUsing,
+}
+
+/// IDEA's "Build and run using" for Gradle builds; IDEA defaults to Gradle.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
+#[serde(rename_all = "camelCase")]
+pub enum GradleRunUsing {
+ /// A `JavaExec` task on the source set's runtime classpath (`gradleRun.gradle`).
+ #[default]
+ Gradle,
+ /// The Java language server's classpath, launched by OpenIDEA.
+ Ide,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize, Type)]
@@ -1026,6 +1039,7 @@ mod gradle_settings_tests {
distribution,
home: "/gradle".into(),
user_home: "/cache/gradle".into(),
+ run_using: GradleRunUsing::Ide,
};
let restored: Settings = serde_json::from_str(&serde_json::to_string(&settings).unwrap()).unwrap();
assert_eq!(restored.languages.java.gradle, settings.languages.java.gradle);
diff --git a/crates/ide-host/src/ops/build.rs b/crates/ide-host/src/ops/build.rs
index 03bf903d2..4f1bc5a70 100644
--- a/crates/ide-host/src/ops/build.rs
+++ b/crates/ide-host/src/ops/build.rs
@@ -150,6 +150,13 @@ pub async fn build_sync(
.map_err(join_err);
host.end_request(request);
let model = result??;
+ if tool == BuildTool::Gradle {
+ // The sync may report project folders outside the project (`includeFlat`): index and list them.
+ project.refresh_index_scope();
+ project.sink.emit(ide_core::IdeEvent::ProjectRootsChanged { root: project.root.clone().into() });
+ let p = project.clone();
+ tokio::task::spawn_blocking(move || p.refresh_repositories());
+ }
if tool == BuildTool::Maven
&& model.maven.is_some()
&& let Some(bridge) = &project.kotlin_bridge
diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rs
index 82e4b0579..2ab2c7b87 100644
--- a/crates/ide-host/src/project.rs
+++ b/crates/ide-host/src/project.rs
@@ -91,7 +91,8 @@ impl Host {
let settings = SettingsStore::load(&self.config_dir, Some(&root));
let detected_roots = Arc::new(RwLock::new(ide_workspace::roots::detect(&root)));
let excludes = exclude_globs(&root, &settings.effective(), &detected_roots.read());
- let extra_roots = content_roots(&settings.effective(), &root);
+ let build_cache = self.local_data_dir.join("cache").join(project_key(&root)).join("build");
+ let extra_roots = content_roots(&settings.effective(), &root, &build_cache);
mark("roots");
// The project's own registry: File Types associations may be project-scoped.
@@ -265,7 +266,7 @@ impl Host {
let kotlin_bridge = crate::kotlin_bridge::KotlinBridge::new(
root.clone(),
- self.local_data_dir.join("cache").join(&project_key).join("build"),
+ build_cache.clone(),
&self.local_data_dir,
settings.clone(),
lsp.clone(),
@@ -292,6 +293,7 @@ impl Host {
let runtime = self.runtime.clone();
let lsp = lsp.clone();
let trusted = trusted.clone();
+ let build_cache = build_cache.clone();
Watcher::start(
&root.clone(),
excludes.clone(),
@@ -328,7 +330,7 @@ impl Host {
// Detected excluded folders (`target`, `build`) leave the index too.
let effective = settings.effective();
index.set_scope(
- index_roots(&root, content_roots(&effective, &root)),
+ index_roots(&root, content_roots(&effective, &root, &build_cache)),
exclude_globs(&root, &effective, &fresh),
);
*detected_roots.write() = fresh;
@@ -366,7 +368,7 @@ impl Host {
matches!(rest.as_slice(), [first, ..] if first == "worktrees" && rest.len() <= 2)
});
if git_dirs {
- scan_repositories(&root, &repos, &settings, &sink);
+ scan_repositories(&root, &repos, &settings, &sink, &build_cache);
}
let vcs_moved = batch.vcs.iter().any(|p| vcs_path_changed(p));
if git_dirs || vcs_moved {
@@ -413,9 +415,10 @@ impl Host {
mark("watcher");
{
let (root, repos, settings, sink) = (root.clone(), repos.clone(), settings.clone(), sink.clone());
+ let build_cache = build_cache.clone();
std::thread::Builder::new()
.name("openidea-vcs-roots".into())
- .spawn(move || scan_repositories(&root, &repos, &settings, &sink))?;
+ .spawn(move || scan_repositories(&root, &repos, &settings, &sink, &build_cache))?;
}
mark("git");
tracing::info!("opened {} in window {window} in {} ms {laps:?}", root.display(), started.elapsed().as_millis());
@@ -650,11 +653,17 @@ fn light_watcher(
/// Looks for repositories nested below the project (and the one containing it);
/// emits `VcsChanged` when the set of roots changed.
-fn scan_repositories(root: &Path, repos: &RwLock<Repos>, settings: &SettingsStore, sink: &SharedSink) {
+fn scan_repositories(
+ root: &Path,
+ repos: &RwLock<Repos>,
+ settings: &SettingsStore,
+ sink: &SharedSink,
+ build_cache: &Path,
+) {
let ignored = settings.effective().ignored_names();
let skip = |p: &Path| p.file_name().is_some_and(|n| ignored.is_ignored_name(&n.to_string_lossy()));
let mut roots = vec![root.to_path_buf()];
- roots.extend(content_roots(&settings.effective(), root));
+ roots.extend(content_roots(&settings.effective(), root, build_cache));
match Repos::discover_roots(&roots, &skip) {
Ok(found) => {
if found.roots() != repos.read().roots() {
@@ -668,7 +677,7 @@ fn scan_repositories(root: &Path, repos: &RwLock<Repos>, settings: &SettingsStor
impl Project {
pub fn refresh_repositories(&self) {
- scan_repositories(&self.root, &self.repos, &self.settings, &self.sink);
+ scan_repositories(&self.root, &self.repos, &self.settings, &self.sink, &self.build_cache_dir());
}
/// The project's git repositories.
@@ -774,7 +783,8 @@ impl Project {
/// Effective source / test / resource / excluded roots (detected + Project Structure marks).
pub fn roots(&self) -> ProjectRoots {
- linked_roots(&self.root, &self.settings.effective(), &self.detected_roots.read())
+ let detected = with_gradle_roots(&self.root, &self.build_cache_dir(), &self.detected_roots.read());
+ linked_roots(&self.root, &self.settings.effective(), &detected)
}
/// Where the Maven / Gradle tool windows cache what the build tools reported.
@@ -841,7 +851,7 @@ impl Project {
/// Project Structure content roots besides the project folder (existing directories).
pub fn content_roots(&self) -> Vec<PathBuf> {
- content_roots(&self.settings.effective(), &self.root)
+ content_roots(&self.settings.effective(), &self.root, &self.build_cache_dir())
}
/// Applies Settings › File Types; open documents whose language changed are
@@ -960,14 +970,15 @@ fn index_roots(root: &Path, folders: Vec<PathBuf>) -> ide_index::IndexRoots {
ide_index::IndexRoots { include_root: !root.join(ide_workspace::workspace::FILE).is_file(), folders }
}
-/// Workspace members in manifest order, or extra Project Structure directories.
-fn content_roots(settings: &ide_core::settings::Settings, root: &Path) -> Vec<PathBuf> {
+/// Workspace members in manifest order, or extra Project Structure directories and the
+/// Gradle project folders outside the project as of the last sync (`build_cache`).
+fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cache: &Path) -> Vec<PathBuf> {
if let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root) {
return workspace.projects;
}
let mut out: Vec<PathBuf> = Vec::new();
- for r in &settings.project_structure.content_roots {
- let p = PathBuf::from(r.trim());
+ let user = settings.project_structure.content_roots.iter().map(|r| PathBuf::from(r.trim()));
+ for p in user.chain(ide_build::gradle_external_roots(root, build_cache)) {
if p.is_absolute() && p.is_dir() && !p.starts_with(root) && !out.contains(&p) {
out.push(p);
}
@@ -1024,6 +1035,33 @@ pub(crate) fn unlinked_maven_poms(root: &Path, settings: &ide_core::settings::Se
ide_build::maven::UnlinkedProjects::load(root, &settings.languages.java.maven).poms().map(PathBuf::from).collect()
}
+/// The detected roots with the last Gradle sync's source sets first: Gradle evaluated what
+/// static detection guesses. Folders outside the project keep their absolute path, which
+/// `normalize` turns into the same form the UI compares (`Users/me/svc/src/main/java`).
+fn with_gradle_roots(root: &Path, build_cache: &Path, detected: &[SourceFolder]) -> Vec<SourceFolder> {
+ use ide_build::gradle::ReportedRoot;
+ use ide_workspace::roots::RootKind;
+ let mut out: Vec<SourceFolder> = Vec::new();
+ for (dir, kind) in ide_build::gradle_source_roots(build_cache) {
+ if !dir.is_dir() {
+ continue;
+ }
+ let path = ide_workspace::roots::normalize(&dir.strip_prefix(root).unwrap_or(&dir).to_string_lossy());
+ let kind = match kind {
+ ReportedRoot::Source => RootKind::Source,
+ ReportedRoot::Test => RootKind::Test,
+ ReportedRoot::Resources => RootKind::Resources,
+ ReportedRoot::TestResources => RootKind::TestResources,
+ ReportedRoot::Excluded => RootKind::Excluded,
+ };
+ if !out.iter().any(|f| f.path == path) {
+ out.push(SourceFolder { path, kind, detected_from: Some("Gradle".into()) });
+ }
+ }
+ out.extend(detected.iter().filter(|d| !out.iter().any(|o| o.path == d.path)).cloned().collect::<Vec<_>>());
+ out
+}
+
fn linked_roots(root: &Path, settings: &ide_core::settings::Settings, detected: &[SourceFolder]) -> ProjectRoots {
let unlinked = ide_build::maven::UnlinkedProjects::load(root, &settings.languages.java.maven);
let detected = detected
@@ -1225,6 +1263,46 @@ fn vcs_path_changed(path: &Path) -> bool {
!path.ends_with(".git/index") || !ide_vcs::is_own_index_write(path)
}
+#[cfg(test)]
+mod gradle_roots_tests {
+ use super::*;
+ use ide_workspace::RootKind;
+
+ #[test]
+ fn gradle_sync_roots_win_and_reach_outside_the_project() {
+ let tmp = tempfile::tempdir().unwrap();
+ let ws = dunce::canonicalize(tmp.path()).unwrap();
+ let (root, svc, cache) = (ws.join("p"), ws.join("svc"), ws.join("cache"));
+ for d in [root.join("src/it/java"), svc.join("src/main/java"), svc.join("build")] {
+ std::fs::create_dir_all(d).unwrap();
+ }
+ let s = |p: PathBuf| p.to_string_lossy().into_owned();
+ let json = serde_json::json!({ "hash": "", "at_ms": 1.0, "error": null, "tasks": [], "projects": [
+ { "path": ":", "dir": s(root.clone()), "sourceSets": [
+ { "name": "integrationTest", "test": true, "src": [s(root.join("src/it/java"))], "res": [] } ] },
+ { "path": ":svc", "dir": s(svc.clone()), "buildDir": s(svc.join("build")), "sourceSets": [
+ { "name": "main", "test": false,
+ "src": [s(svc.join("src/main/java")), s(svc.join("src/main/kotlin"))], "res": [] } ] },
+ ]});
+ std::fs::create_dir_all(&cache).unwrap();
+ std::fs::write(cache.join("gradle.json"), json.to_string()).unwrap();
+ let guessed = SourceFolder { path: "src/it/java".into(), kind: RootKind::Source, detected_from: None };
+ let other = SourceFolder { path: "web".into(), kind: RootKind::Source, detected_from: None };
+ let out = with_gradle_roots(&root, &cache, &[guessed, other.clone()]);
+ let abs = |p: PathBuf| ide_workspace::roots::normalize(&s(p));
+ let got: Vec<(String, RootKind)> = out.iter().map(|f| (f.path.clone(), f.kind)).collect();
+ assert_eq!(
+ got,
+ [
+ ("src/it/java".into(), RootKind::Test),
+ (abs(svc.join("src/main/java")), RootKind::Source),
+ (abs(svc.join("build")), RootKind::Excluded),
+ ("web".into(), RootKind::Source),
+ ]
+ );
+ }
+}
+
#[cfg(test)]
mod index_event_tests {
use super::vcs_path_changed;
diff --git a/src/bindings.ts b/src/bindings.ts
index 074ab6ec8..047982315 100644
--- a/src/bindings.ts
+++ b/src/bindings.ts
@@ -3489,7 +3489,10 @@ export type GradleModel = {
};
export type GradleProject = {
- /** Gradle path: `:` for the root project, `:app`, `:libs:core`. */
+ /**
+ * Gradle path: `:` for the root project, `:app`, `:libs:core`; for a project of a
+ * nested build its identity path (`:lib:core`), which addresses its tasks from the root.
+ */
path: string,
name: string,
/** Project-relative directory. */
@@ -3497,8 +3500,20 @@ export type GradleProject = {
/** Project-relative build script, if any. */
buildFile: string | null,
tasks: GradleTask[],
+ /**
+ * Identity path of the nested build holding the project (`:lib` for `includeBuild`,
+ * `:buildSrc`); null for the opened build.
+ */
+ build?: string | null,
};
+/** IDEA's "Build and run using" for Gradle builds; IDEA defaults to Gradle. */
+export type GradleRunUsing =
+/** A `JavaExec` task on the source set's runtime classpath (`gradleRun.gradle`). */
+"gradle" |
+/** The Java language server's classpath, launched by OpenIDEA. */
+"ide";
+
/** Build Tools › Gradle. */
export type GradleSettings = {
/** Empty = Project JDK; otherwise a JDK home. */
@@ -3508,6 +3523,8 @@ export type GradleSettings = {
home?: string,
/** Empty = Gradle's default user home. */
userHome?: string,
+ /** IDEA's "Build and run using": who builds and launches an Application main. */
+ runUsing?: GradleRunUsing,
};
export type GradleTask = {
diff --git a/src/features/build-tools/index.ts b/src/features/build-tools/index.ts
index 172d3e3af..58d31bc7a 100644
--- a/src/features/build-tools/index.ts
+++ b/src/features/build-tools/index.ts
@@ -43,7 +43,8 @@ export const MAVEN_WHEN = "projectOpen && build.maven";
export const GRADLE_WHEN = "projectOpen && build.gradle";
/** Build files whose creation / change / removal re-reads the model. */
-const BUILD_FILE = /(?:^|\/)(?:pom\.xml|(?:build|settings)\.gradle(?:\.kts)?|mvnw(?:\.cmd)?|gradlew(?:\.bat)?)$/;
+const BUILD_FILE =
+ /(?:^|\/)(?:pom\.xml|(?:build|settings)\.gradle(?:\.kts)?|mvnw(?:\.cmd)?|gradlew(?:\.bat)?|gradle\.properties|gradle-wrapper\.properties|[^/]+\.versions\.toml)$/;
function expandAll(tool: BuildTool) {
const { model, configs } = useBuild.getState();
diff --git a/src/features/build-tools/store.ts b/src/features/build-tools/store.ts
index 936fbb117..33f141b27 100644
--- a/src/features/build-tools/store.ts
+++ b/src/features/build-tools/store.ts
@@ -23,6 +23,7 @@ import {
type SyncProgress,
} from "@/platform/ipc";
import { downloadJdkActions } from "@/platform/jdk";
+import { useBuildModel } from "@/platform/buildModel";
import { useProject } from "@/platform/project";
import { editorService, notifications } from "@/workbench/contributions";
import { cancelTask, removeTask, upsertTask, useTasks } from "@/workbench/tasks";
@@ -74,6 +75,14 @@ export const useBuild = create<BuildState>(() => ({
current: {},
}));
+// Shared with the features that follow the build (run, Project view).
+useBuild.subscribe((s) => {
+ const shared = useBuildModel.getState();
+ const gradleOffline = s.settings.gradle.offline;
+ if (shared.root !== s.root || shared.model !== s.model || shared.gradleOffline !== gradleOffline)
+ useBuildModel.setState({ root: s.root, model: s.model, gradleOffline });
+});
+
// ---------------------------------------------------------------------------
// Settings (per project)
@@ -189,6 +198,9 @@ export function changedOutsideIde(paths: readonly string[], now = Date.now()): b
return external;
}
+/** Root whose never-synced Gradle build was imported on open (once per open). */
+let autoImported: string | null = null;
+
/** Re-reads the build model (and the run configurations) of the open project. */
export async function loadModel(): Promise<void> {
const root = useProject.getState().project?.root ?? null;
@@ -218,6 +230,11 @@ export async function loadModel(): Promise<void> {
const maven = model.maven;
if (maven?.stale && maven.syncedAt !== null && !useBuild.getState().syncing.maven) void syncTool("maven");
}
+ // Like IDEA, a Gradle build is imported when first opened; later changes wait for Reload.
+ if (model.gradle && model.gradle.syncedAt === null && autoImported !== root) {
+ autoImported = root;
+ void syncTool("gradle");
+ }
} catch (e) {
if (gen === generation) useBuild.setState({ loading: false, error: e instanceof Error ? e.message : String(e) });
}
diff --git a/src/features/project-tree/ProjectView.tsx b/src/features/project-tree/ProjectView.tsx
index 363912c43..26548a64e 100644
--- a/src/features/project-tree/ProjectView.tsx
+++ b/src/features/project-tree/ProjectView.tsx
@@ -132,7 +132,9 @@ function iconFor(
const kind = folderKind(node, roots, root, build, detected);
if (kind !== "plain") return folderIconName(kind);
const rel = root ? (node.path === root ? "" : relativePath(root, node.path)) : null;
- const module = rel === null ? null : moduleFolderIcon(rel, node.root, build.modules);
+ // Modules outside the project are keyed by their absolute folder.
+ const key = rel !== null && build.modules.has(rel) ? rel : node.path;
+ const module = root ? moduleFolderIcon(key, node.root, build.modules) : null;
if (module) return module;
return node.root ? "module" : "folder";
}
diff --git a/src/features/project-tree/index.ts b/src/features/project-tree/index.ts
index 6897ce40b..b4d699fb5 100644
--- a/src/features/project-tree/index.ts
+++ b/src/features/project-tree/index.ts
@@ -1,6 +1,7 @@
/** Project view: the "project" tool window, its file operations and actions. */
import { onEditorEvent, openEditorPaths } from "@/editor/api";
import { onIdeEvent } from "@/platform/ipc";
+import { useBuildModel } from "@/platform/buildModel";
import { validateProjectStructure, type RootFolder } from "@/platform/languageSettings";
import { useProject } from "@/platform/project";
import { initProjectRoots, useProjectRoots } from "@/platform/projectRoots";
@@ -15,6 +16,7 @@ import {
useProjectViewRoots,
} from "@/workbench/contributions";
import { registerProjectActions } from "./actions";
+import { gradleModuleGroups } from "./moduleGroups";
import { FileRefactorDialogHost } from "./FileRefactorDialogs";
import { NewPopupHost } from "./NewPopup";
import { RefactoringPreviewHost } from "./RefactoringPreview";
@@ -65,14 +67,20 @@ export function activate(): () => void {
if (s.root && s.root === prev.root && detectedExcluded(s) !== detectedExcluded(prev)) void reloadAll();
});
- // Project Structure content roots besides the project folder, listed after it.
+ // Project Structure content roots after the project folder, and IDEA's module groups of
+ // a Gradle build with modules outside it (as of the last sync) before it.
let contentRoots: Array<() => void> = [];
let shownRoots = "";
const syncContentRoots = () => {
const { project, settings } = useProject.getState();
- const paths =
- project && !project.workspace ? validateProjectStructure(settings?.projectStructure).contentRoots : [];
- const key = JSON.stringify(paths);
+ const own = project && !project.workspace;
+ const paths = own ? validateProjectStructure(settings?.projectStructure).contentRoots : [];
+ // The Build tool window's model (one load per build change), not a load of our own.
+ const build = useBuildModel.getState();
+ const gradleProjects = build.root === project?.root ? (build.model?.gradle?.projects ?? []) : [];
+ const rootName = gradleProjects.find((p) => p.path === ":")?.name ?? "";
+ const groups = own && project ? gradleModuleGroups(gradleProjects, rootName, project.root) : [];
+ const key = JSON.stringify([paths, groups]);
if (key === shownRoots) return;
shownRoots = key;
contentRoots.forEach((d) => d());
@@ -86,8 +94,14 @@ export function activate(): () => void {
order: -100 + i,
}),
);
+ groups.forEach((g, i) =>
+ contentRoots.push(registerProjectViewRoot({ ...g, id: g.id!, order: -200 + i, beforeProject: true })),
+ );
};
syncContentRoots();
+ const unsubGradleRoots = useBuildModel.subscribe((s, prev) => {
+ if (s.model !== prev.model || s.root !== prev.root) syncContentRoots();
+ });
const unsubContentRoots = useProject.subscribe((s, prev) => {
if (s.settings !== prev.settings || s.project !== prev.project) syncContentRoots();
});
@@ -124,6 +138,7 @@ export function activate(): () => void {
unsubExtraRoots,
unsubExcludes,
unsubContentRoots,
+ unsubGradleRoots,
() => contentRoots.forEach((d) => d()),
disposeRoots,
unsubRoots,
diff --git a/src/features/project-tree/model.ts b/src/features/project-tree/model.ts
index fd0099535..832109d34 100644
--- a/src/features/project-tree/model.ts
+++ b/src/features/project-tree/model.ts
@@ -249,6 +249,8 @@ export interface ExtraRoot {
children?: readonly ExtraRoot[];
detail?: string;
readOnly?: boolean;
+ /** Listed above the project folder (IDEA's module group of the build). */
+ beforeProject?: boolean;
}
/** Key prefix of group nodes that show no folder ("External Libraries", an SDK). */
@@ -387,13 +389,24 @@ export function withExtraRoots(
readOnly: true,
};
out.byKey.set(key, node);
- const kids = (extra.children ?? []).map((c) => add(c, key, ro)).filter((n): n is ProjectNode => !!n);
- out.children.set(key, kids);
+ // Deepest folders first: a module folder nested in a sibling's (`billing/modules/core`
+ // in `billing`) would otherwise already be keyed by the sibling's listing and dropped.
+ const children = extra.children ?? [];
+ const depth = (c: ExtraRoot) => c.path?.split("/").length ?? 0;
+ const built: (ProjectNode | null)[] = [];
+ for (const i of children.map((_, i) => i).sort((a, b) => depth(children[b]!) - depth(children[a]!)))
+ built[i] = add(children[i]!, key, ro);
+ out.children.set(
+ key,
+ built.filter((n): n is ProjectNode => !!n),
+ );
return node;
};
+ let before = 0;
for (const extra of extras) {
const node = add(extra, null, false);
- if (node) out.roots.push(node);
+ if (node && extra.beforeProject) out.roots.splice(before++, 0, node);
+ else if (node) out.roots.push(node);
}
return out;
}
diff --git a/src/features/project-tree/moduleGroups.test.ts b/src/features/project-tree/moduleGroups.test.ts
new file mode 100644
index 000000000..c7d70ae28
--- /dev/null
+++ b/src/features/project-tree/moduleGroups.test.ts
@@ -0,0 +1,125 @@
+import { describe, expect, it } from "vitest";
+import type { FileEntry } from "@/bindings";
+import { buildModel, DEFAULT_TREE_OPTIONS, type ExtraRoot, withExtraRoots } from "./model";
+import { gradleModuleGroups } from "./moduleGroups";
+
+type Shown = { label: string; detail?: string; children?: Shown[] };
+const shape = (e: ExtraRoot): Shown => ({
+ label: e.label,
+ ...(e.detail ? { detail: e.detail } : {}),
+ ...(e.children ? { children: e.children.map(shape) } : {}),
+});
+
+describe("gradleModuleGroups (IDEA's module groups)", () => {
+ // `includeFlat` sibling modules, one with layer modules nested in its folder.
+ const flat = [
+ { path: ":", dir: "" },
+ { path: ":common", dir: "/w/common" },
+ { path: ":billing", dir: "/w/billing" },
+ ...["core", "api"].map((l) => ({ path: `:billing:${l}`, dir: `/w/billing/modules/${l}` })),
+ ];
+
+ it("lists every module of the group, nested ones flattened, as IntelliJ shows it", () => {
+ expect(gradleModuleGroups(flat, "Shop", "/w/shop").map(shape)).toEqual([
+ {
+ label: "Shop",
+ children: [
+ { label: "api", detail: "Shop.billing.api" },
+ { label: "billing", detail: "Shop.billing" },
+ { label: "common", detail: "Shop.common" },
+ { label: "core", detail: "Shop.billing.core" },
+ ],
+ },
+ ]);
+ });
+
+ it("shows no group while every module lives in the project folder", () => {
+ const inside = [
+ { path: ":", dir: "" },
+ { path: ":app", dir: "app" },
+ { path: ":libs:core", dir: "libs/core" },
+ ];
+ expect(gradleModuleGroups(inside, "demo", "/w/demo")).toEqual([]);
+ });
+
+ it("keeps a subgroup that no module is named like", () => {
+ const projects = [
+ { path: ":", dir: "" },
+ { path: ":svc", dir: "/w/svc" },
+ { path: ":libs:a", dir: "/w/libs/a" },
+ { path: ":libs:b", dir: "/w/libs/b" },
+ ];
+ expect(gradleModuleGroups(projects, "R", "/w/r").map(shape)).toEqual([
+ {
+ label: "R",
+ children: [
+ {
+ label: "libs",
+ children: [
+ { label: "a", detail: "R.libs.a" },
+ { label: "b", detail: "R.libs.b" },
+ ],
+ },
+ { label: "svc", detail: "R.svc" },
+ ],
+ },
+ ]);
+ });
+
+ it("names an included build's modules after it and lists it as an ungrouped module", () => {
+ const projects = [
+ { path: ":", dir: "" },
+ { path: ":app", dir: "app" },
+ { path: ":buildSrc", dir: "buildSrc", build: ":buildSrc" },
+ { path: ":lib", dir: "/w/lib", build: ":lib" },
+ { path: ":lib:core", dir: "/w/lib/core", build: ":lib" },
+ ];
+ expect(gradleModuleGroups(projects, "Shop", "/w/shop").map(shape)).toEqual([{ label: "lib" }]);
+ // Beside includeFlat modules: the group (every `Shop.*` module), then the included build.
+ const both = [...projects, { path: ":svc", dir: "/w/svc" }];
+ expect(gradleModuleGroups(both, "Shop", "/w/shop").map(shape)).toEqual([
+ {
+ label: "Shop",
+ children: [
+ { label: "app", detail: "Shop.app" },
+ { label: "buildSrc", detail: "Shop.buildSrc" },
+ { label: "svc", detail: "Shop.svc" },
+ ],
+ },
+ { label: "lib" },
+ ]);
+ });
+});
+
+const dir = (path: string): FileEntry => ({
+ name: path.slice(path.lastIndexOf("/") + 1),
+ path,
+ kind: "dir",
+ size: 0,
+ mtimeMs: 1,
+ ignored: false,
+ excluded: false,
+ hidden: false,
+});
+
+describe("module group nodes in the tree", () => {
+ it("lists the group above the project and keeps a nested module whose parent is expanded", () => {
+ const listings = new Map([
+ ["/w/billing", [dir("/w/billing/modules")]],
+ ["/w/billing/modules", [dir("/w/billing/modules/core")]],
+ ]);
+ const base = buildModel({ path: "/p", name: "p" }, new Map(), DEFAULT_TREE_OPTIONS);
+ const group = {
+ label: "Shop",
+ icon: "gradle-project",
+ beforeProject: true,
+ children: [
+ { label: "billing", icon: "gradle-module", path: "/w/billing" },
+ { label: "core", icon: "gradle-module", path: "/w/billing/modules/core" },
+ ],
+ };
+ const m = withExtraRoots(base, [group], listings, DEFAULT_TREE_OPTIONS);
+ expect(m.roots.map((r) => r.label)).toEqual(["Shop", "p"]);
+ expect(m.children.get(m.roots[0]!.key)!.map((n) => n.label)).toEqual(["billing", "core"]);
+ });
+});
diff --git a/src/features/project-tree/moduleGroups.ts b/src/features/project-tree/moduleGroups.ts
new file mode 100644
index 000000000..40a178f72
--- /dev/null
+++ b/src/features/project-tree/moduleGroups.ts
@@ -0,0 +1,92 @@
+/**
+ * IDEA's module groups in the Project view, for Gradle builds whose modules live outside
+ * the project folder (`includeFlat`, computed `projectDir`s, `includeBuild`). Mirrors IntelliJ's
+ * `AbstractProjectNode.modulesAndGroups`, `ModuleGroup.modulesInGroup` / `childGroups`
+ * and the `QualifiedNameGrouper` of qualified module names (`<root project>.billing.core`).
+ */
+import type { ExtraRoot } from "./model";
+import { isSameOrInside, nameOf } from "./paths";
+
+interface Module {
+ /** Qualified name: `<root project>.<path segments>`. */
+ name: string;
+ dir: string;
+}
+
+const isAbsolute = (p: string) => p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p);
+const segments = (name: string) => name.split(".");
+const groupOf = (m: Module) => segments(m.name).slice(0, -1);
+const same = (a: readonly string[], b: readonly string[]) => a.length === b.length && a.every((x, i) => x === b[i]);
+const isChild = (parent: readonly string[], d: readonly string[]) =>
+ d.length > parent.length && same(d.slice(0, parent.length), parent);
+const byLabel = (a: ExtraRoot, b: ExtraRoot) => a.label.localeCompare(b.label, undefined, { sensitivity: "base" });
+
+/**
+ * Group nodes to list beside the project folder: none while the project folder is the only
+ * top-level module root (every module inside it), as in IDEA.
+ */
+export function gradleModuleGroups(
+ projects: readonly { path: string; dir: string; build?: string | null }[],
+ rootName: string,
+ projectRoot: string,
+): ExtraRoot[] {
+ const modules: Module[] = projects.map((p) => {
+ const path = p.path.split(":").filter(Boolean);
+ // An included build's modules are named after that build (`lib.core`); buildSrc and
+ // the opened build's after the root project (`shop.buildSrc`), as IDEA names them.
+ const own = !p.build || p.build === ":buildSrc";
+ return {
+ name: (own ? [rootName, ...path] : path).join("."),
+ dir: isAbsolute(p.dir) ? p.dir : p.dir ? `${projectRoot}/${p.dir}` : projectRoot,
+ };
+ });
+ // A content root is top level when no other content root contains it (`isTopLevelRoot`).
+ const roots = [projectRoot, ...modules.map((m) => m.dir)];
+ const topLevel = modules.filter(
+ (m) => m.dir === projectRoot || !roots.some((r) => r !== m.dir && isSameOrInside(m.dir, r)),
+ );
+ if (topLevel.length <= 1) return [];
+ const asGroups = modules.map((m) => segments(m.name));
+ const isModulePath = (path: readonly string[]) => asGroups.some((g) => same(g, path));
+
+ const moduleNode = (m: Module): ExtraRoot => {
+ const label = nameOf(m.dir) || m.dir;
+ return { id: m.name, label, detail: m.name === label ? undefined : m.name, icon: "gradle-module", path: m.dir };
+ };
+ // `modulesAndGroups`: ungrouped top-level modules as they are (the project folder is
+ // shown anyway), one node for the common group path of the grouped ones.
+ const loose = topLevel.filter((m) => !groupOf(m).length && m.dir !== projectRoot).map(moduleNode);
+ const grouped = topLevel.map(groupOf).filter((g) => g.length);
+ if (!grouped.length) return loose.sort(byLabel);
+ let common = grouped[0]!;
+ for (const g of grouped.slice(1)) {
+ let n = 0;
+ while (n < Math.min(common.length, g.length) && common[n] === g[n]) n++;
+ common = common.slice(0, n);
+ }
+ const tops = common.length ? [common] : [...new Map(grouped.map((g) => [g[0]!, [g[0]!]])).values()];
+
+ const node = (group: readonly string[]): ExtraRoot => {
+ // `childGroups`: direct subgroups not named like a module (those fold into this group).
+ const childGroups = new Map<string, string[]>();
+ for (const m of modules) {
+ const g = groupOf(m);
+ const direct = [...group, g[group.length]!];
+ if (isChild(group, g) && !isModulePath(direct)) childGroups.set(direct.join("."), direct);
+ }
+ // `modulesInGroup`: this group's modules, and those under a subgroup named like a module.
+ const members = modules.filter((m) => {
+ const g = groupOf(m);
+ return same(g, group) || (isChild(group, g) && isModulePath(g.slice(0, group.length + 1)));
+ });
+ const seen = new Set<string>();
+ const moduleNodes = members.filter((m) => !seen.has(m.dir) && !!seen.add(m.dir)).map(moduleNode);
+ return {
+ id: `gradleGroup:${group.join(".")}`,
+ label: group[group.length - 1]!,
+ icon: "gradle-project",
+ children: [...[...childGroups.values()].map(node).sort(byLabel), ...moduleNodes.sort(byLabel)],
+ };
+ };
+ return [...tops.map(node), ...loose.sort(byLabel)];
+}
diff --git a/src/features/run/application.ts b/src/features/run/application.ts
index 9be6396ab..b77cc1f00 100644
--- a/src/features/run/application.ts
+++ b/src/features/run/application.ts
@@ -5,14 +5,21 @@
*/
import type { RunConfig } from "@/platform/ipc";
import { CLASSPATH, TEST_CLASSPATH, jvmModuleDir } from "@/platform/javaLaunch";
-import { isTestPath } from "@/platform/languageSettings";
+import { isTestPath, rootFor } from "@/platform/languageSettings";
import { currentRoots } from "@/platform/projectRoots";
import { simpleClassName } from "./jvmTargets";
export { jvmModuleDir } from "@/platform/javaLaunch";
-/** In a test source root (detected or marked in Project Structure), or Maven's `src/test`. */
-const isTestSource = (relPath: string) => /(^|\/)src\/test\//.test(relPath) || isTestPath(currentRoots(), relPath);
+/**
+ * In a test source root, as IDEA's `getClasspathType` decides: the root holding the file
+ * (synced from Gradle, detected or marked in Project Structure) wins; `src/test` only
+ * while no root is known for the file.
+ */
+const isTestSource = (relPath: string) => {
+ const roots = currentRoots();
+ return rootFor(roots, relPath) ? isTestPath(roots, relPath) : /(^|\/)src\/test\//.test(relPath);
+};
/** Temporary "Application" configuration that runs `className` (a binary name). */
export function applicationConfig(
diff --git a/src/features/run/contextRun.ts b/src/features/run/contextRun.ts
index 742e6a7c0..be9e39187 100644
--- a/src/features/run/contextRun.ts
+++ b/src/features/run/contextRun.ts
@@ -8,6 +8,8 @@ import { activeEditor } from "@/editor/api";
import { executeAction, getAction } from "@/platform/actions";
import { call, commands, isTauri, type RunConfig } from "@/platform/ipc";
import { useProject } from "@/platform/project";
+import { validateProjectStructure } from "@/platform/languageSettings";
+import { useBuildModel } from "@/platform/buildModel";
import { isVirtualUri } from "@/platform/virtualDocs";
import { showContextMenu, type MenuItem } from "@/ui";
import {
@@ -42,6 +44,31 @@ async function ensureConfigs() {
}
/** The focused editor's file, text and caret line. */
+/** Project folders outside its root: Project Structure content roots and Gradle modules (as of the last sync). */
+export function projectContentRoots(): string[] {
+ const own = validateProjectStructure(useProject.getState().settings?.projectStructure).contentRoots;
+ // The build model keeps the folders of modules outside the project absolute.
+ const gradle = (useBuildModel.getState().model?.gradle?.projects ?? [])
+ .map((p) => p.dir)
+ .filter((d) => isAbsolute(d));
+ return [...new Set([...own, ...gradle])];
+}
+
+const isAbsolute = (p: string) => p.startsWith("/") || /^[A-Za-z]:[\\/]/.test(p);
+
+/**
+ * The project side of every run input (editor, gutter, menus, actions): built in one place
+ * so no entry point runs a project file as a stray one.
+ */
+export function projectContext(): Pick<ContextInput, "root" | "configs" | "goModule" | "contentRoots"> {
+ return {
+ root: useProject.getState().project?.root ?? null,
+ configs: useRun.getState().configs,
+ goModule: goModulePath,
+ contentRoots: projectContentRoots(),
+ };
+}
+
export function editorInput(): ContextInput | null {
const path = maybeEditorService()?.activePath() ?? activeEditor()?.ctx.path ?? null;
if (!path || isVirtualUri(path)) return null;
@@ -49,12 +76,10 @@ export function editorInput(): ContextInput | null {
const same = editor && editor.ctx.path === path;
const state = same ? editor.view.state : null;
return {
+ ...projectContext(),
path,
- root: useProject.getState().project?.root ?? null,
- configs: useRun.getState().configs,
content: state ? state.doc.sliceString(0, CONTENT_LIMIT) : undefined,
line: state ? state.doc.lineAt(state.selection.main.head).number - 1 : undefined,
- goModule: goModulePath,
};
}
@@ -148,7 +173,7 @@ export async function compiledDebugPlan(config: RunConfig): Promise<Produced | n
} catch {
return null;
}
- const input: ContextInput = { path, root, configs: useRun.getState().configs, content };
+ const input: ContextInput = { ...projectContext(), root, path, content };
const env = await toolEnv(neededTools(input), path, root, false);
if (m[2]) {
// A test: find the target by name again.
@@ -262,13 +287,11 @@ function contextArg(arg: unknown): (ContextInput & { dir?: boolean }) | null {
const editor = activeEditor();
const state = editor && editor.ctx.path === a.path ? editor.view.state : null;
return {
+ ...projectContext(),
path: a.path,
dir: a.dir,
- root: useProject.getState().project?.root ?? null,
- configs: useRun.getState().configs,
content: a.content ?? state?.doc.sliceString(0, CONTENT_LIMIT) ?? peekContent(a.path),
line: a.line,
- goModule: goModulePath,
};
}
@@ -327,12 +350,11 @@ export function contextMenuItems(menu: ContextMenuId, ctx: MenuGroupContext): Me
const content = ctx.text ?? peekContent(path);
const line = menu === "editor" ? ctx.line : undefined;
const input: ContextInput = {
- path,
+ ...projectContext(),
root,
- configs: useRun.getState().configs,
+ path,
content: content?.slice(0, CONTENT_LIMIT),
line,
- goModule: goModulePath,
};
const p = dir ? produceDirectory(input) : produceContext(input, OPTIMISTIC);
if (!p) return [];
diff --git a/src/features/run/gradleRun.gradle b/src/features/run/gradleRun.gradle
new file mode 100644
index 000000000..e47cf7740
--- /dev/null
+++ b/src/features/run/gradleRun.gradle
@@ -0,0 +1,31 @@
+// OpenIDEA: runs a main class on its Gradle source set's runtime classpath, like IntelliJ
+// IDEA's "Build and run using: Gradle" (ApplicationTaskInitScript.gradle). Parameters come
+// as system properties so this file never changes: see `gradleRun.ts`.
+import groovy.json.JsonSlurper
+
+def target = System.getProperty('openidea.run.project')
+if (target != null) {
+ allprojects { p ->
+ // `target` is an identity path (`:lib:core` for a project of an included build).
+ def id = { try { p.identityPath.toString() } catch (ignored) { p.path } }
+ if (id() != target) return
+ p.plugins.withId('java') {
+ def json = new JsonSlurper()
+ def list = { String key -> (List) json.parseText(System.getProperty(key, '[]')) }
+ p.tasks.register('openideaRun', JavaExec) { t ->
+ t.description = 'Runs a main class for OpenIDEA.'
+ t.classpath = p.sourceSets.getByName(System.getProperty('openidea.run.sourceSet', 'main')).runtimeClasspath
+ t.mainClass.set(System.getProperty('openidea.run.main'))
+ t.args(list('openidea.run.args'))
+ t.jvmArgs(list('openidea.run.jvmArgs'))
+ // The IDE attaches to this JVM, not to the Gradle daemon; port 0 prints the one picked.
+ if (Boolean.getBoolean('openidea.run.debug')) {
+ t.jvmArgs('-agentlib:jdwp=transport=dt_socket,server=y,suspend=y,address=127.0.0.1:0')
+ }
+ def dir = System.getProperty('openidea.run.workingDir')
+ if (dir) t.workingDir = dir
+ t.standardInput = System.in
+ }
+ }
+ }
+}
diff --git a/src/features/run/gradleRun.test.ts b/src/features/run/gradleRun.test.ts
new file mode 100644
index 000000000..27584d19e
--- /dev/null
+++ b/src/features/run/gradleRun.test.ts
@@ -0,0 +1,124 @@
+import { describe, expect, it } from "vitest";
+import type { GradleModel, RunConfig } from "@/platform/ipc";
+import { applicationConfig } from "./application";
+import { DELEGATED_DEBUG, delegatedGradleConfig, wrapperGradleVersion } from "./gradleRun";
+import { jdwpLaunch } from "./javaDebug";
+import { isJvmApplication } from "@/platform/javaLaunch";
+
+const ROOT = "/w/shop";
+const CORE = "/w/billing/modules/core";
+const gradle = {
+ dir: "",
+ command: "/w/shop/gradlew",
+ env: { JAVA_HOME: "/jdk21" },
+ projects: [
+ { path: ":", name: "Shop", dir: "", buildFile: null, tasks: [] },
+ { path: ":billing:core", name: "core", dir: CORE, buildFile: null, tasks: [] },
+ { path: ":app", name: "app", dir: "app", buildFile: null, tasks: [] },
+ ],
+} as unknown as GradleModel;
+const ctx = {
+ root: ROOT,
+ gradle,
+ script: "/tmp/openidea-gradle-run.gradle",
+ offline: false,
+ configurationCache: false,
+};
+
+describe("Build and run using: Gradle", () => {
+ it("runs an Application of an includeFlat module as its JavaExec task", () => {
+ const app: RunConfig = {
+ ...applicationConfig(
+ { className: "com.example.ShopApplication", spring: true },
+ `${CORE}/src/main/java/com/example/ShopApplication.java`,
+ [],
+ ),
+ args: ["-Xmx1g", "-cp", "${classpath}", "com.example.ShopApplication", "--port", "8081 x"],
+ env: { SPRING_PROFILES_ACTIVE: "dev" },
+ };
+ const run = delegatedGradleConfig(app, CORE, ctx)!;
+ expect(run).toMatchObject({
+ kind: "gradle",
+ name: "ShopApplication",
+ command: "/w/shop/gradlew",
+ cwd: null,
+ module: CORE,
+ env: { JAVA_HOME: "/jdk21", SPRING_PROFILES_ACTIVE: "dev" },
+ });
+ expect(run.args).toEqual([
+ "--console=plain",
+ "--init-script",
+ "/tmp/openidea-gradle-run.gradle",
+ "-Dopenidea.run.project=:billing:core",
+ "-Dopenidea.run.main=com.example.ShopApplication",
+ "-Dopenidea.run.sourceSet=main",
+ '-Dopenidea.run.args=["--port","8081 x"]',
+ '-Dopenidea.run.jvmArgs=["-Xmx1g"]',
+ `-Dopenidea.run.workingDir=${CORE}`,
+ ":billing:core:openideaRun",
+ ]);
+ });
+
+ it("uses the test classpath, a project-relative module and offline mode", () => {
+ const test = applicationConfig({ className: "a.Tool" }, "app/src/test/java/a/Tool.java", []);
+ const run = delegatedGradleConfig(test, "app", { ...ctx, offline: true })!;
+ expect(run.args).toContain("-Dopenidea.run.sourceSet=test");
+ expect(run.args).toContain("-Dopenidea.run.workingDir=/w/shop/app");
+ expect(run.args.slice(-2)).toEqual(["--offline", ":app:openideaRun"]);
+ });
+
+ it("reuses Gradle's configuration cache on Gradle 8.1+ wrappers", () => {
+ const app = applicationConfig({ className: "a.Main" }, "app/src/main/java/a/Main.java", []);
+ const run = delegatedGradleConfig(app, "app", { ...ctx, configurationCache: true })!;
+ expect(run.args.slice(-3)).toEqual([
+ "--configuration-cache",
+ "--configuration-cache-problems=warn",
+ ":app:openideaRun",
+ ]);
+ const props = (url: string) => `distributionBase=GRADLE_USER_HOME\ndistributionUrl=${url}\n`;
+ expect(wrapperGradleVersion(props("https\\://services.gradle.org/distributions/gradle-8.10.2-bin.zip"))).toEqual([
+ 8, 10,
+ ]);
+ expect(wrapperGradleVersion(props("https://x/gradle-7.6-all.zip"))).toEqual([7, 6]);
+ expect(wrapperGradleVersion("# no distribution\n")).toBeNull();
+ });
+
+ it("leaves mains outside the build's modules to the language server", () => {
+ const stray = applicationConfig({ className: "x.Main" }, "/elsewhere/src/main/java/x/Main.java", []);
+ expect(delegatedGradleConfig(stray, "/elsewhere", ctx)).toBeNull();
+ });
+
+ it("runs included builds' modules by identity path, never buildSrc's", () => {
+ const nested = {
+ ...ctx,
+ gradle: {
+ ...gradle,
+ projects: [
+ ...gradle.projects,
+ { path: ":lib:core", name: "core", dir: "/w/lib/core", buildFile: null, tasks: [], build: ":lib" },
+ { path: ":buildSrc", name: "buildSrc", dir: "buildSrc", buildFile: null, tasks: [], build: ":buildSrc" },
+ ],
+ },
+ };
+ const main = (file: string) => applicationConfig({ className: "a.Main" }, file, []);
+ const lib = delegatedGradleConfig(main("/w/lib/core/src/main/java/a/Main.java"), "/w/lib/core", nested)!;
+ expect(lib.args.at(-1)).toBe(":lib:core:openideaRun");
+ expect(delegatedGradleConfig(main("buildSrc/src/main/java/a/Main.java"), "buildSrc", nested)).toBeNull();
+ });
+
+ it("is a Gradle run from then on: never delegated twice, the Application's params dropped", () => {
+ const app = { ...applicationConfig({ className: "a.Main" }, "app/src/main/java/a/Main.java", []) };
+ const run = delegatedGradleConfig({ ...app, params: { vmOptions: "-Xmx1g" } }, "app", ctx)!;
+ expect(isJvmApplication(run)).toBe(false);
+ expect(run.params).toBeUndefined();
+ });
+
+ it("debugs the forked JVM: the init script adds the agent", () => {
+ const app = applicationConfig({ className: "a.Main" }, "app/src/main/java/a/Main.java", []);
+ const run = delegatedGradleConfig(app, "app", ctx)!;
+ const debug = jdwpLaunch(run)!;
+ expect(debug.args.at(-1)).toBe(DELEGATED_DEBUG);
+ expect(debug.args).not.toContain("--debug-jvm");
+ expect(jdwpLaunch(debug)!.args.filter((a) => a === DELEGATED_DEBUG)).toHaveLength(1);
+ });
+});
diff --git a/src/features/run/gradleRun.ts b/src/features/run/gradleRun.ts
new file mode 100644
index 000000000..43a605007
--- /dev/null
+++ b/src/features/run/gradleRun.ts
@@ -0,0 +1,134 @@
+/**
+ * IDEA's "Build and run using: Gradle": an Application / Spring Boot configuration of a
+ * Gradle module keeps its settings, only its launch becomes a Gradle run of a `JavaExec`
+ * task (`gradleRun.gradle`) on the source set's runtime classpath. Gradle compiles the
+ * module and its dependencies and processes resources first; the debugger attaches to
+ * the forked JVM (`-Dopenidea.run.debug`), not to the Gradle daemon.
+ */
+import RUN_SCRIPT from "./gradleRun.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 { useProject } from "@/platform/project";
+
+/** System property that marks a delegated run (read by `jdwpLaunch` to add the debug flag). */
+export const DELEGATED_MAIN = "-Dopenidea.run.main=";
+export const DELEGATED_DEBUG = "-Dopenidea.run.debug=true";
+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 interface DelegationContext {
+ /** Project root. */
+ root: string;
+ gradle: GradleModel;
+ /** Absolute path of the written `gradleRun.gradle`. */
+ script: string;
+ offline: boolean;
+ /**
+ * Gradle's configuration cache: a repeated launch skips configuring the build (about half of
+ * Gradle's share of a warm start). Only for Gradle 8.1+, where it is stable.
+ */
+ configurationCache: boolean;
+}
+
+/** Major / minor of the wrapper's `distributionUrl` (`gradle-8.10.2-bin.zip`), null when unknown. */
+export function wrapperGradleVersion(properties: string): [number, number] | null {
+ const m = /^\s*distributionUrl\s*=.*gradle-(\d+)\.(\d+)/m.exec(properties);
+ return m ? [Number(m[1]), Number(m[2])] : null;
+}
+
+const atLeast = (v: [number, number] | null, major: number, minor: number) =>
+ !!v && (v[0] > major || (v[0] === major && v[1] >= minor));
+
+/**
+ * The Gradle run of `config`, or null when it is not an Application of a module of this
+ * Gradle build (`module`: its folder, project-relative or absolute).
+ */
+export function delegatedGradleConfig(config: RunConfig, module: string, ctx: DelegationContext): RunConfig | null {
+ const parsed = parseJavaArgs(config.args);
+ if (!parsed.mainClass) return null;
+ const dir = absolute(ctx.root, module);
+ const project = ctx.gradle.projects.find((p) => absolute(ctx.root, p.dir) === dir);
+ // buildSrc tasks are not addressable from the root build; included builds' are (`:lib:core:…`).
+ if (!project || project.build?.endsWith(":buildSrc")) return null;
+ const task = project.path === ":" ? `:${TASK}` : `${project.path}:${TASK}`;
+ const args = [
+ "--console=plain",
+ "--init-script",
+ ctx.script,
+ `-Dopenidea.run.project=${project.path}`,
+ `${DELEGATED_MAIN}${parsed.mainClass}`,
+ `-Dopenidea.run.sourceSet=${parsed.classpath === "test" ? "test" : "main"}`,
+ `-Dopenidea.run.args=${JSON.stringify(parsed.programArgs)}`,
+ `-Dopenidea.run.jvmArgs=${JSON.stringify(parsed.vmArgs)}`,
+ `-Dopenidea.run.workingDir=${config.cwd ? absolute(ctx.root, config.cwd) : dir}`,
+ ...(ctx.offline ? ["--offline"] : []),
+ // Problems only warn: a build with incompatible plugins still runs, uncached.
+ ...(ctx.configurationCache ? ["--configuration-cache", "--configuration-cache-problems=warn"] : []),
+ task,
+ ];
+ // 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 {
+ ...rest,
+ kind: "gradle",
+ command: ctx.gradle.command,
+ args,
+ cwd: ctx.gradle.dir || null,
+ // The Gradle JVM's JAVA_HOME first; the configuration's own environment wins.
+ env: { ...ctx.gradle.env, ...config.env },
+ module: module,
+ };
+}
+
+/** Writes the init script where Gradle can read it; it never changes, so once per session. */
+let scriptPath: Promise<string> | null = null;
+function writeScript(): Promise<string> {
+ scriptPath ??= (async () => {
+ const { tempDir, join } = await import("@tauri-apps/api/path");
+ const path = await join(await tempDir(), "openidea-gradle-run.gradle");
+ await call(commands.fsDelete(path)).catch(() => {});
+ await call(commands.fsCreateFileBytes(path, Array.from(new TextEncoder().encode(RUN_SCRIPT))));
+ return path;
+ })().catch((e) => {
+ scriptPath = null;
+ throw e;
+ });
+ return scriptPath;
+}
+
+/**
+ * The launch of an Application / Spring Boot `config` through Gradle, when the project
+ * runs with Gradle (Settings › Build Tools › Gradle) and the main class is in one of its
+ * modules; null to launch it on the language server's classpath.
+ */
+export async function gradleDelegation(config: RunConfig): Promise<RunConfig | null> {
+ if (!isTauri() || !isJvmApplication(config)) return null;
+ const { project, settings } = useProject.getState();
+ if (!project?.root || settings?.languages?.java?.gradle?.runUsing === "ide") return null;
+ const { model, gradleOffline } = useBuildModel.getState();
+ if (!model?.gradle) return null;
+ const module = config.module ?? (await findJavaModule(config));
+ if (module === null) return null;
+ const ctx = {
+ root: project.root,
+ gradle: model.gradle,
+ script: "",
+ offline: gradleOffline,
+ configurationCache: false,
+ };
+ if (!delegatedGradleConfig(config, module, ctx)) return null;
+ const [script, configurationCache] = await Promise.all([writeScript(), supportsConfigurationCache(ctx)]);
+ return delegatedGradleConfig(config, module, { ...ctx, script, configurationCache });
+}
+
+/** The wrapper's Gradle is 8.1+ (a local or PATH Gradle's version is not known here). */
+async function supportsConfigurationCache(ctx: Pick<DelegationContext, "root" | "gradle">): Promise<boolean> {
+ if (!/(^|[/\\])gradlew(\.bat)?$/.test(ctx.gradle.command)) return false;
+ const props = `${absolute(ctx.root, ctx.gradle.dir)}/gradle/wrapper/gradle-wrapper.properties`;
+ const text = await call(commands.fsReadText(props)).catch(() => "");
+ return atLeast(wrapperGradleVersion(text), 8, 1);
+}
diff --git a/src/features/run/index.ts b/src/features/run/index.ts
index 71de5b36e..0e16b4db1 100644
--- a/src/features/run/index.ts
+++ b/src/features/run/index.ts
@@ -47,6 +47,7 @@ import { isDebugOnly, registerBuiltinTypes } from "./types";
import { listenForApplicationDeactivation, showApplicationUpdate, updatableSessions } from "./applicationUpdate";
import { npmGutter } from "./npmGutter";
import { runGutter } from "./runGutter";
+import { gradleDelegation } from "./gradleRun";
import { activateStackTrace, useStackTraces } from "./stackTrace";
import { clearRuntimeCache } from "./runtimes";
import {
@@ -119,6 +120,12 @@ async function debugConfig(config: RunConfig, chain: readonly string[] = []) {
await launchProduced(compiled, true);
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;
+ if (delegated) {
+ await debugWithAgent(delegated);
+ return;
+ }
// Maven / Gradle: the build tool starts the JVM with a debug agent, the debugger attaches.
if (jdwpLaunch(config) && getAction("debug.attach")) {
await debugWithAgent(config);
diff --git a/src/features/run/java.test.ts b/src/features/run/java.test.ts
index 161e1017a..4ea7b7cd2 100644
--- a/src/features/run/java.test.ts
+++ b/src/features/run/java.test.ts
@@ -140,6 +140,17 @@ describe("application configurations", () => {
expect(jvmModuleDir("odd/App.java", [cfg({ id: "m", kind: "maven", cwd: "odd" })])).toBe("odd");
});
+ it("takes the innermost module the build model knows, like IDEA's file index", () => {
+ const modules = ["", "/w/billing", "/w/billing/modules/core", "legacy"];
+ // `sourceSets.main.java.srcDirs = ['src']`: no `src/main/java` to guess from.
+ expect(jvmModuleDir("legacy/src/a/App.java", [], modules)).toBe("legacy");
+ expect(jvmModuleDir("/w/billing/modules/core/src/main/java/a/App.java", [], modules)).toBe(
+ "/w/billing/modules/core",
+ );
+ // A module the model does not know yet (before the first sync): the source layout.
+ expect(jvmModuleDir("services/api/src/main/java/a/App.java", [], modules)).toBe("services/api");
+ });
+
it("adds JDWP to a script explicitly assigned the Kotlin debugger", () => {
const rc = cfg({ id: "kotlin-script", kind: "shell", command: "./run.sh", debugAdapter: "kotlin-debug-adapter" });
expect(jdwpLaunch(rc)?.env.JAVA_TOOL_OPTIONS).toContain("-agentlib:jdwp=");
diff --git a/src/features/run/javaDebug.ts b/src/features/run/javaDebug.ts
index e62c82be4..1932608cb 100644
--- a/src/features/run/javaDebug.ts
+++ b/src/features/run/javaDebug.ts
@@ -12,6 +12,7 @@ import { executeAction } from "@/platform/actions";
import type { RunConfig } from "@/platform/ipc";
import { isJvmApplication, JDWP_AGENT, jdwpListeningPort } from "@/platform/javaLaunch";
import { startRun, useRun } from "./store";
+import { DELEGATED_DEBUG, DELEGATED_MAIN } from "./gradleRun";
const isMavenTestGoal = (a: string) =>
/^(test|verify|integration-test|surefire:test|failsafe:integration-test)$/.test(a);
@@ -55,6 +56,9 @@ export function jdwpLaunch(config: RunConfig): RunConfig | null {
return null;
}
if (config.kind === "gradle" || /(^|\/)gradlew?(\.bat)?$/.test(config.command)) {
+ // A delegated Application: its init script adds the agent (port 0) to the JavaExec JVM.
+ if (args.some((a) => a.startsWith(DELEGATED_MAIN)))
+ return args.includes(DELEGATED_DEBUG) ? config : { ...config, args: [...args, DELEGATED_DEBUG] };
if (!args.some(isGradleJvmTask)) return null;
return args.includes("--debug-jvm") ? config : { ...config, args: [...args, "--debug-jvm"] };
}
@@ -74,7 +78,8 @@ export async function debugWithAgent(config: RunConfig): Promise<boolean> {
const runId = useRun.getState().sessions.find((s) => s.id === sessionId)?.runId ?? null;
void executeAction("debug.attach", {
name: config.name,
- module: config.cwd ?? "",
+ // The application's module (a delegated run's working directory is the Gradle build).
+ module: config.module ?? config.cwd ?? "",
hostName: "127.0.0.1",
port,
process: runId,
diff --git a/src/features/run/producers.test.ts b/src/features/run/producers.test.ts
index 2fb9cb445..4e73b7583 100644
--- a/src/features/run/producers.test.ts
+++ b/src/features/run/producers.test.ts
@@ -309,6 +309,28 @@ describe("single-file producers (scratches)", () => {
expect(p.config!.args.at(-1)).toBe("demo.Hi");
});
+ it("Java: a main in a Gradle module outside the project runs on the module's classpath", () => {
+ // `includeFlat 'billing'`: the module folder is a sibling of the project folder.
+ const svc = "/work/billing/modules/core";
+ const boot =
+ "package com.example;\nimport org.springframework.boot.SpringApplication;\n@SpringBootApplication\n" +
+ "public class ShopApplication {\n public static void main(String[] args) {\n" +
+ " SpringApplication.run(ShopApplication.class, args);\n }\n}";
+ const gradle = [cfg({ id: "gradle:test", kind: "gradle", command: "./gradlew", args: ["test"], isTest: true })];
+ const input = (contentRoots?: string[]) => ({
+ path: `${svc}/src/main/java/com/example/ShopApplication.java`,
+ root: ROOT,
+ configs: gradle,
+ content: boot,
+ line: 4,
+ contentRoots,
+ });
+ expect(produceContext(input(), ALL)!.config!.kind).toBe("java-file");
+ const p = produceContext(input(["/work/billing", svc]), ALL)!;
+ expect(p.config).toMatchObject({ kind: "spring-boot", module: svc, cwd: svc });
+ expect(p.config!.args).toEqual(["-cp", "${classpath}", "com.example.ShopApplication"]);
+ });
+
describe("Java / Kotlin mains in a build nested in a folder of repositories", () => {
// RuoYi-Vue-Plus (Maven) next to plus-ui (npm), opened together.
const boot =
diff --git a/src/features/run/producers.ts b/src/features/run/producers.ts
index c0425628f..efed66bd7 100644
--- a/src/features/run/producers.ts
+++ b/src/features/run/producers.ts
@@ -56,6 +56,12 @@ export interface ContextInput {
goModule?: (dir: string) => string | null | undefined;
/** 0-based caret line: the element at the caret wins over the file. */
line?: number;
+ /**
+ * Absolute folders outside `root` that belong to the project (IDEA's module content
+ * roots: `includeFlat` Gradle modules, Project Structure roots); their files run like
+ * the project's own, through its build.
+ */
+ contentRoots?: readonly string[];
}
export interface Missing {
@@ -363,8 +369,14 @@ interface FileSite {
inProject: boolean;
}
+/** In the project folder or one of its content roots: run through the project's build. */
+function isProjectPath(input: Pick<ContextInput, "path" | "root" | "contentRoots">): boolean {
+ if (!input.root) return false;
+ return [input.root, ...(input.contentRoots ?? [])].some((r) => inProject(input.path, r));
+}
+
function site(input: ContextInput): FileSite {
- const inside = inProject(input.path, input.root);
+ const inside = isProjectPath(input);
const rel = relTo(input.path, input.root);
return {
idPath: rel,
@@ -809,8 +821,11 @@ export function standaloneTargets(content: string, path: string): RunTarget[] {
}
/** Run targets of a file for the caret / gutter: project-aware inside the project, standalone outside. */
-export function fileTargets(input: Pick<ContextInput, "path" | "root" | "configs">, content: string): RunTarget[] {
- const s = { inProject: inProject(input.path, input.root), rel: relTo(input.path, input.root) };
+export function fileTargets(
+ input: Pick<ContextInput, "path" | "root" | "configs" | "contentRoots">,
+ content: string,
+): RunTarget[] {
+ const s = { inProject: isProjectPath(input), rel: relTo(input.path, input.root) };
const rust = /\.rs$/.test(input.path);
if (/\.(c|cpp|cc|cxx)$/.test(input.path)) return standaloneTargets(content, input.path);
const cargo =
@@ -879,8 +894,7 @@ export function produceContext(input: ContextInput, env: ToolEnv): Produced | nu
*/
export function produceContextChoices(input: ContextInput, env: ToolEnv): Produced[] {
const produced = produceContext(input, env);
- if (!produced?.config || produced.scope === "directory" || !inProject(input.path, input.root))
- return produced ? [produced] : [];
+ if (!produced?.config || produced.scope === "directory" || !isProjectPath(input)) return produced ? [produced] : [];
const rel = relTo(input.path, input.root);
const cmake = cmakeTargets(input);
if (cmake.length > 1) return cmake.map((config) => ({ name: config.name, scope: produced.scope, config }));
@@ -907,7 +921,7 @@ export function produceContextChoices(input: ContextInput, env: ToolEnv): Produc
}
function cmakeTargets(input: ContextInput): RunConfig[] {
- if (!inProject(input.path, input.root)) return [];
+ if (!isProjectPath(input)) return [];
const lang = scriptLanguage(input.path, input.content);
if (lang !== "c" && lang !== "cpp") return [];
const rel = relTo(input.path, input.root);
@@ -921,7 +935,7 @@ const TEST_DIR = /(^|\/)(tests?|__tests__|specs?|test_?\w*)$/;
export function produceDirectory(input: ContextInput): Produced | null {
const { root } = input;
- if (!root || !inProject(input.path, root) || input.path === root) return null;
+ if (!root || !isProjectPath(input) || input.path === root) return null;
const rel = relTo(input.path, root);
const name = baseName(rel);
const jvmRoot = /^(?:(.*)\/)?src\/test(?:\/(java|kotlin|scala|groovy))?$/.exec(rel);
diff --git a/src/features/run/runGutter.ts b/src/features/run/runGutter.ts
index 63836c683..0fe0e8b6a 100644
--- a/src/features/run/runGutter.ts
+++ b/src/features/run/runGutter.ts
@@ -12,8 +12,15 @@ import { isVirtualUri } from "@/platform/virtualDocs";
import { shortcutLabel } from "@/platform/keymap";
import { gutterIconMarkup, showContextMenu, type MenuItem } from "@/ui";
import { notifications, runExecutors } from "@/workbench/contributions";
-import { choiceItems, executeContext, launchProduced, modifyContext, produceResolved } from "./contextRun";
-import { goModulePath, loadGoModules } from "./goModules";
+import {
+ choiceItems,
+ executeContext,
+ launchProduced,
+ modifyContext,
+ produceResolved,
+ projectContext,
+} from "./contextRun";
+import { loadGoModules } from "./goModules";
import { fileTargets, OPTIMISTIC, produceContextChoices, type ContextInput } from "./producers";
import { loadConfigs, useRun } from "./store";
import { targetLanguage, type RunTarget } from "./targets";
@@ -52,14 +59,7 @@ const targetsField = StateField.define<PlacedTarget[]>({
});
function targetInput(path: string, content: string, line: number): ContextInput {
- return {
- path,
- root: useProject.getState().project?.root ?? null,
- configs: useRun.getState().configs,
- content,
- line,
- goModule: goModulePath,
- };
+ return { ...projectContext(), path, content, line };
}
async function launch(target: RunTarget, path: string, debug: boolean, content: string) {
@@ -197,8 +197,7 @@ export function runGutter(ctx: EditorDocContext): Extension {
if (!useProject.getState().project?.root || isVirtualUri(path) || !hasGutterTargets(path)) return [];
if (/\.go$/.test(path))
void loadGoModules(useProject.getState().project?.root ?? null, useRun.getState().configs).catch(() => {});
- const detect = (text: string) =>
- fileTargets({ path, root: useProject.getState().project?.root ?? null, configs: useRun.getState().configs }, text);
+ const detect = (text: string) => fileTargets({ ...projectContext(), path }, text);
const detector = ViewPlugin.fromClass(
class {
diff --git a/src/features/run/store.ts b/src/features/run/store.ts
index b01914472..90d22e7be 100644
--- a/src/features/run/store.ts
+++ b/src/features/run/store.ts
@@ -53,6 +53,7 @@ import { typeFor } from "./types";
import { recordRun } from "./services";
import { startedPort } from "./serverPort";
import { tomcatBrowserUrl } from "./tomcat";
+import { gradleDelegation } from "./gradleRun";
import { openUrl } from "./navigate";
import { tx } from "@/platform/i18n";
@@ -661,7 +662,11 @@ export async function startRun(
};
try {
let launch = options.launch ?? config;
- if (isJvmApplication(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;
+ if (delegated) launch = delegated;
+ else if (isJvmApplication(launch)) {
const resolved = await resolveJvmApplication(sessionId, launch);
if (runtimes.get(sessionId)?.generation !== generation) return getSession(sessionId) ?? null;
if (!resolved) {
diff --git a/src/features/settings/languages/LanguagePages.tsx b/src/features/settings/languages/LanguagePages.tsx
index aef56ed21..8357c2304 100644
--- a/src/features/settings/languages/LanguagePages.tsx
+++ b/src/features/settings/languages/LanguagePages.tsx
@@ -318,9 +318,24 @@ export function JavaPage() {
export function GradlePage() {
const [distribution, setDistribution] = useSetting<string>("languages.java.gradle.distribution");
+ const [runUsing, setRunUsing] = useSetting<string>("languages.java.gradle.runUsing");
return (
<div className={styles.page}>
<Section>
+ <Row
+ label="Build and run using"
+ hint="Gradle runs a main class as a JavaExec task on its source set's runtime classpath (Gradle's resource processing included). OpenIDEA launches it on the Java language server's classpath."
+ >
+ <Select
+ value={runUsing || "gradle"}
+ onChange={setRunUsing}
+ aria-label="Build and run using"
+ options={[
+ { value: "gradle", label: "Gradle" },
+ { value: "ide", label: "OpenIDEA" },
+ ]}
+ />
+ </Row>
<SdkRow
k="languages.java.gradle.jvm"
label="Gradle JVM"
diff --git a/src/features/settings/pages/execution.tsx b/src/features/settings/pages/execution.tsx
index 3498655c9..a35358170 100644
--- a/src/features/settings/pages/execution.tsx
+++ b/src/features/settings/pages/execution.tsx
@@ -118,6 +118,9 @@ export const EXECUTION_PAGES: PageSpec[] = [
group: BUILD_GROUP,
order: 358,
keywords: [
+ "Build and run using",
+ "delegate",
+ "JavaExec",
"Gradle JVM",
"JDK",
"JAVA_HOME",
diff --git a/src/platform/buildModel.ts b/src/platform/buildModel.ts
new file mode 100644
index 000000000..2e2d992b5
--- /dev/null
+++ b/src/platform/buildModel.ts
@@ -0,0 +1,16 @@
+/**
+ * The open project's build model as the Maven / Gradle tool windows last loaded it, for the
+ * features that follow the build (run, Project view) without loading it again.
+ */
+import { create } from "zustand";
+import type { BuildModel } from "./ipc";
+
+export interface SharedBuildModel {
+ /** Project the model belongs to. */
+ root: string | null;
+ model: BuildModel | null;
+ /** Gradle tool window's "Offline" toggle. */
+ gradleOffline: boolean;
+}
+
+export const useBuildModel = create<SharedBuildModel>(() => ({ root: null, model: null, gradleOffline: false }));
diff --git a/src/platform/javaLaunch.ts b/src/platform/javaLaunch.ts
index 75c57eefb..e35f8b245 100644
--- a/src/platform/javaLaunch.ts
+++ b/src/platform/javaLaunch.ts
@@ -6,6 +6,7 @@
*/
import { call, commands, IpcError, type JavaLaunchInfo, type RunConfig, type RequestId } from "@/platform/ipc";
import { tx } from "@/platform/i18n";
+import { useBuildPresentation } from "@/platform/projectPresentation";
export const CLASSPATH = "${classpath}";
export const TEST_CLASSPATH = "${testClasspath}";
@@ -117,11 +118,19 @@ export function jdwpListeningPort(line: string): number | null {
}
/**
- * Module directory (relative to the project root, `""` for the root) of a JVM
- * source file: the part before `src/{main,test}/…`, else the working directory
- * of the closest Maven / Gradle configuration.
+ * Module directory (relative to the project root, `""` for the root; absolute for a
+ * module outside it) of a JVM source file. Like IDEA's `ProjectFileIndex.getModuleForFile`:
+ * the innermost Maven / Gradle module folder holding the file, as the build model knows
+ * them (`modules`). Before a model knows a deeper one: the part before
+ * `src/{main,test}/…`, else the working directory of the closest Maven / Gradle configuration.
*/
-export function jvmModuleDir(relPath: string, configs: readonly RunConfig[] = []): string {
+export function jvmModuleDir(
+ relPath: string,
+ configs: readonly RunConfig[] = [],
+ modules: Iterable<string> = useBuildPresentation.getState().modules.keys(),
+): string {
+ const owner = [...modules].filter((d) => d && relPath.startsWith(d + "/")).sort((a, b) => b.length - a.length)[0];
+ if (owner) return owner;
const m = /^(?:(.*)\/)?src\/(?:main|test|[\w-]+)\/(?:java|kotlin|scala|groovy)\//.exec(relPath);
if (m) return m[1] ?? "";
const cwds = configs
diff --git a/src/platform/languageSettings.ts b/src/platform/languageSettings.ts
index 248dbb7fa..e3cfe0f3e 100644
--- a/src/platform/languageSettings.ts
+++ b/src/platform/languageSettings.ts
@@ -80,7 +80,14 @@ export interface LanguagesValid {
jdk: string;
jdtlsJdk: string;
jdtlsVmArgs: string;
- gradle: { jvm: string; distribution: "wrapper" | "local"; home: string; userHome: string };
+ gradle: {
+ jvm: string;
+ distribution: "wrapper" | "local";
+ home: string;
+ userHome: string;
+ /** IDEA's "Build and run using": Gradle (`JavaExec`) or the IDE (the language server's classpath). */
+ runUsing: "gradle" | "ide";
+ };
maven: { home: string; userSettings: string; localRepository: string; unlinkedProjects: string[] };
};
/** Preview font size in px; `null` follows the editor font size. */
@@ -124,7 +131,7 @@ export const DEFAULT_LANGUAGES: LanguagesValid = {
jdk: "",
jdtlsJdk: "",
jdtlsVmArgs: "",
- gradle: { jvm: "", distribution: "wrapper", home: "", userHome: "" },
+ gradle: { jvm: "", distribution: "wrapper", home: "", userHome: "", runUsing: "gradle" },
maven: { home: "", userSettings: "", localRepository: "", unlinkedProjects: [] },
},
markdown: { previewFontSize: null },
@@ -250,6 +257,7 @@ export function validateLanguages(raw: unknown): LanguagesValid {
distribution: oneOf(gradle.distribution, ["wrapper", "local"] as const, d.java.gradle.distribution),
home: text(gradle.home, d.java.gradle.home),
userHome: text(gradle.userHome, d.java.gradle.userHome),
+ runUsing: oneOf(gradle.runUsing, ["gradle", "ide"] as const, d.java.gradle.runUsing),
},
maven: {
home: text(maven.home, d.java.maven.home),
diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json
index e468db291..4d6b52798 100644
--- a/src/platform/locales/text/zh.json
+++ b/src/platform/locales/text/zh.json
@@ -5703,5 +5703,7 @@
"Usage limits": "用量限额",
"The account's 5-hour and weekly limits, when the agent reports them (Claude Code)": "账户的 5 小时和每周限额,在智能体报告时显示(Claude Code)",
"Session cost": "会话花费",
- "What the session has cost so far, as the agent reports it (API pricing, also shown on subscriptions)": "智能体报告的本会话目前花费(按 API 价格计算,订阅账户也会显示)"
+ "What the session has cost so far, as the agent reports it (API pricing, also shown on subscriptions)": "智能体报告的本会话目前花费(按 API 价格计算,订阅账户也会显示)",
+ "Build and run using": "构建和运行使用",
+ "Gradle runs a main class as a JavaExec task on its source set's runtime classpath (Gradle's resource processing included). OpenIDEA launches it on the Java language server's classpath.": "Gradle 以 JavaExec 任务在源集的运行时类路径上运行主类(包括 Gradle 的资源处理)。OpenIDEA 在 Java 语言服务器的类路径上启动它。"
}
diff --git a/src/workbench/contributions.ts b/src/workbench/contributions.ts
index f53a2d48e..4f8d8df13 100644
--- a/src/workbench/contributions.ts
+++ b/src/workbench/contributions.ts
@@ -896,6 +896,8 @@ export interface ProjectViewRootContribution extends ProjectViewRootEntry {
order?: number;
/** Which project view mode lists it besides "Project" ("Scratches and Consoles"). */
scope?: "scratches";
+ /** Listed above the project folder (IDEA's module group of the build). */
+ beforeProject?: boolean;
}
export const useProjectViewRoots = create<{ roots: Map<string, ProjectViewRootContribution> }>(() => ({