Add support for git branches on remote projects (#19755)

Release Notes:

- Fixed a bug where the branch switcher could not be used remotely.

crates/fs/src/fs.rs

@@ -813,6 +813,7 @@ struct FakeFsState {
     root: Arc<Mutex<FakeFsEntry>>,
     next_inode: u64,
     next_mtime: SystemTime,
+    git_event_tx: smol::channel::Sender<PathBuf>,
     event_txs: Vec<smol::channel::Sender<Vec<PathEvent>>>,
     events_paused: bool,
     buffered_events: Vec<PathEvent>,
@@ -969,8 +970,10 @@ impl FakeFs {
     const SYSTEMTIME_INTERVAL: u64 = 100;
 
     pub fn new(executor: gpui::BackgroundExecutor) -> Arc<Self> {
-        Arc::new(Self {
-            executor,
+        let (tx, mut rx) = smol::channel::bounded::<PathBuf>(10);
+
+        let this = Arc::new(Self {
+            executor: executor.clone(),
             state: Mutex::new(FakeFsState {
                 root: Arc::new(Mutex::new(FakeFsEntry::Dir {
                     inode: 0,
@@ -979,6 +982,7 @@ impl FakeFs {
                     entries: Default::default(),
                     git_repo_state: None,
                 })),
+                git_event_tx: tx,
                 next_mtime: SystemTime::UNIX_EPOCH,
                 next_inode: 1,
                 event_txs: Default::default(),
@@ -987,7 +991,22 @@ impl FakeFs {
                 read_dir_call_count: 0,
                 metadata_call_count: 0,
             }),
-        })
+        });
+
+        executor.spawn({
+            let this = this.clone();
+            async move {
+                while let Some(git_event) = rx.next().await {
+                    if let Some(mut state) = this.state.try_lock() {
+                        state.emit_event([(git_event, None)]);
+                    } else {
+                        panic!("Failed to lock file system state, this execution would have caused a test hang");
+                    }
+                }
+            }
+        }).detach();
+
+        this
     }
 
     pub fn set_next_mtime(&self, next_mtime: SystemTime) {
@@ -1181,7 +1200,12 @@ impl FakeFs {
         let mut entry = entry.lock();
 
         if let FakeFsEntry::Dir { git_repo_state, .. } = &mut *entry {
-            let repo_state = git_repo_state.get_or_insert_with(Default::default);
+            let repo_state = git_repo_state.get_or_insert_with(|| {
+                Arc::new(Mutex::new(FakeGitRepositoryState::new(
+                    dot_git.to_path_buf(),
+                    state.git_event_tx.clone(),
+                )))
+            });
             let mut repo_state = repo_state.lock();
 
             f(&mut repo_state);
@@ -1196,7 +1220,22 @@ impl FakeFs {
 
     pub fn set_branch_name(&self, dot_git: &Path, branch: Option<impl Into<String>>) {
         self.with_git_state(dot_git, true, |state| {
-            state.branch_name = branch.map(Into::into)
+            let branch = branch.map(Into::into);
+            state.branches.extend(branch.clone());
+            state.current_branch_name = branch.map(Into::into)
+        })
+    }
+
+    pub fn insert_branches(&self, dot_git: &Path, branches: &[&str]) {
+        self.with_git_state(dot_git, true, |state| {
+            if let Some(first) = branches.first() {
+                if state.current_branch_name.is_none() {
+                    state.current_branch_name = Some(first.to_string())
+                }
+            }
+            state
+                .branches
+                .extend(branches.iter().map(ToString::to_string));
         })
     }
 
@@ -1836,7 +1875,12 @@ impl Fs for FakeFs {
         let mut entry = entry.lock();
         if let FakeFsEntry::Dir { git_repo_state, .. } = &mut *entry {
             let state = git_repo_state
-                .get_or_insert_with(|| Arc::new(Mutex::new(FakeGitRepositoryState::default())))
+                .get_or_insert_with(|| {
+                    Arc::new(Mutex::new(FakeGitRepositoryState::new(
+                        abs_dot_git.to_path_buf(),
+                        state.git_event_tx.clone(),
+                    )))
+                })
                 .clone();
             Some(git::repository::FakeGitRepository::open(state))
         } else {