The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix: Status refresh loop, double project open at startup, jdtls Java requirement (#5)
l0ng-ai63a03d1c0820
diff --git a/Cargo.lock b/Cargo.lockindex ed22c6b25..92ae7cbd3 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -4272,6 +4272,7 @@ dependencies = ["tempfile","toml 0.9.12+spec-1.1.0","tracing",+ "zip 2.4.2",][[package]]diff --git a/crates/ide-sdk/Cargo.toml b/crates/ide-sdk/Cargo.tomlindex 5ea28d80c..cce2ab5b1 100644--- a/crates/ide-sdk/Cargo.toml+++ b/crates/ide-sdk/Cargo.toml@@ -15,6 +15,7 @@ serde_json.workspace = truespecta.workspace = truetoml.workspace = truetracing.workspace = true+zip = { version = "=2.4.2", default-features = false, features = ["deflate"] }[dev-dependencies]tempfile.workspace = truediff --git a/crates/ide-sdk/src/java.rs b/crates/ide-sdk/src/java.rsindex 1f16029e2..c21c6eebe 100644--- a/crates/ide-sdk/src/java.rs+++ b/crates/ide-sdk/src/java.rs@@ -126,23 +126,101 @@ pub fn installed_jdks() -> Arc<[Jdk]> {}}-/// Like [`installed_jdks`], but while none can run jdtls the list is rescanned-/// (at most every [`RESCAN_AFTER`]), so a JDK installed after startup is picked-/// up when the server is restarted.-pub fn jdtls_jdks() -> Arc<[Jdk]> {+/// Like [`installed_jdks`], but while none can run jdtls (on Java `min_java`)+/// the list is rescanned (at most every [`RESCAN_AFTER`]), so a JDK installed+/// after startup is picked up when the server is restarted.+pub fn jdtls_jdks(min_java: u32) -> Arc<[Jdk]> {let mut slot = JDKS.lock().unwrap_or_else(|e| e.into_inner());match &*slot {- Some(s) if jdtls_runtime(&s.jdks).is_some() || s.at.elapsed() < RESCAN_AFTER => s.jdks.clone(),+ Some(s) if jdtls_runtime(&s.jdks, min_java).is_some() || s.at.elapsed() < RESCAN_AFTER => s.jdks.clone(),_ => rescan(&mut slot),}}-/// Oldest Java version jdtls itself runs on (projects may target older ones).+/// Oldest Java version jdtls runs on when its install can't tell (its launcher's check).pub const JDTLS_MIN_JAVA: u32 = 21;/// The JDK to run jdtls with: the first found that is new enough (`JAVA_HOME` wins).-pub fn jdtls_runtime(jdks: &[Jdk]) -> Option<&Jdk> {- jdks.iter().find(|j| j.major >= JDTLS_MIN_JAVA)+pub fn jdtls_runtime(jdks: &[Jdk], min_java: u32) -> Option<&Jdk> {+ jdks.iter().find(|j| j.major >= min_java)+}++/// The Java version the jdtls that `cfg` launches needs: the highest any of its+/// bundles requires, never below [`JDTLS_MIN_JAVA`]. Its launcher only checks+/// for 21, but the Eclipse platform it ships moves on (1.63 needs 25), and on+/// an older JDK the server dies resolving its bundles.+pub fn jdtls_min_java(cfg: &LanguageServerConfig) -> u32 {+ let search = cfg.env.get("PATH").map(std::ffi::OsString::from).or_else(|| std::env::var_os("PATH"));+ let required = search+ .and_then(|s| ide_run::which::find_executable(&cfg.command, &s))+ .and_then(|exe| dunce::canonicalize(exe).ok())+ .and_then(|exe| Some(exe.parent()?.parent()?.to_path_buf()))+ .and_then(|home| bundles_min_java(&home));+ required.map_or(JDTLS_MIN_JAVA, |v| v.max(JDTLS_MIN_JAVA))+}++/// Per install: (plugins directory mtime, its requirement).+static BUNDLE_JAVA: Mutex<BTreeMap<PathBuf, (std::time::SystemTime, Option<u32>)>> = Mutex::new(BTreeMap::new());++/// Highest Java version required by the bundles in `home`'s `plugins` (or Homebrew's+/// `libexec/plugins`); `None` when there are none to read.+fn bundles_min_java(home: &Path) -> Option<u32> {+ let plugins = [home.join("plugins"), home.join("libexec").join("plugins")].into_iter().find(|p| p.is_dir())?;+ let modified = std::fs::metadata(&plugins).and_then(|m| m.modified()).ok()?;+ let mut cache = BUNDLE_JAVA.lock().unwrap_or_else(|e| e.into_inner());+ if let Some((at, v)) = cache.get(&plugins)+ && *at == modified+ {+ return *v;+ }+ let required = std::fs::read_dir(&plugins)+ .ok()?+ .filter_map(Result::ok)+ .map(|e| e.path())+ .filter(|p| p.extension().is_some_and(|x| x == "jar"))+ .filter_map(|jar| jar_manifest(&jar))+ .filter_map(|manifest| manifest_min_java(&manifest))+ .max();+ cache.insert(plugins, (modified, required));+ required+}++fn jar_manifest(jar: &Path) -> Option<String> {+ use std::io::Read;+ let mut zip = zip::ZipArchive::new(std::fs::File::open(jar).ok()?).ok()?;+ let mut entry = zip.by_name("META-INF/MANIFEST.MF").ok()?;+ let mut text = String::new();+ entry.read_to_string(&mut text).ok()?;+ Some(text)+}++/// The Java version an OSGi bundle manifest requires: its `osgi.ee` capability+/// (`version=25`), else the oldest of its `Bundle-RequiredExecutionEnvironment`s.+fn manifest_min_java(manifest: &str) -> Option<u32> {+ // Long headers continue on lines starting with a space.+ let mut headers: Vec<String> = Vec::new();+ for line in manifest.lines() {+ match (line.strip_prefix(' '), headers.last_mut()) {+ (Some(rest), Some(last)) => last.push_str(rest),+ _ => headers.push(line.to_owned()),+ }+ }+ let header = |name: &str| headers.iter().find_map(|h| h.strip_prefix(name)?.strip_prefix(':')).map(str::trim);+ if let Some(caps) = header("Require-Capability") {+ let ee = caps.split(',').filter(|c| c.trim_start().starts_with("osgi.ee")).find_map(|c| {+ let v = c.split("version=").nth(1)?;+ let digits: String = v.chars().take_while(char::is_ascii_digit).collect();+ digits.parse::<u32>().ok()+ });+ if ee.is_some() {+ return ee;+ }+ }+ header("Bundle-RequiredExecutionEnvironment")?+ .split(',')+ .filter_map(|ee| ee.trim().strip_prefix("JavaSE-"))+ .filter_map(|v| if v == "1.8" { Some(8) } else { v.parse().ok() })+ .min()}/// jdtls `java.configuration.runtimes`: one JDK per Java version (the first@@ -178,14 +256,15 @@ const METADATA_PROPERTY: &str = "java.import.generatesMetadataFilesAtProjectRoot/// jdtls: its Eclipse workspace (`-data`) lives under the IDE's data/// directory, one per server root, and no Eclipse metadata is written into-/// the project; it runs on a JDK 21+ (via `JAVA_HOME`, which its launcher-/// reads), installed JDKs are registered as runtimes and `bundles` (e.g. the-/// java-debug plugin jar) are loaded into the server.+/// the project; it runs on a JDK `min_java`+ (via `JAVA_HOME`, which its+/// launcher reads), installed JDKs are registered as runtimes and `bundles`+/// (e.g. the java-debug plugin jar) are loaded into the server.pub fn configure_jdtls(cfg: &mut LanguageServerConfig,server_root: &Path,data_dir: &Path,jdks: &[Jdk],+ min_java: u32,bundles: &[PathBuf],) {if cfg.name != "jdtls" {@@ -201,11 +280,11 @@ pub fn configure_jdtls(cfg.args.push(format!("--jvm-arg=-D{METADATA_PROPERTY}=false"));}if !cfg.env.contains_key("JAVA_HOME") {- match jdtls_runtime(jdks) {+ match jdtls_runtime(jdks, min_java) {Some(jdk) => {cfg.env.insert("JAVA_HOME".to_owned(), jdk.home.to_string_lossy().into_owned());}- None => cfg.launch_error = Some(missing_runtime_message(jdks)),+ None => cfg.launch_error = Some(missing_runtime_message(jdks, min_java)),}}let runtimes = runtimes(jdks);@@ -218,7 +297,7 @@ pub fn configure_jdtls(}}-fn missing_runtime_message(jdks: &[Jdk]) -> String {+fn missing_runtime_message(jdks: &[Jdk], min_java: u32) -> String {let mut found: Vec<u32> = jdks.iter().map(|j| j.major).collect();found.sort_unstable();found.dedup();@@ -229,7 +308,7 @@ fn missing_runtime_message(jdks: &[Jdk]) -> String {format!("found JDK {}", list.join(", "))};format!(- "jdtls needs JDK {JDTLS_MIN_JAVA} or newer to run ({found}). Install one (or point JAVA_HOME at it) and \+ "jdtls needs JDK {min_java} or newer to run ({found}). Install one (or point JAVA_HOME at it) and \restart the server; the project can still target an older Java version.")}@@ -330,7 +409,7 @@ mod tests {Jdk { major: 8, home: PathBuf::from("/jdk8") },];let bundles = [PathBuf::from("/tools/java-debug/bin/com.microsoft.java.debug.plugin.jar")];- configure_jdtls(&mut cfg, Path::new("/p/demo"), Path::new("/data"), &jdks, &bundles);+ configure_jdtls(&mut cfg, Path::new("/p/demo"), Path::new("/data"), &jdks, JDTLS_MIN_JAVA, &bundles);assert_eq!(cfg.args[0], "-data");assert!(cfg.args[1].starts_with("/data/lsp/jdtls/"), "{}", cfg.args[1]);assert_eq!(cfg.args[2], "--jvm-arg=-Djava.import.generatesMetadataFilesAtProjectRoot=false");@@ -345,36 +424,74 @@ mod tests {// Deterministic (reconfigure compares configs) and idempotent.let before = cfg.clone();- configure_jdtls(&mut cfg, Path::new("/p/demo"), Path::new("/data"), &jdks, &bundles);+ configure_jdtls(&mut cfg, Path::new("/p/demo"), Path::new("/data"), &jdks, JDTLS_MIN_JAVA, &bundles);assert_eq!(cfg, before);let mut other: LanguageServerConfig = toml::from_str("name = \"pyright\"\ncommand = \"x\"").unwrap();- configure_jdtls(&mut other, Path::new("/p"), Path::new("/data"), &jdks, &bundles);+ configure_jdtls(&mut other, Path::new("/p"), Path::new("/data"), &jdks, JDTLS_MIN_JAVA, &bundles);assert!(other.args.is_empty() && other.initialization_options.is_none());}#[test]- fn jdtls_needs_a_jdk_21_to_run() {+ fn jdtls_needs_a_new_enough_jdk_to_run() {let jdtls = || -> LanguageServerConfig { toml::from_str("name = \"jdtls\"\ncommand = \"jdtls\"").unwrap() };let old = [Jdk { major: 17, home: PathBuf::from("/jdk17") }, Jdk { major: 8, home: PathBuf::from("/jdk8") }];let mut cfg = jdtls();- configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &old, &[]);+ configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &old, JDTLS_MIN_JAVA, &[]);assert!(!cfg.env.contains_key("JAVA_HOME"));let err = cfg.launch_error.unwrap();assert!(err.contains("JDK 21 or newer") && err.contains("found JDK 8, 17"), "{err}");let mut cfg = jdtls();- configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &[], &[]);+ configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &[], JDTLS_MIN_JAVA, &[]);assert!(cfg.launch_error.unwrap().contains("no JDK was found"));// An explicit JAVA_HOME is the user's call.let mut cfg = jdtls();cfg.env.insert("JAVA_HOME".into(), "/custom".into());- configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &old, &[]);+ configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &old, JDTLS_MIN_JAVA, &[]);assert_eq!((cfg.env["JAVA_HOME"].as_str(), cfg.launch_error), ("/custom", None));let mixed = [old[0].clone(), Jdk { major: 21, home: PathBuf::from("/jdk21") }];- assert_eq!(jdtls_runtime(&mixed).unwrap().major, 21);+ assert_eq!(jdtls_runtime(&mixed, 21).unwrap().major, 21);++ // A jdtls whose bundles need 25 doesn't start on 21, and says what it needs.+ let mut cfg = jdtls();+ configure_jdtls(&mut cfg, Path::new("/p"), Path::new("/data"), &mixed, 25, &[]);+ let err = cfg.launch_error.unwrap();+ assert!(err.contains("JDK 25 or newer") && err.contains("found JDK 17, 21"), "{err}");+ }++ #[test]+ fn bundle_manifests_give_the_java_jdtls_needs() {+ let ee = |m: &str| manifest_min_java(m);+ assert_eq!(ee("Bundle-RequiredExecutionEnvironment: JavaSE-25\n"), Some(25));+ assert_eq!(ee("Bundle-RequiredExecutionEnvironment: JavaSE-17, JavaSE-1.8\n"), Some(8));+ // The capability wins, also when folded over continuation lines.+ let folded = "Require-Capability: osgi.service;filter:=\"(x=1)\",osgi.ee;filter:=\"(&(osgi.ee=Ja\r\n \+ vaSE)(version=21))\"\r\nBundle-RequiredExecutionEnvironment: JavaSE-17\r\n";+ assert_eq!(ee(folded), Some(21));+ assert_eq!(ee("Bundle-Name: x\n"), None);++ let home = tempfile::tempdir().unwrap();+ let plugins = home.path().join("plugins");+ std::fs::create_dir(&plugins).unwrap();+ let jar = |name: &str, manifest: &str| {+ let mut zip = zip::ZipWriter::new(std::fs::File::create(plugins.join(name)).unwrap());+ let opts = zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Stored);+ zip.start_file("META-INF/MANIFEST.MF", opts).unwrap();+ std::io::Write::write_all(&mut zip, manifest.as_bytes()).unwrap();+ zip.finish().unwrap();+ };+ jar(+ "org.eclipse.jdt.ls.core_1.63.0.jar",+ "Require-Capability: osgi.ee;filter:=\"(&(osgi.ee=JavaSE)(version=21))\"\n",+ );+ jar("org.eclipse.core.filesystem_1.12.0.jar", "Bundle-RequiredExecutionEnvironment: JavaSE-25\n");+ jar("plain.jar", "Manifest-Version: 1.0\n");+ std::fs::write(plugins.join("notes.txt"), "not a jar").unwrap();+ assert_eq!(bundles_min_java(home.path()), Some(25));+ assert_eq!(bundles_min_java(&home.path().join("missing")), None);}#[test]diff --git a/crates/ide-vcs/src/status.rs b/crates/ide-vcs/src/status.rsindex 88057afcb..a98c3d369 100644--- a/crates/ide-vcs/src/status.rs+++ b/crates/ide-vcs/src/status.rs@@ -87,7 +87,10 @@ pub(crate) fn status(r: &Repo) -> IdeResult<Vec<FileStatus>> {}}// Persist refreshed stat info so the next status is cheaper (like `git status` does).+ // Only when something changed: `write_changes` writes even an empty change set, and+ // the rewritten `.git/index` comes back as a VCS change that triggers the next status.if let Some(mut outcome) = iter.into_outcome()+ && outcome.has_changes()&& let Some(Err(e)) = outcome.write_changes(){tracing::debug!("could not write refreshed index: {e}");diff --git a/crates/ide-vcs/tests/repo.rs b/crates/ide-vcs/tests/repo.rsindex a49f31fd9..fa12939ff 100644--- a/crates/ide-vcs/tests/repo.rs+++ b/crates/ide-vcs/tests/repo.rs@@ -145,6 +145,26 @@ fn repository_without_commits() {assert!(repo.status().unwrap().is_empty());}+#[test]+fn status_leaves_an_up_to_date_index_alone() {+ // The watcher reports `.git/index` writes as VCS changes, which refresh the+ // status: rewriting it unconditionally made that a loop.+ let fx = Fixture::new();+ fx.write("a.txt", "a\n");+ // Older than the index, so it isn't racily clean (that settles after a write or two).+ let past = std::time::SystemTime::now() - std::time::Duration::from_secs(60);+ std::fs::File::options().write(true).open(fx.path("a.txt")).unwrap().set_modified(past).unwrap();+ fx.commit_all("init");+ let repo = fx.repo();+ repo.status().unwrap(); // may persist refreshed stat info once+ let index = fx.path(".git/index");+ let before = std::fs::metadata(&index).unwrap().modified().unwrap();+ for _ in 0..3 {+ assert!(repo.status().unwrap().is_empty());+ }+ assert_eq!(std::fs::metadata(&index).unwrap().modified().unwrap(), before);+}+#[test]fn status_matrix() {let fx = Fixture::new();diff --git a/src-tauri/src/state.rs b/src-tauri/src/state.rsindex bc03077ed..77aed1065 100644--- a/src-tauri/src/state.rs+++ b/src-tauri/src/state.rs@@ -246,8 +246,9 @@ impl AppState {if cfg.name == "jdtls" {let bundles: Vec<PathBuf> =ide_tools::managed_bundle(&data_dir, "java-debug").into_iter().collect();- let jdks = ide_sdk::java::jdtls_jdks();- ide_sdk::java::configure_jdtls(cfg, server_root, &data_dir, &jdks, &bundles);+ let min_java = ide_sdk::java::jdtls_min_java(cfg);+ let jdks = ide_sdk::java::jdtls_jdks(min_java);+ ide_sdk::java::configure_jdtls(cfg, server_root, &data_dir, &jdks, min_java, &bundles);}}));}diff --git a/src/features/app/windows.ts b/src/features/app/windows.tsindex 45568af18..c4cadfd4a 100644--- a/src/features/app/windows.ts+++ b/src/features/app/windows.ts@@ -6,7 +6,7 @@import type { Action } from "@/platform/actions";import { t } from "@/platform/i18n";import { call, commands, isTauri } from "@/platform/ipc";-import { basename, confirmLeaveProject, openProject, useProject } from "@/platform/project";+import { basename, confirmLeaveProject, openProject, provideStartupLaunch, useProject } from "@/platform/project";import { notifications } from "@/workbench/contributions";import { ask } from "./prompt";@@ -195,7 +195,7 @@ export function installLaunchHandling(): () => void {if (!isTauri()) return () => {};let disposed = false;let unlisten: (() => void) | undefined;- void consumeLaunch();+ provideStartupLaunch(consumeLaunch());void import("@tauri-apps/api/webviewWindow").then(async ({ getCurrentWebviewWindow }) => {const off = await getCurrentWebviewWindow().listen(LAUNCH_EVENT, () => void consumeLaunch());if (disposed) off();diff --git a/src/features/welcome/session.test.ts b/src/features/welcome/session.test.tsnew file mode 100644index 000000000..a45f5413b--- /dev/null+++ b/src/features/welcome/session.test.ts@@ -0,0 +1,54 @@+import { beforeEach, describe, expect, it, vi } from "vitest";++const openProject = vi.fn();++vi.mock("@/platform/ipc", async (orig) => {+ const real = await orig<typeof import("@/platform/ipc")>();+ return {+ ...real,+ isTauri: () => true,+ commands: { ...real.commands, settingsGet: async () => ({ general: { reopenLastProject: true } }) },+ };+});+vi.mock("@tauri-apps/api/window", () => ({ getCurrentWindow: () => ({ label: "main" }) }));+vi.mock("@/platform/project", async (orig) => {+ const real = await orig<typeof import("@/platform/project")>();+ return { ...real, openProject: (p: string) => openProject(p) };+});++const { reopenLastProject, _resetSessionForTests } = await import("./session");+const { provideStartupLaunch, useProject } = await import("@/platform/project");++beforeEach(() => {+ openProject.mockReset();+ useProject.setState({ project: null });+ sessionStorage.clear();+ localStorage.setItem("openidea.session.openProject", "/p/last");+ _resetSessionForTests();+});++describe("reopenLastProject", () => {+ it("waits for the command-line project instead of opening the last one too", async () => {+ let finishLaunch!: () => void;+ provideStartupLaunch(+ new Promise<void>((resolve) => {+ finishLaunch = () => {+ useProject.setState({ project: { root: "/p/launch" } as never });+ resolve();+ };+ }),+ );+ const reopened = reopenLastProject();+ await new Promise((r) => setTimeout(r, 0));+ expect(openProject).not.toHaveBeenCalled();+ finishLaunch();+ await reopened;+ expect(openProject).not.toHaveBeenCalled();+ });++ it("reopens the last project when the launch named none", async () => {+ provideStartupLaunch(Promise.resolve());+ await reopenLastProject();+ expect(openProject).toHaveBeenCalledWith("/p/last");+ });+});diff --git a/src/features/welcome/session.ts b/src/features/welcome/session.tsindex 08440d41b..6035159af 100644--- a/src/features/welcome/session.ts+++ b/src/features/welcome/session.ts@@ -6,7 +6,7 @@import { getCurrentWindow } from "@tauri-apps/api/window";import { create } from "zustand";import { commands, isTauri, type Settings } from "@/platform/ipc";-import { openProject, useProject } from "@/platform/project";+import { openProject, startupLaunchHandled, useProject } from "@/platform/project";import { notifications } from "@/workbench/contributions";const SESSION_KEY = "openidea.session.openProject";@@ -104,6 +104,8 @@ export async function reopenLastProject(): Promise<void> {/* use the local preference */}if (!reopenEnabled(settings, useSession.getState().reopenPref)) return;+ // A project passed on the command line wins over the last session's.+ await startupLaunchHandled();if (useProject.getState().project) return;await reopen(path);}diff --git a/src/platform/project.ts b/src/platform/project.tsindex f23c11fd9..e5888bd64 100644--- a/src/platform/project.ts+++ b/src/platform/project.ts@@ -27,6 +27,18 @@ export function confirmLeaveProject(): Promise<boolean> {return useProject.getState().project && leaveGuard ? leaveGuard() : Promise.resolve(true);}+let startupLaunch: Promise<void> | null = null;++/** Installs this window's startup launch (the project it was started or created for, features/app/windows.ts). */+export function provideStartupLaunch(launch: Promise<void>) {+ startupLaunch = launch;+}++/** Settles once the startup launch has opened its project (if any), so a restore doesn't race it. */+export function startupLaunchHandled(): Promise<void> {+ return (startupLaunch ?? Promise.resolve()).catch(() => {});+}+export async function openProject(path: string): Promise<ProjectInfo> {useProject.setState({ opening: true });try {