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(vcs): discover worktrees created while the project is open (#930)
arookieofc53e76e29c641
diff --git a/crates/ide-host/src/ops/vcs/commands.rs b/crates/ide-host/src/ops/vcs/commands.rsindex d3913c0af..d8655e3b6 100644--- a/crates/ide-host/src/ops/vcs/commands.rs+++ b/crates/ide-host/src/ops/vcs/commands.rs@@ -729,7 +729,13 @@ pub async fn vcs_add_worktree(host.require_trust(window)?;let project = host.project(window)?;blocking(move || {- project.with_repo_recorded(repo.as_deref(), None, |r| r.add_worktree(&path, &commitish, new_branch.as_deref()))+ let result = project+ .with_repo_recorded(repo.as_deref(), None, |r| r.add_worktree(&path, &commitish, new_branch.as_deref()));+ // A worktree below the project is a new repository: rescan so its files+ // join the status and gutter queries (the watcher picks the gitfile up+ // too, but only as a debounced event later).+ project.refresh_repositories();+ result}).await}@@ -743,7 +749,12 @@ pub async fn vcs_remove_worktree() -> IdeResult<()> {host.require_trust(window)?;let project = host.project(window)?;- blocking(move || project.with_repo_at(repo.as_deref(), |r| r.remove_worktree(&path, force))).await+ blocking(move || {+ let result = project.with_repo_at(repo.as_deref(), |r| r.remove_worktree(&path, force));+ project.refresh_repositories();+ result+ })+ .await}pub async fn vcs_compare_scope(host: &Host, window: &str, paths: Vec<PathBuf>) -> IdeResult<CompareScope> {diff --git a/crates/ide-host/src/project.rs b/crates/ide-host/src/project.rsindex 9b4dda808..1391f6182 100644--- a/crates/ide-host/src/project.rs+++ b/crates/ide-host/src/project.rs@@ -325,15 +325,35 @@ impl Host {sink.emit(IdeEvent::ProjectRootsChanged { root: root.clone().into() });}}- // A repository was cloned / initialised / removed below the project: its- // `.git/HEAD` (the watcher reports nothing else of `.git`) appeared or went.+ // A repository was cloned / initialised / removed below the project:+ // its `.git/HEAD` appeared or went. A linked worktree's `.git` is a+ // plain gitfile, and that file is the only marker written inside the+ // worktree itself, so the `.git` path counts too.let known = repos.read().roots();- let git_dirs = changed.iter().chain(&batch.removed).chain(&batch.vcs).any(|p| {- let Some(dir) = p.ends_with(".git/HEAD").then(|| p.parent().and_then(Path::parent)).flatten()- else {- return false;+ let mut git_dirs = changed.iter().chain(&batch.removed).chain(&batch.vcs).any(|p| {+ let dir = if p.ends_with(".git/HEAD") {+ p.parent().and_then(Path::parent)+ } else if p.ends_with(".git") {+ p.parent()+ } else {+ None};- known.iter().any(|r| r == dir) != p.is_file()+ let Some(dir) = dir else { return false };+ known.iter().any(|r| r == dir) != p.exists()+ });+ // A linked worktree was registered or unregistered in the main+ // gitdir: `git worktree add` / `remove` creates or deletes+ // `.git/worktrees/<name>`. Its own gitfile is written before the+ // watcher can watch the new directory, so this entry is what+ // Linux per-directory watchers see.+ git_dirs |= batch.vcs.iter().any(|p| {+ let rest: Vec<_> = p+ .components()+ .skip_while(|c| c.as_os_str() != ".git")+ .skip(1) // the `.git` component itself+ .map(|c| c.as_os_str().to_string_lossy().into_owned())+ .collect();+ matches!(rest.as_slice(), [first, ..] if first == "worktrees" && rest.len() <= 2)});if git_dirs {scan_repositories(&root, &repos, &settings, &sink);diff --git a/crates/ide-host/tests/vcs_worktrees.rs b/crates/ide-host/tests/vcs_worktrees.rsnew file mode 100644index 000000000..57304d189--- /dev/null+++ b/crates/ide-host/tests/vcs_worktrees.rs@@ -0,0 +1,93 @@+use ide_core::NullSink;+use ide_host::{Host, HostConfig, Project, ops::vcs};+use std::{path::PathBuf, process::Command, sync::Arc, time::Duration};++fn git(root: &std::path::Path, args: &[&str]) {+ let out = Command::new("git").current_dir(root).args(args).output().unwrap();+ assert!(out.status.success(), "{}", String::from_utf8_lossy(&out.stderr));+}++async fn wait_for_repos(project: &Arc<Project>, count: usize) {+ for _ in 0..200 {+ if project.repos().all().len() >= count {+ return;+ }+ tokio::time::sleep(Duration::from_millis(100)).await;+ }+ panic!("expected {} repositories, found {}", count, project.repos().all().len());+}++struct Fixture {+ host: Host,+ project: Arc<Project>,+ root: PathBuf,+ _temp: tempfile::TempDir,+}++impl Fixture {+ async fn new() -> Self {+ let temp = tempfile::tempdir().unwrap();+ let base = dunce::canonicalize(temp.path()).unwrap();+ let root = base.join("project");+ std::fs::create_dir_all(&root).unwrap();+ git(&root, &["init", "-b", "main"]);+ git(&root, &["config", "user.name", "Test"]);+ git(&root, &["config", "user.email", "[email protected]"]);+ git(&root, &["config", "commit.gpgsign", "false"]);+ git(&root, &["config", "core.autocrlf", "false"]);+ std::fs::write(root.join("file.txt"), "original\n").unwrap();+ git(&root, &["add", "."]);+ git(&root, &["commit", "-m", "original"]);+ let host = Host::new(HostConfig {+ config_dir: base.join("config"),+ data_dir: base.join("data"),+ local_data_dir: base.join("data"),+ languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),+ syntax: Arc::default(),+ sink_for: Box::new(|_| Arc::new(NullSink)),+ owner: |w| w,+ runtime: tokio::runtime::Handle::current(),+ project_environment: false,+ });+ host.trust.decide(&root, true, false).unwrap();+ let project = host.open_project("main", &root).unwrap();+ wait_for_repos(&project, 1).await;+ Self { host, project, root, _temp: temp }+ }+}++impl Drop for Fixture {+ fn drop(&mut self) {+ self.host.close_project("main");+ }+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn command_added_worktree_joins_the_repository_set() {+ let f = Fixture::new().await;+ let linked = f.root.join("linked");+ vcs::vcs_add_worktree(&f.host, "main", None, linked.clone(), "main".into(), Some("topic".into())).await.unwrap();+ let roots = f.project.repos().roots();+ assert!(roots.contains(&linked), "worktree below the project did not join the repository set: {roots:?}");+ assert_eq!(roots.len(), 2);+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn removed_worktree_leaves_the_repository_set() {+ let f = Fixture::new().await;+ let linked = f.root.join("linked");+ vcs::vcs_add_worktree(&f.host, "main", None, linked.clone(), "main".into(), Some("topic".into())).await.unwrap();+ assert_eq!(f.project.repos().all().len(), 2);+ vcs::vcs_remove_worktree(&f.host, "main", None, linked, false).await.unwrap();+ assert_eq!(f.project.repos().all().len(), 1);+}++#[tokio::test(flavor = "multi_thread", worker_threads = 2)]+async fn watcher_picks_up_a_worktree_added_below_the_project() {+ let f = Fixture::new().await;+ let linked = f.root.join("watched");+ git(&f.root, &["worktree", "add", "watched", "-b", "watched"]);+ wait_for_repos(&f.project, 2).await;+ let roots = f.project.repos().roots();+ assert!(roots.contains(&linked), "watcher did not discover the worktree added below the project: {roots:?}");+}diff --git a/crates/ide-vfs/src/watch.rs b/crates/ide-vfs/src/watch.rsindex 44dbce5b7..011cab690 100644--- a/crates/ide-vfs/src/watch.rs+++ b/crates/ide-vfs/src/watch.rs@@ -277,6 +277,15 @@ impl DirState {self.watch_tree(path, true, &mut discovered);}}+ // VCS metadata directories (`.git`, `.git/worktrees/<name>`) need+ // watches too: a worktree registered in the main gitdir writes its+ // entry below `.git/worktrees`, and the events in a gitdir created+ // during this batch would otherwise never be seen.+ for path in &batch.vcs {+ if !self.watched.lock().contains(path) && path.symlink_metadata().is_ok_and(|m| m.is_dir()) {+ self.watch_tree(path, false, &mut discovered);+ }+ }for path in &batch.removed {self.unwatch_tree(path);}@@ -415,15 +424,29 @@ impl EventFilter {let idx = comps.iter().position(|c| *c == ".git")?;let rest = &comps[idx + 1..];Some(match rest {- [one] => *one == "HEAD" || *one == "index" || *one == "packed-refs",- [first, ..] => *first == "refs" && !rest.last().is_some_and(|l| l.to_string_lossy().ends_with(".lock")),- [] => false,+ // `refs` and `worktrees` are directories whose creation is itself a+ // registration event (`git init`, the first `git worktree add`);+ // they must surface even though the depth below them is handled+ // separately.+ [one] => matches!(one.to_str(), Some("HEAD" | "index" | "packed-refs" | "refs" | "worktrees" | "info")),+ [first, ..] => {+ let metadata = *first == "refs"+ // Linked-worktree gitdirs: a worktree added or removed below+ // the project writes its HEAD here.+ || *first == "worktrees";+ metadata && !rest.last().is_some_and(|l| l.to_string_lossy().ends_with(".lock"))+ }+ // The `.git` path itself: a linked worktree's `.git` is a plain+ // file (gitfile), and it is the only marker a new worktree writes+ // inside its own directory.+ [] => true,})}/// Whether a directory deserves its own watch in per-directory mode: not- /// excluded or git-ignored; inside `.git` only the directory itself and- /// `refs/` (HEAD, index and refs are what VCS refresh needs).+ /// excluded or git-ignored; inside `.git` the directory itself, `refs/`+ /// and `worktrees/` (HEAD, index, refs and worktree metadata are what VCS+ /// refresh needs).pub fn should_watch_dir(&self, dir: &Path) -> bool {let Ok(rel) = dir.strip_prefix(&self.root) else { return false };if rel.as_os_str().is_empty() {@@ -435,6 +458,7 @@ impl EventFilter {return match rest.as_slice() {[] => true,[first, ..] if *first == "refs" => true,+ [first, ..] if *first == "worktrees" => true,[only] => *only == "info",_ => false,};@@ -690,7 +714,18 @@ mod tests {assert_eq!(g(".git/refs/heads/main"), Some(true));assert_eq!(g(".git/refs/heads/main.lock"), Some(false));assert_eq!(g(".git/objects/aa/bb"), Some(false));- assert_eq!(g(".git"), Some(false));+ // The `.git` path itself: a repo dir, or a linked worktree's gitfile.+ assert_eq!(g(".git"), Some(true));+ assert_eq!(g("wt/.git"), Some(true));+ // Linked-worktree gitdir metadata below the main repository.+ assert_eq!(g(".git/worktrees/wt/HEAD"), Some(true));+ assert_eq!(g(".git/worktrees/wt/index.lock"), Some(false));+ // The depth-1 directories themselves: `git init` or the first+ // `git worktree add` creates them in an already-watched gitdir.+ assert_eq!(g(".git/refs"), Some(true));+ assert_eq!(g(".git/worktrees"), Some(true));+ assert_eq!(g(".git/info"), Some(true));+ assert_eq!(g(".git/objects"), Some(false));}#[test]@@ -744,6 +779,9 @@ mod tests {assert!(!w("build") && w("src/build"));assert!(w(".git") && w(".git/refs") && w(".git/refs/heads") && w(".git/info"));assert!(!w(".git/objects") && !w(".git/objects/ab") && !w(".git/logs"));+ // Linked-worktree gitdirs are watched so worktrees added below the+ // project while it is open are discovered.+ assert!(w(".git/worktrees") && w(".git/worktrees/wt") && w(".git/worktrees/wt/rebase-merge"));assert!(!filter.should_watch_dir(Path::new("/elsewhere")));// Excludes are replaced in place (Watcher::set_excludes).*filter.excludes.write() = ExcludeMatcher::new(&["gen".into()]);@@ -861,6 +899,51 @@ mod tests {assert_eq!(batches.lock().len(), n, "no events after drop");}+ #[test]+ fn per_directory_mode_follows_worktree_registrations() {+ let tmp = tempfile::tempdir().unwrap();+ let root = dunce::canonicalize(tmp.path()).unwrap();+ for d in ["wt", ".git/refs/heads"] {+ std::fs::create_dir_all(root.join(d)).unwrap();+ }+ // The worktree's gitfile is written before any watch on the worktree+ // directory could register it — the same window a real+ // `git worktree add` runs into.+ std::fs::write(root.join("wt/.git"), "gitdir: ../.git/worktrees/wt\n").unwrap();+ let batches: Arc<Mutex<Vec<FsBatch>>> = Arc::default();+ let sink: SharedSink = Arc::new(|_e: IdeEvent| {});+ let watcher = {+ let batches = batches.clone();+ Watcher::start_with(+ &root,+ Vec::new(),+ sink,+ Box::new(move |b| batches.lock().push(b.clone())),+ WatchMode::PerDirectory,+ )+ .unwrap()+ };+ // Registering the worktree in the main gitdir surfaces as VCS metadata+ // (the deepest directory itself may be created before its parent gains+ // a watch, so `.git/worktrees` is the event that reliably fires)...+ std::fs::create_dir_all(root.join(".git/worktrees/wt")).unwrap();+ assert!(+ wait_for(&batches, |b| b.iter().any(|b| b.vcs.contains(&root.join(".git/worktrees")))),+ "{:?}",+ batches.lock()+ );+ // ...and the registered gitdir gains a watch, so writes inside it are+ // seen even though nothing reported the directory itself.+ std::thread::sleep(Duration::from_millis(200));+ std::fs::write(root.join(".git/worktrees/wt/HEAD"), "ref: refs/heads/topic\n").unwrap();+ assert!(+ wait_for(&batches, |b| b.iter().any(|b| b.vcs.contains(&root.join(".git/worktrees/wt/HEAD")))),+ "{:?}",+ batches.lock()+ );+ drop(watcher);+ }+#[test]fn flat_mode_reports_the_roots_own_entries_only() {let tmp = tempfile::tempdir().unwrap();