Cherrypick/fix misc bugs 8

crates/editor/src/editor.rs

@@ -5738,11 +5738,17 @@ impl Editor {
         _: &mut Window,
         cx: &mut Context<Self>,
     ) {
+        // A project an embedder made read-only cannot be unlocked per file.
+        let project_read_only = self
+            .project
+            .as_ref()
+            .is_some_and(|project| project.read(cx).is_read_only(cx));
         if let Some(buffer) = self.buffer.read(cx).as_singleton() {
             buffer.update(cx, |buffer, cx| {
                 buffer.set_capability(
                     match buffer.capability() {
                         Capability::ReadWrite => Capability::Read,
+                        Capability::Read if project_read_only => Capability::Read,
                         Capability::Read => Capability::ReadWrite,
                         Capability::ReadOnly => Capability::ReadOnly,
                     },

crates/editor/src/items.rs

@@ -888,11 +888,17 @@ impl Item for Editor {
     // Note: this mirrors the logic in `Editor::toggle_read_only`, but is reachable
     // without relying on focus-based action dispatch.
     fn toggle_read_only(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        // A project an embedder made read-only cannot be unlocked per file.
+        let project_read_only = self
+            .project
+            .as_ref()
+            .is_some_and(|project| project.read(cx).is_read_only(cx));
         if let Some(buffer) = self.buffer.read(cx).as_singleton() {
             buffer.update(cx, |buffer, cx| {
                 buffer.set_capability(
                     match buffer.capability() {
                         Capability::ReadWrite => Capability::Read,
+                        Capability::Read if project_read_only => Capability::Read,
                         Capability::Read => Capability::ReadWrite,
                         Capability::ReadOnly => Capability::ReadOnly,
                     },
@@ -928,6 +934,27 @@ impl Item for Editor {
         window: &mut Window,
         cx: &mut Context<Self>,
     ) -> Task<Result<()>> {
+        // A read-only project (a snapshot, a remote tree) has nothing to write:
+        // skip formatting and the save prompt entirely. Edits made before the
+        // project became read-only cannot be written either, and saying so keeps
+        // the item from closing as if they had been saved.
+        if project.read(cx).is_read_only(cx) {
+            let has_unsaved_edits = self
+                .buffer()
+                .read(cx)
+                .all_buffers()
+                .iter()
+                .any(|buffer| buffer.read(cx).is_dirty());
+            // An autosave tick cannot do anything about it and must not fail
+            // on every tick; an explicit save says so.
+            return Task::ready(if has_unsaved_edits && !options.autosave {
+                Err(anyhow!(
+                    "This project is read-only, so these edits cannot be saved"
+                ))
+            } else {
+                Ok(())
+            });
+        }
         // Add meta data tracking # of auto saves
         if options.autosave {
             self.report_editor_event(ReportEditorEvent::Saved { auto_saved: true }, None, cx);

crates/fs/src/fs.rs

@@ -71,6 +71,14 @@ use std::ffi::OsStr;
 pub trait Watcher: Send + Sync {
     fn add(&self, path: &Path) -> Result<()>;
     fn remove(&self, path: &Path) -> Result<()>;
+
+    /// Add `path` and resolve once its OS watch is in place, so no change made
+    /// after it resolves can be missed. `add` may return before then (a new
+    /// FSEvents watch is applied on a watcher thread). Waiting never blocks a
+    /// thread.
+    fn add_and_wait<'a>(&'a self, path: &'a Path) -> BoxFuture<'a, Result<()>> {
+        Box::pin(async move { self.add(path) })
+    }
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]
@@ -1075,13 +1083,15 @@ impl Fs for RealFs {
         let (tx, rx) = async_channel::unbounded();
         let pending_paths: Arc<Mutex<Vec<PathEvent>>> = Default::default();
 
-        let watcher: Arc<dyn Watcher> = Arc::new(fs_watcher::FsWatcher::new(
+        let watcher = Arc::new(fs_watcher::FsWatcher::new(
             executor.clone(),
             tx.clone(),
             pending_paths.clone(),
         ));
 
-        if let Err(e) = watcher.add(path) {
+        // Awaited rather than queued, so a change made after `watch` returns is
+        // never missed; the OS work runs on the watcher thread either way.
+        if let Err(e) = watcher.add_and_wait(path).await {
             log::warn!("Failed to watch {}:\n{e}", path.display());
         }
 
@@ -1097,11 +1107,12 @@ impl Fs for RealFs {
                     target = SanitizedPath::new(&canonical).as_path().to_path_buf();
                 }
             }
-            watcher.add(&target).ok();
+            watcher.add_and_wait(&target).await.ok();
             if let Some(parent) = target.parent() {
-                watcher.add(parent).log_err();
+                watcher.add_and_wait(parent).await.log_err();
             }
         }
+        let watcher: Arc<dyn Watcher> = watcher;
 
         (
             Box::pin(rx.filter_map({