Rebuild buffer store to be aware of remote/local distinction (#18303)

Release Notes:

- N/A

---------

Co-authored-by: Mikayla <mikayla@zed.dev>

crates/collab/src/tests/remote_editing_collaboration_tests.rs

@@ -3,6 +3,7 @@ use call::ActiveCall;
 use fs::{FakeFs, Fs as _};
 use gpui::{Context as _, TestAppContext};
 use language::language_settings::all_language_settings;
+use project::ProjectPath;
 use remote::SshSession;
 use remote_server::HeadlessProject;
 use serde_json::json;
@@ -108,14 +109,36 @@ async fn test_sharing_an_ssh_remote_project(
     });
 
     project_b
-        .update(cx_b, |project, cx| project.save_buffer(buffer_b, cx))
+        .update(cx_b, |project, cx| {
+            project.save_buffer_as(
+                buffer_b.clone(),
+                ProjectPath {
+                    worktree_id: worktree_id.to_owned(),
+                    path: Arc::from(Path::new("src/renamed.rs")),
+                },
+                cx,
+            )
+        })
         .await
         .unwrap();
     assert_eq!(
         remote_fs
-            .load("/code/project1/src/lib.rs".as_ref())
+            .load("/code/project1/src/renamed.rs".as_ref())
             .await
             .unwrap(),
         "fn one() -> usize { 100 }"
     );
+    cx_b.run_until_parked();
+    cx_b.update(|cx| {
+        assert_eq!(
+            buffer_b
+                .read(cx)
+                .file()
+                .unwrap()
+                .path()
+                .to_string_lossy()
+                .to_string(),
+            "src/renamed.rs".to_string()
+        );
+    });
 }

crates/project/src/lsp_command.rs

@@ -1,10 +1,9 @@
 mod signature_help;
 
 use crate::{
-    buffer_store::BufferStore, lsp_store::LspStore, CodeAction, CoreCompletion, DocumentHighlight,
+    lsp_store::LspStore, CodeAction, CoreCompletion, DocumentHighlight, Hover, HoverBlock,
-    Hover, HoverBlock, HoverBlockKind, InlayHint, InlayHintLabel, InlayHintLabelPart,
+    HoverBlockKind, InlayHint, InlayHintLabel, InlayHintLabelPart, InlayHintLabelPartTooltip,
-    InlayHintLabelPartTooltip, InlayHintTooltip, Location, LocationLink, MarkupContent,
+    InlayHintTooltip, Location, LocationLink, MarkupContent, ProjectTransaction, ResolveState,
-    ProjectTransaction, ResolveState,
 };
 use anyhow::{anyhow, Context, Result};
 use async_trait::async_trait;
@@ -417,17 +416,17 @@ impl LspCommand for PerformRename {
         message: proto::PerformRenameResponse,
         lsp_store: Model<LspStore>,
         _: Model<Buffer>,
-        cx: AsyncAppContext,
+        mut cx: AsyncAppContext,
     ) -> Result<ProjectTransaction> {
         let message = message
             .transaction
             .ok_or_else(|| anyhow!("missing transaction"))?;
-        BufferStore::deserialize_project_transaction(
+        lsp_store
-            lsp_store.read_with(&cx, |lsp_store, _| lsp_store.buffer_store().downgrade())?,
+            .update(&mut cx, |lsp_store, cx| {
-            message,
+                lsp_store.buffer_store().update(cx, |buffer_store, cx| {
-            self.push_to_history,
+                    buffer_store.deserialize_project_transaction(message, self.push_to_history, cx)
-            cx,
+                })
-        )
+            })?
             .await
     }
 

crates/project/src/lsp_store.rs

@@ -1601,18 +1601,18 @@ impl LspStore {
                 buffer_id: buffer_handle.read(cx).remote_id().into(),
                 action: Some(Self::serialize_code_action(&action)),
             };
-            cx.spawn(move |this, cx| async move {
+            let buffer_store = self.buffer_store();
+            cx.spawn(move |_, mut cx| async move {
                 let response = upstream_client
                     .request(request)
                     .await?
                     .transaction
                     .ok_or_else(|| anyhow!("missing transaction"))?;
-                BufferStore::deserialize_project_transaction(
+
-                    this.read_with(&cx, |this, _| this.buffer_store.downgrade())?,
+                buffer_store
-                    response,
+                    .update(&mut cx, |buffer_store, cx| {
-                    push_to_history,
+                        buffer_store.deserialize_project_transaction(response, push_to_history, cx)
-                    cx,
+                    })?
-                )
                     .await
             })
         } else {
@@ -5062,6 +5062,7 @@ impl LspStore {
                 .spawn(this.languages.language_for_name(language_name.0.as_ref()))
                 .detach();
 
+            // host
             let adapter = this.languages.get_or_register_lsp_adapter(
                 language_name.clone(),
                 server_name.clone(),
@@ -5259,7 +5260,8 @@ impl LspStore {
                 result
             })
         } else if let Some((client, project_id)) = self.upstream_client() {
-            cx.spawn(move |this, mut cx| async move {
+            let buffer_store = self.buffer_store();
+            cx.spawn(move |_, mut cx| async move {
                 let response = client
                     .request(proto::FormatBuffers {
                         project_id,
@@ -5274,12 +5276,11 @@ impl LspStore {
                     .await?
                     .transaction
                     .ok_or_else(|| anyhow!("missing transaction"))?;
-                BufferStore::deserialize_project_transaction(
+
-                    this.read_with(&cx, |this, _| this.buffer_store.downgrade())?,
+                buffer_store
-                    response,
+                    .update(&mut cx, |buffer_store, cx| {
-                    push_to_history,
+                        buffer_store.deserialize_project_transaction(response, push_to_history, cx)
-                    cx,
+                    })?
-                )
                     .await
             })
         } else {

crates/project/src/project.rs

@@ -1667,16 +1667,8 @@ impl Project {
     }
 
     pub fn create_buffer(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<Model<Buffer>>> {
-        self.buffer_store.update(cx, |buffer_store, cx| {
+        self.buffer_store
-            buffer_store.create_buffer(
+            .update(cx, |buffer_store, cx| buffer_store.create_buffer(cx))
-                if self.is_via_collab() {
-                    Some((self.client.clone().into(), self.remote_id().unwrap()))
-                } else {
-                    None
-                },
-                cx,
-            )
-        })
     }
 
     pub fn create_local_buffer(
@@ -1685,7 +1677,7 @@ impl Project {
         language: Option<Arc<Language>>,
         cx: &mut ModelContext<Self>,
     ) -> Model<Buffer> {
-        if self.is_via_collab() {
+        if self.is_via_collab() || self.is_via_ssh() {
             panic!("called create_local_buffer on a remote project")
         }
         self.buffer_store.update(cx, |buffer_store, cx| {
@@ -3770,7 +3762,9 @@ impl Project {
         envelope: TypedEnvelope<proto::OpenNewBuffer>,
         mut cx: AsyncAppContext,
     ) -> Result<proto::OpenBufferResponse> {
-        let buffer = this.update(&mut cx, |this, cx| this.create_local_buffer("", None, cx))?;
+        let buffer = this
+            .update(&mut cx, |this, cx| this.create_buffer(cx))?
+            .await?;
         let peer_id = envelope.original_sender_id()?;
 
         Project::respond_to_open_buffer_request(this, buffer, peer_id, &mut cx)

crates/remote_server/src/remote_editing_tests.rs

@@ -56,6 +56,7 @@ async fn test_basic_remote_editing(cx: &mut TestAppContext, server_cx: &mut Test
         })
         .await
         .unwrap();
+
     buffer.update(cx, |buffer, cx| {
         assert_eq!(buffer.text(), "fn one() -> usize { 1 }");
         assert_eq!(