v0.70.x preview

Allow pasting the same entry more than once in project panel

.github/workflows/release_actions.yml

@@ -21,6 +21,15 @@ jobs:
           
           ${{ github.event.release.body }}
           ```
+  discourse_release:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Install Node
+        uses: actions/setup-node@v2
+        if: ${{ ! github.event.release.prerelease }}
+        with:
+          node-version: '16'
+      - run: script/discourse_release ${{ secrets.DISCOURSE_RELEASES_API_KEY }} ${{ github.event.release.tag_name }} ${{ github.event.release.body }}
   mixpanel_release:
     runs-on: ubuntu-latest
     steps:

Cargo.lock

@@ -820,9 +820,12 @@ dependencies = [
  "async-broadcast",
  "client",
  "collections",
+ "fs",
  "futures 0.3.25",
  "gpui",
+ "language",
  "live_kit_client",
+ "log",
  "media",
  "postage",
  "project",
@@ -1130,7 +1133,7 @@ dependencies = [
 
 [[package]]
 name = "collab"
-version = "0.3.3"
+version = "0.5.2"
 dependencies = [
  "anyhow",
  "async-tungstenite",
@@ -2560,7 +2563,6 @@ dependencies = [
  "sum_tree",
  "time 0.3.17",
  "tiny-skia",
- "tree-sitter",
  "usvg",
  "util",
  "waker-fn",
@@ -2756,6 +2758,12 @@ version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
 
+[[package]]
+name = "human_bytes"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39b528196c838e8b3da8b665e08c30958a6f2ede91d79f2ffcd0d4664b9c64eb"
+
 [[package]]
 name = "humantime"
 version = "2.1.0"
@@ -3754,6 +3762,15 @@ dependencies = [
  "winapi 0.3.9",
 ]
 
+[[package]]
+name = "ntapi"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc51db7b362b205941f71232e56c625156eb9a929f8cf74a428fd5bc094a4afc"
+dependencies = [
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "nu-ansi-term"
 version = "0.46.0"
@@ -4423,7 +4440,7 @@ source = "git+https://github.com/zed-industries/wezterm?rev=5cd757e5f2eb039ed0c6
 dependencies = [
  "libc",
  "log",
- "ntapi",
+ "ntapi 0.3.7",
  "winapi 0.3.9",
 ]
 
@@ -4434,6 +4451,7 @@ dependencies = [
  "aho-corasick",
  "anyhow",
  "async-trait",
+ "backtrace",
  "client",
  "clock",
  "collections",
@@ -4806,6 +4824,24 @@ dependencies = [
  "rand_core 0.3.1",
 ]
 
+[[package]]
+name = "recent_projects"
+version = "0.1.0"
+dependencies = [
+ "db",
+ "editor",
+ "fuzzy",
+ "gpui",
+ "language",
+ "ordered-float",
+ "picker",
+ "postage",
+ "settings",
+ "smol",
+ "text",
+ "workspace",
+]
+
 [[package]]
 name = "redox_syscall"
 version = "0.2.16"
@@ -6200,6 +6236,21 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "sysinfo"
+version = "0.27.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccb297c0afb439440834b4bcf02c5c9da8ec2e808e70f36b0d8e815ff403bd24"
+dependencies = [
+ "cfg-if 1.0.0",
+ "core-foundation-sys",
+ "libc",
+ "ntapi 0.4.0",
+ "once_cell",
+ "rayon",
+ "winapi 0.3.9",
+]
+
 [[package]]
 name = "system-interface"
 version = "0.20.0"
@@ -7182,6 +7233,12 @@ dependencies = [
  "serde",
 ]
 
+[[package]]
+name = "urlencoding"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8db7427f936968176eaa7cdf81b7f98b980b18495ec28f1b5791ac3bfe3eea9"
+
 [[package]]
 name = "usvg"
 version = "0.14.1"
@@ -8129,7 +8186,7 @@ checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
 
 [[package]]
 name = "zed"
-version = "0.68.0"
+version = "0.70.0"
 dependencies = [
  "activity_indicator",
  "anyhow",
@@ -8161,6 +8218,7 @@ dependencies = [
  "fuzzy",
  "go_to_line",
  "gpui",
+ "human_bytes",
  "ignore",
  "image",
  "indexmap",
@@ -8180,6 +8238,7 @@ dependencies = [
  "project_panel",
  "project_symbols",
  "rand 0.8.5",
+ "recent_projects",
  "regex",
  "rpc",
  "rsa",
@@ -8193,6 +8252,7 @@ dependencies = [
  "smallvec",
  "smol",
  "sum_tree",
+ "sysinfo",
  "tempdir",
  "terminal_view",
  "text",
@@ -8221,6 +8281,7 @@ dependencies = [
  "tree-sitter-typescript",
  "unindent",
  "url",
+ "urlencoding",
  "util",
  "vim",
  "workspace",

Cargo.toml

@@ -40,6 +40,7 @@ members = [
     "crates/project",
     "crates/project_panel",
     "crates/project_symbols",
+    "crates/recent_projects",
     "crates/rope",
     "crates/rpc",
     "crates/search",

README.md

@@ -83,56 +83,3 @@ rustup target add wasm32-wasi
 ```
 
 Plugins can be found in the `plugins` folder in the root. For more information about how plugins work, check the [Plugin Guide](./crates/plugin_runtime/README.md) in `crates/plugin_runtime/README.md`.
-
-## Roadmap
-
-We will organize our efforts around the following major milestones. We'll create tracking issues for each of these milestones to detail the individual tasks that comprise them.
-
-### Minimal text editor
-
-[Tracking issue](https://github.com/zed-industries/zed/issues/2)
-
-Ship a minimal text editor to investors and other insiders. It should be extremely fast and stable, but all it can do is open, edit, and save text files, making it potentially useful for basic editing but not for real coding.
-
-Establish basic infrastructure for building the app bundle and uploading an artifact. Once this is released, we should regularly distribute updates as features land.
-
-### Collaborative code editor for internal use
-
-[Tracking issue](https://github.com/zed-industries/zed/issues/6)
-
-Turn the minimal text editor into a collaborative _code_ editor. This will include the minimal features that the Zed team needs to collaborate in Zed to build Zed without net loss in developer productivity. This includes productivity-critical features such as:
-
-- Syntax highlighting and syntax-aware editing and navigation
-- The ability to see and edit non-local working copies of a repository
-- Language server support for Rust code navigation, refactoring, diagnostics, etc.
-- Project browsing and project-wide search and replace
-
-We want to tackle collaboration fairly early so that the rest of the design of the product can flow around that assumption. We could probably produce a single-player code editor more quickly, but at the risk of having collaboration feel more "bolted on" when we eventually add it.
-
-### Private alpha for Rust teams on macOS
-
-The "minimal" milestones were about getting Zed to a point where the Zed team could use Zed productively to build Zed. What features are required for someone outside the company to use Zed to productively work on another project that is also written in Rust?
-
-This includes infrastructure like auto-updates, error reporting, and metrics collection. It also includes some amount of polish to make the tool more discoverable for someone that didn't write it, such as a UI for updating settings and key bindings. We may also need to enhance the server to support user authentication and related concerns.
-
-The initial target audience is like us. A small team working in Rust that's potentially interested in collaborating. As the alpha proceeds, we can work with teams of different sizes.
-
-### Private beta for Rust teams on macOS
-
-Once we're getting sufficiently positive feedback from our initial alpha users, we widen the audience by letting people share invites. Now may be a good time to get Zed running on the web, so that it's extremely easy for a Zed user to share a link and be collaborating in seconds. Once someone is using Zed on the Web, we'll let them register for the private beta and download the native binary if they're on macOS.
-
-### Expand to other languages
-
-Depending on how the Rust beta is going, focus hard on dominating another niche language such as Elixr or getting a foothold within a niche of a larger language, such as React/Typescript. Alternatively, go wide at this point and add decent support several widely-used languages such as Python, Ruby, Typescript, etc. This would entail taking 1-2 weeks per language and making sure we ship a solid experience based on a publicly-available language server. Each language has slightly different development practices, so we need to make sure Zed's UX meshes well with those practices.
-
-### Future directions
-
-Each of these sections could probably broken into multiple milestones, but this part of the roadmap is too far in the future to go into that level of detail at this point.
-
-#### Expand to other platforms
-
-Support Linux and Windows. We'll probably want to hire at least one person that prefers to work on each respective platform and have them spearhead the effort to port Zed to that platform. Once they've done so, they can join the general development effort while ensuring the user experience stays good on that platform.
-
-#### Expand on collaboration
-
-To start with, we'll focus on synchronous collaboration because that's where we're most differentiated, but there's no reason we have to limit ourselves to that. How can our tool facilitate collaboration generally, whether it's sync or async? What would it take for a team to go 100% Zed and collaborate fully within the tool? If we haven't added it already, basic Git support would be nice.

assets/keymaps/default.json

@@ -20,8 +20,10 @@
             "alt-cmd-left": "pane::ActivatePrevItem",
             "alt-cmd-right": "pane::ActivateNextItem",
             "cmd-w": "pane::CloseActiveItem",
-            "cmd-shift-w": "workspace::CloseWindow",
             "alt-cmd-t": "pane::CloseInactiveItems",
+            "cmd-k u": "pane::CloseCleanItems",
+            "cmd-k cmd-w": "pane::CloseAllItems",
+            "cmd-shift-w": "workspace::CloseWindow",
             "cmd-s": "workspace::Save",
             "cmd-shift-s": "workspace::SaveAs",
             "cmd-=": "zed::IncreaseBufferFontSize",
@@ -36,6 +38,7 @@
             "cmd-n": "workspace::NewFile",
             "cmd-shift-n": "workspace::NewWindow",
             "cmd-o": "workspace::Open",
+            "alt-cmd-o": "recent_projects::Toggle",
             "ctrl-`": "workspace::NewTerminal"
         }
     },
@@ -66,9 +69,11 @@
             "up": "editor::MoveUp",
             "pageup": "editor::PageUp",
             "shift-pageup": "editor::MovePageUp",
+            "home": "editor::MoveToBeginningOfLine",
             "down": "editor::MoveDown",
             "pagedown": "editor::PageDown",
             "shift-pagedown": "editor::MovePageDown",
+            "end": "editor::MoveToEndOfLine",
             "left": "editor::MoveLeft",
             "right": "editor::MoveRight",
             "ctrl-p": "editor::MoveUp",
@@ -109,6 +114,12 @@
                     "stop_at_soft_wraps": true
                 }
             ],
+            "shift-home": [
+                "editor::SelectToBeginningOfLine",
+                {
+                    "stop_at_soft_wraps": true
+                }
+            ],
             "ctrl-shift-a": [
                 "editor::SelectToBeginningOfLine",
                 {
@@ -121,6 +132,12 @@
                     "stop_at_soft_wraps": true
                 }
             ],
+            "shift-end": [
+                "editor::SelectToEndOfLine",
+                {
+                    "stop_at_soft_wraps": true
+                }
+            ],
             "ctrl-shift-e": [
                 "editor::SelectToEndOfLine",
                 {
@@ -169,10 +186,10 @@
         }
     },
     {
-        "context": "BufferSearchBar",
+        "context": "BufferSearchBar > Editor",
         "bindings": {
             "escape": "buffer_search::Dismiss",
-            "cmd-f": "buffer_search::FocusEditor",
+            "tab": "buffer_search::FocusEditor",
             "enter": "search::SelectNextMatch",
             "shift-enter": "search::SelectPrevMatch"
         }

assets/keymaps/vim.json

@@ -1,6 +1,6 @@
 [
     {
-        "context": "Editor && VimControl",
+        "context": "Editor && VimControl && !VimWaiting",
         "bindings": {
             "g": [
                 "vim::PushOperator",
@@ -53,6 +53,42 @@
                 }
             ],
             "%": "vim::Matching",
+            "ctrl-y": [
+                "vim::Scroll",
+                "LineUp"
+            ],
+            "f": [
+                "vim::PushOperator",
+                {
+                    "FindForward": {
+                        "before": false
+                    }
+                }
+            ],
+            "t": [
+                "vim::PushOperator",
+                {
+                    "FindForward": {
+                        "before": true
+                    }
+                }
+            ],
+            "shift-f": [
+                "vim::PushOperator",
+                {
+                    "FindBackward": {
+                        "after": false
+                    }
+                }
+            ],
+            "shift-t": [
+                "vim::PushOperator",
+                {
+                    "FindBackward": {
+                        "after": true
+                    }
+                }
+            ],
             "escape": "editor::Cancel",
             "0": "vim::StartOfLine", // When no number operator present, use start of line motion
             "1": [
@@ -94,7 +130,7 @@
         }
     },
     {
-        "context": "Editor && vim_mode == normal && vim_operator == none",
+        "context": "Editor && vim_mode == normal && vim_operator == none && !VimWaiting",
         "bindings": {
             "c": [
                 "vim::PushOperator",
@@ -174,9 +210,9 @@
                 "vim::Scroll",
                 "LineDown"
             ],
-            "ctrl-y": [
-                "vim::Scroll",
-                "LineUp"
+            "r": [
+                "vim::PushOperator",
+                "Replace"
             ]
         }
     },
@@ -255,14 +291,18 @@
         }
     },
     {
-        "context": "Editor && vim_mode == visual",
+        "context": "Editor && vim_mode == visual && !VimWaiting",
         "bindings": {
             "u": "editor::Undo",
             "c": "vim::VisualChange",
             "d": "vim::VisualDelete",
             "x": "vim::VisualDelete",
             "y": "vim::VisualYank",
-            "p": "vim::VisualPaste"
+            "p": "vim::VisualPaste",
+            "r": [
+                "vim::PushOperator",
+                "Replace"
+            ]
         }
     },
     {
@@ -271,5 +311,11 @@
             "escape": "vim::NormalBefore",
             "ctrl-c": "vim::NormalBefore"
         }
+    },
+    {
+        "context": "Editor && VimWaiting",
+        "bindings": {
+            "*": "gpui::KeyPressed"
+        }
     }
 ]

assets/settings/default.json

@@ -79,6 +79,13 @@
     "hard_tabs": false,
     // How many columns a tab should occupy.
     "tab_size": 4,
+    // Control what info Zed sends to our servers
+    "telemetry": {
+        // Send debug info like crash reports.
+        "diagnostics": true,
+        // Send anonymized usage data like what languages you're using Zed with.
+        "metrics": true
+    },
     // Git gutter behavior configuration.
     "git": {
         // Control whether the git gutter is shown. May take 2 values:
@@ -221,7 +228,7 @@
         // rust-analyzer
         // typescript-language-server
         // vscode-json-languageserver
-        // "rust_analyzer": {
+        // "rust-analyzer": {
         //     //These initialization options are merged into Zed's defaults
         //     "initialization_options": {
         //         "checkOnSave": {

crates/call/Cargo.toml

@@ -21,7 +21,10 @@ test-support = [
 client = { path = "../client" }
 collections = { path = "../collections" }
 gpui = { path = "../gpui" }
+log = "0.4"
 live_kit_client = { path = "../live_kit_client" }
+fs = { path = "../fs" }
+language = { path = "../language" }
 media = { path = "../media" }
 project = { path = "../project" }
 util = { path = "../util" }
@@ -33,6 +36,8 @@ postage = { version = "0.4.1", features = ["futures-traits"] }
 
 [dev-dependencies]
 client = { path = "../client", features = ["test-support"] }
+fs = { path = "../fs", features = ["test-support"] }
+language = { path = "../language", features = ["test-support"] }
 collections = { path = "../collections", features = ["test-support"] }
 gpui = { path = "../gpui", features = ["test-support"] }
 live_kit_client = { path = "../live_kit_client", features = ["test-support"] }

crates/call/src/participant.rs

@@ -39,6 +39,7 @@ pub struct LocalParticipant {
 #[derive(Clone, Debug)]
 pub struct RemoteParticipant {
     pub user: Arc<User>,
+    pub peer_id: proto::PeerId,
     pub projects: Vec<proto::ParticipantProject>,
     pub location: ParticipantLocation,
     pub tracks: HashMap<live_kit_client::Sid, Arc<RemoteVideoTrack>>,

crates/call/src/room.rs

@@ -3,27 +3,32 @@ use crate::{
     IncomingCall,
 };
 use anyhow::{anyhow, Result};
-use client::{proto, Client, PeerId, TypedEnvelope, User, UserStore};
-use collections::{BTreeMap, HashSet};
+use client::{
+    proto::{self, PeerId},
+    Client, TypedEnvelope, User, UserStore,
+};
+use collections::{BTreeMap, HashMap, HashSet};
+use fs::Fs;
 use futures::{FutureExt, StreamExt};
 use gpui::{
     AsyncAppContext, Entity, ModelContext, ModelHandle, MutableAppContext, Task, WeakModelHandle,
 };
+use language::LanguageRegistry;
 use live_kit_client::{LocalTrackPublication, LocalVideoTrack, RemoteVideoTrackUpdate};
 use postage::stream::Stream;
 use project::Project;
 use std::{mem, sync::Arc, time::Duration};
-use util::{post_inc, ResultExt};
+use util::{post_inc, ResultExt, TryFutureExt};
 
 pub const RECONNECT_TIMEOUT: Duration = client::RECEIVE_TIMEOUT;
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Event {
     ParticipantLocationChanged {
-        participant_id: PeerId,
+        participant_id: proto::PeerId,
     },
     RemoteVideoTracksChanged {
-        participant_id: PeerId,
+        participant_id: proto::PeerId,
     },
     RemoteProjectShared {
         owner: Arc<User>,
@@ -40,8 +45,10 @@ pub struct Room {
     id: u64,
     live_kit: Option<LiveKitRoom>,
     status: RoomStatus,
+    shared_projects: HashSet<WeakModelHandle<Project>>,
+    joined_projects: HashSet<WeakModelHandle<Project>>,
     local_participant: LocalParticipant,
-    remote_participants: BTreeMap<PeerId, RemoteParticipant>,
+    remote_participants: BTreeMap<u64, RemoteParticipant>,
     pending_participants: Vec<Arc<User>>,
     participant_user_ids: HashSet<u64>,
     pending_call_count: usize,
@@ -50,7 +57,7 @@ pub struct Room {
     user_store: ModelHandle<UserStore>,
     subscriptions: Vec<client::Subscription>,
     pending_room_update: Option<Task<()>>,
-    maintain_connection: Option<Task<Result<()>>>,
+    maintain_connection: Option<Task<Option<()>>>,
 }
 
 impl Entity for Room {
@@ -58,7 +65,8 @@ impl Entity for Room {
 
     fn release(&mut self, _: &mut MutableAppContext) {
         if self.status.is_online() {
-            self.client.send(proto::LeaveRoom {}).log_err();
+            log::info!("room was released, sending leave message");
+            let _ = self.client.send(proto::LeaveRoom {});
         }
     }
 }
@@ -122,12 +130,14 @@ impl Room {
         };
 
         let maintain_connection =
-            cx.spawn_weak(|this, cx| Self::maintain_connection(this, client.clone(), cx));
+            cx.spawn_weak(|this, cx| Self::maintain_connection(this, client.clone(), cx).log_err());
 
         Self {
             id,
             live_kit: live_kit_room,
             status: RoomStatus::Online,
+            shared_projects: Default::default(),
+            joined_projects: Default::default(),
             participant_user_ids: Default::default(),
             local_participant: Default::default(),
             remote_participants: Default::default(),
@@ -229,6 +239,23 @@ impl Room {
 
         cx.notify();
         cx.emit(Event::Left);
+        log::info!("leaving room");
+
+        for project in self.shared_projects.drain() {
+            if let Some(project) = project.upgrade(cx) {
+                project.update(cx, |project, cx| {
+                    project.unshare(cx).log_err();
+                });
+            }
+        }
+        for project in self.joined_projects.drain() {
+            if let Some(project) = project.upgrade(cx) {
+                project.update(cx, |project, cx| {
+                    project.disconnected_from_host(cx);
+                });
+            }
+        }
+
         self.status = RoomStatus::Offline;
         self.remote_participants.clear();
         self.pending_participants.clear();
@@ -252,15 +279,15 @@ impl Room {
                 .next()
                 .await
                 .map_or(false, |s| s.is_connected());
+
             // Even if we're initially connected, any future change of the status means we momentarily disconnected.
             if !is_connected || client_status.next().await.is_some() {
-                let room_id = this
-                    .upgrade(&cx)
+                log::info!("detected client disconnection");
+                this.upgrade(&cx)
                     .ok_or_else(|| anyhow!("room was dropped"))?
                     .update(&mut cx, |this, cx| {
                         this.status = RoomStatus::Rejoining;
                         cx.notify();
-                        this.id
                     });
 
                 // Wait for client to re-establish a connection to the server.
@@ -269,30 +296,25 @@ impl Room {
                     let client_reconnection = async {
                         let mut remaining_attempts = 3;
                         while remaining_attempts > 0 {
-                            if let Some(status) = client_status.next().await {
-                                if status.is_connected() {
-                                    let rejoin_room = async {
-                                        let response =
-                                            client.request(proto::JoinRoom { id: room_id }).await?;
-                                        let room_proto =
-                                            response.room.ok_or_else(|| anyhow!("invalid room"))?;
-                                        this.upgrade(&cx)
-                                            .ok_or_else(|| anyhow!("room was dropped"))?
-                                            .update(&mut cx, |this, cx| {
-                                                this.status = RoomStatus::Online;
-                                                this.apply_room_update(room_proto, cx)
-                                            })?;
-                                        anyhow::Ok(())
-                                    };
+                            log::info!(
+                                "waiting for client status change, remaining attempts {}",
+                                remaining_attempts
+                            );
+                            let Some(status) = client_status.next().await else { break };
+                            if status.is_connected() {
+                                log::info!("client reconnected, attempting to rejoin room");
 
-                                    if rejoin_room.await.is_ok() {
-                                        return true;
-                                    } else {
-                                        remaining_attempts -= 1;
-                                    }
+                                let Some(this) = this.upgrade(&cx) else { break };
+                                if this
+                                    .update(&mut cx, |this, cx| this.rejoin(cx))
+                                    .await
+                                    .log_err()
+                                    .is_some()
+                                {
+                                    return true;
+                                } else {
+                                    remaining_attempts -= 1;
                                 }
-                            } else {
-                                return false;
                             }
                         }
                         false
@@ -303,12 +325,15 @@ impl Room {
                     futures::select_biased! {
                         reconnected = client_reconnection => {
                             if reconnected {
+                                log::info!("successfully reconnected to room");
                                 // If we successfully joined the room, go back around the loop
                                 // waiting for future connection status changes.
                                 continue;
                             }
                         }
-                        _ = reconnection_timeout => {}
+                        _ = reconnection_timeout => {
+                            log::info!("room reconnection timeout expired");
+                        }
                     }
                 }
 
@@ -316,6 +341,7 @@ impl Room {
                 // or an error occurred while trying to re-join the room. Either way
                 // we leave the room and return an error.
                 if let Some(this) = this.upgrade(&cx) {
+                    log::info!("reconnection failed, leaving room");
                     let _ = this.update(&mut cx, |this, cx| this.leave(cx));
                 }
                 return Err(anyhow!(
@@ -325,6 +351,82 @@ impl Room {
         }
     }
 
+    fn rejoin(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
+        let mut projects = HashMap::default();
+        let mut reshared_projects = Vec::new();
+        let mut rejoined_projects = Vec::new();
+        self.shared_projects.retain(|project| {
+            if let Some(handle) = project.upgrade(cx) {
+                let project = handle.read(cx);
+                if let Some(project_id) = project.remote_id() {
+                    projects.insert(project_id, handle.clone());
+                    reshared_projects.push(proto::UpdateProject {
+                        project_id,
+                        worktrees: project.worktree_metadata_protos(cx),
+                    });
+                    return true;
+                }
+            }
+            false
+        });
+        self.joined_projects.retain(|project| {
+            if let Some(handle) = project.upgrade(cx) {
+                let project = handle.read(cx);
+                if let Some(project_id) = project.remote_id() {
+                    projects.insert(project_id, handle.clone());
+                    rejoined_projects.push(proto::RejoinProject {
+                        id: project_id,
+                        worktrees: project
+                            .worktrees(cx)
+                            .map(|worktree| {
+                                let worktree = worktree.read(cx);
+                                proto::RejoinWorktree {
+                                    id: worktree.id().to_proto(),
+                                    scan_id: worktree.completed_scan_id() as u64,
+                                }
+                            })
+                            .collect(),
+                    });
+                }
+                return true;
+            }
+            false
+        });
+
+        let response = self.client.request(proto::RejoinRoom {
+            id: self.id,
+            reshared_projects,
+            rejoined_projects,
+        });
+
+        cx.spawn(|this, mut cx| async move {
+            let response = response.await?;
+            let room_proto = response.room.ok_or_else(|| anyhow!("invalid room"))?;
+            this.update(&mut cx, |this, cx| {
+                this.status = RoomStatus::Online;
+                this.apply_room_update(room_proto, cx)?;
+
+                for reshared_project in response.reshared_projects {
+                    if let Some(project) = projects.get(&reshared_project.id) {
+                        project.update(cx, |project, cx| {
+                            project.reshared(reshared_project, cx).log_err();
+                        });
+                    }
+                }
+
+                for rejoined_project in response.rejoined_projects {
+                    if let Some(project) = projects.get(&rejoined_project.id) {
+                        project.update(cx, |project, cx| {
+                            project.rejoined(rejoined_project, cx).log_err();
+                        });
+                    }
+                }
+
+                anyhow::Ok(())
+            })
+        })
+    }
+
     pub fn id(&self) -> u64 {
         self.id
     }
@@ -337,10 +439,16 @@ impl Room {
         &self.local_participant
     }
 
-    pub fn remote_participants(&self) -> &BTreeMap<PeerId, RemoteParticipant> {
+    pub fn remote_participants(&self) -> &BTreeMap<u64, RemoteParticipant> {
         &self.remote_participants
     }
 
+    pub fn remote_participant_for_peer_id(&self, peer_id: PeerId) -> Option<&RemoteParticipant> {
+        self.remote_participants
+            .values()
+            .find(|p| p.peer_id == peer_id)
+    }
+
     pub fn pending_participants(&self) -> &[Arc<User>] {
         &self.pending_participants
     }
@@ -405,15 +513,13 @@ impl Room {
                 }
 
                 if let Some(participants) = remote_participants.log_err() {
-                    let mut participant_peer_ids = HashSet::default();
                     for (participant, user) in room.participants.into_iter().zip(participants) {
-                        let peer_id = PeerId(participant.peer_id);
+                        let Some(peer_id) = participant.peer_id else { continue };
                         this.participant_user_ids.insert(participant.user_id);
-                        participant_peer_ids.insert(peer_id);
 
                         let old_projects = this
                             .remote_participants
-                            .get(&peer_id)
+                            .get(&participant.user_id)
                             .into_iter()
                             .flat_map(|existing| &existing.projects)
                             .map(|project| project.id)
@@ -435,6 +541,20 @@ impl Room {
                         }
 
                         for unshared_project_id in old_projects.difference(&new_projects) {
+                            this.joined_projects.retain(|project| {
+                                if let Some(project) = project.upgrade(cx) {
+                                    project.update(cx, |project, cx| {
+                                        if project.remote_id() == Some(*unshared_project_id) {
+                                            project.disconnected_from_host(cx);
+                                            false
+                                        } else {
+                                            true
+                                        }
+                                    })
+                                } else {
+                                    false
+                                }
+                            });
                             cx.emit(Event::RemoteProjectUnshared {
                                 project_id: *unshared_project_id,
                             });
@@ -442,9 +562,11 @@ impl Room {
 
                         let location = ParticipantLocation::from_proto(participant.location)
                             .unwrap_or(ParticipantLocation::External);
-                        if let Some(remote_participant) = this.remote_participants.get_mut(&peer_id)
+                        if let Some(remote_participant) =
+                            this.remote_participants.get_mut(&participant.user_id)
                         {
                             remote_participant.projects = participant.projects;
+                            remote_participant.peer_id = peer_id;
                             if location != remote_participant.location {
                                 remote_participant.location = location;
                                 cx.emit(Event::ParticipantLocationChanged {
@@ -453,9 +575,10 @@ impl Room {
                             }
                         } else {
                             this.remote_participants.insert(
-                                peer_id,
+                                participant.user_id,
                                 RemoteParticipant {
                                     user: user.clone(),
+                                    peer_id,
                                     projects: participant.projects,
                                     location,
                                     tracks: Default::default(),
@@ -464,7 +587,7 @@ impl Room {
 
                             if let Some(live_kit) = this.live_kit.as_ref() {
                                 let tracks =
-                                    live_kit.room.remote_video_tracks(&peer_id.0.to_string());
+                                    live_kit.room.remote_video_tracks(&peer_id.to_string());
                                 for track in tracks {
                                     this.remote_video_track_updated(
                                         RemoteVideoTrackUpdate::Subscribed(track),
@@ -476,8 +599,8 @@ impl Room {
                         }
                     }
 
-                    this.remote_participants.retain(|peer_id, participant| {
-                        if participant_peer_ids.contains(peer_id) {
+                    this.remote_participants.retain(|user_id, participant| {
+                        if this.participant_user_ids.contains(user_id) {
                             true
                         } else {
                             for project in &participant.projects {
@@ -499,6 +622,7 @@ impl Room {
 
                 this.pending_room_update.take();
                 if this.should_leave() {
+                    log::info!("room is empty, leaving");
                     let _ = this.leave(cx);
                 }
 
@@ -518,11 +642,11 @@ impl Room {
     ) -> Result<()> {
         match change {
             RemoteVideoTrackUpdate::Subscribed(track) => {
-                let peer_id = PeerId(track.publisher_id().parse()?);
+                let user_id = track.publisher_id().parse()?;
                 let track_id = track.sid().to_string();
                 let participant = self
                     .remote_participants
-                    .get_mut(&peer_id)
+                    .get_mut(&user_id)
                     .ok_or_else(|| anyhow!("subscribed to track by unknown participant"))?;
                 participant.tracks.insert(
                     track_id.clone(),
@@ -531,21 +655,21 @@ impl Room {
                     }),
                 );
                 cx.emit(Event::RemoteVideoTracksChanged {
-                    participant_id: peer_id,
+                    participant_id: participant.peer_id,
                 });
             }
             RemoteVideoTrackUpdate::Unsubscribed {
                 publisher_id,
                 track_id,
             } => {
-                let peer_id = PeerId(publisher_id.parse()?);
+                let user_id = publisher_id.parse()?;
                 let participant = self
                     .remote_participants
-                    .get_mut(&peer_id)
+                    .get_mut(&user_id)
                     .ok_or_else(|| anyhow!("unsubscribed from track by unknown participant"))?;
                 participant.tracks.remove(&track_id);
                 cx.emit(Event::RemoteVideoTracksChanged {
-                    participant_id: peer_id,
+                    participant_id: participant.peer_id,
                 });
             }
         }
@@ -607,6 +731,32 @@ impl Room {
         })
     }
 
+    pub fn join_project(
+        &mut self,
+        id: u64,
+        language_registry: Arc<LanguageRegistry>,
+        fs: Arc<dyn Fs>,
+        cx: &mut ModelContext<Self>,
+    ) -> Task<Result<ModelHandle<Project>>> {
+        let client = self.client.clone();
+        let user_store = self.user_store.clone();
+        cx.spawn(|this, mut cx| async move {
+            let project =
+                Project::remote(id, client, user_store, language_registry, fs, cx.clone()).await?;
+            this.update(&mut cx, |this, cx| {
+                this.joined_projects.retain(|project| {
+                    if let Some(project) = project.upgrade(cx) {
+                        !project.read(cx).is_read_only()
+                    } else {
+                        false
+                    }
+                });
+                this.joined_projects.insert(project.downgrade());
+            });
+            Ok(project)
+        })
+    }
+
     pub(crate) fn share_project(
         &mut self,
         project: ModelHandle<Project>,
@@ -618,31 +768,18 @@ impl Room {
 
         let request = self.client.request(proto::ShareProject {
             room_id: self.id(),
-            worktrees: project
-                .read(cx)
-                .worktrees(cx)
-                .map(|worktree| {
-                    let worktree = worktree.read(cx);
-                    proto::WorktreeMetadata {
-                        id: worktree.id().to_proto(),
-                        root_name: worktree.root_name().into(),
-                        visible: worktree.is_visible(),
-                        abs_path: worktree.abs_path().to_string_lossy().into(),
-                    }
-                })
-                .collect(),
+            worktrees: project.read(cx).worktree_metadata_protos(cx),
         });
         cx.spawn(|this, mut cx| async move {
             let response = request.await?;
 
             project.update(&mut cx, |project, cx| {
-                project
-                    .shared(response.project_id, cx)
-                    .detach_and_log_err(cx)
-            });
+                project.shared(response.project_id, cx)
+            })?;
 
             // If the user's location is in this project, it changes from UnsharedProject to SharedProject.
             this.update(&mut cx, |this, cx| {
+                this.shared_projects.insert(project.downgrade());
                 let active_project = this.local_participant.active_project.as_ref();
                 if active_project.map_or(false, |location| *location == project) {
                     this.set_location(Some(&project), cx)

crates/client/src/client.rs

@@ -23,8 +23,9 @@ use lazy_static::lazy_static;
 use parking_lot::RwLock;
 use postage::watch;
 use rand::prelude::*;
-use rpc::proto::{AnyTypedEnvelope, EntityMessage, EnvelopedMessage, RequestMessage};
+use rpc::proto::{AnyTypedEnvelope, EntityMessage, EnvelopedMessage, PeerId, RequestMessage};
 use serde::Deserialize;
+use settings::{Settings, TelemetrySettings};
 use std::{
     any::TypeId,
     collections::HashMap,
@@ -140,7 +141,7 @@ impl EstablishConnectionError {
     }
 }
 
-#[derive(Copy, Clone, Debug, Eq, PartialEq)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 pub enum Status {
     SignedOut,
     UpgradeRequired,
@@ -306,7 +307,7 @@ impl Client {
     pub fn new(http: Arc<dyn HttpClient>, cx: &AppContext) -> Arc<Self> {
         Arc::new(Self {
             id: 0,
-            peer: Peer::new(),
+            peer: Peer::new(0),
             telemetry: Telemetry::new(http.clone(), cx),
             http,
             state: Default::default(),
@@ -333,14 +334,14 @@ impl Client {
     }
 
     #[cfg(any(test, feature = "test-support"))]
-    pub fn tear_down(&self) {
+    pub fn teardown(&self) {
         let mut state = self.state.write();
         state._reconnect_task.take();
         state.message_handlers.clear();
         state.models_by_message_type.clear();
         state.entities_by_type_and_remote_id.clear();
         state.entity_id_extractors.clear();
-        self.peer.reset();
+        self.peer.teardown();
     }
 
     #[cfg(any(test, feature = "test-support"))]
@@ -423,7 +424,9 @@ impl Client {
                 }));
             }
             Status::SignedOut | Status::UpgradeRequired => {
-                self.telemetry.set_authenticated_user_info(None, false);
+                let telemetry_settings = cx.read(|cx| cx.global::<Settings>().telemetry());
+                self.telemetry
+                    .set_authenticated_user_info(None, false, telemetry_settings);
                 state._reconnect_task.take();
             }
             _ => {}
@@ -706,7 +709,13 @@ impl Client {
             credentials = read_credentials_from_keychain(cx);
             read_from_keychain = credentials.is_some();
             if read_from_keychain {
-                self.report_event("read credentials from keychain", Default::default());
+                cx.read(|cx| {
+                    self.report_event(
+                        "read credentials from keychain",
+                        Default::default(),
+                        cx.global::<Settings>().telemetry(),
+                    );
+                });
             }
         }
         if credentials.is_none() {
@@ -810,7 +819,11 @@ impl Client {
                         hello_message_type_name
                     )
                 })?;
-            Ok(PeerId(hello.payload.peer_id))
+            let peer_id = hello
+                .payload
+                .peer_id
+                .ok_or_else(|| anyhow!("invalid peer id"))?;
+            Ok(peer_id)
         };
 
         let peer_id = match peer_id.await {
@@ -822,7 +835,7 @@ impl Client {
         };
 
         log::info!(
-            "set status to connected (connection id: {}, peer id: {})",
+            "set status to connected (connection id: {:?}, peer id: {:?})",
             connection_id,
             peer_id
         );
@@ -853,7 +866,7 @@ impl Client {
             .spawn(async move {
                 match handle_io.await {
                     Ok(()) => {
-                        if *this.status().borrow()
+                        if this.status().borrow().clone()
                             == (Status::Connected {
                                 connection_id,
                                 peer_id,
@@ -993,6 +1006,8 @@ impl Client {
         let executor = cx.background();
         let telemetry = self.telemetry.clone();
         let http = self.http.clone();
+        let metrics_enabled = cx.read(|cx| cx.global::<Settings>().telemetry());
+
         executor.clone().spawn(async move {
             // Generate a pair of asymmetric encryption keys. The public key will be used by the
             // zed server to encrypt the user's access token, so that it can'be intercepted by
@@ -1075,7 +1090,11 @@ impl Client {
                 .context("failed to decrypt access token")?;
             platform.activate(true);
 
-            telemetry.report_event("authenticate with browser", Default::default());
+            telemetry.report_event(
+                "authenticate with browser",
+                Default::default(),
+                metrics_enabled,
+            );
 
             Ok(Credentials {
                 user_id: user_id.parse()?,
@@ -1194,7 +1213,7 @@ impl Client {
         let mut state = self.state.write();
         let type_name = message.payload_type_name();
         let payload_type_id = message.payload_type_id();
-        let sender_id = message.original_sender_id().map(|id| id.0);
+        let sender_id = message.original_sender_id();
 
         let mut subscriber = None;
 
@@ -1231,6 +1250,7 @@ impl Client {
             subscriber
         } else {
             log::info!("unhandled message {}", type_name);
+            self.peer.respond_with_unhandled_message(message).log_err();
             return;
         };
 
@@ -1274,6 +1294,7 @@ impl Client {
                 .detach();
         } else {
             log::info!("unhandled message {}", type_name);
+            self.peer.respond_with_unhandled_message(message).log_err();
         }
     }
 
@@ -1281,8 +1302,14 @@ impl Client {
         self.telemetry.start();
     }
 
-    pub fn report_event(&self, kind: &str, properties: Value) {
-        self.telemetry.report_event(kind, properties.clone());
+    pub fn report_event(
+        &self,
+        kind: &str,
+        properties: Value,
+        telemetry_settings: TelemetrySettings,
+    ) {
+        self.telemetry
+            .report_event(kind, properties.clone(), telemetry_settings);
     }
 
     pub fn telemetry_log_file_path(&self) -> Option<PathBuf> {

crates/client/src/telemetry.rs

@@ -10,6 +10,7 @@ use lazy_static::lazy_static;
 use parking_lot::Mutex;
 use serde::Serialize;
 use serde_json::json;
+use settings::TelemetrySettings;
 use std::{
     io::Write,
     mem,
@@ -184,11 +185,18 @@ impl Telemetry {
             .detach();
     }
 
+    /// This method takes the entire TelemetrySettings struct in order to force client code
+    /// to pull the struct out of the settings global. Do not remove!
     pub fn set_authenticated_user_info(
         self: &Arc<Self>,
         metrics_id: Option<String>,
         is_staff: bool,
+        telemetry_settings: TelemetrySettings,
     ) {
+        if !telemetry_settings.metrics() {
+            return;
+        }
+
         let this = self.clone();
         let mut state = self.state.lock();
         let device_id = state.device_id.clone();
@@ -221,7 +229,16 @@ impl Telemetry {
         }
     }
 
-    pub fn report_event(self: &Arc<Self>, kind: &str, properties: Value) {
+    pub fn report_event(
+        self: &Arc<Self>,
+        kind: &str,
+        properties: Value,
+        telemetry_settings: TelemetrySettings,
+    ) {
+        if !telemetry_settings.metrics() {
+            return;
+        }
+
         let mut state = self.state.lock();
         let event = MixpanelEvent {
             event: kind.to_string(),

crates/client/src/test.rs

@@ -35,7 +35,7 @@ impl FakeServer {
         cx: &TestAppContext,
     ) -> Self {
         let server = Self {
-            peer: Peer::new(),
+            peer: Peer::new(0),
             state: Default::default(),
             user_id: client_user_id,
             executor: cx.foreground(),
@@ -92,7 +92,7 @@ impl FakeServer {
                         peer.send(
                             connection_id,
                             proto::Hello {
-                                peer_id: connection_id.0,
+                                peer_id: Some(connection_id.into()),
                             },
                         )
                         .unwrap();

crates/client/src/user.rs

@@ -5,6 +5,7 @@ use futures::{channel::mpsc, future, AsyncReadExt, Future, StreamExt};
 use gpui::{AsyncAppContext, Entity, ImageData, ModelContext, ModelHandle, Task};
 use postage::{sink::Sink, watch};
 use rpc::proto::{RequestMessage, UsersResponse};
+use settings::Settings;
 use std::sync::{Arc, Weak};
 use util::TryFutureExt as _;
 
@@ -141,14 +142,11 @@ impl UserStore {
                                 let fetch_metrics_id =
                                     client.request(proto::GetPrivateUserInfo {}).log_err();
                                 let (user, info) = futures::join!(fetch_user, fetch_metrics_id);
-                                if let Some(info) = info {
-                                    client.telemetry.set_authenticated_user_info(
-                                        Some(info.metrics_id.clone()),
-                                        info.staff,
-                                    );
-                                } else {
-                                    client.telemetry.set_authenticated_user_info(None, false);
-                                }
+                                client.telemetry.set_authenticated_user_info(
+                                    info.as_ref().map(|info| info.metrics_id.clone()),
+                                    info.as_ref().map(|info| info.staff).unwrap_or(false),
+                                    cx.read(|cx| cx.global::<Settings>().telemetry()),
+                                );
 
                                 current_user_tx.send(user).await.ok();
                             }

crates/collab/.env.toml

@@ -2,6 +2,7 @@ DATABASE_URL = "postgres://postgres@localhost/zed"
 HTTP_PORT = 8080
 API_TOKEN = "secret"
 INVITE_LINK_PREFIX = "http://localhost:3000/invites/"
+ZED_ENVIRONMENT = "development"
 LIVE_KIT_SERVER = "http://localhost:7880"
 LIVE_KIT_KEY = "devkey"
 LIVE_KIT_SECRET = "secret"

crates/collab/Cargo.toml

@@ -3,7 +3,7 @@ authors = ["Nathan Sobo <nathan@zed.dev>"]
 default-run = "collab"
 edition = "2021"
 name = "collab"
-version = "0.3.3"
+version = "0.5.2"
 
 [[bin]]
 name = "collab"

crates/collab/k8s/manifest.template.yml

@@ -59,6 +59,12 @@ spec:
           ports:
             - containerPort: 8080
               protocol: TCP
+          readinessProbe:
+            httpGet:
+              path: /
+              port: 8080
+            initialDelaySeconds: 1
+            periodSeconds: 1
           env:
             - name: HTTP_PORT
               value: "8080"
@@ -93,6 +99,8 @@ spec:
               value: ${RUST_LOG}
             - name: LOG_JSON
               value: "true"
+            - name: ZED_ENVIRONMENT
+              value: ${ZED_ENVIRONMENT}
           securityContext:
             capabilities:
               # FIXME - Switch to the more restrictive `PERFMON` capability.

crates/collab/migrations.sqlite/20221109000000_test_schema.sql

@@ -43,11 +43,12 @@ CREATE TABLE "projects" (
     "id" INTEGER PRIMARY KEY AUTOINCREMENT,
     "room_id" INTEGER REFERENCES rooms (id) NOT NULL,
     "host_user_id" INTEGER REFERENCES users (id) NOT NULL,
-    "host_connection_id" INTEGER NOT NULL,
-    "host_connection_epoch" TEXT NOT NULL,
+    "host_connection_id" INTEGER,
+    "host_connection_server_id" INTEGER REFERENCES servers (id) ON DELETE CASCADE,
     "unregistered" BOOLEAN NOT NULL DEFAULT FALSE
 );
-CREATE INDEX "index_projects_on_host_connection_epoch" ON "projects" ("host_connection_epoch");
+CREATE INDEX "index_projects_on_host_connection_server_id" ON "projects" ("host_connection_server_id");
+CREATE INDEX "index_projects_on_host_connection_id_and_host_connection_server_id" ON "projects" ("host_connection_id", "host_connection_server_id");
 
 CREATE TABLE "worktrees" (
     "project_id" INTEGER NOT NULL REFERENCES projects (id) ON DELETE CASCADE,
@@ -56,7 +57,8 @@ CREATE TABLE "worktrees" (
     "abs_path" VARCHAR NOT NULL,
     "visible" BOOL NOT NULL,
     "scan_id" INTEGER NOT NULL,
-    "is_complete" BOOL NOT NULL,
+    "is_complete" BOOL NOT NULL DEFAULT FALSE,
+    "completed_scan_id" INTEGER NOT NULL,
     PRIMARY KEY(project_id, id)
 );
 CREATE INDEX "index_worktrees_on_project_id" ON "worktrees" ("project_id");
@@ -64,6 +66,7 @@ CREATE INDEX "index_worktrees_on_project_id" ON "worktrees" ("project_id");
 CREATE TABLE "worktree_entries" (
     "project_id" INTEGER NOT NULL,
     "worktree_id" INTEGER NOT NULL,
+    "scan_id" INTEGER NOT NULL,
     "id" INTEGER NOT NULL,
     "is_dir" BOOL NOT NULL,
     "path" VARCHAR NOT NULL,
@@ -72,6 +75,7 @@ CREATE TABLE "worktree_entries" (
     "mtime_nanos" INTEGER NOT NULL,
     "is_symlink" BOOL NOT NULL,
     "is_ignored" BOOL NOT NULL,
+    "is_deleted" BOOL NOT NULL,
     PRIMARY KEY(project_id, worktree_id, id),
     FOREIGN KEY(project_id, worktree_id) REFERENCES worktrees (project_id, id) ON DELETE CASCADE
 );
@@ -103,34 +107,39 @@ CREATE TABLE "project_collaborators" (
     "id" INTEGER PRIMARY KEY AUTOINCREMENT,
     "project_id" INTEGER NOT NULL REFERENCES projects (id) ON DELETE CASCADE,
     "connection_id" INTEGER NOT NULL,
-    "connection_epoch" TEXT NOT NULL,
+    "connection_server_id" INTEGER NOT NULL REFERENCES servers (id) ON DELETE CASCADE,
     "user_id" INTEGER NOT NULL,
     "replica_id" INTEGER NOT NULL,
     "is_host" BOOLEAN NOT NULL
 );
 CREATE INDEX "index_project_collaborators_on_project_id" ON "project_collaborators" ("project_id");
 CREATE UNIQUE INDEX "index_project_collaborators_on_project_id_and_replica_id" ON "project_collaborators" ("project_id", "replica_id");
-CREATE INDEX "index_project_collaborators_on_connection_epoch" ON "project_collaborators" ("connection_epoch");
+CREATE INDEX "index_project_collaborators_on_connection_server_id" ON "project_collaborators" ("connection_server_id");
 CREATE INDEX "index_project_collaborators_on_connection_id" ON "project_collaborators" ("connection_id");
-CREATE UNIQUE INDEX "index_project_collaborators_on_project_id_connection_id_and_epoch" ON "project_collaborators" ("project_id", "connection_id", "connection_epoch");
+CREATE UNIQUE INDEX "index_project_collaborators_on_project_id_connection_id_and_server_id" ON "project_collaborators" ("project_id", "connection_id", "connection_server_id");
 
 CREATE TABLE "room_participants" (
     "id" INTEGER PRIMARY KEY AUTOINCREMENT,
     "room_id" INTEGER NOT NULL REFERENCES rooms (id),
     "user_id" INTEGER NOT NULL REFERENCES users (id),
     "answering_connection_id" INTEGER,
-    "answering_connection_epoch" TEXT,
+    "answering_connection_server_id" INTEGER REFERENCES servers (id) ON DELETE CASCADE,
     "answering_connection_lost" BOOLEAN NOT NULL,
     "location_kind" INTEGER,
     "location_project_id" INTEGER,
     "initial_project_id" INTEGER,
     "calling_user_id" INTEGER NOT NULL REFERENCES users (id),
     "calling_connection_id" INTEGER NOT NULL,
-    "calling_connection_epoch" TEXT NOT NULL
+    "calling_connection_server_id" INTEGER REFERENCES servers (id) ON DELETE SET NULL
 );
 CREATE UNIQUE INDEX "index_room_participants_on_user_id" ON "room_participants" ("user_id");
 CREATE INDEX "index_room_participants_on_room_id" ON "room_participants" ("room_id");
-CREATE INDEX "index_room_participants_on_answering_connection_epoch" ON "room_participants" ("answering_connection_epoch");
-CREATE INDEX "index_room_participants_on_calling_connection_epoch" ON "room_participants" ("calling_connection_epoch");
+CREATE INDEX "index_room_participants_on_answering_connection_server_id" ON "room_participants" ("answering_connection_server_id");
+CREATE INDEX "index_room_participants_on_calling_connection_server_id" ON "room_participants" ("calling_connection_server_id");
 CREATE INDEX "index_room_participants_on_answering_connection_id" ON "room_participants" ("answering_connection_id");
-CREATE UNIQUE INDEX "index_room_participants_on_answering_connection_id_and_answering_connection_epoch" ON "room_participants" ("answering_connection_id", "answering_connection_epoch");
+CREATE UNIQUE INDEX "index_room_participants_on_answering_connection_id_and_answering_connection_server_id" ON "room_participants" ("answering_connection_id", "answering_connection_server_id");
+
+CREATE TABLE "servers" (
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT,
+    "environment" VARCHAR NOT NULL
+);

crates/collab/migrations/20221214144346_change_epoch_from_uuid_to_integer.sql

@@ -0,0 +1,30 @@
+CREATE TABLE servers (
+    id SERIAL PRIMARY KEY,
+    environment VARCHAR NOT NULL
+);
+
+DROP TABLE worktree_extensions;
+DROP TABLE project_activity_periods;
+DELETE from projects;
+ALTER TABLE projects
+    DROP COLUMN host_connection_epoch,
+    ADD COLUMN host_connection_server_id INTEGER REFERENCES servers (id) ON DELETE CASCADE;
+CREATE INDEX "index_projects_on_host_connection_server_id" ON "projects" ("host_connection_server_id");
+CREATE INDEX "index_projects_on_host_connection_id_and_host_connection_server_id" ON "projects" ("host_connection_id", "host_connection_server_id");
+
+DELETE FROM project_collaborators;
+ALTER TABLE project_collaborators
+    DROP COLUMN connection_epoch,
+    ADD COLUMN connection_server_id INTEGER NOT NULL REFERENCES servers (id) ON DELETE CASCADE;
+CREATE INDEX "index_project_collaborators_on_connection_server_id" ON "project_collaborators" ("connection_server_id");
+CREATE UNIQUE INDEX "index_project_collaborators_on_project_id_connection_id_and_server_id" ON "project_collaborators" ("project_id", "connection_id", "connection_server_id");
+
+DELETE FROM room_participants;
+ALTER TABLE room_participants
+    DROP COLUMN answering_connection_epoch,
+    DROP COLUMN calling_connection_epoch,
+    ADD COLUMN answering_connection_server_id INTEGER REFERENCES servers (id) ON DELETE CASCADE,
+    ADD COLUMN calling_connection_server_id INTEGER REFERENCES servers (id) ON DELETE SET NULL;
+CREATE INDEX "index_room_participants_on_answering_connection_server_id" ON "room_participants" ("answering_connection_server_id");
+CREATE INDEX "index_room_participants_on_calling_connection_server_id" ON "room_participants" ("calling_connection_server_id");
+CREATE UNIQUE INDEX "index_room_participants_on_answering_connection_id_and_answering_connection_server_id" ON "room_participants" ("answering_connection_id", "answering_connection_server_id");

crates/collab/migrations/20221219181850_project_reconnection_support.sql

@@ -0,0 +1,3 @@
+ALTER TABLE "worktree_entries"
+    ADD COLUMN "scan_id" INT8,
+    ADD COLUMN "is_deleted" BOOL;

crates/collab/migrations/20230103200902_replace_is_completed_with_completed_scan_id.sql

@@ -0,0 +1,3 @@
+ALTER TABLE worktrees
+    ALTER COLUMN is_complete SET DEFAULT FALSE,
+    ADD COLUMN completed_scan_id INT8;

crates/collab/src/api.rs

@@ -353,6 +353,8 @@ pub struct CreateInviteFromCodeParams {
     invite_code: String,
     email_address: String,
     device_id: Option<String>,
+    #[serde(default)]
+    added_to_mailing_list: bool,
 }
 
 async fn create_invite_from_code(
@@ -365,6 +367,7 @@ async fn create_invite_from_code(
                 &params.invite_code,
                 &params.email_address,
                 params.device_id.as_deref(),
+                params.added_to_mailing_list,
             )
             .await?,
     ))

crates/collab/src/db/project.rs

@@ -1,4 +1,6 @@
-use super::{ProjectId, RoomId, UserId};
+use super::{ProjectId, Result, RoomId, ServerId, UserId};
+use anyhow::anyhow;
+use rpc::ConnectionId;
 use sea_orm::entity::prelude::*;
 
 #[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
@@ -8,8 +10,23 @@ pub struct Model {
     pub id: ProjectId,
     pub room_id: RoomId,
     pub host_user_id: UserId,
-    pub host_connection_id: i32,
-    pub host_connection_epoch: Uuid,
+    pub host_connection_id: Option<i32>,
+    pub host_connection_server_id: Option<ServerId>,
+}
+
+impl Model {
+    pub fn host_connection(&self) -> Result<ConnectionId> {
+        let host_connection_server_id = self
+            .host_connection_server_id
+            .ok_or_else(|| anyhow!("empty host_connection_server_id"))?;
+        let host_connection_id = self
+            .host_connection_id
+            .ok_or_else(|| anyhow!("empty host_connection_id"))?;
+        Ok(ConnectionId {
+            owner_id: host_connection_server_id.0 as u32,
+            id: host_connection_id as u32,
+        })
+    }
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]

crates/collab/src/db/project_collaborator.rs

@@ -1,4 +1,5 @@
-use super::{ProjectCollaboratorId, ProjectId, ReplicaId, UserId};
+use super::{ProjectCollaboratorId, ProjectId, ReplicaId, ServerId, UserId};
+use rpc::ConnectionId;
 use sea_orm::entity::prelude::*;
 
 #[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
@@ -8,12 +9,21 @@ pub struct Model {
     pub id: ProjectCollaboratorId,
     pub project_id: ProjectId,
     pub connection_id: i32,
-    pub connection_epoch: Uuid,
+    pub connection_server_id: ServerId,
     pub user_id: UserId,
     pub replica_id: ReplicaId,
     pub is_host: bool,
 }
 
+impl Model {
+    pub fn connection(&self) -> ConnectionId {
+        ConnectionId {
+            owner_id: self.connection_server_id.0 as u32,
+            id: self.connection_id as u32,
+        }
+    }
+}
+
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
 pub enum Relation {
     #[sea_orm(

crates/collab/src/db/room_participant.rs

@@ -1,4 +1,4 @@
-use super::{ProjectId, RoomId, RoomParticipantId, UserId};
+use super::{ProjectId, RoomId, RoomParticipantId, ServerId, UserId};
 use sea_orm::entity::prelude::*;
 
 #[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
@@ -9,14 +9,14 @@ pub struct Model {
     pub room_id: RoomId,
     pub user_id: UserId,
     pub answering_connection_id: Option<i32>,
-    pub answering_connection_epoch: Option<Uuid>,
+    pub answering_connection_server_id: Option<ServerId>,
     pub answering_connection_lost: bool,
     pub location_kind: Option<i32>,
     pub location_project_id: Option<ProjectId>,
     pub initial_project_id: Option<ProjectId>,
     pub calling_user_id: UserId,
     pub calling_connection_id: i32,
-    pub calling_connection_epoch: Uuid,
+    pub calling_connection_server_id: Option<ServerId>,
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]

crates/collab/src/db/server.rs

@@ -0,0 +1,15 @@
+use super::ServerId;
+use sea_orm::entity::prelude::*;
+
+#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
+#[sea_orm(table_name = "servers")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: ServerId,
+    pub environment: String,
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {}
+
+impl ActiveModelBehavior for ActiveModel {}

crates/collab/src/db/tests.rs

@@ -410,6 +410,8 @@ test_both_dbs!(
     test_project_count_sqlite,
     db,
     {
+        let owner_id = db.create_server("test").await.unwrap().0 as u32;
+
         let user1 = db
             .create_user(
                 &format!("admin@example.com"),
@@ -436,36 +438,44 @@ test_both_dbs!(
             .unwrap();
 
         let room_id = RoomId::from_proto(
-            db.create_room(user1.user_id, ConnectionId(0), "")
+            db.create_room(user1.user_id, ConnectionId { owner_id, id: 0 }, "")
                 .await
                 .unwrap()
                 .id,
         );
-        db.call(room_id, user1.user_id, ConnectionId(0), user2.user_id, None)
-            .await
-            .unwrap();
-        db.join_room(room_id, user2.user_id, ConnectionId(1))
+        db.call(
+            room_id,
+            user1.user_id,
+            ConnectionId { owner_id, id: 0 },
+            user2.user_id,
+            None,
+        )
+        .await
+        .unwrap();
+        db.join_room(room_id, user2.user_id, ConnectionId { owner_id, id: 1 })
             .await
             .unwrap();
         assert_eq!(db.project_count_excluding_admins().await.unwrap(), 0);
 
-        db.share_project(room_id, ConnectionId(1), &[])
+        db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[])
             .await
             .unwrap();
         assert_eq!(db.project_count_excluding_admins().await.unwrap(), 1);
 
-        db.share_project(room_id, ConnectionId(1), &[])
+        db.share_project(room_id, ConnectionId { owner_id, id: 1 }, &[])
             .await
             .unwrap();
         assert_eq!(db.project_count_excluding_admins().await.unwrap(), 2);
 
         // Projects shared by admins aren't counted.
-        db.share_project(room_id, ConnectionId(0), &[])
+        db.share_project(room_id, ConnectionId { owner_id, id: 0 }, &[])
             .await
             .unwrap();
         assert_eq!(db.project_count_excluding_admins().await.unwrap(), 2);
 
-        db.leave_room(ConnectionId(1)).await.unwrap();
+        db.leave_room(ConnectionId { owner_id, id: 1 })
+            .await
+            .unwrap();
         assert_eq!(db.project_count_excluding_admins().await.unwrap(), 0);
     }
 );
@@ -557,7 +567,12 @@ async fn test_invite_codes() {
 
     // User 2 redeems the invite code and becomes a contact of user 1.
     let user2_invite = db
-        .create_invite_from_code(&invite_code, "user2@example.com", Some("user-2-device-id"))
+        .create_invite_from_code(
+            &invite_code,
+            "user2@example.com",
+            Some("user-2-device-id"),
+            true,
+        )
         .await
         .unwrap();
     let NewUserResult {
@@ -607,7 +622,7 @@ async fn test_invite_codes() {
 
     // User 3 redeems the invite code and becomes a contact of user 1.
     let user3_invite = db
-        .create_invite_from_code(&invite_code, "user3@example.com", None)
+        .create_invite_from_code(&invite_code, "user3@example.com", None, true)
         .await
         .unwrap();
     let NewUserResult {
@@ -662,9 +677,14 @@ async fn test_invite_codes() {
     );
 
     // Trying to reedem the code for the third time results in an error.
-    db.create_invite_from_code(&invite_code, "user4@example.com", Some("user-4-device-id"))
-        .await
-        .unwrap_err();
+    db.create_invite_from_code(
+        &invite_code,
+        "user4@example.com",
+        Some("user-4-device-id"),
+        true,
+    )
+    .await
+    .unwrap_err();
 
     // Invite count can be updated after the code has been created.
     db.set_invite_count_for_user(user1, 2).await.unwrap();
@@ -674,7 +694,12 @@ async fn test_invite_codes() {
 
     // User 4 can now redeem the invite code and becomes a contact of user 1.
     let user4_invite = db
-        .create_invite_from_code(&invite_code, "user4@example.com", Some("user-4-device-id"))
+        .create_invite_from_code(
+            &invite_code,
+            "user4@example.com",
+            Some("user-4-device-id"),
+            true,
+        )
         .await
         .unwrap();
     let user4 = db
@@ -729,9 +754,14 @@ async fn test_invite_codes() {
     );
 
     // An existing user cannot redeem invite codes.
-    db.create_invite_from_code(&invite_code, "user2@example.com", Some("user-2-device-id"))
-        .await
-        .unwrap_err();
+    db.create_invite_from_code(
+        &invite_code,
+        "user2@example.com",
+        Some("user-2-device-id"),
+        true,
+    )
+    .await
+    .unwrap_err();
     let (_, invite_count) = db.get_invite_code_for_user(user1).await.unwrap().unwrap();
     assert_eq!(invite_count, 1);
 
@@ -753,7 +783,7 @@ async fn test_invite_codes() {
     db.set_invite_count_for_user(user5, 5).await.unwrap();
     let (user5_invite_code, _) = db.get_invite_code_for_user(user5).await.unwrap().unwrap();
     let user5_invite_to_user1 = db
-        .create_invite_from_code(&user5_invite_code, "user1@different.com", None)
+        .create_invite_from_code(&user5_invite_code, "user1@different.com", None, true)
         .await
         .unwrap();
     let user1_2 = db

crates/collab/src/db/worktree.rs

@@ -11,8 +11,10 @@ pub struct Model {
     pub abs_path: String,
     pub root_name: String,
     pub visible: bool,
+    /// The last scan for which we've observed entries. It may be in progress.
     pub scan_id: i64,
-    pub is_complete: bool,
+    /// The last scan that fully completed.
+    pub completed_scan_id: i64,
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]

crates/collab/src/db/worktree_entry.rs

@@ -17,6 +17,8 @@ pub struct Model {
     pub mtime_nanos: i32,
     pub is_symlink: bool,
     pub is_ignored: bool,
+    pub is_deleted: bool,
+    pub scan_id: i64,
 }
 
 #[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]

crates/collab/src/executor.rs

@@ -33,4 +33,12 @@ impl Executor {
             }
         }
     }
+
+    pub fn record_backtrace(&self) {
+        match self {
+            Executor::Production => {}
+            #[cfg(test)]
+            Executor::Deterministic(background) => background.record_backtrace(),
+        }
+    }
 }

crates/collab/src/lib.rs

@@ -3,10 +3,11 @@ pub mod auth;
 pub mod db;
 pub mod env;
 pub mod executor;
-#[cfg(test)]
-mod integration_tests;
 pub mod rpc;
 
+#[cfg(test)]
+mod tests;
+
 use axum::{http::StatusCode, response::IntoResponse};
 use db::Database;
 use serde::Deserialize;
@@ -97,6 +98,7 @@ pub struct Config {
     pub live_kit_secret: Option<String>,
     pub rust_log: Option<String>,
     pub log_json: Option<bool>,
+    pub zed_environment: String,
 }
 
 #[derive(Default, Deserialize)]

crates/collab/src/main.rs

@@ -7,6 +7,7 @@ use std::{
     net::{SocketAddr, TcpListener},
     path::Path,
 };
+use tokio::signal::unix::SignalKind;
 use tracing_log::LogTracer;
 use tracing_subscriber::{filter::EnvFilter, fmt::format::JsonFields, Layer};
 use util::ResultExt;
@@ -56,7 +57,11 @@ async fn main() -> Result<()> {
             let listener = TcpListener::bind(&format!("0.0.0.0:{}", state.config.http_port))
                 .expect("failed to bind TCP listener");
 
-            let rpc_server = collab::rpc::Server::new(state.clone(), Executor::Production);
+            let epoch = state
+                .db
+                .create_server(&state.config.zed_environment)
+                .await?;
+            let rpc_server = collab::rpc::Server::new(epoch, state.clone(), Executor::Production);
             rpc_server.start().await?;
 
             let app = collab::api::routes(rpc_server.clone(), state.clone())
@@ -65,6 +70,18 @@ async fn main() -> Result<()> {
 
             axum::Server::from_tcp(listener)?
                 .serve(app.into_make_service_with_connect_info::<SocketAddr>())
+                .with_graceful_shutdown(async move {
+                    let mut sigterm = tokio::signal::unix::signal(SignalKind::terminate())
+                        .expect("failed to listen for interrupt signal");
+                    let mut sigint = tokio::signal::unix::signal(SignalKind::interrupt())
+                        .expect("failed to listen for interrupt signal");
+                    let sigterm = sigterm.recv();
+                    let sigint = sigint.recv();
+                    futures::pin_mut!(sigterm, sigint);
+                    futures::future::select(sigterm, sigint).await;
+                    tracing::info!("Received interrupt signal");
+                    rpc_server.teardown();
+                })
                 .await?;
         }
         _ => {

crates/collab/src/rpc.rs

@@ -2,7 +2,7 @@ mod connection_pool;
 
 use crate::{
     auth,
-    db::{self, Database, ProjectId, RoomId, User, UserId},
+    db::{self, Database, ProjectId, RoomId, ServerId, User, UserId},
     executor::Executor,
     AppState, Result,
 };
@@ -57,7 +57,8 @@ use tokio::sync::watch;
 use tower::ServiceBuilder;
 use tracing::{info_span, instrument, Instrument};
 
-pub const RECONNECT_TIMEOUT: Duration = Duration::from_secs(60);
+pub const RECONNECT_TIMEOUT: Duration = Duration::from_secs(5);
+pub const CLEANUP_TIMEOUT: Duration = Duration::from_secs(10);
 
 lazy_static! {
     static ref METRIC_CONNECTIONS: IntGauge =
@@ -94,6 +95,7 @@ struct Session {
     peer: Arc<Peer>,
     connection_pool: Arc<parking_lot::Mutex<ConnectionPool>>,
     live_kit_client: Option<Arc<dyn live_kit_server::api::Client>>,
+    executor: Executor,
 }
 
 impl Session {
@@ -137,6 +139,7 @@ impl Deref for DbHandle {
 }
 
 pub struct Server {
+    id: parking_lot::Mutex<ServerId>,
     peer: Arc<Peer>,
     pub(crate) connection_pool: Arc<parking_lot::Mutex<ConnectionPool>>,
     app_state: Arc<AppState>,
@@ -167,9 +170,10 @@ where
 }
 
 impl Server {
-    pub fn new(app_state: Arc<AppState>, executor: Executor) -> Arc<Self> {
+    pub fn new(id: ServerId, app_state: Arc<AppState>, executor: Executor) -> Arc<Self> {
         let mut server = Self {
-            peer: Peer::new(),
+            id: parking_lot::Mutex::new(id),
+            peer: Peer::new(id.0 as u32),
             app_state,
             executor,
             connection_pool: Default::default(),
@@ -181,6 +185,7 @@ impl Server {
             .add_request_handler(ping)
             .add_request_handler(create_room)
             .add_request_handler(join_room)
+            .add_request_handler(rejoin_room)
             .add_message_handler(leave_room)
             .add_request_handler(call)
             .add_request_handler(cancel_call)
@@ -212,6 +217,7 @@ impl Server {
             .add_request_handler(forward_project_request::<proto::PrepareRename>)
             .add_request_handler(forward_project_request::<proto::PerformRename>)
             .add_request_handler(forward_project_request::<proto::ReloadBuffers>)
+            .add_request_handler(forward_project_request::<proto::SynchronizeBuffers>)
             .add_request_handler(forward_project_request::<proto::FormatBuffers>)
             .add_request_handler(forward_project_request::<proto::CreateProjectEntry>)
             .add_request_handler(forward_project_request::<proto::RenameProjectEntry>)
@@ -238,98 +244,136 @@ impl Server {
     }
 
     pub async fn start(&self) -> Result<()> {
-        self.app_state.db.delete_stale_projects().await?;
-        let db = self.app_state.db.clone();
+        let server_id = *self.id.lock();
+        let app_state = self.app_state.clone();
         let peer = self.peer.clone();
-        let timeout = self.executor.sleep(RECONNECT_TIMEOUT);
+        let timeout = self.executor.sleep(CLEANUP_TIMEOUT);
         let pool = self.connection_pool.clone();
         let live_kit_client = self.app_state.live_kit_client.clone();
-        self.executor.spawn_detached(async move {
-            timeout.await;
-            if let Some(room_ids) = db.outdated_room_ids().await.trace_err() {
-                for room_id in room_ids {
-                    let mut contacts_to_update = HashSet::default();
-                    let mut canceled_calls_to_user_ids = Vec::new();
-                    let mut live_kit_room = String::new();
-                    let mut delete_live_kit_room = false;
 
-                    if let Ok(mut refreshed_room) = db.refresh_room(room_id).await {
-                        room_updated(&refreshed_room.room, &peer);
-                        contacts_to_update
-                            .extend(refreshed_room.stale_participant_user_ids.iter().copied());
-                        contacts_to_update
-                            .extend(refreshed_room.canceled_calls_to_user_ids.iter().copied());
-                        canceled_calls_to_user_ids =
-                            mem::take(&mut refreshed_room.canceled_calls_to_user_ids);
-                        live_kit_room = mem::take(&mut refreshed_room.room.live_kit_room);
-                        delete_live_kit_room = refreshed_room.room.participants.is_empty();
-                    }
+        let span = info_span!("start server");
+        self.executor.spawn_detached(
+            async move {
+                tracing::info!("waiting for cleanup timeout");
+                timeout.await;
+                tracing::info!("cleanup timeout expired, retrieving stale rooms");
+                if let Some(room_ids) = app_state
+                    .db
+                    .stale_room_ids(&app_state.config.zed_environment, server_id)
+                    .await
+                    .trace_err()
+                {
+                    tracing::info!(stale_room_count = room_ids.len(), "retrieved stale rooms");
+                    for room_id in room_ids {
+                        let mut contacts_to_update = HashSet::default();
+                        let mut canceled_calls_to_user_ids = Vec::new();
+                        let mut live_kit_room = String::new();
+                        let mut delete_live_kit_room = false;
 
-                    {
-                        let pool = pool.lock();
-                        for canceled_user_id in canceled_calls_to_user_ids {
-                            for connection_id in pool.user_connection_ids(canceled_user_id) {
-                                peer.send(
-                                    connection_id,
-                                    proto::CallCanceled {
-                                        room_id: room_id.to_proto(),
-                                    },
-                                )
-                                .trace_err();
+                        if let Ok(mut refreshed_room) =
+                            app_state.db.refresh_room(room_id, server_id).await
+                        {
+                            tracing::info!(
+                                room_id = room_id.0,
+                                new_participant_count = refreshed_room.room.participants.len(),
+                                "refreshed room"
+                            );
+                            room_updated(&refreshed_room.room, &peer);
+                            contacts_to_update
+                                .extend(refreshed_room.stale_participant_user_ids.iter().copied());
+                            contacts_to_update
+                                .extend(refreshed_room.canceled_calls_to_user_ids.iter().copied());
+                            canceled_calls_to_user_ids =
+                                mem::take(&mut refreshed_room.canceled_calls_to_user_ids);
+                            live_kit_room = mem::take(&mut refreshed_room.room.live_kit_room);
+                            delete_live_kit_room = refreshed_room.room.participants.is_empty();
+                        }
+
+                        {
+                            let pool = pool.lock();
+                            for canceled_user_id in canceled_calls_to_user_ids {
+                                for connection_id in pool.user_connection_ids(canceled_user_id) {
+                                    peer.send(
+                                        connection_id,
+                                        proto::CallCanceled {
+                                            room_id: room_id.to_proto(),
+                                        },
+                                    )
+                                    .trace_err();
+                                }
                             }
                         }
-                    }
 
-                    for user_id in contacts_to_update {
-                        let busy = db.is_user_busy(user_id).await.trace_err();
-                        let contacts = db.get_contacts(user_id).await.trace_err();
-                        if let Some((busy, contacts)) = busy.zip(contacts) {
-                            let pool = pool.lock();
-                            let updated_contact = contact_for_user(user_id, false, busy, &pool);
-                            for contact in contacts {
-                                if let db::Contact::Accepted {
-                                    user_id: contact_user_id,
-                                    ..
-                                } = contact
-                                {
-                                    for contact_conn_id in pool.user_connection_ids(contact_user_id)
+                        for user_id in contacts_to_update {
+                            let busy = app_state.db.is_user_busy(user_id).await.trace_err();
+                            let contacts = app_state.db.get_contacts(user_id).await.trace_err();
+                            if let Some((busy, contacts)) = busy.zip(contacts) {
+                                let pool = pool.lock();
+                                let updated_contact = contact_for_user(user_id, false, busy, &pool);
+                                for contact in contacts {
+                                    if let db::Contact::Accepted {
+                                        user_id: contact_user_id,
+                                        ..
+                                    } = contact
                                     {
-                                        peer.send(
-                                            contact_conn_id,
-                                            proto::UpdateContacts {
-                                                contacts: vec![updated_contact.clone()],
-                                                remove_contacts: Default::default(),
-                                                incoming_requests: Default::default(),
-                                                remove_incoming_requests: Default::default(),
-                                                outgoing_requests: Default::default(),
-                                                remove_outgoing_requests: Default::default(),
-                                            },
-                                        )
-                                        .trace_err();
+                                        for contact_conn_id in
+                                            pool.user_connection_ids(contact_user_id)
+                                        {
+                                            peer.send(
+                                                contact_conn_id,
+                                                proto::UpdateContacts {
+                                                    contacts: vec![updated_contact.clone()],
+                                                    remove_contacts: Default::default(),
+                                                    incoming_requests: Default::default(),
+                                                    remove_incoming_requests: Default::default(),
+                                                    outgoing_requests: Default::default(),
+                                                    remove_outgoing_requests: Default::default(),
+                                                },
+                                            )
+                                            .trace_err();
+                                        }
                                     }
                                 }
                             }
                         }
-                    }
 
-                    if let Some(live_kit) = live_kit_client.as_ref() {
-                        if delete_live_kit_room {
-                            live_kit.delete_room(live_kit_room).await.trace_err();
+                        if let Some(live_kit) = live_kit_client.as_ref() {
+                            if delete_live_kit_room {
+                                live_kit.delete_room(live_kit_room).await.trace_err();
+                            }
                         }
                     }
                 }
+
+                app_state
+                    .db
+                    .delete_stale_servers(&app_state.config.zed_environment, server_id)
+                    .await
+                    .trace_err();
             }
-        });
+            .instrument(span),
+        );
         Ok(())
     }
 
-    #[cfg(test)]
     pub fn teardown(&self) {
-        self.peer.reset();
+        self.peer.teardown();
         self.connection_pool.lock().reset();
         let _ = self.teardown.send(());
     }
 
+    #[cfg(test)]
+    pub fn reset(&self, id: ServerId) {
+        self.teardown();
+        *self.id.lock() = id;
+        self.peer.reset(id.0 as u32);
+    }
+
+    #[cfg(test)]
+    pub fn id(&self) -> ServerId {
+        *self.id.lock()
+    }
+
     fn add_handler<F, Fut, M>(&mut self, handler: F) -> &mut Self
     where
         F: 'static + Send + Sync + Fn(TypedEnvelope<M>, Session) -> Fut,
@@ -438,7 +482,7 @@ impl Server {
                 });
 
             tracing::info!(%user_id, %login, %connection_id, %address, "connection opened");
-            this.peer.send(connection_id, proto::Hello { peer_id: connection_id.0 })?;
+            this.peer.send(connection_id, proto::Hello { peer_id: Some(connection_id.into()) })?;
             tracing::info!(%user_id, %login, %connection_id, %address, "sent hello message");
 
             if let Some(send_connection_id) = send_connection_id.take() {
@@ -478,7 +522,8 @@ impl Server {
                 db: Arc::new(tokio::sync::Mutex::new(DbHandle(this.app_state.db.clone()))),
                 peer: this.peer.clone(),
                 connection_pool: this.connection_pool.clone(),
-                live_kit_client: this.app_state.live_kit_client.clone()
+                live_kit_client: this.app_state.live_kit_client.clone(),
+                executor: executor.clone(),
             };
             update_user_contacts(user_id, &session).await?;
 
@@ -535,7 +580,7 @@ impl Server {
 
             drop(foreground_message_handlers);
             tracing::info!(%user_id, %login, %connection_id, %address, "signing out");
-            if let Err(error) = sign_out(session, teardown, executor).await {
+            if let Err(error) = connection_lost(session, teardown, executor).await {
                 tracing::error!(%user_id, %login, %connection_id, %address, ?error, "error signing out");
             }
 
@@ -627,15 +672,17 @@ impl<'a> Drop for ConnectionPoolGuard<'a> {
 }
 
 fn broadcast<F>(
-    sender_id: ConnectionId,
+    sender_id: Option<ConnectionId>,
     receiver_ids: impl IntoIterator<Item = ConnectionId>,
     mut f: F,
 ) where
     F: FnMut(ConnectionId) -> anyhow::Result<()>,
 {
     for receiver_id in receiver_ids {
-        if receiver_id != sender_id {
-            f(receiver_id).trace_err();
+        if Some(receiver_id) != sender_id {
+            if let Err(error) = f(receiver_id) {
+                tracing::error!("failed to send to {:?} {}", receiver_id, error);
+            }
         }
     }
 }
@@ -736,7 +783,7 @@ pub async fn handle_metrics(Extension(server): Extension<Arc<Server>>) -> Result
 }
 
 #[instrument(err, skip(executor))]
-async fn sign_out(
+async fn connection_lost(
     session: Session,
     mut teardown: watch::Receiver<()>,
     executor: Executor,
@@ -747,17 +794,12 @@ async fn sign_out(
         .await
         .remove_connection(session.connection_id)?;
 
-    if let Some(mut left_projects) = session
+    session
         .db()
         .await
         .connection_lost(session.connection_id)
         .await
-        .trace_err()
-    {
-        for left_project in mem::take(&mut *left_projects) {
-            project_left(&left_project, &session);
-        }
-    }
+        .trace_err();
 
     futures::select_biased! {
         _ = executor.sleep(RECONNECT_TIMEOUT).fuse() => {
@@ -769,7 +811,7 @@ async fn sign_out(
                 .is_user_online(session.user_id)
             {
                 let db = session.db().await;
-                if let Some(room) = db.decline_call(None, session.user_id).await.trace_err() {
+                if let Some(room) = db.decline_call(None, session.user_id).await.trace_err().flatten() {
                     room_updated(&room, &session.peer);
                 }
             }
@@ -799,7 +841,7 @@ async fn create_room(
             .trace_err()
         {
             if let Some(token) = live_kit
-                .room_token(&live_kit_room, &session.connection_id.to_string())
+                .room_token(&live_kit_room, &session.user_id.to_string())
                 .trace_err()
             {
                 Some(proto::LiveKitConnectionInfo {
@@ -867,7 +909,7 @@ async fn join_room(
 
     let live_kit_connection_info = if let Some(live_kit) = session.live_kit_client.as_ref() {
         if let Some(token) = live_kit
-            .room_token(&room.live_kit_room, &session.connection_id.to_string())
+            .room_token(&room.live_kit_room, &session.user_id.to_string())
             .trace_err()
         {
             Some(proto::LiveKitConnectionInfo {
@@ -890,6 +932,164 @@ async fn join_room(
     Ok(())
 }
 
+async fn rejoin_room(
+    request: proto::RejoinRoom,
+    response: Response<proto::RejoinRoom>,
+    session: Session,
+) -> Result<()> {
+    {
+        let mut rejoined_room = session
+            .db()
+            .await
+            .rejoin_room(request, session.user_id, session.connection_id)
+            .await?;
+
+        response.send(proto::RejoinRoomResponse {
+            room: Some(rejoined_room.room.clone()),
+            reshared_projects: rejoined_room
+                .reshared_projects
+                .iter()
+                .map(|project| proto::ResharedProject {
+                    id: project.id.to_proto(),
+                    collaborators: project
+                        .collaborators
+                        .iter()
+                        .map(|collaborator| collaborator.to_proto())
+                        .collect(),
+                })
+                .collect(),
+            rejoined_projects: rejoined_room
+                .rejoined_projects
+                .iter()
+                .map(|rejoined_project| proto::RejoinedProject {
+                    id: rejoined_project.id.to_proto(),
+                    worktrees: rejoined_project
+                        .worktrees
+                        .iter()
+                        .map(|worktree| proto::WorktreeMetadata {
+                            id: worktree.id,
+                            root_name: worktree.root_name.clone(),
+                            visible: worktree.visible,
+                            abs_path: worktree.abs_path.clone(),
+                        })
+                        .collect(),
+                    collaborators: rejoined_project
+                        .collaborators
+                        .iter()
+                        .map(|collaborator| collaborator.to_proto())
+                        .collect(),
+                    language_servers: rejoined_project.language_servers.clone(),
+                })
+                .collect(),
+        })?;
+        room_updated(&rejoined_room.room, &session.peer);
+
+        for project in &rejoined_room.reshared_projects {
+            for collaborator in &project.collaborators {
+                session
+                    .peer
+                    .send(
+                        collaborator.connection_id,
+                        proto::UpdateProjectCollaborator {
+                            project_id: project.id.to_proto(),
+                            old_peer_id: Some(project.old_connection_id.into()),
+                            new_peer_id: Some(session.connection_id.into()),
+                        },
+                    )
+                    .trace_err();
+            }
+
+            broadcast(
+                Some(session.connection_id),
+                project
+                    .collaborators
+                    .iter()
+                    .map(|collaborator| collaborator.connection_id),
+                |connection_id| {
+                    session.peer.forward_send(
+                        session.connection_id,
+                        connection_id,
+                        proto::UpdateProject {
+                            project_id: project.id.to_proto(),
+                            worktrees: project.worktrees.clone(),
+                        },
+                    )
+                },
+            );
+        }
+
+        for project in &rejoined_room.rejoined_projects {
+            for collaborator in &project.collaborators {
+                session
+                    .peer
+                    .send(
+                        collaborator.connection_id,
+                        proto::UpdateProjectCollaborator {
+                            project_id: project.id.to_proto(),
+                            old_peer_id: Some(project.old_connection_id.into()),
+                            new_peer_id: Some(session.connection_id.into()),
+                        },
+                    )
+                    .trace_err();
+            }
+        }
+
+        for project in &mut rejoined_room.rejoined_projects {
+            for worktree in mem::take(&mut project.worktrees) {
+                #[cfg(any(test, feature = "test-support"))]
+                const MAX_CHUNK_SIZE: usize = 2;
+                #[cfg(not(any(test, feature = "test-support")))]
+                const MAX_CHUNK_SIZE: usize = 256;
+
+                // Stream this worktree's entries.
+                let message = proto::UpdateWorktree {
+                    project_id: project.id.to_proto(),
+                    worktree_id: worktree.id,
+                    abs_path: worktree.abs_path.clone(),
+                    root_name: worktree.root_name,
+                    updated_entries: worktree.updated_entries,
+                    removed_entries: worktree.removed_entries,
+                    scan_id: worktree.scan_id,
+                    is_last_update: worktree.completed_scan_id == worktree.scan_id,
+                };
+                for update in proto::split_worktree_update(message, MAX_CHUNK_SIZE) {
+                    session.peer.send(session.connection_id, update.clone())?;
+                }
+
+                // Stream this worktree's diagnostics.
+                for summary in worktree.diagnostic_summaries {
+                    session.peer.send(
+                        session.connection_id,
+                        proto::UpdateDiagnosticSummary {
+                            project_id: project.id.to_proto(),
+                            worktree_id: worktree.id,
+                            summary: Some(summary),
+                        },
+                    )?;
+                }
+            }
+
+            for language_server in &project.language_servers {
+                session.peer.send(
+                    session.connection_id,
+                    proto::UpdateLanguageServer {
+                        project_id: project.id.to_proto(),
+                        language_server_id: language_server.id,
+                        variant: Some(
+                            proto::update_language_server::Variant::DiskBasedDiagnosticsUpdated(
+                                proto::LspDiskBasedDiagnosticsUpdated {},
+                            ),
+                        ),
+                    },
+                )?;
+            }
+        }
+    }
+
+    update_user_contacts(session.user_id, &session).await?;
+    Ok(())
+}
+
 async fn leave_room(_message: proto::LeaveRoom, session: Session) -> Result<()> {
     leave_room_for_session(&session).await
 }
@@ -973,7 +1173,7 @@ async fn cancel_call(
         let room = session
             .db()
             .await
-            .cancel_call(Some(room_id), session.connection_id, called_user_id)
+            .cancel_call(room_id, session.connection_id, called_user_id)
             .await?;
         room_updated(&room, &session.peer);
     }
@@ -1006,7 +1206,8 @@ async fn decline_call(message: proto::DeclineCall, session: Session) -> Result<(
             .db()
             .await
             .decline_call(Some(room_id), session.user_id)
-            .await?;
+            .await?
+            .ok_or_else(|| anyhow!("failed to decline call"))?;
         room_updated(&room, &session.peer);
     }
 
@@ -1080,7 +1281,7 @@ async fn unshare_project(message: proto::UnshareProject, session: Session) -> Re
         .await?;
 
     broadcast(
-        session.connection_id,
+        Some(session.connection_id),
         guest_connection_ids.iter().copied(),
         |conn_id| session.peer.send(conn_id, message.clone()),
     );
@@ -1108,12 +1309,8 @@ async fn join_project(
     let collaborators = project
         .collaborators
         .iter()
-        .filter(|collaborator| collaborator.connection_id != session.connection_id.0 as i32)
-        .map(|collaborator| proto::Collaborator {
-            peer_id: collaborator.connection_id as u32,
-            replica_id: collaborator.replica_id.0 as u32,
-            user_id: collaborator.user_id.to_proto(),
-        })
+        .filter(|collaborator| collaborator.connection_id != session.connection_id)
+        .map(|collaborator| collaborator.to_proto())
         .collect::<Vec<_>>();
     let worktrees = project
         .worktrees
@@ -1130,11 +1327,11 @@ async fn join_project(
         session
             .peer
             .send(
-                ConnectionId(collaborator.peer_id),
+                collaborator.peer_id.unwrap().into(),
                 proto::AddProjectCollaborator {
                     project_id: project_id.to_proto(),
                     collaborator: Some(proto::Collaborator {
-                        peer_id: session.connection_id.0,
+                        peer_id: Some(session.connection_id.into()),
                         replica_id: replica_id.0 as u32,
                         user_id: guest_user_id.to_proto(),
                     }),
@@ -1166,7 +1363,7 @@ async fn join_project(
             updated_entries: worktree.entries,
             removed_entries: Default::default(),
             scan_id: worktree.scan_id,
-            is_last_update: worktree.is_complete,
+            is_last_update: worktree.scan_id == worktree.completed_scan_id,
         };
         for update in proto::split_worktree_update(message, MAX_CHUNK_SIZE) {
             session.peer.send(session.connection_id, update.clone())?;
@@ -1235,7 +1432,7 @@ async fn update_project(
         .update_project(project_id, session.connection_id, &request.worktrees)
         .await?;
     broadcast(
-        session.connection_id,
+        Some(session.connection_id),
         guest_connection_ids.iter().copied(),
         |connection_id| {
             session
@@ -1261,7 +1458,7 @@ async fn update_worktree(
         .await?;
 
     broadcast(
-        session.connection_id,
+        Some(session.connection_id),
         guest_connection_ids.iter().copied(),
         |connection_id| {
             session
@@ -1284,7 +1481,7 @@ async fn update_diagnostic_summary(
         .await?;
 
     broadcast(
-        session.connection_id,
+        Some(session.connection_id),
         guest_connection_ids.iter().copied(),
         |connection_id| {
             session
@@ -1307,7 +1504,7 @@ async fn start_language_server(
         .await?;
 
     broadcast(
-        session.connection_id,
+        Some(session.connection_id),
         guest_connection_ids.iter().copied(),
         |connection_id| {
             session
@@ -1322,6 +1519,7 @@ async fn update_language_server(
     request: proto::UpdateLanguageServer,
     session: Session,
 ) -> Result<()> {
+    session.executor.record_backtrace();
     let project_id = ProjectId::from_proto(request.project_id);
     let project_connection_ids = session
         .db()
@@ -1329,7 +1527,7 @@ async fn update_language_server(
         .project_connection_ids(project_id, session.connection_id)
         .await?;
     broadcast(
-        session.connection_id,
+        Some(session.connection_id),
         project_connection_ids.iter().copied(),
         |connection_id| {
             session
@@ -1348,6 +1546,7 @@ async fn forward_project_request<T>(
 where
     T: EntityMessage + RequestMessage,
 {
+    session.executor.record_backtrace();
     let project_id = ProjectId::from_proto(request.remote_entity_id());
     let host_connection_id = {
         let collaborators = session
@@ -1355,13 +1554,11 @@ where
             .await
             .project_collaborators(project_id, session.connection_id)
             .await?;
-        ConnectionId(
-            collaborators
-                .iter()
-                .find(|collaborator| collaborator.is_host)
-                .ok_or_else(|| anyhow!("host not found"))?
-                .connection_id as u32,
-        )
+        collaborators
+            .iter()
+            .find(|collaborator| collaborator.is_host)
+            .ok_or_else(|| anyhow!("host not found"))?
+            .connection_id
     };
 
     let payload = session
@@ -1385,11 +1582,11 @@ async fn save_buffer(
             .await
             .project_collaborators(project_id, session.connection_id)
             .await?;
-        let host = collaborators
+        collaborators
             .iter()
             .find(|collaborator| collaborator.is_host)
-            .ok_or_else(|| anyhow!("host not found"))?;
-        ConnectionId(host.connection_id as u32)
+            .ok_or_else(|| anyhow!("host not found"))?
+            .connection_id
     };
     let response_payload = session
         .peer
@@ -1401,16 +1598,19 @@ async fn save_buffer(
         .await
         .project_collaborators(project_id, session.connection_id)
         .await?;
-    collaborators
-        .retain(|collaborator| collaborator.connection_id != session.connection_id.0 as i32);
+    collaborators.retain(|collaborator| collaborator.connection_id != session.connection_id);
     let project_connection_ids = collaborators
         .iter()
-        .map(|collaborator| ConnectionId(collaborator.connection_id as u32));
-    broadcast(host_connection_id, project_connection_ids, |conn_id| {
-        session
-            .peer
-            .forward_send(host_connection_id, conn_id, response_payload.clone())
-    });
+        .map(|collaborator| collaborator.connection_id);
+    broadcast(
+        Some(host_connection_id),
+        project_connection_ids,
+        |conn_id| {
+            session
+                .peer
+                .forward_send(host_connection_id, conn_id, response_payload.clone())
+        },
+    );
     response.send(response_payload)?;
     Ok(())
 }
@@ -1419,11 +1619,11 @@ async fn create_buffer_for_peer(
     request: proto::CreateBufferForPeer,
     session: Session,
 ) -> Result<()> {
-    session.peer.forward_send(
-        session.connection_id,
-        ConnectionId(request.peer_id),
-        request,
-    )?;
+    session.executor.record_backtrace();
+    let peer_id = request.peer_id.ok_or_else(|| anyhow!("invalid peer id"))?;
+    session
+        .peer
+        .forward_send(session.connection_id, peer_id.into(), request)?;
     Ok(())
 }
 
@@ -1432,6 +1632,7 @@ async fn update_buffer(
     response: Response<proto::UpdateBuffer>,
     session: Session,
 ) -> Result<()> {
+    session.executor.record_backtrace();
     let project_id = ProjectId::from_proto(request.project_id);
     let project_connection_ids = session
         .db()
@@ -1439,8 +1640,10 @@ async fn update_buffer(
         .project_connection_ids(project_id, session.connection_id)
         .await?;
 
+    session.executor.record_backtrace();
+
     broadcast(
-        session.connection_id,
+        Some(session.connection_id),
         project_connection_ids.iter().copied(),
         |connection_id| {
             session
@@ -1461,7 +1664,7 @@ async fn update_buffer_file(request: proto::UpdateBufferFile, session: Session)
         .await?;
 
     broadcast(
-        session.connection_id,
+        Some(session.connection_id),
         project_connection_ids.iter().copied(),
         |connection_id| {
             session
@@ -1480,7 +1683,7 @@ async fn buffer_reloaded(request: proto::BufferReloaded, session: Session) -> Re
         .project_connection_ids(project_id, session.connection_id)
         .await?;
     broadcast(
-        session.connection_id,
+        Some(session.connection_id),
         project_connection_ids.iter().copied(),
         |connection_id| {
             session
@@ -1499,7 +1702,7 @@ async fn buffer_saved(request: proto::BufferSaved, session: Session) -> Result<(
         .project_connection_ids(project_id, session.connection_id)
         .await?;
     broadcast(
-        session.connection_id,
+        Some(session.connection_id),
         project_connection_ids.iter().copied(),
         |connection_id| {
             session
@@ -1516,7 +1719,10 @@ async fn follow(
     session: Session,
 ) -> Result<()> {
     let project_id = ProjectId::from_proto(request.project_id);
-    let leader_id = ConnectionId(request.leader_id);
+    let leader_id = request
+        .leader_id
+        .ok_or_else(|| anyhow!("invalid leader id"))?
+        .into();
     let follower_id = session.connection_id;
     {
         let project_connection_ids = session
@@ -1536,14 +1742,17 @@ async fn follow(
         .await?;
     response_payload
         .views
-        .retain(|view| view.leader_id != Some(follower_id.0));
+        .retain(|view| view.leader_id != Some(follower_id.into()));
     response.send(response_payload)?;
     Ok(())
 }
 
 async fn unfollow(request: proto::Unfollow, session: Session) -> Result<()> {
     let project_id = ProjectId::from_proto(request.project_id);
-    let leader_id = ConnectionId(request.leader_id);
+    let leader_id = request
+        .leader_id
+        .ok_or_else(|| anyhow!("invalid leader id"))?
+        .into();
     let project_connection_ids = session
         .db()
         .await
@@ -1572,12 +1781,16 @@ async fn update_followers(request: proto::UpdateFollowers, session: Session) ->
         proto::update_followers::Variant::UpdateView(payload) => payload.leader_id,
         proto::update_followers::Variant::UpdateActiveView(payload) => payload.leader_id,
     });
-    for follower_id in &request.follower_ids {
-        let follower_id = ConnectionId(*follower_id);
-        if project_connection_ids.contains(&follower_id) && Some(follower_id.0) != leader_id {
-            session
-                .peer
-                .forward_send(session.connection_id, follower_id, request.clone())?;
+    for follower_peer_id in request.follower_ids.iter().copied() {
+        let follower_connection_id = follower_peer_id.into();
+        if project_connection_ids.contains(&follower_connection_id)
+            && Some(follower_peer_id) != leader_id
+        {
+            session.peer.forward_send(
+                session.connection_id,
+                follower_connection_id,
+                request.clone(),
+            )?;
         }
     }
     Ok(())
@@ -1781,7 +1994,7 @@ async fn update_diff_base(request: proto::UpdateDiffBase, session: Session) -> R
         .project_connection_ids(project_id, session.connection_id)
         .await?;
     broadcast(
-        session.connection_id,
+        Some(session.connection_id),
         project_connection_ids.iter().copied(),
         |connection_id| {
             session
@@ -1891,15 +2104,20 @@ fn contact_for_user(
 }
 
 fn room_updated(room: &proto::Room, peer: &Peer) {
-    for participant in &room.participants {
-        peer.send(
-            ConnectionId(participant.peer_id),
-            proto::RoomUpdated {
-                room: Some(room.clone()),
-            },
-        )
-        .trace_err();
-    }
+    broadcast(
+        None,
+        room.participants
+            .iter()
+            .filter_map(|participant| Some(participant.peer_id?.into())),
+        |peer_id| {
+            peer.send(
+                peer_id.into(),
+                proto::RoomUpdated {
+                    room: Some(room.clone()),
+                },
+            )
+        },
+    );
 }
 
 async fn update_user_contacts(user_id: UserId, session: &Session) -> Result<()> {
@@ -1943,8 +2161,7 @@ async fn leave_room_for_session(session: &Session) -> Result<()> {
     let canceled_calls_to_user_ids;
     let live_kit_room;
     let delete_live_kit_room;
-    {
-        let mut left_room = session.db().await.leave_room(session.connection_id).await?;
+    if let Some(mut left_room) = session.db().await.leave_room(session.connection_id).await? {
         contacts_to_update.insert(session.user_id);
 
         for project in left_room.left_projects.values() {
@@ -1956,6 +2173,8 @@ async fn leave_room_for_session(session: &Session) -> Result<()> {
         canceled_calls_to_user_ids = mem::take(&mut left_room.canceled_calls_to_user_ids);
         live_kit_room = mem::take(&mut left_room.room.live_kit_room);
         delete_live_kit_room = left_room.room.participants.is_empty();
+    } else {
+        return Ok(());
     }
 
     {
@@ -1982,7 +2201,7 @@ async fn leave_room_for_session(session: &Session) -> Result<()> {
 
     if let Some(live_kit) = session.live_kit_client.as_ref() {
         live_kit
-            .remove_participant(live_kit_room.clone(), session.connection_id.to_string())
+            .remove_participant(live_kit_room.clone(), session.user_id.to_string())
             .await
             .trace_err();
 
@@ -2013,22 +2232,12 @@ fn project_left(project: &db::LeftProject, session: &Session) {
                     *connection_id,
                     proto::RemoveProjectCollaborator {
                         project_id: project.id.to_proto(),
-                        peer_id: session.connection_id.0,
+                        peer_id: Some(session.connection_id.into()),
                     },
                 )
                 .trace_err();
         }
     }
-
-    session
-        .peer
-        .send(
-            session.connection_id,
-            proto::UnshareProject {
-                project_id: project.id.to_proto(),
-            },
-        )
-        .trace_err();
 }
 
 pub trait ResultExt {

crates/collab/src/tests.rs

@@ -0,0 +1,466 @@
+use crate::{
+    db::{NewUserParams, TestDb, UserId},
+    executor::Executor,
+    rpc::{Server, CLEANUP_TIMEOUT},
+    AppState,
+};
+use anyhow::anyhow;
+use call::ActiveCall;
+use client::{
+    self, proto::PeerId, test::FakeHttpClient, Client, Connection, Credentials,
+    EstablishConnectionError, UserStore,
+};
+use collections::{HashMap, HashSet};
+use fs::{FakeFs, HomeDir};
+use futures::{channel::oneshot, StreamExt as _};
+use gpui::{
+    executor::Deterministic, test::EmptyView, ModelHandle, Task, TestAppContext, ViewHandle,
+};
+use language::LanguageRegistry;
+use parking_lot::Mutex;
+use project::{Project, WorktreeId};
+use settings::Settings;
+use std::{
+    env,
+    ops::Deref,
+    path::{Path, PathBuf},
+    sync::{
+        atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst},
+        Arc,
+    },
+};
+use theme::ThemeRegistry;
+use workspace::Workspace;
+
+mod integration_tests;
+mod randomized_integration_tests;
+
+struct TestServer {
+    app_state: Arc<AppState>,
+    server: Arc<Server>,
+    connection_killers: Arc<Mutex<HashMap<PeerId, Arc<AtomicBool>>>>,
+    forbid_connections: Arc<AtomicBool>,
+    _test_db: TestDb,
+    test_live_kit_server: Arc<live_kit_client::TestServer>,
+}
+
+impl TestServer {
+    async fn start(deterministic: &Arc<Deterministic>) -> Self {
+        static NEXT_LIVE_KIT_SERVER_ID: AtomicUsize = AtomicUsize::new(0);
+
+        let use_postgres = env::var("USE_POSTGRES").ok();
+        let use_postgres = use_postgres.as_deref();
+        let test_db = if use_postgres == Some("true") || use_postgres == Some("1") {
+            TestDb::postgres(deterministic.build_background())
+        } else {
+            TestDb::sqlite(deterministic.build_background())
+        };
+        let live_kit_server_id = NEXT_LIVE_KIT_SERVER_ID.fetch_add(1, SeqCst);
+        let live_kit_server = live_kit_client::TestServer::create(
+            format!("http://livekit.{}.test", live_kit_server_id),
+            format!("devkey-{}", live_kit_server_id),
+            format!("secret-{}", live_kit_server_id),
+            deterministic.build_background(),
+        )
+        .unwrap();
+        let app_state = Self::build_app_state(&test_db, &live_kit_server).await;
+        let epoch = app_state
+            .db
+            .create_server(&app_state.config.zed_environment)
+            .await
+            .unwrap();
+        let server = Server::new(
+            epoch,
+            app_state.clone(),
+            Executor::Deterministic(deterministic.build_background()),
+        );
+        server.start().await.unwrap();
+        // Advance clock to ensure the server's cleanup task is finished.
+        deterministic.advance_clock(CLEANUP_TIMEOUT);
+        Self {
+            app_state,
+            server,
+            connection_killers: Default::default(),
+            forbid_connections: Default::default(),
+            _test_db: test_db,
+            test_live_kit_server: live_kit_server,
+        }
+    }
+
+    async fn reset(&self) {
+        self.app_state.db.reset();
+        let epoch = self
+            .app_state
+            .db
+            .create_server(&self.app_state.config.zed_environment)
+            .await
+            .unwrap();
+        self.server.reset(epoch);
+    }
+
+    async fn create_client(&mut self, cx: &mut TestAppContext, name: &str) -> TestClient {
+        cx.update(|cx| {
+            cx.set_global(HomeDir(Path::new("/tmp/").to_path_buf()));
+
+            let mut settings = Settings::test(cx);
+            settings.projects_online_by_default = false;
+            cx.set_global(settings);
+        });
+
+        let http = FakeHttpClient::with_404_response();
+        let user_id = if let Ok(Some(user)) = self
+            .app_state
+            .db
+            .get_user_by_github_account(name, None)
+            .await
+        {
+            user.id
+        } else {
+            self.app_state
+                .db
+                .create_user(
+                    &format!("{name}@example.com"),
+                    false,
+                    NewUserParams {
+                        github_login: name.into(),
+                        github_user_id: 0,
+                        invite_count: 0,
+                    },
+                )
+                .await
+                .expect("creating user failed")
+                .user_id
+        };
+        let client_name = name.to_string();
+        let mut client = cx.read(|cx| Client::new(http.clone(), cx));
+        let server = self.server.clone();
+        let db = self.app_state.db.clone();
+        let connection_killers = self.connection_killers.clone();
+        let forbid_connections = self.forbid_connections.clone();
+
+        Arc::get_mut(&mut client)
+            .unwrap()
+            .set_id(user_id.0 as usize)
+            .override_authenticate(move |cx| {
+                cx.spawn(|_| async move {
+                    let access_token = "the-token".to_string();
+                    Ok(Credentials {
+                        user_id: user_id.0 as u64,
+                        access_token,
+                    })
+                })
+            })
+            .override_establish_connection(move |credentials, cx| {
+                assert_eq!(credentials.user_id, user_id.0 as u64);
+                assert_eq!(credentials.access_token, "the-token");
+
+                let server = server.clone();
+                let db = db.clone();
+                let connection_killers = connection_killers.clone();
+                let forbid_connections = forbid_connections.clone();
+                let client_name = client_name.clone();
+                cx.spawn(move |cx| async move {
+                    if forbid_connections.load(SeqCst) {
+                        Err(EstablishConnectionError::other(anyhow!(
+                            "server is forbidding connections"
+                        )))
+                    } else {
+                        let (client_conn, server_conn, killed) =
+                            Connection::in_memory(cx.background());
+                        let (connection_id_tx, connection_id_rx) = oneshot::channel();
+                        let user = db
+                            .get_user_by_id(user_id)
+                            .await
+                            .expect("retrieving user failed")
+                            .unwrap();
+                        cx.background()
+                            .spawn(server.handle_connection(
+                                server_conn,
+                                client_name,
+                                user,
+                                Some(connection_id_tx),
+                                Executor::Deterministic(cx.background()),
+                            ))
+                            .detach();
+                        let connection_id = connection_id_rx.await.unwrap();
+                        connection_killers
+                            .lock()
+                            .insert(connection_id.into(), killed);
+                        Ok(client_conn)
+                    }
+                })
+            });
+
+        let fs = FakeFs::new(cx.background());
+        let user_store = cx.add_model(|cx| UserStore::new(client.clone(), http, cx));
+        let app_state = Arc::new(workspace::AppState {
+            client: client.clone(),
+            user_store: user_store.clone(),
+            languages: Arc::new(LanguageRegistry::new(Task::ready(()))),
+            themes: ThemeRegistry::new((), cx.font_cache()),
+            fs: fs.clone(),
+            build_window_options: Default::default,
+            initialize_workspace: |_, _, _| unimplemented!(),
+            dock_default_item_factory: |_, _| unimplemented!(),
+        });
+
+        Project::init(&client);
+        cx.update(|cx| {
+            workspace::init(app_state.clone(), cx);
+            call::init(client.clone(), user_store.clone(), cx);
+        });
+
+        client
+            .authenticate_and_connect(false, &cx.to_async())
+            .await
+            .unwrap();
+
+        let client = TestClient {
+            client,
+            username: name.to_string(),
+            local_projects: Default::default(),
+            remote_projects: Default::default(),
+            next_root_dir_id: 0,
+            user_store,
+            fs,
+            language_registry: Arc::new(LanguageRegistry::test()),
+            buffers: Default::default(),
+        };
+        client.wait_for_current_user(cx).await;
+        client
+    }
+
+    fn disconnect_client(&self, peer_id: PeerId) {
+        self.connection_killers
+            .lock()
+            .remove(&peer_id)
+            .unwrap()
+            .store(true, SeqCst);
+    }
+
+    fn forbid_connections(&self) {
+        self.forbid_connections.store(true, SeqCst);
+    }
+
+    fn allow_connections(&self) {
+        self.forbid_connections.store(false, SeqCst);
+    }
+
+    async fn make_contacts(&self, clients: &mut [(&TestClient, &mut TestAppContext)]) {
+        for ix in 1..clients.len() {
+            let (left, right) = clients.split_at_mut(ix);
+            let (client_a, cx_a) = left.last_mut().unwrap();
+            for (client_b, cx_b) in right {
+                client_a
+                    .user_store
+                    .update(*cx_a, |store, cx| {
+                        store.request_contact(client_b.user_id().unwrap(), cx)
+                    })
+                    .await
+                    .unwrap();
+                cx_a.foreground().run_until_parked();
+                client_b
+                    .user_store
+                    .update(*cx_b, |store, cx| {
+                        store.respond_to_contact_request(client_a.user_id().unwrap(), true, cx)
+                    })
+                    .await
+                    .unwrap();
+            }
+        }
+    }
+
+    async fn create_room(&self, clients: &mut [(&TestClient, &mut TestAppContext)]) {
+        self.make_contacts(clients).await;
+
+        let (left, right) = clients.split_at_mut(1);
+        let (_client_a, cx_a) = &mut left[0];
+        let active_call_a = cx_a.read(ActiveCall::global);
+
+        for (client_b, cx_b) in right {
+            let user_id_b = client_b.current_user_id(*cx_b).to_proto();
+            active_call_a
+                .update(*cx_a, |call, cx| call.invite(user_id_b, None, cx))
+                .await
+                .unwrap();
+
+            cx_b.foreground().run_until_parked();
+            let active_call_b = cx_b.read(ActiveCall::global);
+            active_call_b
+                .update(*cx_b, |call, cx| call.accept_incoming(cx))
+                .await
+                .unwrap();
+        }
+    }
+
+    async fn build_app_state(
+        test_db: &TestDb,
+        fake_server: &live_kit_client::TestServer,
+    ) -> Arc<AppState> {
+        Arc::new(AppState {
+            db: test_db.db().clone(),
+            live_kit_client: Some(Arc::new(fake_server.create_api_client())),
+            config: Default::default(),
+        })
+    }
+}
+
+impl Deref for TestServer {
+    type Target = Server;
+
+    fn deref(&self) -> &Self::Target {
+        &self.server
+    }
+}
+
+impl Drop for TestServer {
+    fn drop(&mut self) {
+        self.server.teardown();
+        self.test_live_kit_server.teardown().unwrap();
+    }
+}
+
+struct TestClient {
+    client: Arc<Client>,
+    username: String,
+    local_projects: Vec<ModelHandle<Project>>,
+    remote_projects: Vec<ModelHandle<Project>>,
+    next_root_dir_id: usize,
+    pub user_store: ModelHandle<UserStore>,
+    language_registry: Arc<LanguageRegistry>,
+    fs: Arc<FakeFs>,
+    buffers: HashMap<ModelHandle<Project>, HashSet<ModelHandle<language::Buffer>>>,
+}
+
+impl Deref for TestClient {
+    type Target = Arc<Client>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.client
+    }
+}
+
+struct ContactsSummary {
+    pub current: Vec<String>,
+    pub outgoing_requests: Vec<String>,
+    pub incoming_requests: Vec<String>,
+}
+
+impl TestClient {
+    pub fn current_user_id(&self, cx: &TestAppContext) -> UserId {
+        UserId::from_proto(
+            self.user_store
+                .read_with(cx, |user_store, _| user_store.current_user().unwrap().id),
+        )
+    }
+
+    async fn wait_for_current_user(&self, cx: &TestAppContext) {
+        let mut authed_user = self
+            .user_store
+            .read_with(cx, |user_store, _| user_store.watch_current_user());
+        while authed_user.next().await.unwrap().is_none() {}
+    }
+
+    async fn clear_contacts(&self, cx: &mut TestAppContext) {
+        self.user_store
+            .update(cx, |store, _| store.clear_contacts())
+            .await;
+    }
+
+    fn summarize_contacts(&self, cx: &TestAppContext) -> ContactsSummary {
+        self.user_store.read_with(cx, |store, _| ContactsSummary {
+            current: store
+                .contacts()
+                .iter()
+                .map(|contact| contact.user.github_login.clone())
+                .collect(),
+            outgoing_requests: store
+                .outgoing_contact_requests()
+                .iter()
+                .map(|user| user.github_login.clone())
+                .collect(),
+            incoming_requests: store
+                .incoming_contact_requests()
+                .iter()
+                .map(|user| user.github_login.clone())
+                .collect(),
+        })
+    }
+
+    async fn build_local_project(
+        &self,
+        root_path: impl AsRef<Path>,
+        cx: &mut TestAppContext,
+    ) -> (ModelHandle<Project>, WorktreeId) {
+        let project = cx.update(|cx| {
+            Project::local(
+                self.client.clone(),
+                self.user_store.clone(),
+                self.language_registry.clone(),
+                self.fs.clone(),
+                cx,
+            )
+        });
+        let (worktree, _) = project
+            .update(cx, |p, cx| {
+                p.find_or_create_local_worktree(root_path, true, cx)
+            })
+            .await
+            .unwrap();
+        worktree
+            .read_with(cx, |tree, _| tree.as_local().unwrap().scan_complete())
+            .await;
+        (project, worktree.read_with(cx, |tree, _| tree.id()))
+    }
+
+    async fn build_remote_project(
+        &self,
+        host_project_id: u64,
+        guest_cx: &mut TestAppContext,
+    ) -> ModelHandle<Project> {
+        let active_call = guest_cx.read(ActiveCall::global);
+        let room = active_call.read_with(guest_cx, |call, _| call.room().unwrap().clone());
+        room.update(guest_cx, |room, cx| {
+            room.join_project(
+                host_project_id,
+                self.language_registry.clone(),
+                self.fs.clone(),
+                cx,
+            )
+        })
+        .await
+        .unwrap()
+    }
+
+    fn build_workspace(
+        &self,
+        project: &ModelHandle<Project>,
+        cx: &mut TestAppContext,
+    ) -> ViewHandle<Workspace> {
+        let (_, root_view) = cx.add_window(|_| EmptyView);
+        cx.add_view(&root_view, |cx| {
+            Workspace::new(
+                Default::default(),
+                0,
+                project.clone(),
+                |_, _| unimplemented!(),
+                cx,
+            )
+        })
+    }
+
+    fn create_new_root_dir(&mut self) -> PathBuf {
+        format!(
+            "/{}-root-{}",
+            self.username,
+            util::post_inc(&mut self.next_root_dir_id)
+        )
+        .into()
+    }
+}
+
+impl Drop for TestClient {
+    fn drop(&mut self) {
+        self.client.teardown();
+    }
+}

crates/collab_ui/src/collab_titlebar_item.rs

@@ -1,6 +1,6 @@
 use crate::{contact_notification::ContactNotification, contacts_popover};
 use call::{ActiveCall, ParticipantLocation};
-use client::{Authenticate, ContactEventKind, PeerId, User, UserStore};
+use client::{proto::PeerId, Authenticate, ContactEventKind, User, UserStore};
 use clock::ReplicaId;
 use contacts_popover::ContactsPopover;
 use gpui::{
@@ -342,24 +342,27 @@ impl CollabTitlebarItem {
             let mut participants = room
                 .read(cx)
                 .remote_participants()
-                .iter()
-                .map(|(peer_id, collaborator)| (*peer_id, collaborator.clone()))
+                .values()
+                .cloned()
                 .collect::<Vec<_>>();
-            participants
-                .sort_by_key(|(peer_id, _)| Some(project.collaborators().get(peer_id)?.replica_id));
+            participants.sort_by_key(|p| Some(project.collaborators().get(&p.peer_id)?.replica_id));
             participants
                 .into_iter()
-                .filter_map(|(peer_id, participant)| {
+                .filter_map(|participant| {
                     let project = workspace.read(cx).project().read(cx);
                     let replica_id = project
                         .collaborators()
-                        .get(&peer_id)
+                        .get(&participant.peer_id)
                         .map(|collaborator| collaborator.replica_id);
                     let user = participant.user.clone();
                     Some(self.render_avatar(
                         &user,
                         replica_id,
-                        Some((peer_id, &user.github_login, participant.location)),
+                        Some((
+                            participant.peer_id,
+                            &user.github_login,
+                            participant.location,
+                        )),
                         workspace,
                         theme,
                         cx,
@@ -474,7 +477,7 @@ impl CollabTitlebarItem {
                         cx.dispatch_action(ToggleFollow(peer_id))
                     })
                     .with_tooltip::<ToggleFollow, _>(
-                        peer_id.0 as usize,
+                        peer_id.as_u64() as usize,
                         if is_followed {
                             format!("Unfollow {}", peer_github_login)
                         } else {
@@ -487,22 +490,24 @@ impl CollabTitlebarItem {
                     .boxed()
             } else if let ParticipantLocation::SharedProject { project_id } = location {
                 let user_id = user.id;
-                MouseEventHandler::<JoinProject>::new(peer_id.0 as usize, cx, move |_, _| content)
-                    .with_cursor_style(CursorStyle::PointingHand)
-                    .on_click(MouseButton::Left, move |_, cx| {
-                        cx.dispatch_action(JoinProject {
-                            project_id,
-                            follow_user_id: user_id,
-                        })
+                MouseEventHandler::<JoinProject>::new(peer_id.as_u64() as usize, cx, move |_, _| {
+                    content
+                })
+                .with_cursor_style(CursorStyle::PointingHand)
+                .on_click(MouseButton::Left, move |_, cx| {
+                    cx.dispatch_action(JoinProject {
+                        project_id,
+                        follow_user_id: user_id,
                     })
-                    .with_tooltip::<JoinProject, _>(
-                        peer_id.0 as usize,
-                        format!("Follow {} into external project", peer_github_login),
-                        Some(Box::new(FollowNextCollaborator)),
-                        theme.tooltip.clone(),
-                        cx,
-                    )
-                    .boxed()
+                })
+                .with_tooltip::<JoinProject, _>(
+                    peer_id.as_u64() as usize,
+                    format!("Follow {} into external project", peer_github_login),
+                    Some(Box::new(FollowNextCollaborator)),
+                    theme.tooltip.clone(),
+                    cx,
+                )
+                .boxed()
             } else {
                 content
             }

crates/collab_ui/src/collab_ui.rs

@@ -7,10 +7,10 @@ mod incoming_call_notification;
 mod notifications;
 mod project_shared_notification;
 
+use anyhow::anyhow;
 use call::ActiveCall;
 pub use collab_titlebar_item::{CollabTitlebarItem, ToggleCollaborationMenu};
 use gpui::MutableAppContext;
-use project::Project;
 use std::sync::Arc;
 use workspace::{AppState, JoinProject, ToggleFollow, Workspace};
 
@@ -39,15 +39,20 @@ pub fn init(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
             let workspace = if let Some(existing_workspace) = existing_workspace {
                 existing_workspace
             } else {
-                let project = Project::remote(
-                    project_id,
-                    app_state.client.clone(),
-                    app_state.user_store.clone(),
-                    app_state.languages.clone(),
-                    app_state.fs.clone(),
-                    cx.clone(),
-                )
-                .await?;
+                let active_call = cx.read(ActiveCall::global);
+                let room = active_call
+                    .read_with(&cx, |call, _| call.room().cloned())
+                    .ok_or_else(|| anyhow!("not in a call"))?;
+                let project = room
+                    .update(&mut cx, |room, cx| {
+                        room.join_project(
+                            project_id,
+                            app_state.languages.clone(),
+                            app_state.fs.clone(),
+                            cx,
+                        )
+                    })
+                    .await?;
 
                 let (_, workspace) = cx.add_window((app_state.build_window_options)(), |cx| {
                     let mut workspace = Workspace::new(
@@ -73,7 +78,7 @@ pub fn init(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
                         .remote_participants()
                         .iter()
                         .find(|(_, participant)| participant.user.id == follow_user_id)
-                        .map(|(peer_id, _)| *peer_id)
+                        .map(|(_, p)| p.peer_id)
                         .or_else(|| {
                             // If we couldn't follow the given user, follow the host instead.
                             let collaborator = workspace

crates/collab_ui/src/contact_list.rs

@@ -2,14 +2,16 @@ use std::{mem, sync::Arc};
 
 use crate::contacts_popover;
 use call::ActiveCall;
-use client::{Contact, PeerId, User, UserStore};
+use client::{proto::PeerId, Contact, User, UserStore};
 use editor::{Cancel, Editor};
 use fuzzy::{match_strings, StringMatchCandidate};
 use gpui::{
     elements::*,
     geometry::{rect::RectF, vector::vec2f},
-    impl_actions, impl_internal_actions, keymap, AppContext, CursorStyle, Entity, ModelHandle,
-    MouseButton, MutableAppContext, RenderContext, Subscription, View, ViewContext, ViewHandle,
+    impl_actions, impl_internal_actions,
+    keymap_matcher::KeymapContext,
+    AppContext, CursorStyle, Entity, ModelHandle, MouseButton, MutableAppContext, RenderContext,
+    Subscription, View, ViewContext, ViewHandle,
 };
 use menu::{Confirm, SelectNext, SelectPrev};
 use project::Project;
@@ -461,15 +463,13 @@ impl ContactList {
             // Populate remote participants.
             self.match_candidates.clear();
             self.match_candidates
-                .extend(
-                    room.remote_participants()
-                        .iter()
-                        .map(|(peer_id, participant)| StringMatchCandidate {
-                            id: peer_id.0 as usize,
-                            string: participant.user.github_login.clone(),
-                            char_bag: participant.user.github_login.chars().collect(),
-                        }),
-                );
+                .extend(room.remote_participants().iter().map(|(_, participant)| {
+                    StringMatchCandidate {
+                        id: participant.user.id as usize,
+                        string: participant.user.github_login.clone(),
+                        char_bag: participant.user.github_login.chars().collect(),
+                    }
+                }));
             let matches = executor.block(match_strings(
                 &self.match_candidates,
                 &query,
@@ -479,8 +479,8 @@ impl ContactList {
                 executor.clone(),
             ));
             for mat in matches {
-                let peer_id = PeerId(mat.candidate_id as u32);
-                let participant = &room.remote_participants()[&peer_id];
+                let user_id = mat.candidate_id as u64;
+                let participant = &room.remote_participants()[&user_id];
                 participant_entries.push(ContactEntry::CallParticipant {
                     user: participant.user.clone(),
                     is_pending: false,
@@ -496,7 +496,7 @@ impl ContactList {
                 }
                 if !participant.tracks.is_empty() {
                     participant_entries.push(ContactEntry::ParticipantScreen {
-                        peer_id,
+                        peer_id: participant.peer_id,
                         is_last: true,
                     });
                 }
@@ -881,75 +881,80 @@ impl ContactList {
         let baseline_offset =
             row.name.text.baseline_offset(font_cache) + (theme.row_height - line_height) / 2.;
 
-        MouseEventHandler::<OpenSharedScreen>::new(peer_id.0 as usize, cx, |mouse_state, _| {
-            let tree_branch = *tree_branch.style_for(mouse_state, is_selected);
-            let row = theme.project_row.style_for(mouse_state, is_selected);
+        MouseEventHandler::<OpenSharedScreen>::new(
+            peer_id.as_u64() as usize,
+            cx,
+            |mouse_state, _| {
+                let tree_branch = *tree_branch.style_for(mouse_state, is_selected);
+                let row = theme.project_row.style_for(mouse_state, is_selected);
 
-            Flex::row()
-                .with_child(
-                    Stack::new()
-                        .with_child(
-                            Canvas::new(move |bounds, _, cx| {
-                                let start_x = bounds.min_x() + (bounds.width() / 2.)
-                                    - (tree_branch.width / 2.);
-                                let end_x = bounds.max_x();
-                                let start_y = bounds.min_y();
-                                let end_y = bounds.min_y() + baseline_offset - (cap_height / 2.);
+                Flex::row()
+                    .with_child(
+                        Stack::new()
+                            .with_child(
+                                Canvas::new(move |bounds, _, cx| {
+                                    let start_x = bounds.min_x() + (bounds.width() / 2.)
+                                        - (tree_branch.width / 2.);
+                                    let end_x = bounds.max_x();
+                                    let start_y = bounds.min_y();
+                                    let end_y =
+                                        bounds.min_y() + baseline_offset - (cap_height / 2.);
 
-                                cx.scene.push_quad(gpui::Quad {
-                                    bounds: RectF::from_points(
-                                        vec2f(start_x, start_y),
-                                        vec2f(
-                                            start_x + tree_branch.width,
-                                            if is_last { end_y } else { bounds.max_y() },
+                                    cx.scene.push_quad(gpui::Quad {
+                                        bounds: RectF::from_points(
+                                            vec2f(start_x, start_y),
+                                            vec2f(
+                                                start_x + tree_branch.width,
+                                                if is_last { end_y } else { bounds.max_y() },
+                                            ),
                                         ),
-                                    ),
-                                    background: Some(tree_branch.color),
-                                    border: gpui::Border::default(),
-                                    corner_radius: 0.,
-                                });
-                                cx.scene.push_quad(gpui::Quad {
-                                    bounds: RectF::from_points(
-                                        vec2f(start_x, end_y),
-                                        vec2f(end_x, end_y + tree_branch.width),
-                                    ),
-                                    background: Some(tree_branch.color),
-                                    border: gpui::Border::default(),
-                                    corner_radius: 0.,
-                                });
-                            })
+                                        background: Some(tree_branch.color),
+                                        border: gpui::Border::default(),
+                                        corner_radius: 0.,
+                                    });
+                                    cx.scene.push_quad(gpui::Quad {
+                                        bounds: RectF::from_points(
+                                            vec2f(start_x, end_y),
+                                            vec2f(end_x, end_y + tree_branch.width),
+                                        ),
+                                        background: Some(tree_branch.color),
+                                        border: gpui::Border::default(),
+                                        corner_radius: 0.,
+                                    });
+                                })
+                                .boxed(),
+                            )
+                            .constrained()
+                            .with_width(host_avatar_height)
                             .boxed(),
-                        )
-                        .constrained()
-                        .with_width(host_avatar_height)
-                        .boxed(),
-                )
-                .with_child(
-                    Svg::new("icons/disable_screen_sharing_12.svg")
-                        .with_color(row.icon.color)
-                        .constrained()
-                        .with_width(row.icon.width)
-                        .aligned()
-                        .left()
-                        .contained()
-                        .with_style(row.icon.container)
-                        .boxed(),
-                )
-                .with_child(
-                    Label::new("Screen".into(), row.name.text.clone())
-                        .aligned()
-                        .left()
-                        .contained()
-                        .with_style(row.name.container)
-                        .flex(1., false)
-                        .boxed(),
-                )
-                .constrained()
-                .with_height(theme.row_height)
-                .contained()
-                .with_style(row.container)
-                .boxed()
-        })
+                    )
+                    .with_child(
+                        Svg::new("icons/disable_screen_sharing_12.svg")
+                            .with_color(row.icon.color)
+                            .constrained()
+                            .with_width(row.icon.width)
+                            .aligned()
+                            .left()
+                            .contained()
+                            .with_style(row.icon.container)
+                            .boxed(),
+                    )
+                    .with_child(
+                        Label::new("Screen".into(), row.name.text.clone())
+                            .aligned()
+                            .left()
+                            .contained()
+                            .with_style(row.name.container)
+                            .flex(1., false)
+                            .boxed(),
+                    )
+                    .constrained()
+                    .with_height(theme.row_height)
+                    .contained()
+                    .with_style(row.container)
+                    .boxed()
+            },
+        )
         .with_cursor_style(CursorStyle::PointingHand)
         .on_click(MouseButton::Left, move |_, cx| {
             cx.dispatch_action(OpenSharedScreen { peer_id });
@@ -1264,7 +1269,7 @@ impl View for ContactList {
         "ContactList"
     }
 
-    fn keymap_context(&self, _: &AppContext) -> keymap::Context {
+    fn keymap_context(&self, _: &AppContext) -> KeymapContext {
         let mut cx = Self::default_keymap_context();
         cx.set.insert("menu".into());
         cx

crates/command_palette/src/command_palette.rs

@@ -3,7 +3,7 @@ use fuzzy::{StringMatch, StringMatchCandidate};
 use gpui::{
     actions,
     elements::{ChildView, Flex, Label, ParentElement},
-    keymap::Keystroke,
+    keymap_matcher::Keystroke,
     Action, AnyViewHandle, Element, Entity, MouseState, MutableAppContext, RenderContext, View,
     ViewContext, ViewHandle,
 };
@@ -64,8 +64,10 @@ impl CommandPalette {
                     name: humanize_action_name(name),
                     action,
                     keystrokes: bindings
+                        .iter()
+                        .filter_map(|binding| binding.keystrokes())
                         .last()
-                        .map_or(Vec::new(), |binding| binding.keystrokes().to_vec()),
+                        .map_or(Vec::new(), |keystrokes| keystrokes.to_vec()),
                 })
             })
             .collect();

crates/context_menu/src/context_menu.rs

@@ -1,7 +1,7 @@
 use gpui::{
-    elements::*, geometry::vector::Vector2F, impl_internal_actions, keymap, platform::CursorStyle,
-    Action, AnyViewHandle, AppContext, Axis, Entity, MouseButton, MutableAppContext, RenderContext,
-    SizeConstraint, Subscription, View, ViewContext,
+    elements::*, geometry::vector::Vector2F, impl_internal_actions, keymap_matcher::KeymapContext,
+    platform::CursorStyle, Action, AnyViewHandle, AppContext, Axis, Entity, MouseButton,
+    MutableAppContext, RenderContext, SizeConstraint, Subscription, View, ViewContext,
 };
 use menu::*;
 use settings::Settings;
@@ -75,7 +75,7 @@ impl View for ContextMenu {
         "ContextMenu"
     }
 
-    fn keymap_context(&self, _: &AppContext) -> keymap::Context {
+    fn keymap_context(&self, _: &AppContext) -> KeymapContext {
         let mut cx = Self::default_keymap_context();
         cx.set.insert("menu".into());
         cx

crates/db/src/db.rs

@@ -20,8 +20,8 @@ use std::fs::create_dir_all;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::{SystemTime, UNIX_EPOCH};
-use util::{async_iife, ResultExt};
 use util::channel::ReleaseChannel;
+use util::{async_iife, ResultExt};
 
 const CONNECTION_INITIALIZE_QUERY: &'static str = sql!(
     PRAGMA foreign_keys=TRUE;
@@ -39,16 +39,24 @@ const FALLBACK_DB_NAME: &'static str = "FALLBACK_MEMORY_DB";
 const DB_FILE_NAME: &'static str = "db.sqlite";
 
 lazy_static::lazy_static! {
+    static ref ZED_STATELESS: bool = std::env::var("ZED_STATELESS").map_or(false, |v| !v.is_empty());
     static ref DB_FILE_OPERATIONS: Mutex<()> = Mutex::new(());
     pub static ref BACKUP_DB_PATH: RwLock<Option<PathBuf>> = RwLock::new(None);
-    pub static ref ALL_FILE_DB_FAILED: AtomicBool = AtomicBool::new(false);    
+    pub static ref ALL_FILE_DB_FAILED: AtomicBool = AtomicBool::new(false);
 }
 
 /// Open or create a database at the given directory path.
 /// This will retry a couple times if there are failures. If opening fails once, the db directory
 /// is moved to a backup folder and a new one is created. If that fails, a shared in memory db is created.
 /// In either case, static variables are set so that the user can be notified.
-pub async fn open_db<M: Migrator + 'static>(db_dir: &Path, release_channel: &ReleaseChannel) -> ThreadSafeConnection<M> {
+pub async fn open_db<M: Migrator + 'static>(
+    db_dir: &Path,
+    release_channel: &ReleaseChannel,
+) -> ThreadSafeConnection<M> {
+    if *ZED_STATELESS {
+        return open_fallback_db().await;
+    }
+
     let release_channel_name = release_channel.dev_name();
     let main_db_dir = db_dir.join(Path::new(&format!("0-{}", release_channel_name)));
 
@@ -64,11 +72,11 @@ pub async fn open_db<M: Migrator + 'static>(db_dir: &Path, release_channel: &Rel
         //
         // Basically: Don't ever push invalid migrations to stable or everyone will have
         // a bad time.
-        
+
         // If no db folder, create one at 0-{channel}
         create_dir_all(&main_db_dir).context("Could not create db directory")?;
         let db_path = main_db_dir.join(Path::new(DB_FILE_NAME));
-        
+
         // Optimistically open databases in parallel
         if !DB_FILE_OPERATIONS.is_locked() {
             // Try building a connection
@@ -76,7 +84,7 @@ pub async fn open_db<M: Migrator + 'static>(db_dir: &Path, release_channel: &Rel
                 return Ok(connection)
             };
         }
-        
+
         // Take a lock in the failure case so that we move the db once per process instead 
         // of potentially multiple times from different threads. This shouldn't happen in the
         // normal path
@@ -84,12 +92,12 @@ pub async fn open_db<M: Migrator + 'static>(db_dir: &Path, release_channel: &Rel
         if let Some(connection) = open_main_db(&db_path).await {
             return Ok(connection)
         };
-        
+
         let backup_timestamp = SystemTime::now()
             .duration_since(UNIX_EPOCH)
             .expect("System clock is set before the unix timestamp, Zed does not support this region of spacetime")
             .as_millis();
-        
+
         // If failed, move 0-{channel} to {current unix timestamp}-{channel}
         let backup_db_dir = db_dir.join(Path::new(&format!(
             "{}-{}",
@@ -105,7 +113,7 @@ pub async fn open_db<M: Migrator + 'static>(db_dir: &Path, release_channel: &Rel
             let mut guard = BACKUP_DB_PATH.write();
             *guard = Some(backup_db_dir);
         }
-        
+
         // Create a new 0-{channel}
         create_dir_all(&main_db_dir).context("Should be able to create the database directory")?;
         let db_path = main_db_dir.join(Path::new(DB_FILE_NAME));
@@ -117,10 +125,10 @@ pub async fn open_db<M: Migrator + 'static>(db_dir: &Path, release_channel: &Rel
     if let Some(connection) = connection {
         return connection;
     }
-   
+
     // Set another static ref so that we can escalate the notification
     ALL_FILE_DB_FAILED.store(true, Ordering::Release);
-    
+
     // If still failed, create an in memory db with a known name
     open_fallback_db().await
 }
@@ -174,15 +182,15 @@ macro_rules! define_connection {
                 &self.0
             }
         }
-        
+
         impl $crate::sqlez::domain::Domain for $t {
             fn name() -> &'static str {
                 stringify!($t)
             }
-            
+
             fn migrations() -> &'static [&'static str] {
                 $migrations
-            } 
+            }
         }
 
         #[cfg(any(test, feature = "test-support"))]
@@ -205,15 +213,15 @@ macro_rules! define_connection {
                 &self.0
             }
         }
-        
+
         impl $crate::sqlez::domain::Domain for $t {
             fn name() -> &'static str {
                 stringify!($t)
             }
-            
+
             fn migrations() -> &'static [&'static str] {
                 $migrations
-            } 
+            }
         }
 
         #[cfg(any(test, feature = "test-support"))]
@@ -232,134 +240,155 @@ macro_rules! define_connection {
 mod tests {
     use std::{fs, thread};
 
-    use sqlez::{domain::Domain, connection::Connection};
+    use sqlez::{connection::Connection, domain::Domain};
     use sqlez_macros::sql;
     use tempdir::TempDir;
 
     use crate::{open_db, DB_FILE_NAME};
-        
+
     // Test bad migration panics
     #[gpui::test]
     #[should_panic]
     async fn test_bad_migration_panics() {
         enum BadDB {}
-        
+
         impl Domain for BadDB {
             fn name() -> &'static str {
                 "db_tests"
             }
-            
+
             fn migrations() -> &'static [&'static str] {
-                &[sql!(CREATE TABLE test(value);),
+                &[
+                    sql!(CREATE TABLE test(value);),
                     // failure because test already exists
-                  sql!(CREATE TABLE test(value);)]
+                    sql!(CREATE TABLE test(value);),
+                ]
             }
         }
-       
+
         let tempdir = TempDir::new("DbTests").unwrap();
         let _bad_db = open_db::<BadDB>(tempdir.path(), &util::channel::ReleaseChannel::Dev).await;
     }
-    
+
     /// Test that DB exists but corrupted (causing recreate)
     #[gpui::test]
     async fn test_db_corruption() {
         enum CorruptedDB {}
-        
+
         impl Domain for CorruptedDB {
             fn name() -> &'static str {
                 "db_tests"
             }
-            
+
             fn migrations() -> &'static [&'static str] {
                 &[sql!(CREATE TABLE test(value);)]
             }
         }
-        
+
         enum GoodDB {}
-        
+
         impl Domain for GoodDB {
             fn name() -> &'static str {
                 "db_tests" //Notice same name
             }
-            
+
             fn migrations() -> &'static [&'static str] {
                 &[sql!(CREATE TABLE test2(value);)] //But different migration
             }
         }
-       
+
         let tempdir = TempDir::new("DbTests").unwrap();
         {
-            let corrupt_db = open_db::<CorruptedDB>(tempdir.path(), &util::channel::ReleaseChannel::Dev).await;
+            let corrupt_db =
+                open_db::<CorruptedDB>(tempdir.path(), &util::channel::ReleaseChannel::Dev).await;
             assert!(corrupt_db.persistent());
         }
-        
-        
+
         let good_db = open_db::<GoodDB>(tempdir.path(), &util::channel::ReleaseChannel::Dev).await;
-        assert!(good_db.select_row::<usize>("SELECT * FROM test2").unwrap()().unwrap().is_none());
-        
-        let mut corrupted_backup_dir = fs::read_dir(
-            tempdir.path()
-        ).unwrap().find(|entry| {
-            !entry.as_ref().unwrap().file_name().to_str().unwrap().starts_with("0")
-        }
-        ).unwrap().unwrap().path();
+        assert!(
+            good_db.select_row::<usize>("SELECT * FROM test2").unwrap()()
+                .unwrap()
+                .is_none()
+        );
+
+        let mut corrupted_backup_dir = fs::read_dir(tempdir.path())
+            .unwrap()
+            .find(|entry| {
+                !entry
+                    .as_ref()
+                    .unwrap()
+                    .file_name()
+                    .to_str()
+                    .unwrap()
+                    .starts_with("0")
+            })
+            .unwrap()
+            .unwrap()
+            .path();
         corrupted_backup_dir.push(DB_FILE_NAME);
-        
-        dbg!(&corrupted_backup_dir);
-        
+
         let backup = Connection::open_file(&corrupted_backup_dir.to_string_lossy());
-        assert!(backup.select_row::<usize>("SELECT * FROM test").unwrap()().unwrap().is_none());
+        assert!(backup.select_row::<usize>("SELECT * FROM test").unwrap()()
+            .unwrap()
+            .is_none());
     }
-    
+
     /// Test that DB exists but corrupted (causing recreate)
     #[gpui::test]
     async fn test_simultaneous_db_corruption() {
         enum CorruptedDB {}
-        
+
         impl Domain for CorruptedDB {
             fn name() -> &'static str {
                 "db_tests"
             }
-            
+
             fn migrations() -> &'static [&'static str] {
                 &[sql!(CREATE TABLE test(value);)]
             }
         }
-        
+
         enum GoodDB {}
-        
+
         impl Domain for GoodDB {
             fn name() -> &'static str {
                 "db_tests" //Notice same name
             }
-            
+
             fn migrations() -> &'static [&'static str] {
                 &[sql!(CREATE TABLE test2(value);)] //But different migration
             }
         }
-       
+
         let tempdir = TempDir::new("DbTests").unwrap();
         {
             // Setup the bad database
-            let corrupt_db = open_db::<CorruptedDB>(tempdir.path(), &util::channel::ReleaseChannel::Dev).await;
+            let corrupt_db =
+                open_db::<CorruptedDB>(tempdir.path(), &util::channel::ReleaseChannel::Dev).await;
             assert!(corrupt_db.persistent());
         }
-        
+
         // Try to connect to it a bunch of times at once
         let mut guards = vec![];
         for _ in 0..10 {
             let tmp_path = tempdir.path().to_path_buf();
             let guard = thread::spawn(move || {
-                let good_db = smol::block_on(open_db::<GoodDB>(tmp_path.as_path(), &util::channel::ReleaseChannel::Dev));
-                assert!(good_db.select_row::<usize>("SELECT * FROM test2").unwrap()().unwrap().is_none());
+                let good_db = smol::block_on(open_db::<GoodDB>(
+                    tmp_path.as_path(),
+                    &util::channel::ReleaseChannel::Dev,
+                ));
+                assert!(
+                    good_db.select_row::<usize>("SELECT * FROM test2").unwrap()()
+                        .unwrap()
+                        .is_none()
+                );
             });
-            
+
             guards.push(guard);
-        
         }
-        
-       for guard in guards.into_iter() {
-           assert!(guard.join().is_ok());
-       }
+
+        for guard in guards.into_iter() {
+            assert!(guard.join().is_ok());
+        }
     }
 }

crates/db/src/query.rs

@@ -80,7 +80,7 @@ macro_rules! query {
 
             let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
 
-            self.select::<$return_type>(sql_stmt)?(())
+            self.select::<$return_type>(sql_stmt)?()
                 .context(::std::format!(
                     "Error in {}, select_row failed to execute or parse for: {}",
                     ::std::stringify!($id),
@@ -95,7 +95,7 @@ macro_rules! query {
             self.write(|connection| {
                 let sql_stmt = $crate::sqlez_macros::sql!($($sql)+);
 
-                connection.select::<$return_type>(sql_stmt)?(())
+                connection.select::<$return_type>(sql_stmt)?()
                     .context(::std::format!(
                         "Error in {}, select_row failed to execute or parse for: {}",
                         ::std::stringify!($id),

crates/diagnostics/src/diagnostics.rs

@@ -164,7 +164,7 @@ impl ProjectDiagnosticsEditor {
             editor.set_vertical_scroll_margin(5, cx);
             editor
         });
-        cx.subscribe(&editor, |_, _, event, cx| cx.emit(*event))
+        cx.subscribe(&editor, |_, _, event, cx| cx.emit(event.clone()))
             .detach();
 
         let project = project_handle.read(cx);
@@ -575,6 +575,15 @@ impl Item for ProjectDiagnosticsEditor {
         unreachable!()
     }
 
+    fn git_diff_recalc(
+        &mut self,
+        project: ModelHandle<Project>,
+        cx: &mut ViewContext<Self>,
+    ) -> Task<Result<()>> {
+        self.editor
+            .update(cx, |editor, cx| editor.git_diff_recalc(project, cx))
+    }
+
     fn to_item_events(event: &Self::Event) -> Vec<ItemEvent> {
         Editor::to_item_events(event)
     }

crates/editor/src/editor.rs

@@ -36,6 +36,7 @@ use gpui::{
     fonts::{self, HighlightStyle, TextStyle},
     geometry::vector::Vector2F,
     impl_actions, impl_internal_actions,
+    keymap_matcher::KeymapContext,
     platform::CursorStyle,
     serde_json::json,
     AnyViewHandle, AppContext, AsyncAppContext, ClipboardItem, Element, ElementBox, Entity,
@@ -84,7 +85,7 @@ use std::{
 pub use sum_tree::Bias;
 use theme::{DiagnosticStyle, Theme};
 use util::{post_inc, ResultExt, TryFutureExt};
-use workspace::{ItemNavHistory, Workspace, WorkspaceId};
+use workspace::{ItemNavHistory, ViewId, Workspace, WorkspaceId};
 
 use crate::git::diff_hunk_to_display;
 
@@ -464,9 +465,10 @@ pub struct Editor {
     searchable: bool,
     cursor_shape: CursorShape,
     workspace_id: Option<WorkspaceId>,
-    keymap_context_layers: BTreeMap<TypeId, gpui::keymap::Context>,
+    keymap_context_layers: BTreeMap<TypeId, KeymapContext>,
     input_enabled: bool,
     leader_replica_id: Option<u16>,
+    remote_id: Option<ViewId>,
     hover_state: HoverState,
     link_go_to_definition_state: LinkGoToDefinitionState,
     _subscriptions: Vec<Subscription>,
@@ -826,6 +828,23 @@ impl CompletionsMenu {
                 })
                 .collect()
         };
+
+        //Remove all candidates where the query's start does not match the start of any word in the candidate
+        if let Some(query) = query {
+            if let Some(query_start) = query.chars().next() {
+                matches.retain(|string_match| {
+                    split_words(&string_match.string).any(|word| {
+                        //Check that the first codepoint of the word as lowercase matches the first
+                        //codepoint of the query as lowercase
+                        word.chars()
+                            .flat_map(|codepoint| codepoint.to_lowercase())
+                            .zip(query_start.to_lowercase())
+                            .all(|(word_cp, query_cp)| word_cp == query_cp)
+                    })
+                });
+            }
+        }
+
         matches.sort_unstable_by_key(|mat| {
             let completion = &self.completions[mat.candidate_id];
             (
@@ -1108,6 +1127,7 @@ impl Editor {
             keymap_context_layers: Default::default(),
             input_enabled: true,
             leader_replica_id: None,
+            remote_id: None,
             hover_state: Default::default(),
             link_go_to_definition_state: Default::default(),
             _subscriptions: vec![
@@ -1223,7 +1243,7 @@ impl Editor {
         }
     }
 
-    pub fn set_keymap_context_layer<Tag: 'static>(&mut self, context: gpui::keymap::Context) {
+    pub fn set_keymap_context_layer<Tag: 'static>(&mut self, context: KeymapContext) {
         self.keymap_context_layers
             .insert(TypeId::of::<Tag>(), context);
     }
@@ -2000,7 +2020,9 @@ impl Editor {
                     old_selections
                         .iter()
                         .map(|s| (s.start..s.end, text.clone())),
-                    Some(AutoindentMode::EachLine),
+                    Some(AutoindentMode::Block {
+                        original_indent_columns: Vec::new(),
+                    }),
                     cx,
                 );
                 anchors
@@ -4779,7 +4801,7 @@ impl Editor {
             if let Some(popover) = self.hover_state.diagnostic_popover.as_ref() {
                 let (group_id, jump_to) = popover.activation_info();
                 if self.activate_diagnostics(group_id, cx) {
-                    self.change_selections(Some(Autoscroll::center()), cx, |s| {
+                    self.change_selections(Some(Autoscroll::fit()), cx, |s| {
                         let mut new_selection = s.newest_anchor().clone();
                         new_selection.collapse_to(jump_to, SelectionGoal::None);
                         s.select_anchors(vec![new_selection.clone()]);
@@ -4825,7 +4847,7 @@ impl Editor {
 
             if let Some((primary_range, group_id)) = group {
                 if self.activate_diagnostics(group_id, cx) {
-                    self.change_selections(Some(Autoscroll::center()), cx, |s| {
+                    self.change_selections(Some(Autoscroll::fit()), cx, |s| {
                         s.select(vec![Selection {
                             id: selection.id,
                             start: primary_range.start,
@@ -4900,7 +4922,7 @@ impl Editor {
                 .dedup();
 
             if let Some(hunk) = hunks.next() {
-                this.change_selections(Some(Autoscroll::center()), cx, |s| {
+                this.change_selections(Some(Autoscroll::fit()), cx, |s| {
                     let row = hunk.start_display_row();
                     let point = DisplayPoint::new(row, 0);
                     s.select_display_ranges([point..point]);
@@ -4998,7 +5020,7 @@ impl Editor {
                 if editor_handle != target_editor_handle {
                     pane.update(cx, |pane, _| pane.disable_history());
                 }
-                target_editor.change_selections(Some(Autoscroll::center()), cx, |s| {
+                target_editor.change_selections(Some(Autoscroll::fit()), cx, |s| {
                     s.select_ranges([range]);
                 });
 
@@ -5451,11 +5473,17 @@ impl Editor {
     pub fn set_selections_from_remote(
         &mut self,
         selections: Vec<Selection<Anchor>>,
+        pending_selection: Option<Selection<Anchor>>,
         cx: &mut ViewContext<Self>,
     ) {
         let old_cursor_position = self.selections.newest_anchor().head();
         self.selections.change_with(cx, |s| {
             s.select_anchors(selections);
+            if let Some(pending_selection) = pending_selection {
+                s.set_pending(pending_selection, SelectMode::Character);
+            } else {
+                s.clear_pending();
+            }
         });
         self.selections_did_change(false, &old_cursor_position, cx);
     }
@@ -5883,25 +5911,36 @@ impl Editor {
     fn on_buffer_event(
         &mut self,
         _: ModelHandle<MultiBuffer>,
-        event: &language::Event,
+        event: &multi_buffer::Event,
         cx: &mut ViewContext<Self>,
     ) {
         match event {
-            language::Event::Edited => {
+            multi_buffer::Event::Edited => {
                 self.refresh_active_diagnostics(cx);
                 self.refresh_code_actions(cx);
                 cx.emit(Event::BufferEdited);
             }
-            language::Event::Reparsed => cx.emit(Event::Reparsed),
-            language::Event::DirtyChanged => cx.emit(Event::DirtyChanged),
-            language::Event::Saved => cx.emit(Event::Saved),
-            language::Event::FileHandleChanged => cx.emit(Event::TitleChanged),
-            language::Event::Reloaded => cx.emit(Event::TitleChanged),
-            language::Event::Closed => cx.emit(Event::Closed),
-            language::Event::DiagnosticsUpdated => {
+            multi_buffer::Event::ExcerptsAdded {
+                buffer,
+                predecessor,
+                excerpts,
+            } => cx.emit(Event::ExcerptsAdded {
+                buffer: buffer.clone(),
+                predecessor: *predecessor,
+                excerpts: excerpts.clone(),
+            }),
+            multi_buffer::Event::ExcerptsRemoved { ids } => {
+                cx.emit(Event::ExcerptsRemoved { ids: ids.clone() })
+            }
+            multi_buffer::Event::Reparsed => cx.emit(Event::Reparsed),
+            multi_buffer::Event::DirtyChanged => cx.emit(Event::DirtyChanged),
+            multi_buffer::Event::Saved => cx.emit(Event::Saved),
+            multi_buffer::Event::FileHandleChanged => cx.emit(Event::TitleChanged),
+            multi_buffer::Event::Reloaded => cx.emit(Event::TitleChanged),
+            multi_buffer::Event::Closed => cx.emit(Event::Closed),
+            multi_buffer::Event::DiagnosticsUpdated => {
                 self.refresh_active_diagnostics(cx);
             }
-            _ => {}
         }
     }
 
@@ -6050,10 +6089,11 @@ impl Editor {
             let extension = Path::new(file.file_name(cx))
                 .extension()
                 .and_then(|e| e.to_str());
-            project
-                .read(cx)
-                .client()
-                .report_event(name, json!({ "File Extension": extension }));
+            project.read(cx).client().report_event(
+                name,
+                json!({ "File Extension": extension }),
+                cx.global::<Settings>().telemetry(),
+            );
         }
     }
 }
@@ -6084,8 +6124,16 @@ impl Deref for EditorSnapshot {
     }
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Event {
+    ExcerptsAdded {
+        buffer: ModelHandle<Buffer>,
+        predecessor: ExcerptId,
+        excerpts: Vec<(ExcerptId, ExcerptRange<language::Anchor>)>,
+    },
+    ExcerptsRemoved {
+        ids: Vec<ExcerptId>,
+    },
     BufferEdited,
     Edited,
     Reparsed,
@@ -6093,8 +6141,12 @@ pub enum Event {
     DirtyChanged,
     Saved,
     TitleChanged,
-    SelectionsChanged { local: bool },
-    ScrollPositionChanged { local: bool },
+    SelectionsChanged {
+        local: bool,
+    },
+    ScrollPositionChanged {
+        local: bool,
+    },
     Closed,
 }
 
@@ -6214,7 +6266,7 @@ impl View for Editor {
         false
     }
 
-    fn keymap_context(&self, _: &AppContext) -> gpui::keymap::Context {
+    fn keymap_context(&self, _: &AppContext) -> KeymapContext {
         let mut context = Self::default_keymap_context();
         let mode = match self.mode {
             EditorMode::SingleLine => "single_line",
@@ -6768,6 +6820,34 @@ pub fn styled_runs_for_code_label<'a>(
         })
 }
 
+pub fn split_words<'a>(text: &'a str) -> impl std::iter::Iterator<Item = &'a str> + 'a {
+    let mut index = 0;
+    let mut codepoints = text.char_indices().peekable();
+
+    std::iter::from_fn(move || {
+        let start_index = index;
+        while let Some((new_index, codepoint)) = codepoints.next() {
+            index = new_index + codepoint.len_utf8();
+            let current_upper = codepoint.is_uppercase();
+            let next_upper = codepoints
+                .peek()
+                .map(|(_, c)| c.is_uppercase())
+                .unwrap_or(false);
+
+            if !current_upper && next_upper {
+                return Some(&text[start_index..index]);
+            }
+        }
+
+        index = text.len();
+        if start_index < text.len() {
+            return Some(&text[start_index..]);
+        }
+        None
+    })
+    .flat_map(|word| word.split_inclusive('_'))
+}
+
 trait RangeExt<T> {
     fn sorted(&self) -> Range<T>;
     fn to_inclusive(&self) -> RangeInclusive<T>;

crates/editor/src/editor_tests.rs

@@ -1,8 +1,7 @@
-use std::{cell::RefCell, rc::Rc, time::Instant};
-
 use drag_and_drop::DragAndDrop;
 use futures::StreamExt;
 use indoc::indoc;
+use std::{cell::RefCell, rc::Rc, time::Instant};
 use unindent::Unindent;
 
 use super::*;
@@ -24,13 +23,17 @@ use util::{
 };
 use workspace::{
     item::{FollowableItem, ItemHandle},
-    NavigationEntry, Pane,
+    NavigationEntry, Pane, ViewId,
 };
 
 #[gpui::test]
 fn test_edit_events(cx: &mut MutableAppContext) {
     cx.set_global(Settings::test(cx));
-    let buffer = cx.add_model(|cx| language::Buffer::new(0, "123456", cx));
+    let buffer = cx.add_model(|cx| {
+        let mut buffer = language::Buffer::new(0, "123456", cx);
+        buffer.set_group_interval(Duration::from_secs(1));
+        buffer
+    });
 
     let events = Rc::new(RefCell::new(Vec::new()));
     let (_, editor1) = cx.add_window(Default::default(), {
@@ -41,7 +44,7 @@ fn test_edit_events(cx: &mut MutableAppContext) {
                     event,
                     Event::Edited | Event::BufferEdited | Event::DirtyChanged
                 ) {
-                    events.borrow_mut().push(("editor1", *event));
+                    events.borrow_mut().push(("editor1", event.clone()));
                 }
             })
             .detach();
@@ -56,7 +59,7 @@ fn test_edit_events(cx: &mut MutableAppContext) {
                     event,
                     Event::Edited | Event::BufferEdited | Event::DirtyChanged
                 ) {
-                    events.borrow_mut().push(("editor2", *event));
+                    events.borrow_mut().push(("editor2", event.clone()));
                 }
             })
             .detach();
@@ -3503,6 +3506,8 @@ async fn test_surround_with_pair(cx: &mut gpui::TestAppContext) {
             ]
         );
 
+        view.undo(&Undo, cx);
+        view.undo(&Undo, cx);
         view.undo(&Undo, cx);
         assert_eq!(
             view.text(cx),
@@ -4969,19 +4974,27 @@ fn test_highlighted_ranges(cx: &mut gpui::MutableAppContext) {
 }
 
 #[gpui::test]
-fn test_following(cx: &mut gpui::MutableAppContext) {
-    let buffer = MultiBuffer::build_simple(&sample_text(16, 8, 'a'), cx);
+async fn test_following(cx: &mut gpui::TestAppContext) {
+    Settings::test_async(cx);
+    let fs = FakeFs::new(cx.background());
+    let project = Project::test(fs, ["/file.rs".as_ref()], cx).await;
 
-    cx.set_global(Settings::test(cx));
-
-    let (_, leader) = cx.add_window(Default::default(), |cx| build_editor(buffer.clone(), cx));
-    let (_, follower) = cx.add_window(
-        WindowOptions {
-            bounds: WindowBounds::Fixed(RectF::from_points(vec2f(0., 0.), vec2f(10., 80.))),
-            ..Default::default()
-        },
-        |cx| build_editor(buffer.clone(), cx),
-    );
+    let buffer = project.update(cx, |project, cx| {
+        let buffer = project
+            .create_buffer(&sample_text(16, 8, 'a'), None, cx)
+            .unwrap();
+        cx.add_model(|cx| MultiBuffer::singleton(buffer, cx))
+    });
+    let (_, leader) = cx.add_window(|cx| build_editor(buffer.clone(), cx));
+    let (_, follower) = cx.update(|cx| {
+        cx.add_window(
+            WindowOptions {
+                bounds: WindowBounds::Fixed(RectF::from_points(vec2f(0., 0.), vec2f(10., 80.))),
+                ..Default::default()
+            },
+            |cx| build_editor(buffer.clone(), cx),
+        )
+    });
 
     let is_still_following = Rc::new(RefCell::new(true));
     let pending_update = Rc::new(RefCell::new(None));
@@ -5009,44 +5022,50 @@ fn test_following(cx: &mut gpui::MutableAppContext) {
     leader.update(cx, |leader, cx| {
         leader.change_selections(None, cx, |s| s.select_ranges([1..1]));
     });
-    follower.update(cx, |follower, cx| {
-        follower
-            .apply_update_proto(pending_update.borrow_mut().take().unwrap(), cx)
-            .unwrap();
+    follower
+        .update(cx, |follower, cx| {
+            follower.apply_update_proto(&project, pending_update.borrow_mut().take().unwrap(), cx)
+        })
+        .await
+        .unwrap();
+    follower.read_with(cx, |follower, cx| {
+        assert_eq!(follower.selections.ranges(cx), vec![1..1]);
     });
-    assert_eq!(follower.read(cx).selections.ranges(cx), vec![1..1]);
     assert_eq!(*is_still_following.borrow(), true);
 
     // Update the scroll position only
     leader.update(cx, |leader, cx| {
         leader.set_scroll_position(vec2f(1.5, 3.5), cx);
     });
-    follower.update(cx, |follower, cx| {
-        follower
-            .apply_update_proto(pending_update.borrow_mut().take().unwrap(), cx)
-            .unwrap();
-    });
+    follower
+        .update(cx, |follower, cx| {
+            follower.apply_update_proto(&project, pending_update.borrow_mut().take().unwrap(), cx)
+        })
+        .await
+        .unwrap();
     assert_eq!(
         follower.update(cx, |follower, cx| follower.scroll_position(cx)),
         vec2f(1.5, 3.5)
     );
     assert_eq!(*is_still_following.borrow(), true);
 
-    // Update the selections and scroll position
+    // Update the selections and scroll position. The follower's scroll position is updated
+    // via autoscroll, not via the leader's exact scroll position.
     leader.update(cx, |leader, cx| {
         leader.change_selections(None, cx, |s| s.select_ranges([0..0]));
         leader.request_autoscroll(Autoscroll::newest(), cx);
         leader.set_scroll_position(vec2f(1.5, 3.5), cx);
     });
+    follower
+        .update(cx, |follower, cx| {
+            follower.apply_update_proto(&project, pending_update.borrow_mut().take().unwrap(), cx)
+        })
+        .await
+        .unwrap();
     follower.update(cx, |follower, cx| {
-        let initial_scroll_position = follower.scroll_position(cx);
-        follower
-            .apply_update_proto(pending_update.borrow_mut().take().unwrap(), cx)
-            .unwrap();
-        assert_eq!(follower.scroll_position(cx), initial_scroll_position);
-        assert!(follower.scroll_manager.has_autoscroll_request());
+        assert_eq!(follower.scroll_position(cx), vec2f(1.5, 0.0));
+        assert_eq!(follower.selections.ranges(cx), vec![0..0]);
     });
-    assert_eq!(follower.read(cx).selections.ranges(cx), vec![0..0]);
     assert_eq!(*is_still_following.borrow(), true);
 
     // Creating a pending selection that precedes another selection
@@ -5054,24 +5073,30 @@ fn test_following(cx: &mut gpui::MutableAppContext) {
         leader.change_selections(None, cx, |s| s.select_ranges([1..1]));
         leader.begin_selection(DisplayPoint::new(0, 0), true, 1, cx);
     });
-    follower.update(cx, |follower, cx| {
-        follower
-            .apply_update_proto(pending_update.borrow_mut().take().unwrap(), cx)
-            .unwrap();
+    follower
+        .update(cx, |follower, cx| {
+            follower.apply_update_proto(&project, pending_update.borrow_mut().take().unwrap(), cx)
+        })
+        .await
+        .unwrap();
+    follower.read_with(cx, |follower, cx| {
+        assert_eq!(follower.selections.ranges(cx), vec![0..0, 1..1]);
     });
-    assert_eq!(follower.read(cx).selections.ranges(cx), vec![0..0, 1..1]);
     assert_eq!(*is_still_following.borrow(), true);
 
     // Extend the pending selection so that it surrounds another selection
     leader.update(cx, |leader, cx| {
         leader.extend_selection(DisplayPoint::new(0, 2), 1, cx);
     });
-    follower.update(cx, |follower, cx| {
-        follower
-            .apply_update_proto(pending_update.borrow_mut().take().unwrap(), cx)
-            .unwrap();
+    follower
+        .update(cx, |follower, cx| {
+            follower.apply_update_proto(&project, pending_update.borrow_mut().take().unwrap(), cx)
+        })
+        .await
+        .unwrap();
+    follower.read_with(cx, |follower, cx| {
+        assert_eq!(follower.selections.ranges(cx), vec![0..2]);
     });
-    assert_eq!(follower.read(cx).selections.ranges(cx), vec![0..2]);
 
     // Scrolling locally breaks the follow
     follower.update(cx, |follower, cx| {
@@ -5087,6 +5112,165 @@ fn test_following(cx: &mut gpui::MutableAppContext) {
     assert_eq!(*is_still_following.borrow(), false);
 }
 
+#[gpui::test]
+async fn test_following_with_multiple_excerpts(cx: &mut gpui::TestAppContext) {
+    Settings::test_async(cx);
+    let fs = FakeFs::new(cx.background());
+    let project = Project::test(fs, ["/file.rs".as_ref()], cx).await;
+    let (_, pane) = cx.add_window(|cx| Pane::new(None, cx));
+
+    let leader = pane.update(cx, |_, cx| {
+        let multibuffer = cx.add_model(|_| MultiBuffer::new(0));
+        cx.add_view(|cx| build_editor(multibuffer.clone(), cx))
+    });
+
+    // Start following the editor when it has no excerpts.
+    let mut state_message = leader.update(cx, |leader, cx| leader.to_state_proto(cx));
+    let follower_1 = cx
+        .update(|cx| {
+            Editor::from_state_proto(
+                pane.clone(),
+                project.clone(),
+                ViewId {
+                    creator: Default::default(),
+                    id: 0,
+                },
+                &mut state_message,
+                cx,
+            )
+        })
+        .unwrap()
+        .await
+        .unwrap();
+
+    let update_message = Rc::new(RefCell::new(None));
+    follower_1.update(cx, {
+        let update = update_message.clone();
+        |_, cx| {
+            cx.subscribe(&leader, move |_, leader, event, cx| {
+                leader
+                    .read(cx)
+                    .add_event_to_update_proto(event, &mut *update.borrow_mut(), cx);
+            })
+            .detach();
+        }
+    });
+
+    let (buffer_1, buffer_2) = project.update(cx, |project, cx| {
+        (
+            project
+                .create_buffer("abc\ndef\nghi\njkl\n", None, cx)
+                .unwrap(),
+            project
+                .create_buffer("mno\npqr\nstu\nvwx\n", None, cx)
+                .unwrap(),
+        )
+    });
+
+    // Insert some excerpts.
+    leader.update(cx, |leader, cx| {
+        leader.buffer.update(cx, |multibuffer, cx| {
+            let excerpt_ids = multibuffer.push_excerpts(
+                buffer_1.clone(),
+                [
+                    ExcerptRange {
+                        context: 1..6,
+                        primary: None,
+                    },
+                    ExcerptRange {
+                        context: 12..15,
+                        primary: None,
+                    },
+                    ExcerptRange {
+                        context: 0..3,
+                        primary: None,
+                    },
+                ],
+                cx,
+            );
+            multibuffer.insert_excerpts_after(
+                excerpt_ids[0],
+                buffer_2.clone(),
+                [
+                    ExcerptRange {
+                        context: 8..12,
+                        primary: None,
+                    },
+                    ExcerptRange {
+                        context: 0..6,
+                        primary: None,
+                    },
+                ],
+                cx,
+            );
+        });
+    });
+
+    // Apply the update of adding the excerpts.
+    follower_1
+        .update(cx, |follower, cx| {
+            follower.apply_update_proto(&project, update_message.borrow().clone().unwrap(), cx)
+        })
+        .await
+        .unwrap();
+    assert_eq!(
+        follower_1.read_with(cx, Editor::text),
+        leader.read_with(cx, Editor::text)
+    );
+    update_message.borrow_mut().take();
+
+    // Start following separately after it already has excerpts.
+    let mut state_message = leader.update(cx, |leader, cx| leader.to_state_proto(cx));
+    let follower_2 = cx
+        .update(|cx| {
+            Editor::from_state_proto(
+                pane.clone(),
+                project.clone(),
+                ViewId {
+                    creator: Default::default(),
+                    id: 0,
+                },
+                &mut state_message,
+                cx,
+            )
+        })
+        .unwrap()
+        .await
+        .unwrap();
+    assert_eq!(
+        follower_2.read_with(cx, Editor::text),
+        leader.read_with(cx, Editor::text)
+    );
+
+    // Remove some excerpts.
+    leader.update(cx, |leader, cx| {
+        leader.buffer.update(cx, |multibuffer, cx| {
+            let excerpt_ids = multibuffer.excerpt_ids();
+            multibuffer.remove_excerpts([excerpt_ids[1], excerpt_ids[2]], cx);
+            multibuffer.remove_excerpts([excerpt_ids[0]], cx);
+        });
+    });
+
+    // Apply the update of removing the excerpts.
+    follower_1
+        .update(cx, |follower, cx| {
+            follower.apply_update_proto(&project, update_message.borrow().clone().unwrap(), cx)
+        })
+        .await
+        .unwrap();
+    follower_2
+        .update(cx, |follower, cx| {
+            follower.apply_update_proto(&project, update_message.borrow().clone().unwrap(), cx)
+        })
+        .await
+        .unwrap();
+    update_message.borrow_mut().take();
+    assert_eq!(
+        follower_1.read_with(cx, Editor::text),
+        leader.read_with(cx, Editor::text)
+    );
+}
+
 #[test]
 fn test_combine_syntax_and_fuzzy_match_highlights() {
     let string = "abcdefghijklmnop";
@@ -5261,6 +5445,20 @@ async fn go_to_hunk(deterministic: Arc<Deterministic>, cx: &mut gpui::TestAppCon
     );
 }
 
+#[test]
+fn test_split_words() {
+    fn split<'a>(text: &'a str) -> Vec<&'a str> {
+        split_words(text).collect()
+    }
+
+    assert_eq!(split("HelloWorld"), &["Hello", "World"]);
+    assert_eq!(split("hello_world"), &["hello_", "world"]);
+    assert_eq!(split("_hello_world_"), &["_", "hello_", "world_"]);
+    assert_eq!(split("Hello_World"), &["Hello_", "World"]);
+    assert_eq!(split("helloWOrld"), &["hello", "WOrld"]);
+    assert_eq!(split("helloworld"), &["helloworld"]);
+}
+
 fn empty_range(row: usize, column: usize) -> Range<DisplayPoint> {
     let point = DisplayPoint::new(row as u32, column as u32);
     point..point

crates/editor/src/items.rs

@@ -1,9 +1,19 @@
+use crate::{
+    display_map::ToDisplayPoint, link_go_to_definition::hide_link_definition,
+    movement::surrounding_word, persistence::DB, scroll::ScrollAnchor, Anchor, Autoscroll, Editor,
+    Event, ExcerptId, ExcerptRange, MultiBuffer, MultiBufferSnapshot, NavigationData, ToPoint as _,
+    FORMAT_TIMEOUT,
+};
 use anyhow::{anyhow, Context, Result};
+use collections::HashSet;
+use futures::future::try_join_all;
 use futures::FutureExt;
+
 use gpui::{
     elements::*, geometry::vector::vec2f, AppContext, Entity, ModelHandle, MutableAppContext,
     RenderContext, Subscription, Task, View, ViewContext, ViewHandle, WeakViewHandle,
 };
+use language::proto::serialize_anchor as serialize_text_anchor;
 use language::{Bias, Buffer, File as _, OffsetRangeExt, Point, SelectionGoal};
 use project::{File, FormatTrigger, Project, ProjectEntryId, ProjectPath};
 use rpc::proto::{self, update_view};
@@ -13,97 +23,140 @@ use std::{
     borrow::Cow,
     cmp::{self, Ordering},
     fmt::Write,
+    iter,
     ops::Range,
     path::{Path, PathBuf},
 };
 use text::Selection;
 use util::{ResultExt, TryFutureExt};
+use workspace::item::FollowableItemHandle;
 use workspace::{
     item::{FollowableItem, Item, ItemEvent, ItemHandle, ProjectItem},
     searchable::{Direction, SearchEvent, SearchableItem, SearchableItemHandle},
-    ItemId, ItemNavHistory, Pane, StatusItemView, ToolbarItemLocation, Workspace, WorkspaceId,
-};
-
-use crate::{
-    display_map::ToDisplayPoint, link_go_to_definition::hide_link_definition,
-    movement::surrounding_word, persistence::DB, scroll::ScrollAnchor, Anchor, Autoscroll, Editor,
-    Event, ExcerptId, MultiBuffer, MultiBufferSnapshot, NavigationData, ToPoint as _,
-    FORMAT_TIMEOUT,
+    ItemId, ItemNavHistory, Pane, StatusItemView, ToolbarItemLocation, ViewId, Workspace,
+    WorkspaceId,
 };
 
 pub const MAX_TAB_TITLE_LEN: usize = 24;
 
 impl FollowableItem for Editor {
+    fn remote_id(&self) -> Option<ViewId> {
+        self.remote_id
+    }
+
     fn from_state_proto(
         pane: ViewHandle<workspace::Pane>,
         project: ModelHandle<Project>,
+        remote_id: ViewId,
         state: &mut Option<proto::view::Variant>,
         cx: &mut MutableAppContext,
     ) -> Option<Task<Result<ViewHandle<Self>>>> {
-        let state = if matches!(state, Some(proto::view::Variant::Editor(_))) {
-            if let Some(proto::view::Variant::Editor(state)) = state.take() {
-                state
-            } else {
-                unreachable!()
-            }
-        } else {
-            return None;
-        };
+        let Some(proto::view::Variant::Editor(_)) = state else { return None };
+        let Some(proto::view::Variant::Editor(state)) = state.take() else { unreachable!() };
 
-        let buffer = project.update(cx, |project, cx| {
-            project.open_buffer_by_id(state.buffer_id, cx)
+        let client = project.read(cx).client();
+        let replica_id = project.read(cx).replica_id();
+        let buffer_ids = state
+            .excerpts
+            .iter()
+            .map(|excerpt| excerpt.buffer_id)
+            .collect::<HashSet<_>>();
+        let buffers = project.update(cx, |project, cx| {
+            buffer_ids
+                .iter()
+                .map(|id| project.open_buffer_by_id(*id, cx))
+                .collect::<Vec<_>>()
         });
+
         Some(cx.spawn(|mut cx| async move {
-            let buffer = buffer.await?;
-            let editor = pane
-                .read_with(&cx, |pane, cx| {
-                    pane.items_of_type::<Self>().find(|editor| {
-                        editor.read(cx).buffer.read(cx).as_singleton().as_ref() == Some(&buffer)
-                    })
+            let mut buffers = futures::future::try_join_all(buffers).await?;
+            let editor = pane.read_with(&cx, |pane, cx| {
+                let mut editors = pane.items_of_type::<Self>();
+                editors.find(|editor| {
+                    editor.remote_id(&client, cx) == Some(remote_id)
+                        || state.singleton
+                            && buffers.len() == 1
+                            && editor.read(cx).buffer.read(cx).as_singleton().as_ref()
+                                == Some(&buffers[0])
                 })
-                .unwrap_or_else(|| {
-                    pane.update(&mut cx, |_, cx| {
-                        cx.add_view(|cx| Editor::for_buffer(buffer, Some(project), cx))
-                    })
-                });
+            });
+
+            let editor = editor.unwrap_or_else(|| {
+                pane.update(&mut cx, |_, cx| {
+                    let multibuffer = cx.add_model(|cx| {
+                        let mut multibuffer;
+                        if state.singleton && buffers.len() == 1 {
+                            multibuffer = MultiBuffer::singleton(buffers.pop().unwrap(), cx)
+                        } else {
+                            multibuffer = MultiBuffer::new(replica_id);
+                            let mut excerpts = state.excerpts.into_iter().peekable();
+                            while let Some(excerpt) = excerpts.peek() {
+                                let buffer_id = excerpt.buffer_id;
+                                let buffer_excerpts = iter::from_fn(|| {
+                                    let excerpt = excerpts.peek()?;
+                                    (excerpt.buffer_id == buffer_id)
+                                        .then(|| excerpts.next().unwrap())
+                                });
+                                let buffer =
+                                    buffers.iter().find(|b| b.read(cx).remote_id() == buffer_id);
+                                if let Some(buffer) = buffer {
+                                    multibuffer.push_excerpts(
+                                        buffer.clone(),
+                                        buffer_excerpts.filter_map(deserialize_excerpt_range),
+                                        cx,
+                                    );
+                                }
+                            }
+                        };
+
+                        if let Some(title) = &state.title {
+                            multibuffer = multibuffer.with_title(title.clone())
+                        }
+
+                        multibuffer
+                    });
+
+                    cx.add_view(|cx| Editor::for_multibuffer(multibuffer, Some(project), cx))
+                })
+            });
+
             editor.update(&mut cx, |editor, cx| {
-                let excerpt_id;
-                let buffer_id;
-                {
-                    let buffer = editor.buffer.read(cx).read(cx);
-                    let singleton = buffer.as_singleton().unwrap();
-                    excerpt_id = singleton.0.clone();
-                    buffer_id = singleton.1;
-                }
+                editor.remote_id = Some(remote_id);
+                let buffer = editor.buffer.read(cx).read(cx);
                 let selections = state
                     .selections
                     .into_iter()
                     .map(|selection| {
-                        deserialize_selection(&excerpt_id, buffer_id, selection)
+                        deserialize_selection(&buffer, selection)
                             .ok_or_else(|| anyhow!("invalid selection"))
                     })
                     .collect::<Result<Vec<_>>>()?;
-                if !selections.is_empty() {
-                    editor.set_selections_from_remote(selections, cx);
+                let pending_selection = state
+                    .pending_selection
+                    .map(|selection| deserialize_selection(&buffer, selection))
+                    .flatten();
+                let scroll_top_anchor = state
+                    .scroll_top_anchor
+                    .and_then(|anchor| deserialize_anchor(&buffer, anchor));
+                drop(buffer);
+
+                if !selections.is_empty() || pending_selection.is_some() {
+                    editor.set_selections_from_remote(selections, pending_selection, cx);
                 }
 
-                if let Some(anchor) = state.scroll_top_anchor {
+                if let Some(scroll_top_anchor) = scroll_top_anchor {
                     editor.set_scroll_anchor_remote(
                         ScrollAnchor {
-                            top_anchor: Anchor {
-                                buffer_id: Some(state.buffer_id as usize),
-                                excerpt_id,
-                                text_anchor: language::proto::deserialize_anchor(anchor)
-                                    .ok_or_else(|| anyhow!("invalid scroll top"))?,
-                            },
+                            top_anchor: scroll_top_anchor,
                             offset: vec2f(state.scroll_x, state.scroll_y),
                         },
                         cx,
                     );
                 }
 
-                Ok::<_, anyhow::Error>(())
+                anyhow::Ok(())
             })?;
+
             Ok(editor)
         }))
     }
@@ -134,13 +187,32 @@ impl FollowableItem for Editor {
     }
 
     fn to_state_proto(&self, cx: &AppContext) -> Option<proto::view::Variant> {
-        let buffer_id = self.buffer.read(cx).as_singleton()?.read(cx).remote_id();
+        let buffer = self.buffer.read(cx);
         let scroll_anchor = self.scroll_manager.anchor();
+        let excerpts = buffer
+            .read(cx)
+            .excerpts()
+            .map(|(id, buffer, range)| proto::Excerpt {
+                id: id.to_proto(),
+                buffer_id: buffer.remote_id(),
+                context_start: Some(serialize_text_anchor(&range.context.start)),
+                context_end: Some(serialize_text_anchor(&range.context.end)),
+                primary_start: range
+                    .primary
+                    .as_ref()
+                    .map(|range| serialize_text_anchor(&range.start)),
+                primary_end: range
+                    .primary
+                    .as_ref()
+                    .map(|range| serialize_text_anchor(&range.end)),
+            })
+            .collect();
+
         Some(proto::view::Variant::Editor(proto::view::Editor {
-            buffer_id,
-            scroll_top_anchor: Some(language::proto::serialize_anchor(
-                &scroll_anchor.top_anchor.text_anchor,
-            )),
+            singleton: buffer.is_singleton(),
+            title: (!buffer.is_singleton()).then(|| buffer.title(cx).into()),
+            excerpts,
+            scroll_top_anchor: Some(serialize_anchor(&scroll_anchor.top_anchor)),
             scroll_x: scroll_anchor.offset.x(),
             scroll_y: scroll_anchor.offset.y(),
             selections: self
@@ -149,6 +221,11 @@ impl FollowableItem for Editor {
                 .iter()
                 .map(serialize_selection)
                 .collect(),
+            pending_selection: self
+                .selections
+                .pending_anchor()
+                .as_ref()
+                .map(serialize_selection),
         }))
     }
 
@@ -156,18 +233,43 @@ impl FollowableItem for Editor {
         &self,
         event: &Self::Event,
         update: &mut Option<proto::update_view::Variant>,
-        _: &AppContext,
+        cx: &AppContext,
     ) -> bool {
         let update =
             update.get_or_insert_with(|| proto::update_view::Variant::Editor(Default::default()));
 
         match update {
             proto::update_view::Variant::Editor(update) => match event {
+                Event::ExcerptsAdded {
+                    buffer,
+                    predecessor,
+                    excerpts,
+                } => {
+                    let buffer_id = buffer.read(cx).remote_id();
+                    let mut excerpts = excerpts.iter();
+                    if let Some((id, range)) = excerpts.next() {
+                        update.inserted_excerpts.push(proto::ExcerptInsertion {
+                            previous_excerpt_id: Some(predecessor.to_proto()),
+                            excerpt: serialize_excerpt(buffer_id, id, range),
+                        });
+                        update.inserted_excerpts.extend(excerpts.map(|(id, range)| {
+                            proto::ExcerptInsertion {
+                                previous_excerpt_id: None,
+                                excerpt: serialize_excerpt(buffer_id, id, range),
+                            }
+                        }))
+                    }
+                    true
+                }
+                Event::ExcerptsRemoved { ids } => {
+                    update
+                        .deleted_excerpts
+                        .extend(ids.iter().map(ExcerptId::to_proto));
+                    true
+                }
                 Event::ScrollPositionChanged { .. } => {
                     let scroll_anchor = self.scroll_manager.anchor();
-                    update.scroll_top_anchor = Some(language::proto::serialize_anchor(
-                        &scroll_anchor.top_anchor.text_anchor,
-                    ));
+                    update.scroll_top_anchor = Some(serialize_anchor(&scroll_anchor.top_anchor));
                     update.scroll_x = scroll_anchor.offset.x();
                     update.scroll_y = scroll_anchor.offset.y();
                     true
@@ -177,9 +279,13 @@ impl FollowableItem for Editor {
                         .selections
                         .disjoint_anchors()
                         .iter()
-                        .chain(self.selections.pending_anchor().as_ref())
                         .map(serialize_selection)
                         .collect();
+                    update.pending_selection = self
+                        .selections
+                        .pending_anchor()
+                        .as_ref()
+                        .map(serialize_selection);
                     true
                 }
                 _ => false,
@@ -189,45 +295,102 @@ impl FollowableItem for Editor {
 
     fn apply_update_proto(
         &mut self,
+        project: &ModelHandle<Project>,
         message: update_view::Variant,
         cx: &mut ViewContext<Self>,
-    ) -> Result<()> {
-        match message {
-            update_view::Variant::Editor(message) => {
-                let buffer = self.buffer.read(cx);
-                let buffer = buffer.read(cx);
-                let (excerpt_id, buffer_id, _) = buffer.as_singleton().unwrap();
-                let excerpt_id = excerpt_id.clone();
-                drop(buffer);
+    ) -> Task<Result<()>> {
+        let update_view::Variant::Editor(message) = message;
+        let multibuffer = self.buffer.read(cx);
+        let multibuffer = multibuffer.read(cx);
 
-                let selections = message
-                    .selections
-                    .into_iter()
-                    .filter_map(|selection| {
-                        deserialize_selection(&excerpt_id, buffer_id, selection)
-                    })
-                    .collect::<Vec<_>>();
+        let buffer_ids = message
+            .inserted_excerpts
+            .iter()
+            .filter_map(|insertion| Some(insertion.excerpt.as_ref()?.buffer_id))
+            .collect::<HashSet<_>>();
 
-                if !selections.is_empty() {
-                    self.set_selections_from_remote(selections, cx);
-                    self.request_autoscroll_remotely(Autoscroll::newest(), cx);
-                } else if let Some(anchor) = message.scroll_top_anchor {
-                    self.set_scroll_anchor_remote(
-                        ScrollAnchor {
-                            top_anchor: Anchor {
-                                buffer_id: Some(buffer_id),
-                                excerpt_id,
-                                text_anchor: language::proto::deserialize_anchor(anchor)
-                                    .ok_or_else(|| anyhow!("invalid scroll top"))?,
-                            },
-                            offset: vec2f(message.scroll_x, message.scroll_y),
-                        },
-                        cx,
-                    );
+        let mut removals = message
+            .deleted_excerpts
+            .into_iter()
+            .map(ExcerptId::from_proto)
+            .collect::<Vec<_>>();
+        removals.sort_by(|a, b| a.cmp(&b, &multibuffer));
+
+        let selections = message
+            .selections
+            .into_iter()
+            .filter_map(|selection| deserialize_selection(&multibuffer, selection))
+            .collect::<Vec<_>>();
+        let pending_selection = message
+            .pending_selection
+            .and_then(|selection| deserialize_selection(&multibuffer, selection));
+
+        let scroll_top_anchor = message
+            .scroll_top_anchor
+            .and_then(|anchor| deserialize_anchor(&multibuffer, anchor));
+        drop(multibuffer);
+
+        let buffers = project.update(cx, |project, cx| {
+            buffer_ids
+                .into_iter()
+                .map(|id| project.open_buffer_by_id(id, cx))
+                .collect::<Vec<_>>()
+        });
+
+        let project = project.clone();
+        cx.spawn(|this, mut cx| async move {
+            let _buffers = try_join_all(buffers).await?;
+            this.update(&mut cx, |this, cx| {
+                this.buffer.update(cx, |multibuffer, cx| {
+                    let mut insertions = message.inserted_excerpts.into_iter().peekable();
+                    while let Some(insertion) = insertions.next() {
+                        let Some(excerpt) = insertion.excerpt else { continue };
+                        let Some(previous_excerpt_id) = insertion.previous_excerpt_id else { continue };
+                        let buffer_id = excerpt.buffer_id;
+                        let Some(buffer) = project.read(cx).buffer_for_id(buffer_id, cx) else { continue };
+
+                        let adjacent_excerpts = iter::from_fn(|| {
+                            let insertion = insertions.peek()?;
+                            if insertion.previous_excerpt_id.is_none()
+                                && insertion.excerpt.as_ref()?.buffer_id == buffer_id
+                            {
+                                insertions.next()?.excerpt
+                            } else {
+                                None
+                            }
+                        });
+
+                        multibuffer.insert_excerpts_with_ids_after(
+                            ExcerptId::from_proto(previous_excerpt_id),
+                            buffer,
+                            [excerpt]
+                                .into_iter()
+                                .chain(adjacent_excerpts)
+                                .filter_map(|excerpt| {
+                                    Some((
+                                        ExcerptId::from_proto(excerpt.id),
+                                        deserialize_excerpt_range(excerpt)?,
+                                    ))
+                                }),
+                            cx,
+                        );
+                    }
+
+                    multibuffer.remove_excerpts(removals, cx);
+                });
+
+                if !selections.is_empty() || pending_selection.is_some() {
+                    this.set_selections_from_remote(selections, pending_selection, cx);
+                    this.request_autoscroll_remotely(Autoscroll::newest(), cx);
+                } else if let Some(anchor) = scroll_top_anchor {
+                    this.set_scroll_anchor_remote(ScrollAnchor {
+                        top_anchor: anchor,
+                        offset: vec2f(message.scroll_x, message.scroll_y)
+                    }, cx);
                 }
-            }
-        }
-        Ok(())
+            });
+            Ok(())
+        })
     }
 
     fn should_unfollow_on_event(event: &Self::Event, _: &AppContext) -> bool {
@@ -240,41 +403,82 @@ impl FollowableItem for Editor {
     }
 }
 
+fn serialize_excerpt(
+    buffer_id: u64,
+    id: &ExcerptId,
+    range: &ExcerptRange<language::Anchor>,
+) -> Option<proto::Excerpt> {
+    Some(proto::Excerpt {
+        id: id.to_proto(),
+        buffer_id,
+        context_start: Some(serialize_text_anchor(&range.context.start)),
+        context_end: Some(serialize_text_anchor(&range.context.end)),
+        primary_start: range
+            .primary
+            .as_ref()
+            .map(|r| serialize_text_anchor(&r.start)),
+        primary_end: range
+            .primary
+            .as_ref()
+            .map(|r| serialize_text_anchor(&r.end)),
+    })
+}
+
 fn serialize_selection(selection: &Selection<Anchor>) -> proto::Selection {
     proto::Selection {
         id: selection.id as u64,
-        start: Some(language::proto::serialize_anchor(
-            &selection.start.text_anchor,
-        )),
-        end: Some(language::proto::serialize_anchor(
-            &selection.end.text_anchor,
-        )),
+        start: Some(serialize_anchor(&selection.start)),
+        end: Some(serialize_anchor(&selection.end)),
         reversed: selection.reversed,
     }
 }
 
+fn serialize_anchor(anchor: &Anchor) -> proto::EditorAnchor {
+    proto::EditorAnchor {
+        excerpt_id: anchor.excerpt_id.to_proto(),
+        anchor: Some(serialize_text_anchor(&anchor.text_anchor)),
+    }
+}
+
+fn deserialize_excerpt_range(excerpt: proto::Excerpt) -> Option<ExcerptRange<language::Anchor>> {
+    let context = {
+        let start = language::proto::deserialize_anchor(excerpt.context_start?)?;
+        let end = language::proto::deserialize_anchor(excerpt.context_end?)?;
+        start..end
+    };
+    let primary = excerpt
+        .primary_start
+        .zip(excerpt.primary_end)
+        .and_then(|(start, end)| {
+            let start = language::proto::deserialize_anchor(start)?;
+            let end = language::proto::deserialize_anchor(end)?;
+            Some(start..end)
+        });
+    Some(ExcerptRange { context, primary })
+}
+
 fn deserialize_selection(
-    excerpt_id: &ExcerptId,
-    buffer_id: usize,
+    buffer: &MultiBufferSnapshot,
     selection: proto::Selection,
 ) -> Option<Selection<Anchor>> {
     Some(Selection {
         id: selection.id as usize,
-        start: Anchor {
-            buffer_id: Some(buffer_id),
-            excerpt_id: excerpt_id.clone(),
-            text_anchor: language::proto::deserialize_anchor(selection.start?)?,
-        },
-        end: Anchor {
-            buffer_id: Some(buffer_id),
-            excerpt_id: excerpt_id.clone(),
-            text_anchor: language::proto::deserialize_anchor(selection.end?)?,
-        },
+        start: deserialize_anchor(buffer, selection.start?)?,
+        end: deserialize_anchor(buffer, selection.end?)?,
         reversed: selection.reversed,
         goal: SelectionGoal::None,
     })
 }
 
+fn deserialize_anchor(buffer: &MultiBufferSnapshot, anchor: proto::EditorAnchor) -> Option<Anchor> {
+    let excerpt_id = ExcerptId::from_proto(anchor.excerpt_id);
+    Some(Anchor {
+        excerpt_id,
+        text_anchor: language::proto::deserialize_anchor(anchor.anchor?)?,
+        buffer_id: buffer.buffer_id_for_excerpt(excerpt_id),
+    })
+}
+
 impl Item for Editor {
     fn navigate(&mut self, data: Box<dyn std::any::Any>, cx: &mut ViewContext<Self>) -> bool {
         if let Ok(data) = data.downcast::<NavigationData>() {
@@ -562,6 +766,7 @@ impl Item for Editor {
     fn added_to_workspace(&mut self, workspace: &mut Workspace, cx: &mut ViewContext<Self>) {
         let workspace_id = workspace.database_id();
         let item_id = cx.view_id();
+        self.workspace_id = Some(workspace_id);
 
         fn serialize(
             buffer: ModelHandle<Buffer>,
@@ -633,7 +838,11 @@ impl Item for Editor {
                         .context("Project item at stored path was not a buffer")?;
 
                     Ok(cx.update(|cx| {
-                        cx.add_view(pane, |cx| Editor::for_buffer(buffer, Some(project), cx))
+                        cx.add_view(pane, |cx| {
+                            let mut editor = Editor::for_buffer(buffer, Some(project), cx);
+                            editor.read_scroll_position_from_db(item_id, workspace_id, cx);
+                            editor
+                        })
                     }))
                 })
             })
@@ -911,7 +1120,7 @@ fn path_for_buffer<'a>(
     cx: &'a AppContext,
 ) -> Option<Cow<'a, Path>> {
     let file = buffer.read(cx).as_singleton()?.read(cx).file()?;
-    path_for_file(file, height, include_filename, cx)
+    path_for_file(file.as_ref(), height, include_filename, cx)
 }
 
 fn path_for_file<'a>(

crates/editor/src/movement.rs

@@ -352,6 +352,29 @@ pub fn surrounding_word(map: &DisplaySnapshot, position: DisplayPoint) -> Range<
     start..end
 }
 
+pub fn split_display_range_by_lines(
+    map: &DisplaySnapshot,
+    range: Range<DisplayPoint>,
+) -> Vec<Range<DisplayPoint>> {
+    let mut result = Vec::new();
+
+    let mut start = range.start;
+    // Loop over all the covered rows until the one containing the range end
+    for row in range.start.row()..range.end.row() {
+        let row_end_column = map.line_len(row);
+        let end = map.clip_point(DisplayPoint::new(row, row_end_column), Bias::Left);
+        if start != end {
+            result.push(start..end);
+        }
+        start = map.clip_point(DisplayPoint::new(row + 1, 0), Bias::Left);
+    }
+
+    // Add the final range from the start of the last end to the original range end.
+    result.push(start..range.end);
+
+    result
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/editor/src/multi_buffer.rs

@@ -9,9 +9,9 @@ use gpui::{AppContext, Entity, ModelContext, ModelHandle, Task};
 pub use language::Completion;
 use language::{
     char_kind, AutoindentMode, Buffer, BufferChunks, BufferSnapshot, CharKind, Chunk, CursorShape,
-    DiagnosticEntry, Event, File, IndentSize, Language, OffsetRangeExt, OffsetUtf16, Outline,
-    OutlineItem, Point, PointUtf16, Selection, TextDimension, ToOffset as _, ToOffsetUtf16 as _,
-    ToPoint as _, ToPointUtf16 as _, TransactionId, Unclipped,
+    DiagnosticEntry, File, IndentSize, Language, OffsetRangeExt, OffsetUtf16, Outline, OutlineItem,
+    Point, PointUtf16, Selection, TextDimension, ToOffset as _, ToOffsetUtf16 as _, ToPoint as _,
+    ToPointUtf16 as _, TransactionId, Unclipped,
 };
 use smallvec::SmallVec;
 use std::{
@@ -50,6 +50,26 @@ pub struct MultiBuffer {
     title: Option<String>,
 }
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Event {
+    ExcerptsAdded {
+        buffer: ModelHandle<Buffer>,
+        predecessor: ExcerptId,
+        excerpts: Vec<(ExcerptId, ExcerptRange<language::Anchor>)>,
+    },
+    ExcerptsRemoved {
+        ids: Vec<ExcerptId>,
+    },
+    Edited,
+    Reloaded,
+    Reparsed,
+    Saved,
+    FileHandleChanged,
+    Closed,
+    DirtyChanged,
+    DiagnosticsUpdated,
+}
+
 #[derive(Clone)]
 struct History {
     next_transaction_id: TransactionId,
@@ -833,6 +853,30 @@ impl MultiBuffer {
     ) -> Vec<ExcerptId>
     where
         O: text::ToOffset,
+    {
+        let mut ids = Vec::new();
+        let mut next_excerpt_id = self.next_excerpt_id;
+        self.insert_excerpts_with_ids_after(
+            prev_excerpt_id,
+            buffer,
+            ranges.into_iter().map(|range| {
+                let id = ExcerptId(post_inc(&mut next_excerpt_id));
+                ids.push(id);
+                (id, range)
+            }),
+            cx,
+        );
+        ids
+    }
+
+    pub fn insert_excerpts_with_ids_after<O>(
+        &mut self,
+        prev_excerpt_id: ExcerptId,
+        buffer: ModelHandle<Buffer>,
+        ranges: impl IntoIterator<Item = (ExcerptId, ExcerptRange<O>)>,
+        cx: &mut ModelContext<Self>,
+    ) where
+        O: text::ToOffset,
     {
         assert_eq!(self.history.transaction_depth, 0);
         let mut ranges = ranges.into_iter().peekable();
@@ -858,7 +902,7 @@ impl MultiBuffer {
                 cx.observe(&buffer, |_, _, cx| cx.notify()),
                 cx.subscribe(&buffer, Self::on_buffer_event),
             ],
-            buffer,
+            buffer: buffer.clone(),
         });
 
         let mut snapshot = self.snapshot.borrow_mut();
@@ -883,8 +927,8 @@ impl MultiBuffer {
             Locator::max()
         };
 
-        let mut ids = Vec::new();
-        while let Some(range) = ranges.next() {
+        let mut excerpts = Vec::new();
+        while let Some((id, range)) = ranges.next() {
             let locator = Locator::between(&prev_locator, &next_locator);
             if let Err(ix) = buffer_state.excerpts.binary_search(&locator) {
                 buffer_state.excerpts.insert(ix, locator.clone());
@@ -897,7 +941,10 @@ impl MultiBuffer {
                         ..buffer_snapshot.anchor_after(&primary.end)
                 }),
             };
-            let id = ExcerptId(post_inc(&mut self.next_excerpt_id));
+            if id.0 >= self.next_excerpt_id {
+                self.next_excerpt_id = id.0 + 1;
+            }
+            excerpts.push((id, range.clone()));
             let excerpt = Excerpt::new(
                 id,
                 locator.clone(),
@@ -909,7 +956,6 @@ impl MultiBuffer {
             new_excerpts.push(excerpt, &());
             prev_locator = locator.clone();
             new_excerpt_ids.push(ExcerptIdMapping { id, locator }, &());
-            ids.push(id);
         }
 
         let edit_end = new_excerpts.summary().text.len;
@@ -929,12 +975,17 @@ impl MultiBuffer {
             new: edit_start..edit_end,
         }]);
         cx.emit(Event::Edited);
+        cx.emit(Event::ExcerptsAdded {
+            buffer,
+            predecessor: prev_excerpt_id,
+            excerpts,
+        });
         cx.notify();
-        ids
     }
 
     pub fn clear(&mut self, cx: &mut ModelContext<Self>) {
         self.sync(cx);
+        let ids = self.excerpt_ids();
         self.buffers.borrow_mut().clear();
         let mut snapshot = self.snapshot.borrow_mut();
         let prev_len = snapshot.len();
@@ -948,6 +999,7 @@ impl MultiBuffer {
             new: 0..0,
         }]);
         cx.emit(Event::Edited);
+        cx.emit(Event::ExcerptsRemoved { ids });
         cx.notify();
     }
 
@@ -1071,12 +1123,14 @@ impl MultiBuffer {
         cx: &mut ModelContext<Self>,
     ) {
         self.sync(cx);
+        let ids = excerpt_ids.into_iter().collect::<Vec<_>>();
+
         let mut buffers = self.buffers.borrow_mut();
         let mut snapshot = self.snapshot.borrow_mut();
         let mut new_excerpts = SumTree::new();
         let mut cursor = snapshot.excerpts.cursor::<(Option<&Locator>, usize)>();
         let mut edits = Vec::new();
-        let mut excerpt_ids = excerpt_ids.into_iter().peekable();
+        let mut excerpt_ids = ids.iter().copied().peekable();
 
         while let Some(excerpt_id) = excerpt_ids.next() {
             // Seek to the next excerpt to remove, preserving any preceding excerpts.
@@ -1143,6 +1197,7 @@ impl MultiBuffer {
 
         self.subscriptions.publish_mut(edits);
         cx.emit(Event::Edited);
+        cx.emit(Event::ExcerptsRemoved { ids });
         cx.notify();
     }
 
@@ -1165,10 +1220,22 @@ impl MultiBuffer {
     fn on_buffer_event(
         &mut self,
         _: ModelHandle<Buffer>,
-        event: &Event,
+        event: &language::Event,
         cx: &mut ModelContext<Self>,
     ) {
-        cx.emit(event.clone());
+        cx.emit(match event {
+            language::Event::Edited => Event::Edited,
+            language::Event::DirtyChanged => Event::DirtyChanged,
+            language::Event::Saved => Event::Saved,
+            language::Event::FileHandleChanged => Event::FileHandleChanged,
+            language::Event::Reloaded => Event::Reloaded,
+            language::Event::Reparsed => Event::Reparsed,
+            language::Event::DiagnosticsUpdated => Event::DiagnosticsUpdated,
+            language::Event::Closed => Event::Closed,
+
+            //
+            language::Event::Operation(_) => return,
+        });
     }
 
     pub fn all_buffers(&self) -> HashSet<ModelHandle<Buffer>> {
@@ -1244,7 +1311,7 @@ impl MultiBuffer {
             .and_then(|(buffer, offset)| buffer.read(cx).language_at(offset))
     }
 
-    pub fn files<'a>(&'a self, cx: &'a AppContext) -> SmallVec<[&'a dyn File; 2]> {
+    pub fn files<'a>(&'a self, cx: &'a AppContext) -> SmallVec<[&'a Arc<dyn File>; 2]> {
         let buffers = self.buffers.borrow();
         buffers
             .values()
@@ -1604,7 +1671,7 @@ impl MultiBuffer {
 }
 
 impl Entity for MultiBuffer {
-    type Event = language::Event;
+    type Event = Event;
 }
 
 impl MultiBufferSnapshot {
@@ -2450,6 +2517,14 @@ impl MultiBufferSnapshot {
         }
     }
 
+    pub fn excerpts(
+        &self,
+    ) -> impl Iterator<Item = (ExcerptId, &BufferSnapshot, ExcerptRange<text::Anchor>)> {
+        self.excerpts
+            .iter()
+            .map(|excerpt| (excerpt.id, &excerpt.buffer, excerpt.range.clone()))
+    }
+
     pub fn excerpt_boundaries_in_range<R, T>(
         &self,
         range: R,
@@ -2635,11 +2710,73 @@ impl MultiBufferSnapshot {
         row_range: Range<u32>,
         reversed: bool,
     ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
-        self.as_singleton()
-            .into_iter()
-            .flat_map(move |(_, _, buffer)| {
-                buffer.git_diff_hunks_in_range(row_range.clone(), reversed)
-            })
+        let mut cursor = self.excerpts.cursor::<Point>();
+
+        if reversed {
+            cursor.seek(&Point::new(row_range.end, 0), Bias::Left, &());
+            if cursor.item().is_none() {
+                cursor.prev(&());
+            }
+        } else {
+            cursor.seek(&Point::new(row_range.start, 0), Bias::Right, &());
+        }
+
+        std::iter::from_fn(move || {
+            let excerpt = cursor.item()?;
+            let multibuffer_start = *cursor.start();
+            let multibuffer_end = multibuffer_start + excerpt.text_summary.lines;
+            if multibuffer_start.row >= row_range.end {
+                return None;
+            }
+
+            let mut buffer_start = excerpt.range.context.start;
+            let mut buffer_end = excerpt.range.context.end;
+            let excerpt_start_point = buffer_start.to_point(&excerpt.buffer);
+            let excerpt_end_point = excerpt_start_point + excerpt.text_summary.lines;
+
+            if row_range.start > multibuffer_start.row {
+                let buffer_start_point =
+                    excerpt_start_point + Point::new(row_range.start - multibuffer_start.row, 0);
+                buffer_start = excerpt.buffer.anchor_before(buffer_start_point);
+            }
+
+            if row_range.end < multibuffer_end.row {
+                let buffer_end_point =
+                    excerpt_start_point + Point::new(row_range.end - multibuffer_start.row, 0);
+                buffer_end = excerpt.buffer.anchor_before(buffer_end_point);
+            }
+
+            let buffer_hunks = excerpt
+                .buffer
+                .git_diff_hunks_intersecting_range(buffer_start..buffer_end, reversed)
+                .filter_map(move |hunk| {
+                    let start = multibuffer_start.row
+                        + hunk
+                            .buffer_range
+                            .start
+                            .saturating_sub(excerpt_start_point.row);
+                    let end = multibuffer_start.row
+                        + hunk
+                            .buffer_range
+                            .end
+                            .min(excerpt_end_point.row + 1)
+                            .saturating_sub(excerpt_start_point.row);
+
+                    Some(DiffHunk {
+                        buffer_range: start..end,
+                        diff_base_byte_range: hunk.diff_base_byte_range.clone(),
+                    })
+                });
+
+            if reversed {
+                cursor.prev(&());
+            } else {
+                cursor.next(&());
+            }
+
+            Some(buffer_hunks)
+        })
+        .flatten()
     }
 
     pub fn range_for_syntax_ancestor<T: ToOffset>(&self, range: Range<T>) -> Option<Range<usize>> {
@@ -2746,6 +2883,10 @@ impl MultiBufferSnapshot {
         }
     }
 
+    pub fn buffer_id_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<usize> {
+        Some(self.excerpt(excerpt_id)?.buffer_id)
+    }
+
     fn excerpt<'a>(&'a self, excerpt_id: ExcerptId) -> Option<&'a Excerpt> {
         let mut cursor = self.excerpts.cursor::<Option<&Locator>>();
         let locator = self.excerpt_locator_for_id(excerpt_id);
@@ -3080,6 +3221,14 @@ impl ExcerptId {
         Self(usize::MAX)
     }
 
+    pub fn to_proto(&self) -> u64 {
+        self.0 as _
+    }
+
+    pub fn from_proto(proto: u64) -> Self {
+        Self(proto as _)
+    }
+
     pub fn cmp(&self, other: &Self, snapshot: &MultiBufferSnapshot) -> cmp::Ordering {
         let a = snapshot.excerpt_locator_for_id(*self);
         let b = snapshot.excerpt_locator_for_id(*other);
@@ -3459,16 +3608,17 @@ impl ToPointUtf16 for PointUtf16 {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use gpui::MutableAppContext;
+    use gpui::{MutableAppContext, TestAppContext};
     use language::{Buffer, Rope};
     use rand::prelude::*;
     use settings::Settings;
     use std::{env, rc::Rc};
+    use unindent::Unindent;
 
     use util::test::sample_text;
 
     #[gpui::test]
-    fn test_singleton_multibuffer(cx: &mut MutableAppContext) {
+    fn test_singleton(cx: &mut MutableAppContext) {
         let buffer = cx.add_model(|cx| Buffer::new(0, sample_text(6, 6, 'a'), cx));
         let multibuffer = cx.add_model(|cx| MultiBuffer::singleton(buffer.clone(), cx));
 
@@ -3495,13 +3645,13 @@ mod tests {
     }
 
     #[gpui::test]
-    fn test_remote_multibuffer(cx: &mut MutableAppContext) {
+    fn test_remote(cx: &mut MutableAppContext) {
         let host_buffer = cx.add_model(|cx| Buffer::new(0, "a", cx));
         let guest_buffer = cx.add_model(|cx| {
             let state = host_buffer.read(cx).to_proto();
             let ops = cx
                 .background()
-                .block(host_buffer.read(cx).serialize_ops(cx));
+                .block(host_buffer.read(cx).serialize_ops(None, cx));
             let mut buffer = Buffer::from_proto(1, state, None).unwrap();
             buffer
                 .apply_ops(
@@ -3526,7 +3676,7 @@ mod tests {
     }
 
     #[gpui::test]
-    fn test_excerpt_buffer(cx: &mut MutableAppContext) {
+    fn test_excerpt_boundaries_and_clipping(cx: &mut MutableAppContext) {
         let buffer_1 = cx.add_model(|cx| Buffer::new(0, sample_text(6, 6, 'a'), cx));
         let buffer_2 = cx.add_model(|cx| Buffer::new(0, sample_text(6, 6, 'g'), cx));
         let multibuffer = cx.add_model(|_| MultiBuffer::new(0));
@@ -3535,7 +3685,9 @@ mod tests {
         multibuffer.update(cx, |_, cx| {
             let events = events.clone();
             cx.subscribe(&multibuffer, move |_, _, event, _| {
-                events.borrow_mut().push(event.clone())
+                if let Event::Edited = event {
+                    events.borrow_mut().push(event.clone())
+                }
             })
             .detach();
         });
@@ -3748,7 +3900,84 @@ mod tests {
     }
 
     #[gpui::test]
-    fn test_excerpts_with_context_lines(cx: &mut MutableAppContext) {
+    fn test_excerpt_events(cx: &mut MutableAppContext) {
+        let buffer_1 = cx.add_model(|cx| Buffer::new(0, sample_text(10, 3, 'a'), cx));
+        let buffer_2 = cx.add_model(|cx| Buffer::new(0, sample_text(10, 3, 'm'), cx));
+
+        let leader_multibuffer = cx.add_model(|_| MultiBuffer::new(0));
+        let follower_multibuffer = cx.add_model(|_| MultiBuffer::new(0));
+
+        follower_multibuffer.update(cx, |_, cx| {
+            cx.subscribe(&leader_multibuffer, |follower, _, event, cx| {
+                match event.clone() {
+                    Event::ExcerptsAdded {
+                        buffer,
+                        predecessor,
+                        excerpts,
+                    } => follower.insert_excerpts_with_ids_after(predecessor, buffer, excerpts, cx),
+                    Event::ExcerptsRemoved { ids } => follower.remove_excerpts(ids, cx),
+                    _ => {}
+                }
+            })
+            .detach();
+        });
+
+        leader_multibuffer.update(cx, |leader, cx| {
+            leader.push_excerpts(
+                buffer_1.clone(),
+                [
+                    ExcerptRange {
+                        context: 0..8,
+                        primary: None,
+                    },
+                    ExcerptRange {
+                        context: 12..16,
+                        primary: None,
+                    },
+                ],
+                cx,
+            );
+            leader.insert_excerpts_after(
+                leader.excerpt_ids()[0],
+                buffer_2.clone(),
+                [
+                    ExcerptRange {
+                        context: 0..5,
+                        primary: None,
+                    },
+                    ExcerptRange {
+                        context: 10..15,
+                        primary: None,
+                    },
+                ],
+                cx,
+            )
+        });
+        assert_eq!(
+            leader_multibuffer.read(cx).snapshot(cx).text(),
+            follower_multibuffer.read(cx).snapshot(cx).text(),
+        );
+
+        leader_multibuffer.update(cx, |leader, cx| {
+            let excerpt_ids = leader.excerpt_ids();
+            leader.remove_excerpts([excerpt_ids[1], excerpt_ids[3]], cx);
+        });
+        assert_eq!(
+            leader_multibuffer.read(cx).snapshot(cx).text(),
+            follower_multibuffer.read(cx).snapshot(cx).text(),
+        );
+
+        leader_multibuffer.update(cx, |leader, cx| {
+            leader.clear(cx);
+        });
+        assert_eq!(
+            leader_multibuffer.read(cx).snapshot(cx).text(),
+            follower_multibuffer.read(cx).snapshot(cx).text(),
+        );
+    }
+
+    #[gpui::test]
+    fn test_push_excerpts_with_context_lines(cx: &mut MutableAppContext) {
         let buffer = cx.add_model(|cx| Buffer::new(0, sample_text(20, 3, 'a'), cx));
         let multibuffer = cx.add_model(|_| MultiBuffer::new(0));
         let anchor_ranges = multibuffer.update(cx, |multibuffer, cx| {
@@ -3784,7 +4013,7 @@ mod tests {
     }
 
     #[gpui::test]
-    fn test_empty_excerpt_buffer(cx: &mut MutableAppContext) {
+    fn test_empty_multibuffer(cx: &mut MutableAppContext) {
         let multibuffer = cx.add_model(|_| MultiBuffer::new(0));
 
         let snapshot = multibuffer.read(cx).snapshot(cx);
@@ -3872,9 +4101,7 @@ mod tests {
     }
 
     #[gpui::test]
-    fn test_multibuffer_resolving_anchors_after_replacing_their_excerpts(
-        cx: &mut MutableAppContext,
-    ) {
+    fn test_resolving_anchors_after_replacing_their_excerpts(cx: &mut MutableAppContext) {
         let buffer_1 = cx.add_model(|cx| Buffer::new(0, "abcd", cx));
         let buffer_2 = cx.add_model(|cx| Buffer::new(0, "ABCDEFGHIJKLMNOP", cx));
         let multibuffer = cx.add_model(|_| MultiBuffer::new(0));
@@ -4004,6 +4231,178 @@ mod tests {
         );
     }
 
+    #[gpui::test]
+    async fn test_diff_hunks_in_range(cx: &mut TestAppContext) {
+        use git::diff::DiffHunkStatus;
+
+        // buffer has two modified hunks with two rows each
+        let buffer_1 = cx.add_model(|cx| {
+            let mut buffer = Buffer::new(
+                0,
+                "
+                1.zero
+                1.ONE
+                1.TWO
+                1.three
+                1.FOUR
+                1.FIVE
+                1.six
+            "
+                .unindent(),
+                cx,
+            );
+            buffer.set_diff_base(
+                Some(
+                    "
+                1.zero
+                1.one
+                1.two
+                1.three
+                1.four
+                1.five
+                1.six
+            "
+                    .unindent(),
+                ),
+                cx,
+            );
+            buffer
+        });
+
+        // buffer has a deletion hunk and an insertion hunk
+        let buffer_2 = cx.add_model(|cx| {
+            let mut buffer = Buffer::new(
+                0,
+                "
+                2.zero
+                2.one
+                2.two
+                2.three
+                2.four
+                2.five
+                2.six
+            "
+                .unindent(),
+                cx,
+            );
+            buffer.set_diff_base(
+                Some(
+                    "
+                2.zero
+                2.one
+                2.one-and-a-half
+                2.two
+                2.three
+                2.four
+                2.six
+            "
+                    .unindent(),
+                ),
+                cx,
+            );
+            buffer
+        });
+
+        cx.foreground().run_until_parked();
+
+        let multibuffer = cx.add_model(|cx| {
+            let mut multibuffer = MultiBuffer::new(0);
+            multibuffer.push_excerpts(
+                buffer_1.clone(),
+                [
+                    // excerpt ends in the middle of a modified hunk
+                    ExcerptRange {
+                        context: Point::new(0, 0)..Point::new(1, 5),
+                        primary: Default::default(),
+                    },
+                    // excerpt begins in the middle of a modified hunk
+                    ExcerptRange {
+                        context: Point::new(5, 0)..Point::new(6, 5),
+                        primary: Default::default(),
+                    },
+                ],
+                cx,
+            );
+            multibuffer.push_excerpts(
+                buffer_2.clone(),
+                [
+                    // excerpt ends at a deletion
+                    ExcerptRange {
+                        context: Point::new(0, 0)..Point::new(1, 5),
+                        primary: Default::default(),
+                    },
+                    // excerpt starts at a deletion
+                    ExcerptRange {
+                        context: Point::new(2, 0)..Point::new(2, 5),
+                        primary: Default::default(),
+                    },
+                    // excerpt fully contains a deletion hunk
+                    ExcerptRange {
+                        context: Point::new(1, 0)..Point::new(2, 5),
+                        primary: Default::default(),
+                    },
+                    // excerpt fully contains an insertion hunk
+                    ExcerptRange {
+                        context: Point::new(4, 0)..Point::new(6, 5),
+                        primary: Default::default(),
+                    },
+                ],
+                cx,
+            );
+            multibuffer
+        });
+
+        let snapshot = multibuffer.read_with(cx, |b, cx| b.snapshot(cx));
+
+        assert_eq!(
+            snapshot.text(),
+            "
+                1.zero
+                1.ONE
+                1.FIVE
+                1.six
+                2.zero
+                2.one
+                2.two
+                2.one
+                2.two
+                2.four
+                2.five
+                2.six"
+                .unindent()
+        );
+
+        let expected = [
+            (DiffHunkStatus::Modified, 1..2),
+            (DiffHunkStatus::Modified, 2..3),
+            //TODO: Define better when and where removed hunks show up at range extremities
+            (DiffHunkStatus::Removed, 6..6),
+            (DiffHunkStatus::Removed, 8..8),
+            (DiffHunkStatus::Added, 10..11),
+        ];
+
+        assert_eq!(
+            snapshot
+                .git_diff_hunks_in_range(0..12, false)
+                .map(|hunk| (hunk.status(), hunk.buffer_range))
+                .collect::<Vec<_>>(),
+            &expected,
+        );
+
+        assert_eq!(
+            snapshot
+                .git_diff_hunks_in_range(0..12, true)
+                .map(|hunk| (hunk.status(), hunk.buffer_range))
+                .collect::<Vec<_>>(),
+            expected
+                .iter()
+                .rev()
+                .cloned()
+                .collect::<Vec<_>>()
+                .as_slice(),
+        );
+    }
+
     #[gpui::test(iterations = 100)]
     fn test_random_multibuffer(cx: &mut MutableAppContext, mut rng: StdRng) {
         let operations = env::var("OPERATIONS")

crates/editor/src/persistence.rs

@@ -2,9 +2,19 @@ use std::path::PathBuf;
 
 use db::sqlez_macros::sql;
 use db::{define_connection, query};
+
 use workspace::{ItemId, WorkspaceDb, WorkspaceId};
 
 define_connection!(
+    // Current table shape using pseudo-rust syntax:
+    // editors(
+    //   item_id: usize,
+    //   workspace_id: usize,
+    //   path: PathBuf,
+    //   scroll_top_row: usize,
+    //   scroll_vertical_offset: f32,
+    //   scroll_horizontal_offset: f32,
+    // )
     pub static ref DB: EditorDb<WorkspaceDb> =
         &[sql! (
             CREATE TABLE editors(
@@ -15,8 +25,13 @@ define_connection!(
                 FOREIGN KEY(workspace_id) REFERENCES workspaces(workspace_id)
                 ON DELETE CASCADE
                 ON UPDATE CASCADE
-        ) STRICT;
-    )];
+            ) STRICT;
+        ),
+        sql! (
+            ALTER TABLE editors ADD COLUMN scroll_top_row INTEGER NOT NULL DEFAULT 0;
+            ALTER TABLE editors ADD COLUMN scroll_horizontal_offset REAL NOT NULL DEFAULT 0;
+            ALTER TABLE editors ADD COLUMN scroll_vertical_offset REAL NOT NULL DEFAULT 0;
+        )];
 );
 
 impl EditorDb {
@@ -29,8 +44,40 @@ impl EditorDb {
 
     query! {
         pub async fn save_path(item_id: ItemId, workspace_id: WorkspaceId, path: PathBuf) -> Result<()> {
-            INSERT OR REPLACE INTO editors(item_id, workspace_id, path)
-            VALUES (?, ?, ?)
+            INSERT INTO editors
+                (item_id, workspace_id, path)
+            VALUES
+                (?1, ?2, ?3)
+            ON CONFLICT DO UPDATE SET
+                item_id = ?1,
+                workspace_id = ?2,
+                path = ?3
+        }
+    }
+
+    // Returns the scroll top row, and offset
+    query! {
+        pub fn get_scroll_position(item_id: ItemId, workspace_id: WorkspaceId) -> Result<Option<(u32, f32, f32)>> {
+            SELECT scroll_top_row, scroll_horizontal_offset, scroll_vertical_offset
+            FROM editors
+            WHERE item_id = ? AND workspace_id = ?
+        }
+    }
+
+    query! {
+        pub async fn save_scroll_position(
+            item_id: ItemId,
+            workspace_id: WorkspaceId,
+            top_row: u32,
+            vertical_offset: f32,
+            horizontal_offset: f32
+        ) -> Result<()> {
+            UPDATE OR IGNORE editors
+            SET
+                scroll_top_row = ?3,
+                scroll_horizontal_offset = ?4,
+                scroll_vertical_offset = ?5
+            WHERE item_id = ?1 AND workspace_id = ?2
         }
     }
 }

crates/editor/src/scroll.rs

@@ -11,11 +11,14 @@ use gpui::{
     geometry::vector::{vec2f, Vector2F},
     Axis, MutableAppContext, Task, ViewContext,
 };
-use language::Bias;
+use language::{Bias, Point};
+use util::ResultExt;
+use workspace::WorkspaceId;
 
 use crate::{
     display_map::{DisplaySnapshot, ToDisplayPoint},
     hover_popover::hide_hover,
+    persistence::DB,
     Anchor, DisplayPoint, Editor, EditorMode, Event, MultiBufferSnapshot, ToPoint,
 };
 
@@ -170,37 +173,68 @@ impl ScrollManager {
         scroll_position: Vector2F,
         map: &DisplaySnapshot,
         local: bool,
+        workspace_id: Option<i64>,
         cx: &mut ViewContext<Editor>,
     ) {
-        let new_anchor = if scroll_position.y() <= 0. {
-            ScrollAnchor {
-                top_anchor: Anchor::min(),
-                offset: scroll_position.max(vec2f(0., 0.)),
-            }
+        let (new_anchor, top_row) = if scroll_position.y() <= 0. {
+            (
+                ScrollAnchor {
+                    top_anchor: Anchor::min(),
+                    offset: scroll_position.max(vec2f(0., 0.)),
+                },
+                0,
+            )
         } else {
-            let scroll_top_buffer_offset =
-                DisplayPoint::new(scroll_position.y() as u32, 0).to_offset(&map, Bias::Right);
+            let scroll_top_buffer_point =
+                DisplayPoint::new(scroll_position.y() as u32, 0).to_point(&map);
             let top_anchor = map
                 .buffer_snapshot
-                .anchor_at(scroll_top_buffer_offset, Bias::Right);
+                .anchor_at(scroll_top_buffer_point, Bias::Right);
 
-            ScrollAnchor {
-                top_anchor,
-                offset: vec2f(
-                    scroll_position.x(),
-                    scroll_position.y() - top_anchor.to_display_point(&map).row() as f32,
-                ),
-            }
+            (
+                ScrollAnchor {
+                    top_anchor,
+                    offset: vec2f(
+                        scroll_position.x(),
+                        scroll_position.y() - top_anchor.to_display_point(&map).row() as f32,
+                    ),
+                },
+                scroll_top_buffer_point.row,
+            )
         };
 
-        self.set_anchor(new_anchor, local, cx);
+        self.set_anchor(new_anchor, top_row, local, workspace_id, cx);
     }
 
-    fn set_anchor(&mut self, anchor: ScrollAnchor, local: bool, cx: &mut ViewContext<Editor>) {
+    fn set_anchor(
+        &mut self,
+        anchor: ScrollAnchor,
+        top_row: u32,
+        local: bool,
+        workspace_id: Option<i64>,
+        cx: &mut ViewContext<Editor>,
+    ) {
         self.anchor = anchor;
         cx.emit(Event::ScrollPositionChanged { local });
         self.show_scrollbar(cx);
         self.autoscroll_request.take();
+        if let Some(workspace_id) = workspace_id {
+            let item_id = cx.view_id();
+
+            cx.background()
+                .spawn(async move {
+                    DB.save_scroll_position(
+                        item_id,
+                        workspace_id,
+                        top_row,
+                        anchor.offset.x(),
+                        anchor.offset.y(),
+                    )
+                    .await
+                    .log_err()
+                })
+                .detach()
+        }
         cx.notify();
     }
 
@@ -274,8 +308,13 @@ impl Editor {
         let map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
 
         hide_hover(self, cx);
-        self.scroll_manager
-            .set_scroll_position(scroll_position, &map, local, cx);
+        self.scroll_manager.set_scroll_position(
+            scroll_position,
+            &map,
+            local,
+            self.workspace_id,
+            cx,
+        );
     }
 
     pub fn scroll_position(&self, cx: &mut ViewContext<Self>) -> Vector2F {
@@ -285,7 +324,12 @@ impl Editor {
 
     pub fn set_scroll_anchor(&mut self, scroll_anchor: ScrollAnchor, cx: &mut ViewContext<Self>) {
         hide_hover(self, cx);
-        self.scroll_manager.set_anchor(scroll_anchor, true, cx);
+        let top_row = scroll_anchor
+            .top_anchor
+            .to_point(&self.buffer().read(cx).snapshot(cx))
+            .row;
+        self.scroll_manager
+            .set_anchor(scroll_anchor, top_row, true, self.workspace_id, cx);
     }
 
     pub(crate) fn set_scroll_anchor_remote(
@@ -294,7 +338,12 @@ impl Editor {
         cx: &mut ViewContext<Self>,
     ) {
         hide_hover(self, cx);
-        self.scroll_manager.set_anchor(scroll_anchor, false, cx);
+        let top_row = scroll_anchor
+            .top_anchor
+            .to_point(&self.buffer().read(cx).snapshot(cx))
+            .row;
+        self.scroll_manager
+            .set_anchor(scroll_anchor, top_row, false, self.workspace_id, cx);
     }
 
     pub fn scroll_screen(&mut self, amount: &ScrollAmount, cx: &mut ViewContext<Self>) {
@@ -345,4 +394,25 @@ impl Editor {
 
         Ordering::Greater
     }
+
+    pub fn read_scroll_position_from_db(
+        &mut self,
+        item_id: usize,
+        workspace_id: WorkspaceId,
+        cx: &mut ViewContext<Editor>,
+    ) {
+        let scroll_position = DB.get_scroll_position(item_id, workspace_id);
+        if let Ok(Some((top_row, x, y))) = scroll_position {
+            let top_anchor = self
+                .buffer()
+                .read(cx)
+                .snapshot(cx)
+                .anchor_at(Point::new(top_row as u32, 0), Bias::Left);
+            let scroll_anchor = ScrollAnchor {
+                offset: Vector2F::new(x, y),
+                top_anchor,
+            };
+            self.set_scroll_anchor(scroll_anchor, cx);
+        }
+    }
 }

crates/editor/src/test/editor_test_context.rs

@@ -9,7 +9,9 @@ use indoc::indoc;
 use crate::{
     display_map::ToDisplayPoint, AnchorRangeExt, Autoscroll, DisplayPoint, Editor, MultiBuffer,
 };
-use gpui::{keymap::Keystroke, AppContext, ContextHandle, ModelContext, ViewContext, ViewHandle};
+use gpui::{
+    keymap_matcher::Keystroke, AppContext, ContextHandle, ModelContext, ViewContext, ViewHandle,
+};
 use language::{Buffer, BufferSnapshot};
 use settings::Settings;
 use util::{
@@ -254,7 +256,7 @@ impl<'a> EditorTestContext<'a> {
                     
                     Actual selections:
                     {}
-                    "},
+                "},
                 self.assertion_context(),
                 expected_marked_text,
                 actual_marked_text,

crates/file_finder/src/file_finder.rs

@@ -62,11 +62,12 @@ impl View for FileFinder {
 
 impl FileFinder {
     fn labels_for_match(&self, path_match: &PathMatch) -> (String, Vec<usize>, String, Vec<usize>) {
-        let path_string = path_match.path.to_string_lossy();
+        let path = &path_match.path;
+        let path_string = path.to_string_lossy();
         let full_path = [path_match.path_prefix.as_ref(), path_string.as_ref()].join("");
         let path_positions = path_match.positions.clone();
 
-        let file_name = path_match.path.file_name().map_or_else(
+        let file_name = path.file_name().map_or_else(
             || path_match.path_prefix.to_string(),
             |file_name| file_name.to_string_lossy().to_string(),
         );
@@ -161,7 +162,7 @@ impl FileFinder {
         self.cancel_flag = Arc::new(AtomicBool::new(false));
         let cancel_flag = self.cancel_flag.clone();
         cx.spawn(|this, mut cx| async move {
-            let matches = fuzzy::match_paths(
+            let matches = fuzzy::match_path_sets(
                 candidate_sets.as_slice(),
                 &query,
                 false,

crates/fs/src/fs.rs

@@ -35,7 +35,7 @@ use repository::FakeGitRepositoryState;
 use std::sync::Weak;
 
 lazy_static! {
-    static ref CARRIAGE_RETURNS_REGEX: Regex = Regex::new("\r\n|\r").unwrap();
+    static ref LINE_SEPERATORS_REGEX: Regex = Regex::new("\r\n|\r|\u{2028}|\u{2029}").unwrap();
 }
 
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -80,13 +80,13 @@ impl LineEnding {
     }
 
     pub fn normalize(text: &mut String) {
-        if let Cow::Owned(replaced) = CARRIAGE_RETURNS_REGEX.replace_all(text, "\n") {
+        if let Cow::Owned(replaced) = LINE_SEPERATORS_REGEX.replace_all(text, "\n") {
             *text = replaced;
         }
     }
 
     pub fn normalize_arc(text: Arc<str>) -> Arc<str> {
-        if let Cow::Owned(replaced) = CARRIAGE_RETURNS_REGEX.replace_all(&text, "\n") {
+        if let Cow::Owned(replaced) = LINE_SEPERATORS_REGEX.replace_all(&text, "\n") {
             replaced.into()
         } else {
             text
@@ -389,6 +389,7 @@ pub struct FakeFs {
 struct FakeFsState {
     root: Arc<Mutex<FakeFsEntry>>,
     next_inode: u64,
+    next_mtime: SystemTime,
     event_txs: Vec<smol::channel::Sender<Vec<fsevent::Event>>>,
 }
 
@@ -517,10 +518,11 @@ impl FakeFs {
             state: Mutex::new(FakeFsState {
                 root: Arc::new(Mutex::new(FakeFsEntry::Dir {
                     inode: 0,
-                    mtime: SystemTime::now(),
+                    mtime: SystemTime::UNIX_EPOCH,
                     entries: Default::default(),
                     git_repo_state: None,
                 })),
+                next_mtime: SystemTime::UNIX_EPOCH,
                 next_inode: 1,
                 event_txs: Default::default(),
             }),
@@ -531,10 +533,12 @@ impl FakeFs {
         let mut state = self.state.lock().await;
         let path = path.as_ref();
         let inode = state.next_inode;
+        let mtime = state.next_mtime;
         state.next_inode += 1;
+        state.next_mtime += Duration::from_nanos(1);
         let file = Arc::new(Mutex::new(FakeFsEntry::File {
             inode,
-            mtime: SystemTime::now(),
+            mtime,
             content,
         }));
         state
@@ -631,6 +635,21 @@ impl FakeFs {
         }
     }
 
+    pub async fn paths(&self) -> Vec<PathBuf> {
+        let mut result = Vec::new();
+        let mut queue = collections::VecDeque::new();
+        queue.push_back((PathBuf::from("/"), self.state.lock().await.root.clone()));
+        while let Some((path, entry)) = queue.pop_front() {
+            if let FakeFsEntry::Dir { entries, .. } = &*entry.lock().await {
+                for (name, entry) in entries {
+                    queue.push_back((path.join(name), entry.clone()));
+                }
+            }
+            result.push(path);
+        }
+        result
+    }
+
     pub async fn directories(&self) -> Vec<PathBuf> {
         let mut result = Vec::new();
         let mut queue = collections::VecDeque::new();
@@ -726,6 +745,8 @@ impl Fs for FakeFs {
             }
 
             let inode = state.next_inode;
+            let mtime = state.next_mtime;
+            state.next_mtime += Duration::from_nanos(1);
             state.next_inode += 1;
             state
                 .write_path(&cur_path, |entry| {
@@ -733,7 +754,7 @@ impl Fs for FakeFs {
                         created_dirs.push(cur_path.clone());
                         Arc::new(Mutex::new(FakeFsEntry::Dir {
                             inode,
-                            mtime: SystemTime::now(),
+                            mtime,
                             entries: Default::default(),
                             git_repo_state: None,
                         }))
@@ -751,10 +772,12 @@ impl Fs for FakeFs {
         self.simulate_random_delay().await;
         let mut state = self.state.lock().await;
         let inode = state.next_inode;
+        let mtime = state.next_mtime;
+        state.next_mtime += Duration::from_nanos(1);
         state.next_inode += 1;
         let file = Arc::new(Mutex::new(FakeFsEntry::File {
             inode,
-            mtime: SystemTime::now(),
+            mtime,
             content: String::new(),
         }));
         state
@@ -816,6 +839,9 @@ impl Fs for FakeFs {
         let source = normalize_path(source);
         let target = normalize_path(target);
         let mut state = self.state.lock().await;
+        let mtime = state.next_mtime;
+        let inode = util::post_inc(&mut state.next_inode);
+        state.next_mtime += Duration::from_nanos(1);
         let source_entry = state.read_path(&source).await?;
         let content = source_entry.lock().await.file_content(&source)?.clone();
         let entry = state
@@ -831,8 +857,8 @@ impl Fs for FakeFs {
                 }
                 btree_map::Entry::Vacant(e) => Ok(Some(
                     e.insert(Arc::new(Mutex::new(FakeFsEntry::File {
-                        inode: 0,
-                        mtime: SystemTime::now(),
+                        inode,
+                        mtime,
                         content: String::new(),
                     })))
                     .clone(),

crates/fuzzy/src/fuzzy.rs

@@ -1,794 +1,8 @@
 mod char_bag;
-
-use gpui::executor;
-use std::{
-    borrow::Cow,
-    cmp::{self, Ordering},
-    path::Path,
-    sync::atomic::{self, AtomicBool},
-    sync::Arc,
-};
+mod matcher;
+mod paths;
+mod strings;
 
 pub use char_bag::CharBag;
-
-const BASE_DISTANCE_PENALTY: f64 = 0.6;
-const ADDITIONAL_DISTANCE_PENALTY: f64 = 0.05;
-const MIN_DISTANCE_PENALTY: f64 = 0.2;
-
-pub struct Matcher<'a> {
-    query: &'a [char],
-    lowercase_query: &'a [char],
-    query_char_bag: CharBag,
-    smart_case: bool,
-    max_results: usize,
-    min_score: f64,
-    match_positions: Vec<usize>,
-    last_positions: Vec<usize>,
-    score_matrix: Vec<Option<f64>>,
-    best_position_matrix: Vec<usize>,
-}
-
-trait Match: Ord {
-    fn score(&self) -> f64;
-    fn set_positions(&mut self, positions: Vec<usize>);
-}
-
-trait MatchCandidate {
-    fn has_chars(&self, bag: CharBag) -> bool;
-    fn to_string(&self) -> Cow<'_, str>;
-}
-
-#[derive(Clone, Debug)]
-pub struct PathMatchCandidate<'a> {
-    pub path: &'a Arc<Path>,
-    pub char_bag: CharBag,
-}
-
-#[derive(Clone, Debug)]
-pub struct PathMatch {
-    pub score: f64,
-    pub positions: Vec<usize>,
-    pub worktree_id: usize,
-    pub path: Arc<Path>,
-    pub path_prefix: Arc<str>,
-}
-
-#[derive(Clone, Debug)]
-pub struct StringMatchCandidate {
-    pub id: usize,
-    pub string: String,
-    pub char_bag: CharBag,
-}
-
-pub trait PathMatchCandidateSet<'a>: Send + Sync {
-    type Candidates: Iterator<Item = PathMatchCandidate<'a>>;
-    fn id(&self) -> usize;
-    fn len(&self) -> usize;
-    fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-    fn prefix(&self) -> Arc<str>;
-    fn candidates(&'a self, start: usize) -> Self::Candidates;
-}
-
-impl Match for PathMatch {
-    fn score(&self) -> f64 {
-        self.score
-    }
-
-    fn set_positions(&mut self, positions: Vec<usize>) {
-        self.positions = positions;
-    }
-}
-
-impl Match for StringMatch {
-    fn score(&self) -> f64 {
-        self.score
-    }
-
-    fn set_positions(&mut self, positions: Vec<usize>) {
-        self.positions = positions;
-    }
-}
-
-impl<'a> MatchCandidate for PathMatchCandidate<'a> {
-    fn has_chars(&self, bag: CharBag) -> bool {
-        self.char_bag.is_superset(bag)
-    }
-
-    fn to_string(&self) -> Cow<'a, str> {
-        self.path.to_string_lossy()
-    }
-}
-
-impl StringMatchCandidate {
-    pub fn new(id: usize, string: String) -> Self {
-        Self {
-            id,
-            char_bag: CharBag::from(string.as_str()),
-            string,
-        }
-    }
-}
-
-impl<'a> MatchCandidate for &'a StringMatchCandidate {
-    fn has_chars(&self, bag: CharBag) -> bool {
-        self.char_bag.is_superset(bag)
-    }
-
-    fn to_string(&self) -> Cow<'a, str> {
-        self.string.as_str().into()
-    }
-}
-
-#[derive(Clone, Debug)]
-pub struct StringMatch {
-    pub candidate_id: usize,
-    pub score: f64,
-    pub positions: Vec<usize>,
-    pub string: String,
-}
-
-impl PartialEq for StringMatch {
-    fn eq(&self, other: &Self) -> bool {
-        self.cmp(other).is_eq()
-    }
-}
-
-impl Eq for StringMatch {}
-
-impl PartialOrd for StringMatch {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for StringMatch {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.score
-            .partial_cmp(&other.score)
-            .unwrap_or(Ordering::Equal)
-            .then_with(|| self.candidate_id.cmp(&other.candidate_id))
-    }
-}
-
-impl PartialEq for PathMatch {
-    fn eq(&self, other: &Self) -> bool {
-        self.cmp(other).is_eq()
-    }
-}
-
-impl Eq for PathMatch {}
-
-impl PartialOrd for PathMatch {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for PathMatch {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.score
-            .partial_cmp(&other.score)
-            .unwrap_or(Ordering::Equal)
-            .then_with(|| self.worktree_id.cmp(&other.worktree_id))
-            .then_with(|| Arc::as_ptr(&self.path).cmp(&Arc::as_ptr(&other.path)))
-    }
-}
-
-pub async fn match_strings(
-    candidates: &[StringMatchCandidate],
-    query: &str,
-    smart_case: bool,
-    max_results: usize,
-    cancel_flag: &AtomicBool,
-    background: Arc<executor::Background>,
-) -> Vec<StringMatch> {
-    if candidates.is_empty() || max_results == 0 {
-        return Default::default();
-    }
-
-    if query.is_empty() {
-        return candidates
-            .iter()
-            .map(|candidate| StringMatch {
-                candidate_id: candidate.id,
-                score: 0.,
-                positions: Default::default(),
-                string: candidate.string.clone(),
-            })
-            .collect();
-    }
-
-    let lowercase_query = query.to_lowercase().chars().collect::<Vec<_>>();
-    let query = query.chars().collect::<Vec<_>>();
-
-    let lowercase_query = &lowercase_query;
-    let query = &query;
-    let query_char_bag = CharBag::from(&lowercase_query[..]);
-
-    let num_cpus = background.num_cpus().min(candidates.len());
-    let segment_size = (candidates.len() + num_cpus - 1) / num_cpus;
-    let mut segment_results = (0..num_cpus)
-        .map(|_| Vec::with_capacity(max_results.min(candidates.len())))
-        .collect::<Vec<_>>();
-
-    background
-        .scoped(|scope| {
-            for (segment_idx, results) in segment_results.iter_mut().enumerate() {
-                let cancel_flag = &cancel_flag;
-                scope.spawn(async move {
-                    let segment_start = cmp::min(segment_idx * segment_size, candidates.len());
-                    let segment_end = cmp::min(segment_start + segment_size, candidates.len());
-                    let mut matcher = Matcher::new(
-                        query,
-                        lowercase_query,
-                        query_char_bag,
-                        smart_case,
-                        max_results,
-                    );
-                    matcher.match_strings(
-                        &candidates[segment_start..segment_end],
-                        results,
-                        cancel_flag,
-                    );
-                });
-            }
-        })
-        .await;
-
-    let mut results = Vec::new();
-    for segment_result in segment_results {
-        if results.is_empty() {
-            results = segment_result;
-        } else {
-            util::extend_sorted(&mut results, segment_result, max_results, |a, b| b.cmp(a));
-        }
-    }
-    results
-}
-
-pub async fn match_paths<'a, Set: PathMatchCandidateSet<'a>>(
-    candidate_sets: &'a [Set],
-    query: &str,
-    smart_case: bool,
-    max_results: usize,
-    cancel_flag: &AtomicBool,
-    background: Arc<executor::Background>,
-) -> Vec<PathMatch> {
-    let path_count: usize = candidate_sets.iter().map(|s| s.len()).sum();
-    if path_count == 0 {
-        return Vec::new();
-    }
-
-    let lowercase_query = query.to_lowercase().chars().collect::<Vec<_>>();
-    let query = query.chars().collect::<Vec<_>>();
-
-    let lowercase_query = &lowercase_query;
-    let query = &query;
-    let query_char_bag = CharBag::from(&lowercase_query[..]);
-
-    let num_cpus = background.num_cpus().min(path_count);
-    let segment_size = (path_count + num_cpus - 1) / num_cpus;
-    let mut segment_results = (0..num_cpus)
-        .map(|_| Vec::with_capacity(max_results))
-        .collect::<Vec<_>>();
-
-    background
-        .scoped(|scope| {
-            for (segment_idx, results) in segment_results.iter_mut().enumerate() {
-                scope.spawn(async move {
-                    let segment_start = segment_idx * segment_size;
-                    let segment_end = segment_start + segment_size;
-                    let mut matcher = Matcher::new(
-                        query,
-                        lowercase_query,
-                        query_char_bag,
-                        smart_case,
-                        max_results,
-                    );
-
-                    let mut tree_start = 0;
-                    for candidate_set in candidate_sets {
-                        let tree_end = tree_start + candidate_set.len();
-
-                        if tree_start < segment_end && segment_start < tree_end {
-                            let start = cmp::max(tree_start, segment_start) - tree_start;
-                            let end = cmp::min(tree_end, segment_end) - tree_start;
-                            let candidates = candidate_set.candidates(start).take(end - start);
-
-                            matcher.match_paths(
-                                candidate_set.id(),
-                                candidate_set.prefix(),
-                                candidates,
-                                results,
-                                cancel_flag,
-                            );
-                        }
-                        if tree_end >= segment_end {
-                            break;
-                        }
-                        tree_start = tree_end;
-                    }
-                })
-            }
-        })
-        .await;
-
-    let mut results = Vec::new();
-    for segment_result in segment_results {
-        if results.is_empty() {
-            results = segment_result;
-        } else {
-            util::extend_sorted(&mut results, segment_result, max_results, |a, b| b.cmp(a));
-        }
-    }
-    results
-}
-
-impl<'a> Matcher<'a> {
-    pub fn new(
-        query: &'a [char],
-        lowercase_query: &'a [char],
-        query_char_bag: CharBag,
-        smart_case: bool,
-        max_results: usize,
-    ) -> Self {
-        Self {
-            query,
-            lowercase_query,
-            query_char_bag,
-            min_score: 0.0,
-            last_positions: vec![0; query.len()],
-            match_positions: vec![0; query.len()],
-            score_matrix: Vec::new(),
-            best_position_matrix: Vec::new(),
-            smart_case,
-            max_results,
-        }
-    }
-
-    pub fn match_strings(
-        &mut self,
-        candidates: &[StringMatchCandidate],
-        results: &mut Vec<StringMatch>,
-        cancel_flag: &AtomicBool,
-    ) {
-        self.match_internal(
-            &[],
-            &[],
-            candidates.iter(),
-            results,
-            cancel_flag,
-            |candidate, score| StringMatch {
-                candidate_id: candidate.id,
-                score,
-                positions: Vec::new(),
-                string: candidate.string.to_string(),
-            },
-        )
-    }
-
-    pub fn match_paths<'c: 'a>(
-        &mut self,
-        tree_id: usize,
-        path_prefix: Arc<str>,
-        path_entries: impl Iterator<Item = PathMatchCandidate<'c>>,
-        results: &mut Vec<PathMatch>,
-        cancel_flag: &AtomicBool,
-    ) {
-        let prefix = path_prefix.chars().collect::<Vec<_>>();
-        let lowercase_prefix = prefix
-            .iter()
-            .map(|c| c.to_ascii_lowercase())
-            .collect::<Vec<_>>();
-        self.match_internal(
-            &prefix,
-            &lowercase_prefix,
-            path_entries,
-            results,
-            cancel_flag,
-            |candidate, score| PathMatch {
-                score,
-                worktree_id: tree_id,
-                positions: Vec::new(),
-                path: candidate.path.clone(),
-                path_prefix: path_prefix.clone(),
-            },
-        )
-    }
-
-    fn match_internal<C: MatchCandidate, R, F>(
-        &mut self,
-        prefix: &[char],
-        lowercase_prefix: &[char],
-        candidates: impl Iterator<Item = C>,
-        results: &mut Vec<R>,
-        cancel_flag: &AtomicBool,
-        build_match: F,
-    ) where
-        R: Match,
-        F: Fn(&C, f64) -> R,
-    {
-        let mut candidate_chars = Vec::new();
-        let mut lowercase_candidate_chars = Vec::new();
-
-        for candidate in candidates {
-            if !candidate.has_chars(self.query_char_bag) {
-                continue;
-            }
-
-            if cancel_flag.load(atomic::Ordering::Relaxed) {
-                break;
-            }
-
-            candidate_chars.clear();
-            lowercase_candidate_chars.clear();
-            for c in candidate.to_string().chars() {
-                candidate_chars.push(c);
-                lowercase_candidate_chars.push(c.to_ascii_lowercase());
-            }
-
-            if !self.find_last_positions(lowercase_prefix, &lowercase_candidate_chars) {
-                continue;
-            }
-
-            let matrix_len = self.query.len() * (prefix.len() + candidate_chars.len());
-            self.score_matrix.clear();
-            self.score_matrix.resize(matrix_len, None);
-            self.best_position_matrix.clear();
-            self.best_position_matrix.resize(matrix_len, 0);
-
-            let score = self.score_match(
-                &candidate_chars,
-                &lowercase_candidate_chars,
-                prefix,
-                lowercase_prefix,
-            );
-
-            if score > 0.0 {
-                let mut mat = build_match(&candidate, score);
-                if let Err(i) = results.binary_search_by(|m| mat.cmp(m)) {
-                    if results.len() < self.max_results {
-                        mat.set_positions(self.match_positions.clone());
-                        results.insert(i, mat);
-                    } else if i < results.len() {
-                        results.pop();
-                        mat.set_positions(self.match_positions.clone());
-                        results.insert(i, mat);
-                    }
-                    if results.len() == self.max_results {
-                        self.min_score = results.last().unwrap().score();
-                    }
-                }
-            }
-        }
-    }
-
-    fn find_last_positions(
-        &mut self,
-        lowercase_prefix: &[char],
-        lowercase_candidate: &[char],
-    ) -> bool {
-        let mut lowercase_prefix = lowercase_prefix.iter();
-        let mut lowercase_candidate = lowercase_candidate.iter();
-        for (i, char) in self.lowercase_query.iter().enumerate().rev() {
-            if let Some(j) = lowercase_candidate.rposition(|c| c == char) {
-                self.last_positions[i] = j + lowercase_prefix.len();
-            } else if let Some(j) = lowercase_prefix.rposition(|c| c == char) {
-                self.last_positions[i] = j;
-            } else {
-                return false;
-            }
-        }
-        true
-    }
-
-    fn score_match(
-        &mut self,
-        path: &[char],
-        path_cased: &[char],
-        prefix: &[char],
-        lowercase_prefix: &[char],
-    ) -> f64 {
-        let score = self.recursive_score_match(
-            path,
-            path_cased,
-            prefix,
-            lowercase_prefix,
-            0,
-            0,
-            self.query.len() as f64,
-        ) * self.query.len() as f64;
-
-        if score <= 0.0 {
-            return 0.0;
-        }
-
-        let path_len = prefix.len() + path.len();
-        let mut cur_start = 0;
-        let mut byte_ix = 0;
-        let mut char_ix = 0;
-        for i in 0..self.query.len() {
-            let match_char_ix = self.best_position_matrix[i * path_len + cur_start];
-            while char_ix < match_char_ix {
-                let ch = prefix
-                    .get(char_ix)
-                    .or_else(|| path.get(char_ix - prefix.len()))
-                    .unwrap();
-                byte_ix += ch.len_utf8();
-                char_ix += 1;
-            }
-            cur_start = match_char_ix + 1;
-            self.match_positions[i] = byte_ix;
-        }
-
-        score
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    fn recursive_score_match(
-        &mut self,
-        path: &[char],
-        path_cased: &[char],
-        prefix: &[char],
-        lowercase_prefix: &[char],
-        query_idx: usize,
-        path_idx: usize,
-        cur_score: f64,
-    ) -> f64 {
-        if query_idx == self.query.len() {
-            return 1.0;
-        }
-
-        let path_len = prefix.len() + path.len();
-
-        if let Some(memoized) = self.score_matrix[query_idx * path_len + path_idx] {
-            return memoized;
-        }
-
-        let mut score = 0.0;
-        let mut best_position = 0;
-
-        let query_char = self.lowercase_query[query_idx];
-        let limit = self.last_positions[query_idx];
-
-        let mut last_slash = 0;
-        for j in path_idx..=limit {
-            let path_char = if j < prefix.len() {
-                lowercase_prefix[j]
-            } else {
-                path_cased[j - prefix.len()]
-            };
-            let is_path_sep = path_char == '/' || path_char == '\\';
-
-            if query_idx == 0 && is_path_sep {
-                last_slash = j;
-            }
-
-            if query_char == path_char || (is_path_sep && query_char == '_' || query_char == '\\') {
-                let curr = if j < prefix.len() {
-                    prefix[j]
-                } else {
-                    path[j - prefix.len()]
-                };
-
-                let mut char_score = 1.0;
-                if j > path_idx {
-                    let last = if j - 1 < prefix.len() {
-                        prefix[j - 1]
-                    } else {
-                        path[j - 1 - prefix.len()]
-                    };
-
-                    if last == '/' {
-                        char_score = 0.9;
-                    } else if (last == '-' || last == '_' || last == ' ' || last.is_numeric())
-                        || (last.is_lowercase() && curr.is_uppercase())
-                    {
-                        char_score = 0.8;
-                    } else if last == '.' {
-                        char_score = 0.7;
-                    } else if query_idx == 0 {
-                        char_score = BASE_DISTANCE_PENALTY;
-                    } else {
-                        char_score = MIN_DISTANCE_PENALTY.max(
-                            BASE_DISTANCE_PENALTY
-                                - (j - path_idx - 1) as f64 * ADDITIONAL_DISTANCE_PENALTY,
-                        );
-                    }
-                }
-
-                // Apply a severe penalty if the case doesn't match.
-                // This will make the exact matches have higher score than the case-insensitive and the
-                // path insensitive matches.
-                if (self.smart_case || curr == '/') && self.query[query_idx] != curr {
-                    char_score *= 0.001;
-                }
-
-                let mut multiplier = char_score;
-
-                // Scale the score based on how deep within the path we found the match.
-                if query_idx == 0 {
-                    multiplier /= ((prefix.len() + path.len()) - last_slash) as f64;
-                }
-
-                let mut next_score = 1.0;
-                if self.min_score > 0.0 {
-                    next_score = cur_score * multiplier;
-                    // Scores only decrease. If we can't pass the previous best, bail
-                    if next_score < self.min_score {
-                        // Ensure that score is non-zero so we use it in the memo table.
-                        if score == 0.0 {
-                            score = 1e-18;
-                        }
-                        continue;
-                    }
-                }
-
-                let new_score = self.recursive_score_match(
-                    path,
-                    path_cased,
-                    prefix,
-                    lowercase_prefix,
-                    query_idx + 1,
-                    j + 1,
-                    next_score,
-                ) * multiplier;
-
-                if new_score > score {
-                    score = new_score;
-                    best_position = j;
-                    // Optimization: can't score better than 1.
-                    if new_score == 1.0 {
-                        break;
-                    }
-                }
-            }
-        }
-
-        if best_position != 0 {
-            self.best_position_matrix[query_idx * path_len + path_idx] = best_position;
-        }
-
-        self.score_matrix[query_idx * path_len + path_idx] = Some(score);
-        score
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::path::PathBuf;
-
-    #[test]
-    fn test_get_last_positions() {
-        let mut query: &[char] = &['d', 'c'];
-        let mut matcher = Matcher::new(query, query, query.into(), false, 10);
-        let result = matcher.find_last_positions(&['a', 'b', 'c'], &['b', 'd', 'e', 'f']);
-        assert!(!result);
-
-        query = &['c', 'd'];
-        let mut matcher = Matcher::new(query, query, query.into(), false, 10);
-        let result = matcher.find_last_positions(&['a', 'b', 'c'], &['b', 'd', 'e', 'f']);
-        assert!(result);
-        assert_eq!(matcher.last_positions, vec![2, 4]);
-
-        query = &['z', '/', 'z', 'f'];
-        let mut matcher = Matcher::new(query, query, query.into(), false, 10);
-        let result = matcher.find_last_positions(&['z', 'e', 'd', '/'], &['z', 'e', 'd', '/', 'f']);
-        assert!(result);
-        assert_eq!(matcher.last_positions, vec![0, 3, 4, 8]);
-    }
-
-    #[test]
-    fn test_match_path_entries() {
-        let paths = vec![
-            "",
-            "a",
-            "ab",
-            "abC",
-            "abcd",
-            "alphabravocharlie",
-            "AlphaBravoCharlie",
-            "thisisatestdir",
-            "/////ThisIsATestDir",
-            "/this/is/a/test/dir",
-            "/test/tiatd",
-        ];
-
-        assert_eq!(
-            match_query("abc", false, &paths),
-            vec![
-                ("abC", vec![0, 1, 2]),
-                ("abcd", vec![0, 1, 2]),
-                ("AlphaBravoCharlie", vec![0, 5, 10]),
-                ("alphabravocharlie", vec![4, 5, 10]),
-            ]
-        );
-        assert_eq!(
-            match_query("t/i/a/t/d", false, &paths),
-            vec![("/this/is/a/test/dir", vec![1, 5, 6, 8, 9, 10, 11, 15, 16]),]
-        );
-
-        assert_eq!(
-            match_query("tiatd", false, &paths),
-            vec![
-                ("/test/tiatd", vec![6, 7, 8, 9, 10]),
-                ("/this/is/a/test/dir", vec![1, 6, 9, 11, 16]),
-                ("/////ThisIsATestDir", vec![5, 9, 11, 12, 16]),
-                ("thisisatestdir", vec![0, 2, 6, 7, 11]),
-            ]
-        );
-    }
-
-    #[test]
-    fn test_match_multibyte_path_entries() {
-        let paths = vec!["aαbβ/cγdδ", "αβγδ/bcde", "c1️⃣2️⃣3️⃣/d4️⃣5️⃣6️⃣/e7️⃣8️⃣9️⃣/f", "/d/🆒/h"];
-        assert_eq!("1️⃣".len(), 7);
-        assert_eq!(
-            match_query("bcd", false, &paths),
-            vec![
-                ("αβγδ/bcde", vec![9, 10, 11]),
-                ("aαbβ/cγdδ", vec![3, 7, 10]),
-            ]
-        );
-        assert_eq!(
-            match_query("cde", false, &paths),
-            vec![
-                ("αβγδ/bcde", vec![10, 11, 12]),
-                ("c1️⃣2️⃣3️⃣/d4️⃣5️⃣6️⃣/e7️⃣8️⃣9️⃣/f", vec![0, 23, 46]),
-            ]
-        );
-    }
-
-    fn match_query<'a>(
-        query: &str,
-        smart_case: bool,
-        paths: &[&'a str],
-    ) -> Vec<(&'a str, Vec<usize>)> {
-        let lowercase_query = query.to_lowercase().chars().collect::<Vec<_>>();
-        let query = query.chars().collect::<Vec<_>>();
-        let query_chars = CharBag::from(&lowercase_query[..]);
-
-        let path_arcs = paths
-            .iter()
-            .map(|path| Arc::from(PathBuf::from(path)))
-            .collect::<Vec<_>>();
-        let mut path_entries = Vec::new();
-        for (i, path) in paths.iter().enumerate() {
-            let lowercase_path = path.to_lowercase().chars().collect::<Vec<_>>();
-            let char_bag = CharBag::from(lowercase_path.as_slice());
-            path_entries.push(PathMatchCandidate {
-                char_bag,
-                path: path_arcs.get(i).unwrap(),
-            });
-        }
-
-        let mut matcher = Matcher::new(&query, &lowercase_query, query_chars, smart_case, 100);
-
-        let cancel_flag = AtomicBool::new(false);
-        let mut results = Vec::new();
-        matcher.match_paths(
-            0,
-            "".into(),
-            path_entries.into_iter(),
-            &mut results,
-            &cancel_flag,
-        );
-
-        results
-            .into_iter()
-            .map(|result| {
-                (
-                    paths
-                        .iter()
-                        .copied()
-                        .find(|p| result.path.as_ref() == Path::new(p))
-                        .unwrap(),
-                    result.positions,
-                )
-            })
-            .collect()
-    }
-}
+pub use paths::{match_path_sets, PathMatch, PathMatchCandidate, PathMatchCandidateSet};
+pub use strings::{match_strings, StringMatch, StringMatchCandidate};

crates/fuzzy/src/matcher.rs

@@ -0,0 +1,463 @@
+use std::{
+    borrow::Cow,
+    sync::atomic::{self, AtomicBool},
+};
+
+use crate::CharBag;
+
+const BASE_DISTANCE_PENALTY: f64 = 0.6;
+const ADDITIONAL_DISTANCE_PENALTY: f64 = 0.05;
+const MIN_DISTANCE_PENALTY: f64 = 0.2;
+
+pub struct Matcher<'a> {
+    query: &'a [char],
+    lowercase_query: &'a [char],
+    query_char_bag: CharBag,
+    smart_case: bool,
+    max_results: usize,
+    min_score: f64,
+    match_positions: Vec<usize>,
+    last_positions: Vec<usize>,
+    score_matrix: Vec<Option<f64>>,
+    best_position_matrix: Vec<usize>,
+}
+
+pub trait Match: Ord {
+    fn score(&self) -> f64;
+    fn set_positions(&mut self, positions: Vec<usize>);
+}
+
+pub trait MatchCandidate {
+    fn has_chars(&self, bag: CharBag) -> bool;
+    fn to_string(&self) -> Cow<'_, str>;
+}
+
+impl<'a> Matcher<'a> {
+    pub fn new(
+        query: &'a [char],
+        lowercase_query: &'a [char],
+        query_char_bag: CharBag,
+        smart_case: bool,
+        max_results: usize,
+    ) -> Self {
+        Self {
+            query,
+            lowercase_query,
+            query_char_bag,
+            min_score: 0.0,
+            last_positions: vec![0; query.len()],
+            match_positions: vec![0; query.len()],
+            score_matrix: Vec::new(),
+            best_position_matrix: Vec::new(),
+            smart_case,
+            max_results,
+        }
+    }
+
+    pub fn match_candidates<C: MatchCandidate, R, F>(
+        &mut self,
+        prefix: &[char],
+        lowercase_prefix: &[char],
+        candidates: impl Iterator<Item = C>,
+        results: &mut Vec<R>,
+        cancel_flag: &AtomicBool,
+        build_match: F,
+    ) where
+        R: Match,
+        F: Fn(&C, f64) -> R,
+    {
+        let mut candidate_chars = Vec::new();
+        let mut lowercase_candidate_chars = Vec::new();
+
+        for candidate in candidates {
+            if !candidate.has_chars(self.query_char_bag) {
+                continue;
+            }
+
+            if cancel_flag.load(atomic::Ordering::Relaxed) {
+                break;
+            }
+
+            candidate_chars.clear();
+            lowercase_candidate_chars.clear();
+            for c in candidate.to_string().chars() {
+                candidate_chars.push(c);
+                lowercase_candidate_chars.push(c.to_ascii_lowercase());
+            }
+
+            if !self.find_last_positions(lowercase_prefix, &lowercase_candidate_chars) {
+                continue;
+            }
+
+            let matrix_len = self.query.len() * (prefix.len() + candidate_chars.len());
+            self.score_matrix.clear();
+            self.score_matrix.resize(matrix_len, None);
+            self.best_position_matrix.clear();
+            self.best_position_matrix.resize(matrix_len, 0);
+
+            let score = self.score_match(
+                &candidate_chars,
+                &lowercase_candidate_chars,
+                prefix,
+                lowercase_prefix,
+            );
+
+            if score > 0.0 {
+                let mut mat = build_match(&candidate, score);
+                if let Err(i) = results.binary_search_by(|m| mat.cmp(m)) {
+                    if results.len() < self.max_results {
+                        mat.set_positions(self.match_positions.clone());
+                        results.insert(i, mat);
+                    } else if i < results.len() {
+                        results.pop();
+                        mat.set_positions(self.match_positions.clone());
+                        results.insert(i, mat);
+                    }
+                    if results.len() == self.max_results {
+                        self.min_score = results.last().unwrap().score();
+                    }
+                }
+            }
+        }
+    }
+
+    fn find_last_positions(
+        &mut self,
+        lowercase_prefix: &[char],
+        lowercase_candidate: &[char],
+    ) -> bool {
+        let mut lowercase_prefix = lowercase_prefix.iter();
+        let mut lowercase_candidate = lowercase_candidate.iter();
+        for (i, char) in self.lowercase_query.iter().enumerate().rev() {
+            if let Some(j) = lowercase_candidate.rposition(|c| c == char) {
+                self.last_positions[i] = j + lowercase_prefix.len();
+            } else if let Some(j) = lowercase_prefix.rposition(|c| c == char) {
+                self.last_positions[i] = j;
+            } else {
+                return false;
+            }
+        }
+        true
+    }
+
+    fn score_match(
+        &mut self,
+        path: &[char],
+        path_cased: &[char],
+        prefix: &[char],
+        lowercase_prefix: &[char],
+    ) -> f64 {
+        let score = self.recursive_score_match(
+            path,
+            path_cased,
+            prefix,
+            lowercase_prefix,
+            0,
+            0,
+            self.query.len() as f64,
+        ) * self.query.len() as f64;
+
+        if score <= 0.0 {
+            return 0.0;
+        }
+
+        let path_len = prefix.len() + path.len();
+        let mut cur_start = 0;
+        let mut byte_ix = 0;
+        let mut char_ix = 0;
+        for i in 0..self.query.len() {
+            let match_char_ix = self.best_position_matrix[i * path_len + cur_start];
+            while char_ix < match_char_ix {
+                let ch = prefix
+                    .get(char_ix)
+                    .or_else(|| path.get(char_ix - prefix.len()))
+                    .unwrap();
+                byte_ix += ch.len_utf8();
+                char_ix += 1;
+            }
+            cur_start = match_char_ix + 1;
+            self.match_positions[i] = byte_ix;
+        }
+
+        score
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn recursive_score_match(
+        &mut self,
+        path: &[char],
+        path_cased: &[char],
+        prefix: &[char],
+        lowercase_prefix: &[char],
+        query_idx: usize,
+        path_idx: usize,
+        cur_score: f64,
+    ) -> f64 {
+        if query_idx == self.query.len() {
+            return 1.0;
+        }
+
+        let path_len = prefix.len() + path.len();
+
+        if let Some(memoized) = self.score_matrix[query_idx * path_len + path_idx] {
+            return memoized;
+        }
+
+        let mut score = 0.0;
+        let mut best_position = 0;
+
+        let query_char = self.lowercase_query[query_idx];
+        let limit = self.last_positions[query_idx];
+
+        let mut last_slash = 0;
+        for j in path_idx..=limit {
+            let path_char = if j < prefix.len() {
+                lowercase_prefix[j]
+            } else {
+                path_cased[j - prefix.len()]
+            };
+            let is_path_sep = path_char == '/' || path_char == '\\';
+
+            if query_idx == 0 && is_path_sep {
+                last_slash = j;
+            }
+
+            if query_char == path_char || (is_path_sep && query_char == '_' || query_char == '\\') {
+                let curr = if j < prefix.len() {
+                    prefix[j]
+                } else {
+                    path[j - prefix.len()]
+                };
+
+                let mut char_score = 1.0;
+                if j > path_idx {
+                    let last = if j - 1 < prefix.len() {
+                        prefix[j - 1]
+                    } else {
+                        path[j - 1 - prefix.len()]
+                    };
+
+                    if last == '/' {
+                        char_score = 0.9;
+                    } else if (last == '-' || last == '_' || last == ' ' || last.is_numeric())
+                        || (last.is_lowercase() && curr.is_uppercase())
+                    {
+                        char_score = 0.8;
+                    } else if last == '.' {
+                        char_score = 0.7;
+                    } else if query_idx == 0 {
+                        char_score = BASE_DISTANCE_PENALTY;
+                    } else {
+                        char_score = MIN_DISTANCE_PENALTY.max(
+                            BASE_DISTANCE_PENALTY
+                                - (j - path_idx - 1) as f64 * ADDITIONAL_DISTANCE_PENALTY,
+                        );
+                    }
+                }
+
+                // Apply a severe penalty if the case doesn't match.
+                // This will make the exact matches have higher score than the case-insensitive and the
+                // path insensitive matches.
+                if (self.smart_case || curr == '/') && self.query[query_idx] != curr {
+                    char_score *= 0.001;
+                }
+
+                let mut multiplier = char_score;
+
+                // Scale the score based on how deep within the path we found the match.
+                if query_idx == 0 {
+                    multiplier /= ((prefix.len() + path.len()) - last_slash) as f64;
+                }
+
+                let mut next_score = 1.0;
+                if self.min_score > 0.0 {
+                    next_score = cur_score * multiplier;
+                    // Scores only decrease. If we can't pass the previous best, bail
+                    if next_score < self.min_score {
+                        // Ensure that score is non-zero so we use it in the memo table.
+                        if score == 0.0 {
+                            score = 1e-18;
+                        }
+                        continue;
+                    }
+                }
+
+                let new_score = self.recursive_score_match(
+                    path,
+                    path_cased,
+                    prefix,
+                    lowercase_prefix,
+                    query_idx + 1,
+                    j + 1,
+                    next_score,
+                ) * multiplier;
+
+                if new_score > score {
+                    score = new_score;
+                    best_position = j;
+                    // Optimization: can't score better than 1.
+                    if new_score == 1.0 {
+                        break;
+                    }
+                }
+            }
+        }
+
+        if best_position != 0 {
+            self.best_position_matrix[query_idx * path_len + path_idx] = best_position;
+        }
+
+        self.score_matrix[query_idx * path_len + path_idx] = Some(score);
+        score
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{PathMatch, PathMatchCandidate};
+
+    use super::*;
+    use std::{
+        path::{Path, PathBuf},
+        sync::Arc,
+    };
+
+    #[test]
+    fn test_get_last_positions() {
+        let mut query: &[char] = &['d', 'c'];
+        let mut matcher = Matcher::new(query, query, query.into(), false, 10);
+        let result = matcher.find_last_positions(&['a', 'b', 'c'], &['b', 'd', 'e', 'f']);
+        assert!(!result);
+
+        query = &['c', 'd'];
+        let mut matcher = Matcher::new(query, query, query.into(), false, 10);
+        let result = matcher.find_last_positions(&['a', 'b', 'c'], &['b', 'd', 'e', 'f']);
+        assert!(result);
+        assert_eq!(matcher.last_positions, vec![2, 4]);
+
+        query = &['z', '/', 'z', 'f'];
+        let mut matcher = Matcher::new(query, query, query.into(), false, 10);
+        let result = matcher.find_last_positions(&['z', 'e', 'd', '/'], &['z', 'e', 'd', '/', 'f']);
+        assert!(result);
+        assert_eq!(matcher.last_positions, vec![0, 3, 4, 8]);
+    }
+
+    #[test]
+    fn test_match_path_entries() {
+        let paths = vec![
+            "",
+            "a",
+            "ab",
+            "abC",
+            "abcd",
+            "alphabravocharlie",
+            "AlphaBravoCharlie",
+            "thisisatestdir",
+            "/////ThisIsATestDir",
+            "/this/is/a/test/dir",
+            "/test/tiatd",
+        ];
+
+        assert_eq!(
+            match_single_path_query("abc", false, &paths),
+            vec![
+                ("abC", vec![0, 1, 2]),
+                ("abcd", vec![0, 1, 2]),
+                ("AlphaBravoCharlie", vec![0, 5, 10]),
+                ("alphabravocharlie", vec![4, 5, 10]),
+            ]
+        );
+        assert_eq!(
+            match_single_path_query("t/i/a/t/d", false, &paths),
+            vec![("/this/is/a/test/dir", vec![1, 5, 6, 8, 9, 10, 11, 15, 16]),]
+        );
+
+        assert_eq!(
+            match_single_path_query("tiatd", false, &paths),
+            vec![
+                ("/test/tiatd", vec![6, 7, 8, 9, 10]),
+                ("/this/is/a/test/dir", vec![1, 6, 9, 11, 16]),
+                ("/////ThisIsATestDir", vec![5, 9, 11, 12, 16]),
+                ("thisisatestdir", vec![0, 2, 6, 7, 11]),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_match_multibyte_path_entries() {
+        let paths = vec!["aαbβ/cγdδ", "αβγδ/bcde", "c1️⃣2️⃣3️⃣/d4️⃣5️⃣6️⃣/e7️⃣8️⃣9️⃣/f", "/d/🆒/h"];
+        assert_eq!("1️⃣".len(), 7);
+        assert_eq!(
+            match_single_path_query("bcd", false, &paths),
+            vec![
+                ("αβγδ/bcde", vec![9, 10, 11]),
+                ("aαbβ/cγdδ", vec![3, 7, 10]),
+            ]
+        );
+        assert_eq!(
+            match_single_path_query("cde", false, &paths),
+            vec![
+                ("αβγδ/bcde", vec![10, 11, 12]),
+                ("c1️⃣2️⃣3️⃣/d4️⃣5️⃣6️⃣/e7️⃣8️⃣9️⃣/f", vec![0, 23, 46]),
+            ]
+        );
+    }
+
+    fn match_single_path_query<'a>(
+        query: &str,
+        smart_case: bool,
+        paths: &[&'a str],
+    ) -> Vec<(&'a str, Vec<usize>)> {
+        let lowercase_query = query.to_lowercase().chars().collect::<Vec<_>>();
+        let query = query.chars().collect::<Vec<_>>();
+        let query_chars = CharBag::from(&lowercase_query[..]);
+
+        let path_arcs: Vec<Arc<Path>> = paths
+            .iter()
+            .map(|path| Arc::from(PathBuf::from(path)))
+            .collect::<Vec<_>>();
+        let mut path_entries = Vec::new();
+        for (i, path) in paths.iter().enumerate() {
+            let lowercase_path = path.to_lowercase().chars().collect::<Vec<_>>();
+            let char_bag = CharBag::from(lowercase_path.as_slice());
+            path_entries.push(PathMatchCandidate {
+                char_bag,
+                path: &path_arcs[i],
+            });
+        }
+
+        let mut matcher = Matcher::new(&query, &lowercase_query, query_chars, smart_case, 100);
+
+        let cancel_flag = AtomicBool::new(false);
+        let mut results = Vec::new();
+
+        matcher.match_candidates(
+            &[],
+            &[],
+            path_entries.into_iter(),
+            &mut results,
+            &cancel_flag,
+            |candidate, score| PathMatch {
+                score,
+                worktree_id: 0,
+                positions: Vec::new(),
+                path: candidate.path.clone(),
+                path_prefix: "".into(),
+            },
+        );
+
+        results
+            .into_iter()
+            .map(|result| {
+                (
+                    paths
+                        .iter()
+                        .copied()
+                        .find(|p| result.path.as_ref() == Path::new(p))
+                        .unwrap(),
+                    result.positions,
+                )
+            })
+            .collect()
+    }
+}

crates/fuzzy/src/paths.rs

@@ -0,0 +1,174 @@
+use std::{
+    borrow::Cow,
+    cmp::{self, Ordering},
+    path::Path,
+    sync::{atomic::AtomicBool, Arc},
+};
+
+use gpui::executor;
+
+use crate::{
+    matcher::{Match, MatchCandidate, Matcher},
+    CharBag,
+};
+
+#[derive(Clone, Debug)]
+pub struct PathMatchCandidate<'a> {
+    pub path: &'a Arc<Path>,
+    pub char_bag: CharBag,
+}
+
+#[derive(Clone, Debug)]
+pub struct PathMatch {
+    pub score: f64,
+    pub positions: Vec<usize>,
+    pub worktree_id: usize,
+    pub path: Arc<Path>,
+    pub path_prefix: Arc<str>,
+}
+
+pub trait PathMatchCandidateSet<'a>: Send + Sync {
+    type Candidates: Iterator<Item = PathMatchCandidate<'a>>;
+    fn id(&self) -> usize;
+    fn len(&self) -> usize;
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+    fn prefix(&self) -> Arc<str>;
+    fn candidates(&'a self, start: usize) -> Self::Candidates;
+}
+
+impl Match for PathMatch {
+    fn score(&self) -> f64 {
+        self.score
+    }
+
+    fn set_positions(&mut self, positions: Vec<usize>) {
+        self.positions = positions;
+    }
+}
+
+impl<'a> MatchCandidate for PathMatchCandidate<'a> {
+    fn has_chars(&self, bag: CharBag) -> bool {
+        self.char_bag.is_superset(bag)
+    }
+
+    fn to_string(&self) -> Cow<'a, str> {
+        self.path.to_string_lossy()
+    }
+}
+
+impl PartialEq for PathMatch {
+    fn eq(&self, other: &Self) -> bool {
+        self.cmp(other).is_eq()
+    }
+}
+
+impl Eq for PathMatch {}
+
+impl PartialOrd for PathMatch {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for PathMatch {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.score
+            .partial_cmp(&other.score)
+            .unwrap_or(Ordering::Equal)
+            .then_with(|| self.worktree_id.cmp(&other.worktree_id))
+            .then_with(|| self.path.cmp(&other.path))
+    }
+}
+
+pub async fn match_path_sets<'a, Set: PathMatchCandidateSet<'a>>(
+    candidate_sets: &'a [Set],
+    query: &str,
+    smart_case: bool,
+    max_results: usize,
+    cancel_flag: &AtomicBool,
+    background: Arc<executor::Background>,
+) -> Vec<PathMatch> {
+    let path_count: usize = candidate_sets.iter().map(|s| s.len()).sum();
+    if path_count == 0 {
+        return Vec::new();
+    }
+
+    let lowercase_query = query.to_lowercase().chars().collect::<Vec<_>>();
+    let query = query.chars().collect::<Vec<_>>();
+
+    let lowercase_query = &lowercase_query;
+    let query = &query;
+    let query_char_bag = CharBag::from(&lowercase_query[..]);
+
+    let num_cpus = background.num_cpus().min(path_count);
+    let segment_size = (path_count + num_cpus - 1) / num_cpus;
+    let mut segment_results = (0..num_cpus)
+        .map(|_| Vec::with_capacity(max_results))
+        .collect::<Vec<_>>();
+
+    background
+        .scoped(|scope| {
+            for (segment_idx, results) in segment_results.iter_mut().enumerate() {
+                scope.spawn(async move {
+                    let segment_start = segment_idx * segment_size;
+                    let segment_end = segment_start + segment_size;
+                    let mut matcher = Matcher::new(
+                        query,
+                        lowercase_query,
+                        query_char_bag,
+                        smart_case,
+                        max_results,
+                    );
+
+                    let mut tree_start = 0;
+                    for candidate_set in candidate_sets {
+                        let tree_end = tree_start + candidate_set.len();
+
+                        if tree_start < segment_end && segment_start < tree_end {
+                            let start = cmp::max(tree_start, segment_start) - tree_start;
+                            let end = cmp::min(tree_end, segment_end) - tree_start;
+                            let candidates = candidate_set.candidates(start).take(end - start);
+
+                            let worktree_id = candidate_set.id();
+                            let prefix = candidate_set.prefix().chars().collect::<Vec<_>>();
+                            let lowercase_prefix = prefix
+                                .iter()
+                                .map(|c| c.to_ascii_lowercase())
+                                .collect::<Vec<_>>();
+                            matcher.match_candidates(
+                                &prefix,
+                                &lowercase_prefix,
+                                candidates,
+                                results,
+                                cancel_flag,
+                                |candidate, score| PathMatch {
+                                    score,
+                                    worktree_id,
+                                    positions: Vec::new(),
+                                    path: candidate.path.clone(),
+                                    path_prefix: candidate_set.prefix(),
+                                },
+                            );
+                        }
+                        if tree_end >= segment_end {
+                            break;
+                        }
+                        tree_start = tree_end;
+                    }
+                })
+            }
+        })
+        .await;
+
+    let mut results = Vec::new();
+    for segment_result in segment_results {
+        if results.is_empty() {
+            results = segment_result;
+        } else {
+            util::extend_sorted(&mut results, segment_result, max_results, |a, b| b.cmp(a));
+        }
+    }
+    results
+}

crates/fuzzy/src/strings.rs

@@ -0,0 +1,161 @@
+use std::{
+    borrow::Cow,
+    cmp::{self, Ordering},
+    sync::{atomic::AtomicBool, Arc},
+};
+
+use gpui::executor;
+
+use crate::{
+    matcher::{Match, MatchCandidate, Matcher},
+    CharBag,
+};
+
+#[derive(Clone, Debug)]
+pub struct StringMatchCandidate {
+    pub id: usize,
+    pub string: String,
+    pub char_bag: CharBag,
+}
+
+impl Match for StringMatch {
+    fn score(&self) -> f64 {
+        self.score
+    }
+
+    fn set_positions(&mut self, positions: Vec<usize>) {
+        self.positions = positions;
+    }
+}
+
+impl StringMatchCandidate {
+    pub fn new(id: usize, string: String) -> Self {
+        Self {
+            id,
+            char_bag: CharBag::from(string.as_str()),
+            string,
+        }
+    }
+}
+
+impl<'a> MatchCandidate for &'a StringMatchCandidate {
+    fn has_chars(&self, bag: CharBag) -> bool {
+        self.char_bag.is_superset(bag)
+    }
+
+    fn to_string(&self) -> Cow<'a, str> {
+        self.string.as_str().into()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct StringMatch {
+    pub candidate_id: usize,
+    pub score: f64,
+    pub positions: Vec<usize>,
+    pub string: String,
+}
+
+impl PartialEq for StringMatch {
+    fn eq(&self, other: &Self) -> bool {
+        self.cmp(other).is_eq()
+    }
+}
+
+impl Eq for StringMatch {}
+
+impl PartialOrd for StringMatch {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for StringMatch {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.score
+            .partial_cmp(&other.score)
+            .unwrap_or(Ordering::Equal)
+            .then_with(|| self.candidate_id.cmp(&other.candidate_id))
+    }
+}
+
+pub async fn match_strings(
+    candidates: &[StringMatchCandidate],
+    query: &str,
+    smart_case: bool,
+    max_results: usize,
+    cancel_flag: &AtomicBool,
+    background: Arc<executor::Background>,
+) -> Vec<StringMatch> {
+    if candidates.is_empty() || max_results == 0 {
+        return Default::default();
+    }
+
+    if query.is_empty() {
+        return candidates
+            .iter()
+            .map(|candidate| StringMatch {
+                candidate_id: candidate.id,
+                score: 0.,
+                positions: Default::default(),
+                string: candidate.string.clone(),
+            })
+            .collect();
+    }
+
+    let lowercase_query = query.to_lowercase().chars().collect::<Vec<_>>();
+    let query = query.chars().collect::<Vec<_>>();
+
+    let lowercase_query = &lowercase_query;
+    let query = &query;
+    let query_char_bag = CharBag::from(&lowercase_query[..]);
+
+    let num_cpus = background.num_cpus().min(candidates.len());
+    let segment_size = (candidates.len() + num_cpus - 1) / num_cpus;
+    let mut segment_results = (0..num_cpus)
+        .map(|_| Vec::with_capacity(max_results.min(candidates.len())))
+        .collect::<Vec<_>>();
+
+    background
+        .scoped(|scope| {
+            for (segment_idx, results) in segment_results.iter_mut().enumerate() {
+                let cancel_flag = &cancel_flag;
+                scope.spawn(async move {
+                    let segment_start = cmp::min(segment_idx * segment_size, candidates.len());
+                    let segment_end = cmp::min(segment_start + segment_size, candidates.len());
+                    let mut matcher = Matcher::new(
+                        query,
+                        lowercase_query,
+                        query_char_bag,
+                        smart_case,
+                        max_results,
+                    );
+
+                    matcher.match_candidates(
+                        &[],
+                        &[],
+                        candidates[segment_start..segment_end].iter(),
+                        results,
+                        cancel_flag,
+                        |candidate, score| StringMatch {
+                            candidate_id: candidate.id,
+                            score,
+                            positions: Vec::new(),
+                            string: candidate.string.to_string(),
+                        },
+                    );
+                });
+            }
+        })
+        .await;
+
+    let mut results = Vec::new();
+    for segment_result in segment_results {
+        if results.is_empty() {
+            results = segment_result;
+        } else {
+            util::extend_sorted(&mut results, segment_result, max_results, |a, b| b.cmp(a));
+        }
+    }
+    results
+}

crates/git/src/diff.rs

@@ -71,18 +71,26 @@ impl BufferDiff {
         }
     }
 
-    pub fn hunks_in_range<'a>(
+    pub fn hunks_in_row_range<'a>(
         &'a self,
-        query_row_range: Range<u32>,
+        range: Range<u32>,
         buffer: &'a BufferSnapshot,
         reversed: bool,
     ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
-        let start = buffer.anchor_before(Point::new(query_row_range.start, 0));
-        let end = buffer.anchor_after(Point::new(query_row_range.end, 0));
+        let start = buffer.anchor_before(Point::new(range.start, 0));
+        let end = buffer.anchor_after(Point::new(range.end, 0));
+        self.hunks_intersecting_range(start..end, buffer, reversed)
+    }
 
+    pub fn hunks_intersecting_range<'a>(
+        &'a self,
+        range: Range<Anchor>,
+        buffer: &'a BufferSnapshot,
+        reversed: bool,
+    ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
         let mut cursor = self.tree.filter::<_, DiffHunkSummary>(move |summary| {
-            let before_start = summary.buffer_range.end.cmp(&start, buffer).is_lt();
-            let after_end = summary.buffer_range.start.cmp(&end, buffer).is_gt();
+            let before_start = summary.buffer_range.end.cmp(&range.start, buffer).is_lt();
+            let after_end = summary.buffer_range.start.cmp(&range.end, buffer).is_gt();
             !before_start && !after_end
         });
 
@@ -141,7 +149,9 @@ impl BufferDiff {
 
     #[cfg(test)]
     fn hunks<'a>(&'a self, text: &'a BufferSnapshot) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
-        self.hunks_in_range(0..u32::MAX, text, false)
+        let start = text.anchor_before(Point::new(0, 0));
+        let end = text.anchor_after(Point::new(u32::MAX, u32::MAX));
+        self.hunks_intersecting_range(start..end, text, false)
     }
 
     fn diff<'a>(head: &'a str, current: &'a str) -> Option<GitPatch<'a>> {
@@ -355,7 +365,7 @@ mod tests {
         assert_eq!(diff.hunks(&buffer).count(), 8);
 
         assert_hunks(
-            diff.hunks_in_range(7..12, &buffer, false),
+            diff.hunks_in_row_range(7..12, &buffer, false),
             &buffer,
             &diff_base,
             &[

crates/gpui/Cargo.toml

@@ -45,7 +45,6 @@ smallvec = { version = "1.6", features = ["union"] }
 smol = "1.2"
 time = { version = "0.3", features = ["serde", "serde-well-known"] }
 tiny-skia = "0.5"
-tree-sitter = "0.20"
 usvg = "0.14"
 waker-fn = "1.1.0"
 

crates/gpui/build.rs

@@ -6,7 +6,6 @@ use std::{
 
 fn main() {
     generate_dispatch_bindings();
-    compile_context_predicate_parser();
     compile_metal_shaders();
     generate_shader_bindings();
 }
@@ -30,17 +29,6 @@ fn generate_dispatch_bindings() {
         .expect("couldn't write dispatch bindings");
 }
 
-fn compile_context_predicate_parser() {
-    let dir = PathBuf::from("./grammars/context-predicate/src");
-    let parser_c = dir.join("parser.c");
-
-    println!("cargo:rerun-if-changed={}", &parser_c.to_str().unwrap());
-    cc::Build::new()
-        .include(&dir)
-        .file(parser_c)
-        .compile("tree_sitter_context_predicate");
-}
-
 const SHADER_HEADER_PATH: &str = "./src/platform/mac/shaders/shaders.h";
 
 fn compile_metal_shaders() {
@@ -52,7 +40,7 @@ fn compile_metal_shaders() {
     println!("cargo:rerun-if-changed={}", shader_path);
 
     let output = Command::new("xcrun")
-        .args(&[
+        .args([
             "-sdk",
             "macosx",
             "metal",
@@ -76,7 +64,7 @@ fn compile_metal_shaders() {
     }
 
     let output = Command::new("xcrun")
-        .args(&["-sdk", "macosx", "metallib"])
+        .args(["-sdk", "macosx", "metallib"])
         .arg(air_output_path)
         .arg("-o")
         .arg(metallib_output_path)

crates/gpui/grammars/context-predicate/.gitignore

@@ -1,2 +0,0 @@
-/node_modules
-/build

crates/gpui/grammars/context-predicate/Cargo.toml

@@ -1,20 +0,0 @@
-[package]
-name = "tree-sitter-context-predicate"
-description = "context-predicate grammar for the tree-sitter parsing library"
-version = "0.0.1"
-keywords = ["incremental", "parsing", "context-predicate"]
-categories = ["parsing", "text-editors"]
-repository = "https://github.com/tree-sitter/tree-sitter-javascript"
-edition = "2021"
-license = "MIT"
-build = "bindings/rust/build.rs"
-include = ["bindings/rust/*", "grammar.js", "queries/*", "src/*"]
-
-[lib]
-path = "bindings/rust/lib.rs"
-
-[dependencies]
-tree-sitter = "0.20"
-
-[build-dependencies]
-cc = "1.0"

crates/gpui/grammars/context-predicate/binding.gyp

@@ -1,18 +0,0 @@
-{
-  "targets": [
-    {
-      "target_name": "tree_sitter_context_predicate_binding",
-      "include_dirs": [
-        "<!(node -e \"require('nan')\")",
-        "src"
-      ],
-      "sources": [
-        "src/parser.c",
-        "bindings/node/binding.cc"
-      ],
-      "cflags_c": [
-        "-std=c99",
-      ]
-    }
-  ]
-}

crates/gpui/grammars/context-predicate/bindings/node/binding.cc

@@ -1,30 +0,0 @@
-#include "nan.h"
-#include "tree_sitter/parser.h"
-#include <node.h>
-
-using namespace v8;
-
-extern "C" TSLanguage *tree_sitter_context_predicate();
-
-namespace {
-
-NAN_METHOD(New) {}
-
-void Init(Local<Object> exports, Local<Object> module) {
-  Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
-  tpl->SetClassName(Nan::New("Language").ToLocalChecked());
-  tpl->InstanceTemplate()->SetInternalFieldCount(1);
-
-  Local<Function> constructor = Nan::GetFunction(tpl).ToLocalChecked();
-  Local<Object> instance =
-      constructor->NewInstance(Nan::GetCurrentContext()).ToLocalChecked();
-  Nan::SetInternalFieldPointer(instance, 0, tree_sitter_context_predicate());
-
-  Nan::Set(instance, Nan::New("name").ToLocalChecked(),
-           Nan::New("context_predicate").ToLocalChecked());
-  Nan::Set(module, Nan::New("exports").ToLocalChecked(), instance);
-}
-
-NODE_MODULE(tree_sitter_context_predicate_binding, Init)
-
-} // namespace

crates/gpui/grammars/context-predicate/bindings/node/index.js

@@ -1,19 +0,0 @@
-try {
-  module.exports = require("../../build/Release/tree_sitter_context_predicate_binding");
-} catch (error1) {
-  if (error1.code !== 'MODULE_NOT_FOUND') {
-    throw error1;
-  }
-  try {
-    module.exports = require("../../build/Debug/tree_sitter_context_predicate_binding");
-  } catch (error2) {
-    if (error2.code !== 'MODULE_NOT_FOUND') {
-      throw error2;
-    }
-    throw error1
-  }
-}
-
-try {
-  module.exports.nodeTypeInfo = require("../../src/node-types.json");
-} catch (_) {}

crates/gpui/grammars/context-predicate/bindings/rust/build.rs

@@ -1,40 +0,0 @@
-fn main() {
-    let src_dir = std::path::Path::new("src");
-
-    let mut c_config = cc::Build::new();
-    c_config.include(&src_dir);
-    c_config
-        .flag_if_supported("-Wno-unused-parameter")
-        .flag_if_supported("-Wno-unused-but-set-variable")
-        .flag_if_supported("-Wno-trigraphs");
-    let parser_path = src_dir.join("parser.c");
-    c_config.file(&parser_path);
-
-    // If your language uses an external scanner written in C,
-    // then include this block of code:
-
-    /*
-    let scanner_path = src_dir.join("scanner.c");
-    c_config.file(&scanner_path);
-    println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap());
-    */
-
-    c_config.compile("parser");
-    println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap());
-
-    // If your language uses an external scanner written in C++,
-    // then include this block of code:
-
-    /*
-    let mut cpp_config = cc::Build::new();
-    cpp_config.cpp(true);
-    cpp_config.include(&src_dir);
-    cpp_config
-        .flag_if_supported("-Wno-unused-parameter")
-        .flag_if_supported("-Wno-unused-but-set-variable");
-    let scanner_path = src_dir.join("scanner.cc");
-    cpp_config.file(&scanner_path);
-    cpp_config.compile("scanner");
-    println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap());
-    */
-}

crates/gpui/grammars/context-predicate/bindings/rust/lib.rs

@@ -1,52 +0,0 @@
-//! This crate provides context_predicate language support for the [tree-sitter][] parsing library.
-//!
-//! Typically, you will use the [language][language func] function to add this language to a
-//! tree-sitter [Parser][], and then use the parser to parse some code:
-//!
-//! ```
-//! let code = "";
-//! let mut parser = tree_sitter::Parser::new();
-//! parser.set_language(tree_sitter_context_predicate::language()).expect("Error loading context_predicate grammar");
-//! let tree = parser.parse(code, None).unwrap();
-//! ```
-//!
-//! [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html
-//! [language func]: fn.language.html
-//! [Parser]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Parser.html
-//! [tree-sitter]: https://tree-sitter.github.io/
-
-use tree_sitter::Language;
-
-extern "C" {
-    fn tree_sitter_context_predicate() -> Language;
-}
-
-/// Get the tree-sitter [Language][] for this grammar.
-///
-/// [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html
-pub fn language() -> Language {
-    unsafe { tree_sitter_context_predicate() }
-}
-
-/// The content of the [`node-types.json`][] file for this grammar.
-///
-/// [`node-types.json`]: https://tree-sitter.github.io/tree-sitter/using-parsers#static-node-types
-pub const NODE_TYPES: &'static str = include_str!("../../src/node-types.json");
-
-// Uncomment these to include any queries that this grammar contains
-
-// pub const HIGHLIGHTS_QUERY: &'static str = include_str!("../../queries/highlights.scm");
-// pub const INJECTIONS_QUERY: &'static str = include_str!("../../queries/injections.scm");
-// pub const LOCALS_QUERY: &'static str = include_str!("../../queries/locals.scm");
-// pub const TAGS_QUERY: &'static str = include_str!("../../queries/tags.scm");
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn test_can_load_grammar() {
-        let mut parser = tree_sitter::Parser::new();
-        parser
-            .set_language(super::language())
-            .expect("Error loading context_predicate language");
-    }
-}

crates/gpui/grammars/context-predicate/corpus/expressions.txt

@@ -1,49 +0,0 @@
-==================
-Identifiers
-==================
-
-abc12
-
----
-
-(source (identifier))
-
-==================
-Negation
-==================
-
-!abc
-
----
-
-(source (not (identifier)))
-
-==================
-And/Or
-==================
-
-a || b && c && d
-
----
-
-(source
-  (or
-    (identifier)
-    (and
-      (and (identifier) (identifier))
-      (identifier))))
-
-==================
-Expressions
-==================
-
-a && (b == c || d != e)
-
----
-
-(source
-  (and
-    (identifier)
-    (parenthesized (or
-      (equal (identifier) (identifier))
-      (not_equal (identifier) (identifier))))))

crates/gpui/grammars/context-predicate/grammar.js

@@ -1,31 +0,0 @@
-module.exports = grammar({
-  name: 'context_predicate',
-
-  rules: {
-    source: $ => $._expression,
-
-    _expression: $ => choice(
-      $.identifier,
-      $.not,
-      $.and,
-      $.or,
-      $.equal,
-      $.not_equal,
-      $.parenthesized,
-    ),
-
-    identifier: $ => /[A-Za-z0-9_-]+/,
-
-    not: $ => prec(3, seq("!", field("expression", $._expression))),
-
-    and: $ => prec.left(2, seq(field("left", $._expression), "&&", field("right", $._expression))),
-
-    or: $ => prec.left(1, seq(field("left", $._expression), "||", field("right", $._expression))),
-
-    equal: $ => seq(field("left", $.identifier), "==", field("right", $.identifier)),
-
-    not_equal: $ => seq(field("left", $.identifier), "!=", field("right", $.identifier)),
-
-    parenthesized: $ => seq("(", field("expression", $._expression), ")"),
-  }
-});

crates/gpui/grammars/context-predicate/package-lock.json

@@ -1,44 +0,0 @@
-{
-  "name": "tree-sitter-context-predicate",
-  "lockfileVersion": 2,
-  "requires": true,
-  "packages": {
-    "": {
-      "name": "tree-sitter-context-predicate",
-      "dependencies": {
-        "nan": "^2.14.0"
-      },
-      "devDependencies": {
-        "tree-sitter-cli": "^0.19.5"
-      }
-    },
-    "node_modules/nan": {
-      "version": "2.14.2",
-      "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.2.tgz",
-      "integrity": "sha512-M2ufzIiINKCuDfBSAUr1vWQ+vuVcA9kqx8JJUsbQi6yf1uGRyb7HfpdfUr5qLXf3B/t8dPvcjhKMmlfnP47EzQ=="
-    },
-    "node_modules/tree-sitter-cli": {
-      "version": "0.19.5",
-      "resolved": "https://registry.npmjs.org/tree-sitter-cli/-/tree-sitter-cli-0.19.5.tgz",
-      "integrity": "sha512-kRzKrUAwpDN9AjA3b0tPBwT1hd8N2oQvvvHup2OEsX6mdsSMLmAvR+NSqK9fe05JrRbVvG8mbteNUQsxlMQohQ==",
-      "dev": true,
-      "hasInstallScript": true,
-      "bin": {
-        "tree-sitter": "cli.js"
-      }
-    }
-  },
-  "dependencies": {
-    "nan": {
-      "version": "2.14.2",
-      "resolved": "https://registry.npmjs.org/nan/-/nan-2.14.2.tgz",
-      "integrity": "sha512-M2ufzIiINKCuDfBSAUr1vWQ+vuVcA9kqx8JJUsbQi6yf1uGRyb7HfpdfUr5qLXf3B/t8dPvcjhKMmlfnP47EzQ=="
-    },
-    "tree-sitter-cli": {
-      "version": "0.19.5",
-      "resolved": "https://registry.npmjs.org/tree-sitter-cli/-/tree-sitter-cli-0.19.5.tgz",
-      "integrity": "sha512-kRzKrUAwpDN9AjA3b0tPBwT1hd8N2oQvvvHup2OEsX6mdsSMLmAvR+NSqK9fe05JrRbVvG8mbteNUQsxlMQohQ==",
-      "dev": true
-    }
-  }
-}

crates/gpui/grammars/context-predicate/package.json

@@ -1,10 +0,0 @@
-{
-  "name": "tree-sitter-context-predicate",
-  "main": "bindings/node",
-  "devDependencies": {
-    "tree-sitter-cli": "^0.19.5"
-  },
-  "dependencies": {
-    "nan": "^2.14.0"
-  }
-}

crates/gpui/grammars/context-predicate/src/grammar.json

@@ -1,208 +0,0 @@
-{
-  "name": "context_predicate",
-  "rules": {
-    "source": {
-      "type": "SYMBOL",
-      "name": "_expression"
-    },
-    "_expression": {
-      "type": "CHOICE",
-      "members": [
-        {
-          "type": "SYMBOL",
-          "name": "identifier"
-        },
-        {
-          "type": "SYMBOL",
-          "name": "not"
-        },
-        {
-          "type": "SYMBOL",
-          "name": "and"
-        },
-        {
-          "type": "SYMBOL",
-          "name": "or"
-        },
-        {
-          "type": "SYMBOL",
-          "name": "equal"
-        },
-        {
-          "type": "SYMBOL",
-          "name": "not_equal"
-        },
-        {
-          "type": "SYMBOL",
-          "name": "parenthesized"
-        }
-      ]
-    },
-    "identifier": {
-      "type": "PATTERN",
-      "value": "[A-Za-z0-9_-]+"
-    },
-    "not": {
-      "type": "PREC",
-      "value": 3,
-      "content": {
-        "type": "SEQ",
-        "members": [
-          {
-            "type": "STRING",
-            "value": "!"
-          },
-          {
-            "type": "FIELD",
-            "name": "expression",
-            "content": {
-              "type": "SYMBOL",
-              "name": "_expression"
-            }
-          }
-        ]
-      }
-    },
-    "and": {
-      "type": "PREC_LEFT",
-      "value": 2,
-      "content": {
-        "type": "SEQ",
-        "members": [
-          {
-            "type": "FIELD",
-            "name": "left",
-            "content": {
-              "type": "SYMBOL",
-              "name": "_expression"
-            }
-          },
-          {
-            "type": "STRING",
-            "value": "&&"
-          },
-          {
-            "type": "FIELD",
-            "name": "right",
-            "content": {
-              "type": "SYMBOL",
-              "name": "_expression"
-            }
-          }
-        ]
-      }
-    },
-    "or": {
-      "type": "PREC_LEFT",
-      "value": 1,
-      "content": {
-        "type": "SEQ",
-        "members": [
-          {
-            "type": "FIELD",
-            "name": "left",
-            "content": {
-              "type": "SYMBOL",
-              "name": "_expression"
-            }
-          },
-          {
-            "type": "STRING",
-            "value": "||"
-          },
-          {
-            "type": "FIELD",
-            "name": "right",
-            "content": {
-              "type": "SYMBOL",
-              "name": "_expression"
-            }
-          }
-        ]
-      }
-    },
-    "equal": {
-      "type": "SEQ",
-      "members": [
-        {
-          "type": "FIELD",
-          "name": "left",
-          "content": {
-            "type": "SYMBOL",
-            "name": "identifier"
-          }
-        },
-        {
-          "type": "STRING",
-          "value": "=="
-        },
-        {
-          "type": "FIELD",
-          "name": "right",
-          "content": {
-            "type": "SYMBOL",
-            "name": "identifier"
-          }
-        }
-      ]
-    },
-    "not_equal": {
-      "type": "SEQ",
-      "members": [
-        {
-          "type": "FIELD",
-          "name": "left",
-          "content": {
-            "type": "SYMBOL",
-            "name": "identifier"
-          }
-        },
-        {
-          "type": "STRING",
-          "value": "!="
-        },
-        {
-          "type": "FIELD",
-          "name": "right",
-          "content": {
-            "type": "SYMBOL",
-            "name": "identifier"
-          }
-        }
-      ]
-    },
-    "parenthesized": {
-      "type": "SEQ",
-      "members": [
-        {
-          "type": "STRING",
-          "value": "("
-        },
-        {
-          "type": "FIELD",
-          "name": "expression",
-          "content": {
-            "type": "SYMBOL",
-            "name": "_expression"
-          }
-        },
-        {
-          "type": "STRING",
-          "value": ")"
-        }
-      ]
-    }
-  },
-  "extras": [
-    {
-      "type": "PATTERN",
-      "value": "\\s"
-    }
-  ],
-  "conflicts": [],
-  "precedences": [],
-  "externals": [],
-  "inline": [],
-  "supertypes": []
-}
-

crates/gpui/grammars/context-predicate/src/node-types.json

@@ -1,353 +0,0 @@
-[
-  {
-    "type": "and",
-    "named": true,
-    "fields": {
-      "left": {
-        "multiple": false,
-        "required": true,
-        "types": [
-          {
-            "type": "and",
-            "named": true
-          },
-          {
-            "type": "equal",
-            "named": true
-          },
-          {
-            "type": "identifier",
-            "named": true
-          },
-          {
-            "type": "not",
-            "named": true
-          },
-          {
-            "type": "not_equal",
-            "named": true
-          },
-          {
-            "type": "or",
-            "named": true
-          },
-          {
-            "type": "parenthesized",
-            "named": true
-          }
-        ]
-      },
-      "right": {
-        "multiple": false,
-        "required": true,
-        "types": [
-          {
-            "type": "and",
-            "named": true
-          },
-          {
-            "type": "equal",
-            "named": true
-          },
-          {
-            "type": "identifier",
-            "named": true
-          },
-          {
-            "type": "not",
-            "named": true
-          },
-          {
-            "type": "not_equal",
-            "named": true
-          },
-          {
-            "type": "or",
-            "named": true
-          },
-          {
-            "type": "parenthesized",
-            "named": true
-          }
-        ]
-      }
-    }
-  },
-  {
-    "type": "equal",
-    "named": true,
-    "fields": {
-      "left": {
-        "multiple": false,
-        "required": true,
-        "types": [
-          {
-            "type": "identifier",
-            "named": true
-          }
-        ]
-      },
-      "right": {
-        "multiple": false,
-        "required": true,
-        "types": [
-          {
-            "type": "identifier",
-            "named": true
-          }
-        ]
-      }
-    }
-  },
-  {
-    "type": "not",
-    "named": true,
-    "fields": {
-      "expression": {
-        "multiple": false,
-        "required": true,
-        "types": [
-          {
-            "type": "and",
-            "named": true
-          },
-          {
-            "type": "equal",
-            "named": true
-          },
-          {
-            "type": "identifier",
-            "named": true
-          },
-          {
-            "type": "not",
-            "named": true
-          },
-          {
-            "type": "not_equal",
-            "named": true
-          },
-          {
-            "type": "or",
-            "named": true
-          },
-          {
-            "type": "parenthesized",
-            "named": true
-          }
-        ]
-      }
-    }
-  },
-  {
-    "type": "not_equal",
-    "named": true,
-    "fields": {
-      "left": {
-        "multiple": false,
-        "required": true,
-        "types": [
-          {
-            "type": "identifier",
-            "named": true
-          }
-        ]
-      },
-      "right": {
-        "multiple": false,
-        "required": true,
-        "types": [
-          {
-            "type": "identifier",
-            "named": true
-          }
-        ]
-      }
-    }
-  },
-  {
-    "type": "or",
-    "named": true,
-    "fields": {
-      "left": {
-        "multiple": false,
-        "required": true,
-        "types": [
-          {
-            "type": "and",
-            "named": true
-          },
-          {
-            "type": "equal",
-            "named": true
-          },
-          {
-            "type": "identifier",
-            "named": true
-          },
-          {
-            "type": "not",
-            "named": true
-          },
-          {
-            "type": "not_equal",
-            "named": true
-          },
-          {
-            "type": "or",
-            "named": true
-          },
-          {
-            "type": "parenthesized",
-            "named": true
-          }
-        ]
-      },
-      "right": {
-        "multiple": false,
-        "required": true,
-        "types": [
-          {
-            "type": "and",
-            "named": true
-          },
-          {
-            "type": "equal",
-            "named": true
-          },
-          {
-            "type": "identifier",
-            "named": true
-          },
-          {
-            "type": "not",
-            "named": true
-          },
-          {
-            "type": "not_equal",
-            "named": true
-          },
-          {
-            "type": "or",
-            "named": true
-          },
-          {
-            "type": "parenthesized",
-            "named": true
-          }
-        ]
-      }
-    }
-  },
-  {
-    "type": "parenthesized",
-    "named": true,
-    "fields": {
-      "expression": {
-        "multiple": false,
-        "required": true,
-        "types": [
-          {
-            "type": "and",
-            "named": true
-          },
-          {
-            "type": "equal",
-            "named": true
-          },
-          {
-            "type": "identifier",
-            "named": true
-          },
-          {
-            "type": "not",
-            "named": true
-          },
-          {
-            "type": "not_equal",
-            "named": true
-          },
-          {
-            "type": "or",
-            "named": true
-          },
-          {
-            "type": "parenthesized",
-            "named": true
-          }
-        ]
-      }
-    }
-  },
-  {
-    "type": "source",
-    "named": true,
-    "fields": {},
-    "children": {
-      "multiple": false,
-      "required": true,
-      "types": [
-        {
-          "type": "and",
-          "named": true
-        },
-        {
-          "type": "equal",
-          "named": true
-        },
-        {
-          "type": "identifier",
-          "named": true
-        },
-        {
-          "type": "not",
-          "named": true
-        },
-        {
-          "type": "not_equal",
-          "named": true
-        },
-        {
-          "type": "or",
-          "named": true
-        },
-        {
-          "type": "parenthesized",
-          "named": true
-        }
-      ]
-    }
-  },
-  {
-    "type": "!",
-    "named": false
-  },
-  {
-    "type": "!=",
-    "named": false
-  },
-  {
-    "type": "&&",
-    "named": false
-  },
-  {
-    "type": "(",
-    "named": false
-  },
-  {
-    "type": ")",
-    "named": false
-  },
-  {
-    "type": "==",
-    "named": false
-  },
-  {
-    "type": "identifier",
-    "named": true
-  },
-  {
-    "type": "||",
-    "named": false
-  }
-]

crates/gpui/grammars/context-predicate/src/parser.c

@@ -1,584 +0,0 @@
-#include <tree_sitter/parser.h>
-
-#if defined(__GNUC__) || defined(__clang__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-#endif
-
-#define LANGUAGE_VERSION 13
-#define STATE_COUNT 18
-#define LARGE_STATE_COUNT 6
-#define SYMBOL_COUNT 17
-#define ALIAS_COUNT 0
-#define TOKEN_COUNT 9
-#define EXTERNAL_TOKEN_COUNT 0
-#define FIELD_COUNT 3
-#define MAX_ALIAS_SEQUENCE_LENGTH 3
-#define PRODUCTION_ID_COUNT 3
-
-enum {
-  sym_identifier = 1,
-  anon_sym_BANG = 2,
-  anon_sym_AMP_AMP = 3,
-  anon_sym_PIPE_PIPE = 4,
-  anon_sym_EQ_EQ = 5,
-  anon_sym_BANG_EQ = 6,
-  anon_sym_LPAREN = 7,
-  anon_sym_RPAREN = 8,
-  sym_source = 9,
-  sym__expression = 10,
-  sym_not = 11,
-  sym_and = 12,
-  sym_or = 13,
-  sym_equal = 14,
-  sym_not_equal = 15,
-  sym_parenthesized = 16,
-};
-
-static const char *const ts_symbol_names[] = {
-    [ts_builtin_sym_end] = "end",
-    [sym_identifier] = "identifier",
-    [anon_sym_BANG] = "!",
-    [anon_sym_AMP_AMP] = "&&",
-    [anon_sym_PIPE_PIPE] = "||",
-    [anon_sym_EQ_EQ] = "==",
-    [anon_sym_BANG_EQ] = "!=",
-    [anon_sym_LPAREN] = "(",
-    [anon_sym_RPAREN] = ")",
-    [sym_source] = "source",
-    [sym__expression] = "_expression",
-    [sym_not] = "not",
-    [sym_and] = "and",
-    [sym_or] = "or",
-    [sym_equal] = "equal",
-    [sym_not_equal] = "not_equal",
-    [sym_parenthesized] = "parenthesized",
-};
-
-static const TSSymbol ts_symbol_map[] = {
-    [ts_builtin_sym_end] = ts_builtin_sym_end,
-    [sym_identifier] = sym_identifier,
-    [anon_sym_BANG] = anon_sym_BANG,
-    [anon_sym_AMP_AMP] = anon_sym_AMP_AMP,
-    [anon_sym_PIPE_PIPE] = anon_sym_PIPE_PIPE,
-    [anon_sym_EQ_EQ] = anon_sym_EQ_EQ,
-    [anon_sym_BANG_EQ] = anon_sym_BANG_EQ,
-    [anon_sym_LPAREN] = anon_sym_LPAREN,
-    [anon_sym_RPAREN] = anon_sym_RPAREN,
-    [sym_source] = sym_source,
-    [sym__expression] = sym__expression,
-    [sym_not] = sym_not,
-    [sym_and] = sym_and,
-    [sym_or] = sym_or,
-    [sym_equal] = sym_equal,
-    [sym_not_equal] = sym_not_equal,
-    [sym_parenthesized] = sym_parenthesized,
-};
-
-static const TSSymbolMetadata ts_symbol_metadata[] = {
-    [ts_builtin_sym_end] =
-        {
-            .visible = false,
-            .named = true,
-        },
-    [sym_identifier] =
-        {
-            .visible = true,
-            .named = true,
-        },
-    [anon_sym_BANG] =
-        {
-            .visible = true,
-            .named = false,
-        },
-    [anon_sym_AMP_AMP] =
-        {
-            .visible = true,
-            .named = false,
-        },
-    [anon_sym_PIPE_PIPE] =
-        {
-            .visible = true,
-            .named = false,
-        },
-    [anon_sym_EQ_EQ] =
-        {
-            .visible = true,
-            .named = false,
-        },
-    [anon_sym_BANG_EQ] =
-        {
-            .visible = true,
-            .named = false,
-        },
-    [anon_sym_LPAREN] =
-        {
-            .visible = true,
-            .named = false,
-        },
-    [anon_sym_RPAREN] =
-        {
-            .visible = true,
-            .named = false,
-        },
-    [sym_source] =
-        {
-            .visible = true,
-            .named = true,
-        },
-    [sym__expression] =
-        {
-            .visible = false,
-            .named = true,
-        },
-    [sym_not] =
-        {
-            .visible = true,
-            .named = true,
-        },
-    [sym_and] =
-        {
-            .visible = true,
-            .named = true,
-        },
-    [sym_or] =
-        {
-            .visible = true,
-            .named = true,
-        },
-    [sym_equal] =
-        {
-            .visible = true,
-            .named = true,
-        },
-    [sym_not_equal] =
-        {
-            .visible = true,
-            .named = true,
-        },
-    [sym_parenthesized] =
-        {
-            .visible = true,
-            .named = true,
-        },
-};
-
-enum {
-  field_expression = 1,
-  field_left = 2,
-  field_right = 3,
-};
-
-static const char *const ts_field_names[] = {
-    [0] = NULL,
-    [field_expression] = "expression",
-    [field_left] = "left",
-    [field_right] = "right",
-};
-
-static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = {
-    [1] = {.index = 0, .length = 1},
-    [2] = {.index = 1, .length = 2},
-};
-
-static const TSFieldMapEntry ts_field_map_entries[] = {
-    [0] = {field_expression, 1},
-    [1] = {field_left, 0},
-    {field_right, 2},
-};
-
-static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT]
-                                        [MAX_ALIAS_SEQUENCE_LENGTH] = {
-                                            [0] = {0},
-};
-
-static const uint16_t ts_non_terminal_alias_map[] = {
-    0,
-};
-
-static bool ts_lex(TSLexer *lexer, TSStateId state) {
-  START_LEXER();
-  eof = lexer->eof(lexer);
-  switch (state) {
-  case 0:
-    if (eof)
-      ADVANCE(7);
-    if (lookahead == '!')
-      ADVANCE(10);
-    if (lookahead == '&')
-      ADVANCE(2);
-    if (lookahead == '(')
-      ADVANCE(15);
-    if (lookahead == ')')
-      ADVANCE(16);
-    if (lookahead == '=')
-      ADVANCE(4);
-    if (lookahead == '|')
-      ADVANCE(5);
-    if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' ||
-        lookahead == ' ')
-      SKIP(0)
-    if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') ||
-        ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' ||
-        ('a' <= lookahead && lookahead <= 'z'))
-      ADVANCE(8);
-    END_STATE();
-  case 1:
-    if (lookahead == '!')
-      ADVANCE(9);
-    if (lookahead == '(')
-      ADVANCE(15);
-    if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' ||
-        lookahead == ' ')
-      SKIP(1)
-    if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') ||
-        ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' ||
-        ('a' <= lookahead && lookahead <= 'z'))
-      ADVANCE(8);
-    END_STATE();
-  case 2:
-    if (lookahead == '&')
-      ADVANCE(11);
-    END_STATE();
-  case 3:
-    if (lookahead == '=')
-      ADVANCE(14);
-    END_STATE();
-  case 4:
-    if (lookahead == '=')
-      ADVANCE(13);
-    END_STATE();
-  case 5:
-    if (lookahead == '|')
-      ADVANCE(12);
-    END_STATE();
-  case 6:
-    if (eof)
-      ADVANCE(7);
-    if (lookahead == '!')
-      ADVANCE(3);
-    if (lookahead == '&')
-      ADVANCE(2);
-    if (lookahead == ')')
-      ADVANCE(16);
-    if (lookahead == '=')
-      ADVANCE(4);
-    if (lookahead == '|')
-      ADVANCE(5);
-    if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' ||
-        lookahead == ' ')
-      SKIP(6)
-    END_STATE();
-  case 7:
-    ACCEPT_TOKEN(ts_builtin_sym_end);
-    END_STATE();
-  case 8:
-    ACCEPT_TOKEN(sym_identifier);
-    if (lookahead == '-' || ('0' <= lookahead && lookahead <= '9') ||
-        ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' ||
-        ('a' <= lookahead && lookahead <= 'z'))
-      ADVANCE(8);
-    END_STATE();
-  case 9:
-    ACCEPT_TOKEN(anon_sym_BANG);
-    END_STATE();
-  case 10:
-    ACCEPT_TOKEN(anon_sym_BANG);
-    if (lookahead == '=')
-      ADVANCE(14);
-    END_STATE();
-  case 11:
-    ACCEPT_TOKEN(anon_sym_AMP_AMP);
-    END_STATE();
-  case 12:
-    ACCEPT_TOKEN(anon_sym_PIPE_PIPE);
-    END_STATE();
-  case 13:
-    ACCEPT_TOKEN(anon_sym_EQ_EQ);
-    END_STATE();
-  case 14:
-    ACCEPT_TOKEN(anon_sym_BANG_EQ);
-    END_STATE();
-  case 15:
-    ACCEPT_TOKEN(anon_sym_LPAREN);
-    END_STATE();
-  case 16:
-    ACCEPT_TOKEN(anon_sym_RPAREN);
-    END_STATE();
-  default:
-    return false;
-  }
-}
-
-static const TSLexMode ts_lex_modes[STATE_COUNT] = {
-    [0] = {.lex_state = 0},  [1] = {.lex_state = 1},  [2] = {.lex_state = 1},
-    [3] = {.lex_state = 1},  [4] = {.lex_state = 1},  [5] = {.lex_state = 1},
-    [6] = {.lex_state = 6},  [7] = {.lex_state = 0},  [8] = {.lex_state = 0},
-    [9] = {.lex_state = 0},  [10] = {.lex_state = 0}, [11] = {.lex_state = 0},
-    [12] = {.lex_state = 0}, [13] = {.lex_state = 0}, [14] = {.lex_state = 0},
-    [15] = {.lex_state = 0}, [16] = {.lex_state = 0}, [17] = {.lex_state = 0},
-};
-
-static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = {
-    [0] =
-        {
-            [ts_builtin_sym_end] = ACTIONS(1),
-            [sym_identifier] = ACTIONS(1),
-            [anon_sym_BANG] = ACTIONS(1),
-            [anon_sym_AMP_AMP] = ACTIONS(1),
-            [anon_sym_PIPE_PIPE] = ACTIONS(1),
-            [anon_sym_EQ_EQ] = ACTIONS(1),
-            [anon_sym_BANG_EQ] = ACTIONS(1),
-            [anon_sym_LPAREN] = ACTIONS(1),
-            [anon_sym_RPAREN] = ACTIONS(1),
-        },
-    [1] =
-        {
-            [sym_source] = STATE(15),
-            [sym__expression] = STATE(13),
-            [sym_not] = STATE(13),
-            [sym_and] = STATE(13),
-            [sym_or] = STATE(13),
-            [sym_equal] = STATE(13),
-            [sym_not_equal] = STATE(13),
-            [sym_parenthesized] = STATE(13),
-            [sym_identifier] = ACTIONS(3),
-            [anon_sym_BANG] = ACTIONS(5),
-            [anon_sym_LPAREN] = ACTIONS(7),
-        },
-    [2] =
-        {
-            [sym__expression] = STATE(7),
-            [sym_not] = STATE(7),
-            [sym_and] = STATE(7),
-            [sym_or] = STATE(7),
-            [sym_equal] = STATE(7),
-            [sym_not_equal] = STATE(7),
-            [sym_parenthesized] = STATE(7),
-            [sym_identifier] = ACTIONS(3),
-            [anon_sym_BANG] = ACTIONS(5),
-            [anon_sym_LPAREN] = ACTIONS(7),
-        },
-    [3] =
-        {
-            [sym__expression] = STATE(14),
-            [sym_not] = STATE(14),
-            [sym_and] = STATE(14),
-            [sym_or] = STATE(14),
-            [sym_equal] = STATE(14),
-            [sym_not_equal] = STATE(14),
-            [sym_parenthesized] = STATE(14),
-            [sym_identifier] = ACTIONS(3),
-            [anon_sym_BANG] = ACTIONS(5),
-            [anon_sym_LPAREN] = ACTIONS(7),
-        },
-    [4] =
-        {
-            [sym__expression] = STATE(11),
-            [sym_not] = STATE(11),
-            [sym_and] = STATE(11),
-            [sym_or] = STATE(11),
-            [sym_equal] = STATE(11),
-            [sym_not_equal] = STATE(11),
-            [sym_parenthesized] = STATE(11),
-            [sym_identifier] = ACTIONS(3),
-            [anon_sym_BANG] = ACTIONS(5),
-            [anon_sym_LPAREN] = ACTIONS(7),
-        },
-    [5] =
-        {
-            [sym__expression] = STATE(12),
-            [sym_not] = STATE(12),
-            [sym_and] = STATE(12),
-            [sym_or] = STATE(12),
-            [sym_equal] = STATE(12),
-            [sym_not_equal] = STATE(12),
-            [sym_parenthesized] = STATE(12),
-            [sym_identifier] = ACTIONS(3),
-            [anon_sym_BANG] = ACTIONS(5),
-            [anon_sym_LPAREN] = ACTIONS(7),
-        },
-};
-
-static const uint16_t ts_small_parse_table[] = {
-    [0] = 3,
-    ACTIONS(11),
-    1,
-    anon_sym_EQ_EQ,
-    ACTIONS(13),
-    1,
-    anon_sym_BANG_EQ,
-    ACTIONS(9),
-    4,
-    ts_builtin_sym_end,
-    anon_sym_AMP_AMP,
-    anon_sym_PIPE_PIPE,
-    anon_sym_RPAREN,
-    [13] = 1,
-    ACTIONS(15),
-    4,
-    ts_builtin_sym_end,
-    anon_sym_AMP_AMP,
-    anon_sym_PIPE_PIPE,
-    anon_sym_RPAREN,
-    [20] = 1,
-    ACTIONS(17),
-    4,
-    ts_builtin_sym_end,
-    anon_sym_AMP_AMP,
-    anon_sym_PIPE_PIPE,
-    anon_sym_RPAREN,
-    [27] = 1,
-    ACTIONS(19),
-    4,
-    ts_builtin_sym_end,
-    anon_sym_AMP_AMP,
-    anon_sym_PIPE_PIPE,
-    anon_sym_RPAREN,
-    [34] = 1,
-    ACTIONS(21),
-    4,
-    ts_builtin_sym_end,
-    anon_sym_AMP_AMP,
-    anon_sym_PIPE_PIPE,
-    anon_sym_RPAREN,
-    [41] = 1,
-    ACTIONS(23),
-    4,
-    ts_builtin_sym_end,
-    anon_sym_AMP_AMP,
-    anon_sym_PIPE_PIPE,
-    anon_sym_RPAREN,
-    [48] = 2,
-    ACTIONS(27),
-    1,
-    anon_sym_AMP_AMP,
-    ACTIONS(25),
-    3,
-    ts_builtin_sym_end,
-    anon_sym_PIPE_PIPE,
-    anon_sym_RPAREN,
-    [57] = 3,
-    ACTIONS(27),
-    1,
-    anon_sym_AMP_AMP,
-    ACTIONS(29),
-    1,
-    ts_builtin_sym_end,
-    ACTIONS(31),
-    1,
-    anon_sym_PIPE_PIPE,
-    [67] = 3,
-    ACTIONS(27),
-    1,
-    anon_sym_AMP_AMP,
-    ACTIONS(31),
-    1,
-    anon_sym_PIPE_PIPE,
-    ACTIONS(33),
-    1,
-    anon_sym_RPAREN,
-    [77] = 1,
-    ACTIONS(35),
-    1,
-    ts_builtin_sym_end,
-    [81] = 1,
-    ACTIONS(37),
-    1,
-    sym_identifier,
-    [85] = 1,
-    ACTIONS(39),
-    1,
-    sym_identifier,
-};
-
-static const uint32_t ts_small_parse_table_map[] = {
-    [SMALL_STATE(6)] = 0,   [SMALL_STATE(7)] = 13,  [SMALL_STATE(8)] = 20,
-    [SMALL_STATE(9)] = 27,  [SMALL_STATE(10)] = 34, [SMALL_STATE(11)] = 41,
-    [SMALL_STATE(12)] = 48, [SMALL_STATE(13)] = 57, [SMALL_STATE(14)] = 67,
-    [SMALL_STATE(15)] = 77, [SMALL_STATE(16)] = 81, [SMALL_STATE(17)] = 85,
-};
-
-static const TSParseActionEntry ts_parse_actions[] = {
-    [0] = {.entry = {.count = 0, .reusable = false}},
-    [1] = {.entry = {.count = 1, .reusable = false}},
-    RECOVER(),
-    [3] = {.entry = {.count = 1, .reusable = true}},
-    SHIFT(6),
-    [5] = {.entry = {.count = 1, .reusable = true}},
-    SHIFT(2),
-    [7] = {.entry = {.count = 1, .reusable = true}},
-    SHIFT(3),
-    [9] = {.entry = {.count = 1, .reusable = true}},
-    REDUCE(sym__expression, 1),
-    [11] = {.entry = {.count = 1, .reusable = true}},
-    SHIFT(16),
-    [13] = {.entry = {.count = 1, .reusable = true}},
-    SHIFT(17),
-    [15] = {.entry = {.count = 1, .reusable = true}},
-    REDUCE(sym_not, 2, .production_id = 1),
-    [17] = {.entry = {.count = 1, .reusable = true}},
-    REDUCE(sym_equal, 3, .production_id = 2),
-    [19] = {.entry = {.count = 1, .reusable = true}},
-    REDUCE(sym_not_equal, 3, .production_id = 2),
-    [21] = {.entry = {.count = 1, .reusable = true}},
-    REDUCE(sym_parenthesized, 3, .production_id = 1),
-    [23] = {.entry = {.count = 1, .reusable = true}},
-    REDUCE(sym_and, 3, .production_id = 2),
-    [25] = {.entry = {.count = 1, .reusable = true}},
-    REDUCE(sym_or, 3, .production_id = 2),
-    [27] = {.entry = {.count = 1, .reusable = true}},
-    SHIFT(4),
-    [29] = {.entry = {.count = 1, .reusable = true}},
-    REDUCE(sym_source, 1),
-    [31] = {.entry = {.count = 1, .reusable = true}},
-    SHIFT(5),
-    [33] = {.entry = {.count = 1, .reusable = true}},
-    SHIFT(10),
-    [35] = {.entry = {.count = 1, .reusable = true}},
-    ACCEPT_INPUT(),
-    [37] = {.entry = {.count = 1, .reusable = true}},
-    SHIFT(8),
-    [39] = {.entry = {.count = 1, .reusable = true}},
-    SHIFT(9),
-};
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-#ifdef _WIN32
-#define extern __declspec(dllexport)
-#endif
-
-extern const TSLanguage *tree_sitter_context_predicate(void) {
-  static const TSLanguage language = {
-      .version = LANGUAGE_VERSION,
-      .symbol_count = SYMBOL_COUNT,
-      .alias_count = ALIAS_COUNT,
-      .token_count = TOKEN_COUNT,
-      .external_token_count = EXTERNAL_TOKEN_COUNT,
-      .state_count = STATE_COUNT,
-      .large_state_count = LARGE_STATE_COUNT,
-      .production_id_count = PRODUCTION_ID_COUNT,
-      .field_count = FIELD_COUNT,
-      .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH,
-      .parse_table = &ts_parse_table[0][0],
-      .small_parse_table = ts_small_parse_table,
-      .small_parse_table_map = ts_small_parse_table_map,
-      .parse_actions = ts_parse_actions,
-      .symbol_names = ts_symbol_names,
-      .field_names = ts_field_names,
-      .field_map_slices = ts_field_map_slices,
-      .field_map_entries = ts_field_map_entries,
-      .symbol_metadata = ts_symbol_metadata,
-      .public_symbol_map = ts_symbol_map,
-      .alias_map = ts_non_terminal_alias_map,
-      .alias_sequences = &ts_alias_sequences[0][0],
-      .lex_modes = ts_lex_modes,
-      .lex_fn = ts_lex,
-  };
-  return &language;
-}
-#ifdef __cplusplus
-}
-#endif

crates/gpui/grammars/context-predicate/src/tree_sitter/parser.h

@@ -1,223 +0,0 @@
-#ifndef TREE_SITTER_PARSER_H_
-#define TREE_SITTER_PARSER_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include <stdbool.h>
-#include <stdint.h>
-#include <stdlib.h>
-
-#define ts_builtin_sym_error ((TSSymbol)-1)
-#define ts_builtin_sym_end 0
-#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
-
-typedef uint16_t TSStateId;
-
-#ifndef TREE_SITTER_API_H_
-typedef uint16_t TSSymbol;
-typedef uint16_t TSFieldId;
-typedef struct TSLanguage TSLanguage;
-#endif
-
-typedef struct {
-  TSFieldId field_id;
-  uint8_t child_index;
-  bool inherited;
-} TSFieldMapEntry;
-
-typedef struct {
-  uint16_t index;
-  uint16_t length;
-} TSFieldMapSlice;
-
-typedef struct {
-  bool visible;
-  bool named;
-  bool supertype;
-} TSSymbolMetadata;
-
-typedef struct TSLexer TSLexer;
-
-struct TSLexer {
-  int32_t lookahead;
-  TSSymbol result_symbol;
-  void (*advance)(TSLexer *, bool);
-  void (*mark_end)(TSLexer *);
-  uint32_t (*get_column)(TSLexer *);
-  bool (*is_at_included_range_start)(const TSLexer *);
-  bool (*eof)(const TSLexer *);
-};
-
-typedef enum {
-  TSParseActionTypeShift,
-  TSParseActionTypeReduce,
-  TSParseActionTypeAccept,
-  TSParseActionTypeRecover,
-} TSParseActionType;
-
-typedef union {
-  struct {
-    uint8_t type;
-    TSStateId state;
-    bool extra;
-    bool repetition;
-  } shift;
-  struct {
-    uint8_t type;
-    uint8_t child_count;
-    TSSymbol symbol;
-    int16_t dynamic_precedence;
-    uint16_t production_id;
-  } reduce;
-  uint8_t type;
-} TSParseAction;
-
-typedef struct {
-  uint16_t lex_state;
-  uint16_t external_lex_state;
-} TSLexMode;
-
-typedef union {
-  TSParseAction action;
-  struct {
-    uint8_t count;
-    bool reusable;
-  } entry;
-} TSParseActionEntry;
-
-struct TSLanguage {
-  uint32_t version;
-  uint32_t symbol_count;
-  uint32_t alias_count;
-  uint32_t token_count;
-  uint32_t external_token_count;
-  uint32_t state_count;
-  uint32_t large_state_count;
-  uint32_t production_id_count;
-  uint32_t field_count;
-  uint16_t max_alias_sequence_length;
-  const uint16_t *parse_table;
-  const uint16_t *small_parse_table;
-  const uint32_t *small_parse_table_map;
-  const TSParseActionEntry *parse_actions;
-  const char * const *symbol_names;
-  const char * const *field_names;
-  const TSFieldMapSlice *field_map_slices;
-  const TSFieldMapEntry *field_map_entries;
-  const TSSymbolMetadata *symbol_metadata;
-  const TSSymbol *public_symbol_map;
-  const uint16_t *alias_map;
-  const TSSymbol *alias_sequences;
-  const TSLexMode *lex_modes;
-  bool (*lex_fn)(TSLexer *, TSStateId);
-  bool (*keyword_lex_fn)(TSLexer *, TSStateId);
-  TSSymbol keyword_capture_token;
-  struct {
-    const bool *states;
-    const TSSymbol *symbol_map;
-    void *(*create)(void);
-    void (*destroy)(void *);
-    bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist);
-    unsigned (*serialize)(void *, char *);
-    void (*deserialize)(void *, const char *, unsigned);
-  } external_scanner;
-};
-
-/*
- *  Lexer Macros
- */
-
-#define START_LEXER()           \
-  bool result = false;          \
-  bool skip = false;            \
-  bool eof = false;             \
-  int32_t lookahead;            \
-  goto start;                   \
-  next_state:                   \
-  lexer->advance(lexer, skip);  \
-  start:                        \
-  skip = false;                 \
-  lookahead = lexer->lookahead;
-
-#define ADVANCE(state_value) \
-  {                          \
-    state = state_value;     \
-    goto next_state;         \
-  }
-
-#define SKIP(state_value) \
-  {                       \
-    skip = true;          \
-    state = state_value;  \
-    goto next_state;      \
-  }
-
-#define ACCEPT_TOKEN(symbol_value)     \
-  result = true;                       \
-  lexer->result_symbol = symbol_value; \
-  lexer->mark_end(lexer);
-
-#define END_STATE() return result;
-
-/*
- *  Parse Table Macros
- */
-
-#define SMALL_STATE(id) id - LARGE_STATE_COUNT
-
-#define STATE(id) id
-
-#define ACTIONS(id) id
-
-#define SHIFT(state_value)            \
-  {{                                  \
-    .shift = {                        \
-      .type = TSParseActionTypeShift, \
-      .state = state_value            \
-    }                                 \
-  }}
-
-#define SHIFT_REPEAT(state_value)     \
-  {{                                  \
-    .shift = {                        \
-      .type = TSParseActionTypeShift, \
-      .state = state_value,           \
-      .repetition = true              \
-    }                                 \
-  }}
-
-#define SHIFT_EXTRA()                 \
-  {{                                  \
-    .shift = {                        \
-      .type = TSParseActionTypeShift, \
-      .extra = true                   \
-    }                                 \
-  }}
-
-#define REDUCE(symbol_val, child_count_val, ...) \
-  {{                                             \
-    .reduce = {                                  \
-      .type = TSParseActionTypeReduce,           \
-      .symbol = symbol_val,                      \
-      .child_count = child_count_val,            \
-      __VA_ARGS__                                \
-    },                                           \
-  }}
-
-#define RECOVER()                    \
-  {{                                 \
-    .type = TSParseActionTypeRecover \
-  }}
-
-#define ACCEPT_INPUT()              \
-  {{                                \
-    .type = TSParseActionTypeAccept \
-  }}
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif  // TREE_SITTER_PARSER_H_

crates/gpui/src/app/callback_collection.rs

@@ -1,19 +1,44 @@
+use crate::MutableAppContext;
+use collections::{BTreeMap, HashMap, HashSet};
+use parking_lot::Mutex;
 use std::sync::Arc;
 use std::{hash::Hash, sync::Weak};
 
-use parking_lot::Mutex;
-
-use collections::{btree_map, BTreeMap, HashMap};
-
-use crate::MutableAppContext;
-
-pub type Mapping<K, F> = Mutex<HashMap<K, BTreeMap<usize, Option<F>>>>;
-
-pub struct CallbackCollection<K: Hash + Eq, F> {
-    internal: Arc<Mapping<K, F>>,
+pub struct CallbackCollection<K: Clone + Hash + Eq, F> {
+    internal: Arc<Mutex<Mapping<K, F>>>,
 }
 
-impl<K: Hash + Eq, F> Clone for CallbackCollection<K, F> {
+pub struct Subscription<K: Clone + Hash + Eq, F> {
+    key: K,
+    id: usize,
+    mapping: Option<Weak<Mutex<Mapping<K, F>>>>,
+}
+
+struct Mapping<K, F> {
+    callbacks: HashMap<K, BTreeMap<usize, F>>,
+    dropped_subscriptions: HashMap<K, HashSet<usize>>,
+}
+
+impl<K: Hash + Eq, F> Mapping<K, F> {
+    fn clear_dropped_state(&mut self, key: &K, subscription_id: usize) -> bool {
+        if let Some(subscriptions) = self.dropped_subscriptions.get_mut(&key) {
+            subscriptions.remove(&subscription_id)
+        } else {
+            false
+        }
+    }
+}
+
+impl<K, F> Default for Mapping<K, F> {
+    fn default() -> Self {
+        Self {
+            callbacks: Default::default(),
+            dropped_subscriptions: Default::default(),
+        }
+    }
+}
+
+impl<K: Clone + Hash + Eq, F> Clone for CallbackCollection<K, F> {
     fn clone(&self) -> Self {
         Self {
             internal: self.internal.clone(),
@@ -21,7 +46,7 @@ impl<K: Hash + Eq, F> Clone for CallbackCollection<K, F> {
     }
 }
 
-impl<K: Hash + Eq + Copy, F> Default for CallbackCollection<K, F> {
+impl<K: Clone + Hash + Eq + Copy, F> Default for CallbackCollection<K, F> {
     fn default() -> Self {
         CallbackCollection {
             internal: Arc::new(Mutex::new(Default::default())),
@@ -29,78 +54,114 @@ impl<K: Hash + Eq + Copy, F> Default for CallbackCollection<K, F> {
     }
 }
 
-impl<K: Hash + Eq + Copy, F> CallbackCollection<K, F> {
-    pub fn downgrade(&self) -> Weak<Mapping<K, F>> {
-        Arc::downgrade(&self.internal)
-    }
-
+impl<K: Clone + Hash + Eq + Copy, F> CallbackCollection<K, F> {
     #[cfg(test)]
     pub fn is_empty(&self) -> bool {
-        self.internal.lock().is_empty()
+        self.internal.lock().callbacks.is_empty()
     }
 
-    pub fn add_callback(&mut self, id: K, subscription_id: usize, callback: F) {
-        self.internal
-            .lock()
-            .entry(id)
-            .or_default()
-            .insert(subscription_id, Some(callback));
-    }
-
-    pub fn remove(&mut self, id: K) {
-        self.internal.lock().remove(&id);
-    }
-
-    pub fn add_or_remove_callback(&mut self, id: K, subscription_id: usize, callback: F) {
-        match self
-            .internal
-            .lock()
-            .entry(id)
-            .or_default()
-            .entry(subscription_id)
-        {
-            btree_map::Entry::Vacant(entry) => {
-                entry.insert(Some(callback));
-            }
-
-            btree_map::Entry::Occupied(entry) => {
-                // TODO: This seems like it should never be called because no code
-                // should ever attempt to remove an existing callback
-                debug_assert!(entry.get().is_none());
-                entry.remove();
-            }
+    pub fn subscribe(&mut self, key: K, subscription_id: usize) -> Subscription<K, F> {
+        Subscription {
+            key,
+            id: subscription_id,
+            mapping: Some(Arc::downgrade(&self.internal)),
         }
     }
 
-    pub fn emit_and_cleanup<C: FnMut(&mut F, &mut MutableAppContext) -> bool>(
+    pub fn add_callback(&mut self, key: K, subscription_id: usize, callback: F) {
+        let mut this = self.internal.lock();
+
+        // If this callback's subscription was dropped before the callback was
+        // added, then just drop the callback.
+        if this.clear_dropped_state(&key, subscription_id) {
+            return;
+        }
+
+        this.callbacks
+            .entry(key)
+            .or_default()
+            .insert(subscription_id, callback);
+    }
+
+    pub fn remove(&mut self, key: K) {
+        // Drop these callbacks after releasing the lock, in case one of them
+        // owns a subscription to this callback collection.
+        let mut this = self.internal.lock();
+        let callbacks = this.callbacks.remove(&key);
+        this.dropped_subscriptions.remove(&key);
+        drop(this);
+        drop(callbacks);
+    }
+
+    pub fn emit<C: FnMut(&mut F, &mut MutableAppContext) -> bool>(
         &mut self,
-        id: K,
+        key: K,
         cx: &mut MutableAppContext,
         mut call_callback: C,
     ) {
-        let callbacks = self.internal.lock().remove(&id);
+        let callbacks = self.internal.lock().callbacks.remove(&key);
         if let Some(callbacks) = callbacks {
-            for (subscription_id, callback) in callbacks {
-                if let Some(mut callback) = callback {
-                    let alive = call_callback(&mut callback, cx);
-                    if alive {
-                        match self
-                            .internal
-                            .lock()
-                            .entry(id)
-                            .or_default()
-                            .entry(subscription_id)
-                        {
-                            btree_map::Entry::Vacant(entry) => {
-                                entry.insert(Some(callback));
-                            }
-                            btree_map::Entry::Occupied(entry) => {
-                                entry.remove();
-                            }
-                        }
-                    }
+            for (subscription_id, mut callback) in callbacks {
+                // If this callback's subscription was dropped while invoking an
+                // earlier callback, then just drop the callback.
+                let mut this = self.internal.lock();
+                if this.clear_dropped_state(&key, subscription_id) {
+                    continue;
                 }
+
+                drop(this);
+                let alive = call_callback(&mut callback, cx);
+
+                // If this callback's subscription was dropped while invoking the callback
+                // itself, or if the callback returns false, then just drop the callback.
+                let mut this = self.internal.lock();
+                if this.clear_dropped_state(&key, subscription_id) || !alive {
+                    continue;
+                }
+
+                this.callbacks
+                    .entry(key)
+                    .or_default()
+                    .insert(subscription_id, callback);
             }
         }
     }
 }
+
+impl<K: Clone + Hash + Eq, F> Subscription<K, F> {
+    pub fn id(&self) -> usize {
+        self.id
+    }
+
+    pub fn detach(&mut self) {
+        self.mapping.take();
+    }
+}
+
+impl<K: Clone + Hash + Eq, F> Drop for Subscription<K, F> {
+    fn drop(&mut self) {
+        if let Some(mapping) = self.mapping.as_ref().and_then(|mapping| mapping.upgrade()) {
+            let mut mapping = mapping.lock();
+
+            // If the callback is present in the mapping, then just remove it.
+            if let Some(callbacks) = mapping.callbacks.get_mut(&self.key) {
+                let callback = callbacks.remove(&self.id);
+                if callback.is_some() {
+                    drop(mapping);
+                    drop(callback);
+                    return;
+                }
+            }
+
+            // If this subscription's callback is not present, then either it has been
+            // temporarily removed during emit, or it has not yet been added. Record
+            // that this subscription has been dropped so that the callback can be
+            // removed later.
+            mapping
+                .dropped_subscriptions
+                .entry(self.key.clone())
+                .or_default()
+                .insert(self.id);
+        }
+    }
+}

crates/gpui/src/app/test_app_context.rs

@@ -17,11 +17,11 @@ use parking_lot::{Mutex, RwLock};
 use smol::stream::StreamExt;
 
 use crate::{
-    executor, geometry::vector::Vector2F, keymap::Keystroke, platform, Action, AnyViewHandle,
-    AppContext, Appearance, Entity, Event, FontCache, InputHandler, KeyDownEvent, LeakDetector,
-    ModelContext, ModelHandle, MutableAppContext, Platform, ReadModelWith, ReadViewWith,
-    RenderContext, Task, UpdateModel, UpdateView, View, ViewContext, ViewHandle, WeakHandle,
-    WindowInputHandler,
+    executor, geometry::vector::Vector2F, keymap_matcher::Keystroke, platform, Action,
+    AnyViewHandle, AppContext, Appearance, Entity, Event, FontCache, InputHandler, KeyDownEvent,
+    LeakDetector, ModelContext, ModelHandle, MutableAppContext, Platform, ReadModelWith,
+    ReadViewWith, RenderContext, Task, UpdateModel, UpdateView, View, ViewContext, ViewHandle,
+    WeakHandle, WindowInputHandler,
 };
 use collections::BTreeMap;
 

crates/gpui/src/executor.rs

@@ -74,11 +74,18 @@ struct DeterministicState {
     pending_timers: Vec<(usize, std::time::Instant, postage::barrier::Sender)>,
     waiting_backtrace: Option<backtrace::Backtrace>,
     next_runnable_id: usize,
-    poll_history: Vec<usize>,
+    poll_history: Vec<ExecutorEvent>,
+    previous_poll_history: Option<Vec<ExecutorEvent>>,
     enable_runnable_backtraces: bool,
     runnable_backtraces: collections::HashMap<usize, backtrace::Backtrace>,
 }
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum ExecutorEvent {
+    PollRunnable { id: usize },
+    EnqueuRunnable { id: usize },
+}
+
 #[cfg(any(test, feature = "test-support"))]
 struct ForegroundRunnable {
     id: usize,
@@ -130,6 +137,7 @@ impl Deterministic {
                 waiting_backtrace: None,
                 next_runnable_id: 0,
                 poll_history: Default::default(),
+                previous_poll_history: Default::default(),
                 enable_runnable_backtraces: false,
                 runnable_backtraces: Default::default(),
             })),
@@ -137,10 +145,14 @@ impl Deterministic {
         })
     }
 
-    pub fn runnable_history(&self) -> Vec<usize> {
+    pub fn execution_history(&self) -> Vec<ExecutorEvent> {
         self.state.lock().poll_history.clone()
     }
 
+    pub fn set_previous_execution_history(&self, history: Option<Vec<ExecutorEvent>>) {
+        self.state.lock().previous_poll_history = history;
+    }
+
     pub fn enable_runnable_backtrace(&self) {
         self.state.lock().enable_runnable_backtraces = true;
     }
@@ -185,6 +197,7 @@ impl Deterministic {
         let unparker = self.parker.lock().unparker();
         let (runnable, task) = async_task::spawn_local(future, move |runnable| {
             let mut state = state.lock();
+            state.push_to_history(ExecutorEvent::EnqueuRunnable { id });
             state
                 .scheduled_from_foreground
                 .entry(cx_id)
@@ -212,6 +225,9 @@ impl Deterministic {
         let unparker = self.parker.lock().unparker();
         let (runnable, task) = async_task::spawn(future, move |runnable| {
             let mut state = state.lock();
+            state
+                .poll_history
+                .push(ExecutorEvent::EnqueuRunnable { id });
             state
                 .scheduled_from_background
                 .push(BackgroundRunnable { id, runnable });
@@ -314,7 +330,9 @@ impl Deterministic {
                 let background_len = state.scheduled_from_background.len();
                 let ix = state.rng.gen_range(0..background_len);
                 let background_runnable = state.scheduled_from_background.remove(ix);
-                state.poll_history.push(background_runnable.id);
+                state.push_to_history(ExecutorEvent::PollRunnable {
+                    id: background_runnable.id,
+                });
                 drop(state);
                 background_runnable.runnable.run();
             } else if !state.scheduled_from_foreground.is_empty() {
@@ -332,7 +350,9 @@ impl Deterministic {
                 if scheduled_from_cx.is_empty() {
                     state.scheduled_from_foreground.remove(&cx_id_to_run);
                 }
-                state.poll_history.push(foreground_runnable.id);
+                state.push_to_history(ExecutorEvent::PollRunnable {
+                    id: foreground_runnable.id,
+                });
 
                 drop(state);
 
@@ -366,7 +386,9 @@ impl Deterministic {
             let ix = state.rng.gen_range(0..=runnable_count);
             if ix < state.scheduled_from_background.len() {
                 let background_runnable = state.scheduled_from_background.remove(ix);
-                state.poll_history.push(background_runnable.id);
+                state.push_to_history(ExecutorEvent::PollRunnable {
+                    id: background_runnable.id,
+                });
                 drop(state);
                 background_runnable.runnable.run();
             } else {
@@ -465,6 +487,25 @@ impl Deterministic {
             }
         }
     }
+
+    pub fn record_backtrace(&self) {
+        let mut state = self.state.lock();
+        if state.enable_runnable_backtraces {
+            let current_id = state
+                .poll_history
+                .iter()
+                .rev()
+                .find_map(|event| match event {
+                    ExecutorEvent::PollRunnable { id } => Some(*id),
+                    _ => None,
+                });
+            if let Some(id) = current_id {
+                state
+                    .runnable_backtraces
+                    .insert(id, backtrace::Backtrace::new_unresolved());
+            }
+        }
+    }
 }
 
 impl Drop for Timer {
@@ -506,6 +547,40 @@ impl Future for Timer {
 
 #[cfg(any(test, feature = "test-support"))]
 impl DeterministicState {
+    fn push_to_history(&mut self, event: ExecutorEvent) {
+        use std::fmt::Write as _;
+
+        self.poll_history.push(event);
+        if let Some(prev_history) = &self.previous_poll_history {
+            let ix = self.poll_history.len() - 1;
+            let prev_event = prev_history[ix];
+            if event != prev_event {
+                let mut message = String::new();
+                writeln!(
+                    &mut message,
+                    "current runnable backtrace:\n{:?}",
+                    self.runnable_backtraces.get_mut(&event.id()).map(|trace| {
+                        trace.resolve();
+                        util::CwdBacktrace(trace)
+                    })
+                )
+                .unwrap();
+                writeln!(
+                    &mut message,
+                    "previous runnable backtrace:\n{:?}",
+                    self.runnable_backtraces
+                        .get_mut(&prev_event.id())
+                        .map(|trace| {
+                            trace.resolve();
+                            util::CwdBacktrace(trace)
+                        })
+                )
+                .unwrap();
+                panic!("detected non-determinism after {ix}. {message}");
+            }
+        }
+    }
+
     fn will_park(&mut self) {
         if self.forbid_parking {
             let mut backtrace_message = String::new();
@@ -526,6 +601,16 @@ impl DeterministicState {
     }
 }
 
+#[cfg(any(test, feature = "test-support"))]
+impl ExecutorEvent {
+    pub fn id(&self) -> usize {
+        match self {
+            ExecutorEvent::PollRunnable { id } => *id,
+            ExecutorEvent::EnqueuRunnable { id } => *id,
+        }
+    }
+}
+
 impl Foreground {
     pub fn platform(dispatcher: Arc<dyn platform::Dispatcher>) -> Result<Self> {
         if dispatcher.is_main_thread() {
@@ -755,6 +840,16 @@ impl Background {
             }
         }
     }
+
+    #[cfg(any(test, feature = "test-support"))]
+    pub fn record_backtrace(&self) {
+        match self {
+            Self::Deterministic { executor, .. } => executor.record_backtrace(),
+            _ => {
+                panic!("this method can only be called on a deterministic executor")
+            }
+        }
+    }
 }
 
 impl Default for Background {

crates/gpui/src/gpui.rs

@@ -25,7 +25,7 @@ pub mod executor;
 pub use executor::Task;
 pub mod color;
 pub mod json;
-pub mod keymap;
+pub mod keymap_matcher;
 pub mod platform;
 pub use gpui_macros::test;
 pub use platform::*;

crates/gpui/src/keymap.rs

@@ -1,757 +0,0 @@
-use crate::Action;
-use anyhow::{anyhow, Result};
-use smallvec::SmallVec;
-use std::{
-    any::{Any, TypeId},
-    collections::{HashMap, HashSet},
-    fmt::{Debug, Write},
-};
-use tree_sitter::{Language, Node, Parser};
-
-extern "C" {
-    fn tree_sitter_context_predicate() -> Language;
-}
-
-pub struct Matcher {
-    pending_views: HashMap<usize, Context>,
-    pending_keystrokes: Vec<Keystroke>,
-    keymap: Keymap,
-}
-
-#[derive(Default)]
-pub struct Keymap {
-    bindings: Vec<Binding>,
-    binding_indices_by_action_type: HashMap<TypeId, SmallVec<[usize; 3]>>,
-}
-
-pub struct Binding {
-    keystrokes: SmallVec<[Keystroke; 2]>,
-    action: Box<dyn Action>,
-    context_predicate: Option<ContextPredicate>,
-}
-
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct Keystroke {
-    pub ctrl: bool,
-    pub alt: bool,
-    pub shift: bool,
-    pub cmd: bool,
-    pub function: bool,
-    pub key: String,
-}
-
-#[derive(Clone, Debug, Default, Eq, PartialEq)]
-pub struct Context {
-    pub set: HashSet<String>,
-    pub map: HashMap<String, String>,
-}
-
-#[derive(Debug, Eq, PartialEq)]
-enum ContextPredicate {
-    Identifier(String),
-    Equal(String, String),
-    NotEqual(String, String),
-    Not(Box<ContextPredicate>),
-    And(Box<ContextPredicate>, Box<ContextPredicate>),
-    Or(Box<ContextPredicate>, Box<ContextPredicate>),
-}
-
-trait ActionArg {
-    fn boxed_clone(&self) -> Box<dyn Any>;
-}
-
-impl<T> ActionArg for T
-where
-    T: 'static + Any + Clone,
-{
-    fn boxed_clone(&self) -> Box<dyn Any> {
-        Box::new(self.clone())
-    }
-}
-
-pub enum MatchResult {
-    None,
-    Pending,
-    Matches(Vec<(usize, Box<dyn Action>)>),
-}
-
-impl Debug for MatchResult {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self {
-            MatchResult::None => f.debug_struct("MatchResult::None").finish(),
-            MatchResult::Pending => f.debug_struct("MatchResult::Pending").finish(),
-            MatchResult::Matches(matches) => f
-                .debug_list()
-                .entries(
-                    matches
-                        .iter()
-                        .map(|(view_id, action)| format!("{view_id}, {}", action.name())),
-                )
-                .finish(),
-        }
-    }
-}
-
-impl PartialEq for MatchResult {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (MatchResult::None, MatchResult::None) => true,
-            (MatchResult::Pending, MatchResult::Pending) => true,
-            (MatchResult::Matches(matches), MatchResult::Matches(other_matches)) => {
-                matches.len() == other_matches.len()
-                    && matches.iter().zip(other_matches.iter()).all(
-                        |((view_id, action), (other_view_id, other_action))| {
-                            view_id == other_view_id && action.eq(other_action.as_ref())
-                        },
-                    )
-            }
-            _ => false,
-        }
-    }
-}
-
-impl Eq for MatchResult {}
-
-impl Clone for MatchResult {
-    fn clone(&self) -> Self {
-        match self {
-            MatchResult::None => MatchResult::None,
-            MatchResult::Pending => MatchResult::Pending,
-            MatchResult::Matches(matches) => MatchResult::Matches(
-                matches
-                    .iter()
-                    .map(|(view_id, action)| (*view_id, Action::boxed_clone(action.as_ref())))
-                    .collect(),
-            ),
-        }
-    }
-}
-
-impl Matcher {
-    pub fn new(keymap: Keymap) -> Self {
-        Self {
-            pending_views: HashMap::new(),
-            pending_keystrokes: Vec::new(),
-            keymap,
-        }
-    }
-
-    pub fn set_keymap(&mut self, keymap: Keymap) {
-        self.clear_pending();
-        self.keymap = keymap;
-    }
-
-    pub fn add_bindings<T: IntoIterator<Item = Binding>>(&mut self, bindings: T) {
-        self.clear_pending();
-        self.keymap.add_bindings(bindings);
-    }
-
-    pub fn clear_bindings(&mut self) {
-        self.clear_pending();
-        self.keymap.clear();
-    }
-
-    pub fn bindings_for_action_type(&self, action_type: TypeId) -> impl Iterator<Item = &Binding> {
-        self.keymap.bindings_for_action_type(action_type)
-    }
-
-    pub fn clear_pending(&mut self) {
-        self.pending_keystrokes.clear();
-        self.pending_views.clear();
-    }
-
-    pub fn has_pending_keystrokes(&self) -> bool {
-        !self.pending_keystrokes.is_empty()
-    }
-
-    pub fn push_keystroke(
-        &mut self,
-        keystroke: Keystroke,
-        dispatch_path: Vec<(usize, Context)>,
-    ) -> MatchResult {
-        let mut any_pending = false;
-        let mut matched_bindings = Vec::new();
-
-        let first_keystroke = self.pending_keystrokes.is_empty();
-        self.pending_keystrokes.push(keystroke);
-
-        for (view_id, context) in dispatch_path {
-            // Don't require pending view entry if there are no pending keystrokes
-            if !first_keystroke && !self.pending_views.contains_key(&view_id) {
-                continue;
-            }
-
-            // If there is a previous view context, invalidate that view if it
-            // has changed
-            if let Some(previous_view_context) = self.pending_views.remove(&view_id) {
-                if previous_view_context != context {
-                    continue;
-                }
-            }
-
-            // Find the bindings which map the pending keystrokes and current context
-            for binding in self.keymap.bindings.iter().rev() {
-                if binding.keystrokes.starts_with(&self.pending_keystrokes)
-                    && binding
-                        .context_predicate
-                        .as_ref()
-                        .map(|c| c.eval(&context))
-                        .unwrap_or(true)
-                {
-                    // If the binding is completed, push it onto the matches list
-                    if binding.keystrokes.len() == self.pending_keystrokes.len() {
-                        matched_bindings.push((view_id, binding.action.boxed_clone()));
-                    } else {
-                        // Otherwise, the binding is still pending
-                        self.pending_views.insert(view_id, context.clone());
-                        any_pending = true;
-                    }
-                }
-            }
-        }
-
-        if !any_pending {
-            self.clear_pending();
-        }
-
-        if !matched_bindings.is_empty() {
-            MatchResult::Matches(matched_bindings)
-        } else if any_pending {
-            MatchResult::Pending
-        } else {
-            MatchResult::None
-        }
-    }
-
-    pub fn keystrokes_for_action(
-        &self,
-        action: &dyn Action,
-        cx: &Context,
-    ) -> Option<SmallVec<[Keystroke; 2]>> {
-        for binding in self.keymap.bindings.iter().rev() {
-            if binding.action.eq(action)
-                && binding
-                    .context_predicate
-                    .as_ref()
-                    .map_or(true, |predicate| predicate.eval(cx))
-            {
-                return Some(binding.keystrokes.clone());
-            }
-        }
-        None
-    }
-}
-
-impl Default for Matcher {
-    fn default() -> Self {
-        Self::new(Keymap::default())
-    }
-}
-
-impl Keymap {
-    pub fn new(bindings: Vec<Binding>) -> Self {
-        let mut binding_indices_by_action_type = HashMap::new();
-        for (ix, binding) in bindings.iter().enumerate() {
-            binding_indices_by_action_type
-                .entry(binding.action.as_any().type_id())
-                .or_insert_with(SmallVec::new)
-                .push(ix);
-        }
-        Self {
-            binding_indices_by_action_type,
-            bindings,
-        }
-    }
-
-    fn bindings_for_action_type(&self, action_type: TypeId) -> impl Iterator<Item = &'_ Binding> {
-        self.binding_indices_by_action_type
-            .get(&action_type)
-            .map(SmallVec::as_slice)
-            .unwrap_or(&[])
-            .iter()
-            .map(|ix| &self.bindings[*ix])
-    }
-
-    fn add_bindings<T: IntoIterator<Item = Binding>>(&mut self, bindings: T) {
-        for binding in bindings {
-            self.binding_indices_by_action_type
-                .entry(binding.action.as_any().type_id())
-                .or_default()
-                .push(self.bindings.len());
-            self.bindings.push(binding);
-        }
-    }
-
-    fn clear(&mut self) {
-        self.bindings.clear();
-        self.binding_indices_by_action_type.clear();
-    }
-}
-
-impl Binding {
-    pub fn new<A: Action>(keystrokes: &str, action: A, context: Option<&str>) -> Self {
-        Self::load(keystrokes, Box::new(action), context).unwrap()
-    }
-
-    pub fn load(keystrokes: &str, action: Box<dyn Action>, context: Option<&str>) -> Result<Self> {
-        let context = if let Some(context) = context {
-            Some(ContextPredicate::parse(context)?)
-        } else {
-            None
-        };
-
-        let keystrokes = keystrokes
-            .split_whitespace()
-            .map(Keystroke::parse)
-            .collect::<Result<_>>()?;
-
-        Ok(Self {
-            keystrokes,
-            action,
-            context_predicate: context,
-        })
-    }
-
-    pub fn keystrokes(&self) -> &[Keystroke] {
-        &self.keystrokes
-    }
-
-    pub fn action(&self) -> &dyn Action {
-        self.action.as_ref()
-    }
-}
-
-impl Keystroke {
-    pub fn parse(source: &str) -> anyhow::Result<Self> {
-        let mut ctrl = false;
-        let mut alt = false;
-        let mut shift = false;
-        let mut cmd = false;
-        let mut function = false;
-        let mut key = None;
-
-        let mut components = source.split('-').peekable();
-        while let Some(component) = components.next() {
-            match component {
-                "ctrl" => ctrl = true,
-                "alt" => alt = true,
-                "shift" => shift = true,
-                "cmd" => cmd = true,
-                "fn" => function = true,
-                _ => {
-                    if let Some(component) = components.peek() {
-                        if component.is_empty() && source.ends_with('-') {
-                            key = Some(String::from("-"));
-                            break;
-                        } else {
-                            return Err(anyhow!("Invalid keystroke `{}`", source));
-                        }
-                    } else {
-                        key = Some(String::from(component));
-                    }
-                }
-            }
-        }
-
-        let key = key.ok_or_else(|| anyhow!("Invalid keystroke `{}`", source))?;
-
-        Ok(Keystroke {
-            ctrl,
-            alt,
-            shift,
-            cmd,
-            function,
-            key,
-        })
-    }
-
-    pub fn modified(&self) -> bool {
-        self.ctrl || self.alt || self.shift || self.cmd
-    }
-}
-
-impl std::fmt::Display for Keystroke {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        if self.ctrl {
-            f.write_char('^')?;
-        }
-        if self.alt {
-            f.write_char('⎇')?;
-        }
-        if self.cmd {
-            f.write_char('⌘')?;
-        }
-        if self.shift {
-            f.write_char('⇧')?;
-        }
-        let key = match self.key.as_str() {
-            "backspace" => '⌫',
-            "up" => '↑',
-            "down" => '↓',
-            "left" => '←',
-            "right" => '→',
-            "tab" => '⇥',
-            "escape" => '⎋',
-            key => {
-                if key.len() == 1 {
-                    key.chars().next().unwrap().to_ascii_uppercase()
-                } else {
-                    return f.write_str(key);
-                }
-            }
-        };
-        f.write_char(key)
-    }
-}
-
-impl Context {
-    pub fn extend(&mut self, other: &Context) {
-        for v in &other.set {
-            self.set.insert(v.clone());
-        }
-        for (k, v) in &other.map {
-            self.map.insert(k.clone(), v.clone());
-        }
-    }
-}
-
-impl ContextPredicate {
-    fn parse(source: &str) -> anyhow::Result<Self> {
-        let mut parser = Parser::new();
-        let language = unsafe { tree_sitter_context_predicate() };
-        parser.set_language(language).unwrap();
-        let source = source.as_bytes();
-        let tree = parser.parse(source, None).unwrap();
-        Self::from_node(tree.root_node(), source)
-    }
-
-    fn from_node(node: Node, source: &[u8]) -> anyhow::Result<Self> {
-        let parse_error = "error parsing context predicate";
-        let kind = node.kind();
-
-        match kind {
-            "source" => Self::from_node(node.child(0).ok_or_else(|| anyhow!(parse_error))?, source),
-            "identifier" => Ok(Self::Identifier(node.utf8_text(source)?.into())),
-            "not" => {
-                let child = Self::from_node(
-                    node.child_by_field_name("expression")
-                        .ok_or_else(|| anyhow!(parse_error))?,
-                    source,
-                )?;
-                Ok(Self::Not(Box::new(child)))
-            }
-            "and" | "or" => {
-                let left = Box::new(Self::from_node(
-                    node.child_by_field_name("left")
-                        .ok_or_else(|| anyhow!(parse_error))?,
-                    source,
-                )?);
-                let right = Box::new(Self::from_node(
-                    node.child_by_field_name("right")
-                        .ok_or_else(|| anyhow!(parse_error))?,
-                    source,
-                )?);
-                if kind == "and" {
-                    Ok(Self::And(left, right))
-                } else {
-                    Ok(Self::Or(left, right))
-                }
-            }
-            "equal" | "not_equal" => {
-                let left = node
-                    .child_by_field_name("left")
-                    .ok_or_else(|| anyhow!(parse_error))?
-                    .utf8_text(source)?
-                    .into();
-                let right = node
-                    .child_by_field_name("right")
-                    .ok_or_else(|| anyhow!(parse_error))?
-                    .utf8_text(source)?
-                    .into();
-                if kind == "equal" {
-                    Ok(Self::Equal(left, right))
-                } else {
-                    Ok(Self::NotEqual(left, right))
-                }
-            }
-            "parenthesized" => Self::from_node(
-                node.child_by_field_name("expression")
-                    .ok_or_else(|| anyhow!(parse_error))?,
-                source,
-            ),
-            _ => Err(anyhow!(parse_error)),
-        }
-    }
-
-    fn eval(&self, cx: &Context) -> bool {
-        match self {
-            Self::Identifier(name) => cx.set.contains(name.as_str()),
-            Self::Equal(left, right) => cx
-                .map
-                .get(left)
-                .map(|value| value == right)
-                .unwrap_or(false),
-            Self::NotEqual(left, right) => {
-                cx.map.get(left).map(|value| value != right).unwrap_or(true)
-            }
-            Self::Not(pred) => !pred.eval(cx),
-            Self::And(left, right) => left.eval(cx) && right.eval(cx),
-            Self::Or(left, right) => left.eval(cx) || right.eval(cx),
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use anyhow::Result;
-    use serde::Deserialize;
-
-    use crate::{actions, impl_actions};
-
-    use super::*;
-
-    #[test]
-    fn test_push_keystroke() -> Result<()> {
-        actions!(test, [B, AB, C, D, DA]);
-
-        let mut ctx1 = Context::default();
-        ctx1.set.insert("1".into());
-
-        let mut ctx2 = Context::default();
-        ctx2.set.insert("2".into());
-
-        let dispatch_path = vec![(2, ctx2), (1, ctx1)];
-
-        let keymap = Keymap::new(vec![
-            Binding::new("a b", AB, Some("1")),
-            Binding::new("b", B, Some("2")),
-            Binding::new("c", C, Some("2")),
-            Binding::new("d", D, Some("1")),
-            Binding::new("d", D, Some("2")),
-            Binding::new("d a", DA, Some("2")),
-        ]);
-
-        let mut matcher = Matcher::new(keymap);
-
-        // Binding with pending prefix always takes precedence
-        assert_eq!(
-            matcher.push_keystroke(Keystroke::parse("a")?, dispatch_path.clone()),
-            MatchResult::Pending,
-        );
-        // B alone doesn't match because a was pending, so AB is returned instead
-        assert_eq!(
-            matcher.push_keystroke(Keystroke::parse("b")?, dispatch_path.clone()),
-            MatchResult::Matches(vec![(1, Box::new(AB))]),
-        );
-        assert!(!matcher.has_pending_keystrokes());
-
-        // Without an a prefix, B is dispatched like expected
-        assert_eq!(
-            matcher.push_keystroke(Keystroke::parse("b")?, dispatch_path.clone()),
-            MatchResult::Matches(vec![(2, Box::new(B))]),
-        );
-        assert!(!matcher.has_pending_keystrokes());
-
-        // If a is prefixed, C will not be dispatched because there
-        // was a pending binding for it
-        assert_eq!(
-            matcher.push_keystroke(Keystroke::parse("a")?, dispatch_path.clone()),
-            MatchResult::Pending,
-        );
-        assert_eq!(
-            matcher.push_keystroke(Keystroke::parse("c")?, dispatch_path.clone()),
-            MatchResult::None,
-        );
-        assert!(!matcher.has_pending_keystrokes());
-
-        // If a single keystroke matches multiple bindings in the tree
-        // all of them are returned so that we can fallback if the action
-        // handler decides to propagate the action
-        assert_eq!(
-            matcher.push_keystroke(Keystroke::parse("d")?, dispatch_path.clone()),
-            MatchResult::Matches(vec![(2, Box::new(D)), (1, Box::new(D))]),
-        );
-        // If none of the d action handlers consume the binding, a pending
-        // binding may then be used
-        assert_eq!(
-            matcher.push_keystroke(Keystroke::parse("a")?, dispatch_path.clone()),
-            MatchResult::Matches(vec![(2, Box::new(DA))]),
-        );
-        assert!(!matcher.has_pending_keystrokes());
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_keystroke_parsing() -> Result<()> {
-        assert_eq!(
-            Keystroke::parse("ctrl-p")?,
-            Keystroke {
-                key: "p".into(),
-                ctrl: true,
-                alt: false,
-                shift: false,
-                cmd: false,
-                function: false,
-            }
-        );
-
-        assert_eq!(
-            Keystroke::parse("alt-shift-down")?,
-            Keystroke {
-                key: "down".into(),
-                ctrl: false,
-                alt: true,
-                shift: true,
-                cmd: false,
-                function: false,
-            }
-        );
-
-        assert_eq!(
-            Keystroke::parse("shift-cmd--")?,
-            Keystroke {
-                key: "-".into(),
-                ctrl: false,
-                alt: false,
-                shift: true,
-                cmd: true,
-                function: false,
-            }
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_context_predicate_parsing() -> Result<()> {
-        use ContextPredicate::*;
-
-        assert_eq!(
-            ContextPredicate::parse("a && (b == c || d != e)")?,
-            And(
-                Box::new(Identifier("a".into())),
-                Box::new(Or(
-                    Box::new(Equal("b".into(), "c".into())),
-                    Box::new(NotEqual("d".into(), "e".into())),
-                ))
-            )
-        );
-
-        assert_eq!(
-            ContextPredicate::parse("!a")?,
-            Not(Box::new(Identifier("a".into())),)
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_context_predicate_eval() -> Result<()> {
-        let predicate = ContextPredicate::parse("a && b || c == d")?;
-
-        let mut context = Context::default();
-        context.set.insert("a".into());
-        assert!(!predicate.eval(&context));
-
-        context.set.insert("b".into());
-        assert!(predicate.eval(&context));
-
-        context.set.remove("b");
-        context.map.insert("c".into(), "x".into());
-        assert!(!predicate.eval(&context));
-
-        context.map.insert("c".into(), "d".into());
-        assert!(predicate.eval(&context));
-
-        let predicate = ContextPredicate::parse("!a")?;
-        assert!(predicate.eval(&Context::default()));
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_matcher() -> Result<()> {
-        #[derive(Clone, Deserialize, PartialEq, Eq, Debug)]
-        pub struct A(pub String);
-        impl_actions!(test, [A]);
-        actions!(test, [B, Ab]);
-
-        #[derive(Clone, Debug, Eq, PartialEq)]
-        struct ActionArg {
-            a: &'static str,
-        }
-
-        let keymap = Keymap::new(vec![
-            Binding::new("a", A("x".to_string()), Some("a")),
-            Binding::new("b", B, Some("a")),
-            Binding::new("a b", Ab, Some("a || b")),
-        ]);
-
-        let mut ctx_a = Context::default();
-        ctx_a.set.insert("a".into());
-
-        let mut ctx_b = Context::default();
-        ctx_b.set.insert("b".into());
-
-        let mut matcher = Matcher::new(keymap);
-
-        // Basic match
-        assert_eq!(
-            matcher.push_keystroke(Keystroke::parse("a")?, vec![(1, ctx_a.clone())]),
-            MatchResult::Matches(vec![(1, Box::new(A("x".to_string())))])
-        );
-        matcher.clear_pending();
-
-        // Multi-keystroke match
-        assert_eq!(
-            matcher.push_keystroke(Keystroke::parse("a")?, vec![(1, ctx_b.clone())]),
-            MatchResult::Pending
-        );
-        assert_eq!(
-            matcher.push_keystroke(Keystroke::parse("b")?, vec![(1, ctx_b.clone())]),
-            MatchResult::Matches(vec![(1, Box::new(Ab))])
-        );
-        matcher.clear_pending();
-
-        // Failed matches don't interfere with matching subsequent keys
-        assert_eq!(
-            matcher.push_keystroke(Keystroke::parse("x")?, vec![(1, ctx_a.clone())]),
-            MatchResult::None
-        );
-        assert_eq!(
-            matcher.push_keystroke(Keystroke::parse("a")?, vec![(1, ctx_a.clone())]),
-            MatchResult::Matches(vec![(1, Box::new(A("x".to_string())))])
-        );
-        matcher.clear_pending();
-
-        // Pending keystrokes are cleared when the context changes
-        assert_eq!(
-            matcher.push_keystroke(Keystroke::parse("a")?, vec![(1, ctx_b.clone())]),
-            MatchResult::Pending
-        );
-        assert_eq!(
-            matcher.push_keystroke(Keystroke::parse("b")?, vec![(1, ctx_a.clone())]),
-            MatchResult::None
-        );
-        matcher.clear_pending();
-
-        let mut ctx_c = Context::default();
-        ctx_c.set.insert("c".into());
-
-        // Pending keystrokes are maintained per-view
-        assert_eq!(
-            matcher.push_keystroke(
-                Keystroke::parse("a")?,
-                vec![(1, ctx_b.clone()), (2, ctx_c.clone())]
-            ),
-            MatchResult::Pending
-        );
-        assert_eq!(
-            matcher.push_keystroke(Keystroke::parse("b")?, vec![(1, ctx_b.clone())]),
-            MatchResult::Matches(vec![(1, Box::new(Ab))])
-        );
-
-        Ok(())
-    }
-}

crates/gpui/src/keymap_matcher.rs

@@ -0,0 +1,509 @@
+mod binding;
+mod keymap;
+mod keymap_context;
+mod keystroke;
+
+use std::{any::TypeId, fmt::Debug};
+
+use collections::HashMap;
+use serde::Deserialize;
+use smallvec::SmallVec;
+
+use crate::{impl_actions, Action};
+
+pub use binding::{Binding, BindingMatchResult};
+pub use keymap::Keymap;
+pub use keymap_context::{KeymapContext, KeymapContextPredicate};
+pub use keystroke::Keystroke;
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Deserialize)]
+pub struct KeyPressed {
+    #[serde(default)]
+    pub keystroke: Keystroke,
+}
+
+impl_actions!(gpui, [KeyPressed]);
+
+pub struct KeymapMatcher {
+    pub contexts: Vec<KeymapContext>,
+    pending_views: HashMap<usize, KeymapContext>,
+    pending_keystrokes: Vec<Keystroke>,
+    keymap: Keymap,
+}
+
+impl KeymapMatcher {
+    pub fn new(keymap: Keymap) -> Self {
+        Self {
+            contexts: Vec::new(),
+            pending_views: Default::default(),
+            pending_keystrokes: Vec::new(),
+            keymap,
+        }
+    }
+
+    pub fn set_keymap(&mut self, keymap: Keymap) {
+        self.clear_pending();
+        self.keymap = keymap;
+    }
+
+    pub fn add_bindings<T: IntoIterator<Item = Binding>>(&mut self, bindings: T) {
+        self.clear_pending();
+        self.keymap.add_bindings(bindings);
+    }
+
+    pub fn clear_bindings(&mut self) {
+        self.clear_pending();
+        self.keymap.clear();
+    }
+
+    pub fn bindings_for_action_type(&self, action_type: TypeId) -> impl Iterator<Item = &Binding> {
+        self.keymap.bindings_for_action_type(action_type)
+    }
+
+    pub fn clear_pending(&mut self) {
+        self.pending_keystrokes.clear();
+        self.pending_views.clear();
+    }
+
+    pub fn has_pending_keystrokes(&self) -> bool {
+        !self.pending_keystrokes.is_empty()
+    }
+
+    pub fn push_keystroke(
+        &mut self,
+        keystroke: Keystroke,
+        mut dispatch_path: Vec<(usize, KeymapContext)>,
+    ) -> MatchResult {
+        let mut any_pending = false;
+        let mut matched_bindings: Vec<(usize, Box<dyn Action>)> = Vec::new();
+
+        let first_keystroke = self.pending_keystrokes.is_empty();
+        self.pending_keystrokes.push(keystroke.clone());
+
+        self.contexts.clear();
+        self.contexts
+            .extend(dispatch_path.iter_mut().map(|e| std::mem::take(&mut e.1)));
+
+        for (i, (view_id, _)) in dispatch_path.into_iter().enumerate() {
+            // Don't require pending view entry if there are no pending keystrokes
+            if !first_keystroke && !self.pending_views.contains_key(&view_id) {
+                continue;
+            }
+
+            // If there is a previous view context, invalidate that view if it
+            // has changed
+            if let Some(previous_view_context) = self.pending_views.remove(&view_id) {
+                if previous_view_context != self.contexts[i] {
+                    continue;
+                }
+            }
+
+            // Find the bindings which map the pending keystrokes and current context
+            for binding in self.keymap.bindings().iter().rev() {
+                match binding.match_keys_and_context(&self.pending_keystrokes, &self.contexts[i..])
+                {
+                    BindingMatchResult::Complete(mut action) => {
+                        // Swap in keystroke for special KeyPressed action
+                        if action.name() == "KeyPressed" && action.namespace() == "gpui" {
+                            action = Box::new(KeyPressed {
+                                keystroke: keystroke.clone(),
+                            });
+                        }
+                        matched_bindings.push((view_id, action))
+                    }
+                    BindingMatchResult::Partial => {
+                        self.pending_views.insert(view_id, self.contexts[i].clone());
+                        any_pending = true;
+                    }
+                    _ => {}
+                }
+            }
+        }
+
+        if !any_pending {
+            self.clear_pending();
+        }
+
+        if !matched_bindings.is_empty() {
+            MatchResult::Matches(matched_bindings)
+        } else if any_pending {
+            MatchResult::Pending
+        } else {
+            MatchResult::None
+        }
+    }
+
+    pub fn keystrokes_for_action(
+        &self,
+        action: &dyn Action,
+        contexts: &[KeymapContext],
+    ) -> Option<SmallVec<[Keystroke; 2]>> {
+        self.keymap
+            .bindings()
+            .iter()
+            .rev()
+            .find_map(|binding| binding.keystrokes_for_action(action, contexts))
+    }
+}
+
+impl Default for KeymapMatcher {
+    fn default() -> Self {
+        Self::new(Keymap::default())
+    }
+}
+
+pub enum MatchResult {
+    None,
+    Pending,
+    Matches(Vec<(usize, Box<dyn Action>)>),
+}
+
+impl Debug for MatchResult {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            MatchResult::None => f.debug_struct("MatchResult::None").finish(),
+            MatchResult::Pending => f.debug_struct("MatchResult::Pending").finish(),
+            MatchResult::Matches(matches) => f
+                .debug_list()
+                .entries(
+                    matches
+                        .iter()
+                        .map(|(view_id, action)| format!("{view_id}, {}", action.name())),
+                )
+                .finish(),
+        }
+    }
+}
+
+impl PartialEq for MatchResult {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (MatchResult::None, MatchResult::None) => true,
+            (MatchResult::Pending, MatchResult::Pending) => true,
+            (MatchResult::Matches(matches), MatchResult::Matches(other_matches)) => {
+                matches.len() == other_matches.len()
+                    && matches.iter().zip(other_matches.iter()).all(
+                        |((view_id, action), (other_view_id, other_action))| {
+                            view_id == other_view_id && action.eq(other_action.as_ref())
+                        },
+                    )
+            }
+            _ => false,
+        }
+    }
+}
+
+impl Eq for MatchResult {}
+
+impl Clone for MatchResult {
+    fn clone(&self) -> Self {
+        match self {
+            MatchResult::None => MatchResult::None,
+            MatchResult::Pending => MatchResult::Pending,
+            MatchResult::Matches(matches) => MatchResult::Matches(
+                matches
+                    .iter()
+                    .map(|(view_id, action)| (*view_id, Action::boxed_clone(action.as_ref())))
+                    .collect(),
+            ),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use anyhow::Result;
+    use serde::Deserialize;
+
+    use crate::{actions, impl_actions, keymap_matcher::KeymapContext};
+
+    use super::*;
+
+    #[test]
+    fn test_push_keystroke() -> Result<()> {
+        actions!(test, [B, AB, C, D, DA]);
+
+        let mut context1 = KeymapContext::default();
+        context1.set.insert("1".into());
+
+        let mut context2 = KeymapContext::default();
+        context2.set.insert("2".into());
+
+        let dispatch_path = vec![(2, context2), (1, context1)];
+
+        let keymap = Keymap::new(vec![
+            Binding::new("a b", AB, Some("1")),
+            Binding::new("b", B, Some("2")),
+            Binding::new("c", C, Some("2")),
+            Binding::new("d", D, Some("1")),
+            Binding::new("d", D, Some("2")),
+            Binding::new("d a", DA, Some("2")),
+        ]);
+
+        let mut matcher = KeymapMatcher::new(keymap);
+
+        // Binding with pending prefix always takes precedence
+        assert_eq!(
+            matcher.push_keystroke(Keystroke::parse("a")?, dispatch_path.clone()),
+            MatchResult::Pending,
+        );
+        // B alone doesn't match because a was pending, so AB is returned instead
+        assert_eq!(
+            matcher.push_keystroke(Keystroke::parse("b")?, dispatch_path.clone()),
+            MatchResult::Matches(vec![(1, Box::new(AB))]),
+        );
+        assert!(!matcher.has_pending_keystrokes());
+
+        // Without an a prefix, B is dispatched like expected
+        assert_eq!(
+            matcher.push_keystroke(Keystroke::parse("b")?, dispatch_path.clone()),
+            MatchResult::Matches(vec![(2, Box::new(B))]),
+        );
+        assert!(!matcher.has_pending_keystrokes());
+
+        // If a is prefixed, C will not be dispatched because there
+        // was a pending binding for it
+        assert_eq!(
+            matcher.push_keystroke(Keystroke::parse("a")?, dispatch_path.clone()),
+            MatchResult::Pending,
+        );
+        assert_eq!(
+            matcher.push_keystroke(Keystroke::parse("c")?, dispatch_path.clone()),
+            MatchResult::None,
+        );
+        assert!(!matcher.has_pending_keystrokes());
+
+        // If a single keystroke matches multiple bindings in the tree
+        // all of them are returned so that we can fallback if the action
+        // handler decides to propagate the action
+        assert_eq!(
+            matcher.push_keystroke(Keystroke::parse("d")?, dispatch_path.clone()),
+            MatchResult::Matches(vec![(2, Box::new(D)), (1, Box::new(D))]),
+        );
+        // If none of the d action handlers consume the binding, a pending
+        // binding may then be used
+        assert_eq!(
+            matcher.push_keystroke(Keystroke::parse("a")?, dispatch_path.clone()),
+            MatchResult::Matches(vec![(2, Box::new(DA))]),
+        );
+        assert!(!matcher.has_pending_keystrokes());
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_keystroke_parsing() -> Result<()> {
+        assert_eq!(
+            Keystroke::parse("ctrl-p")?,
+            Keystroke {
+                key: "p".into(),
+                ctrl: true,
+                alt: false,
+                shift: false,
+                cmd: false,
+                function: false,
+            }
+        );
+
+        assert_eq!(
+            Keystroke::parse("alt-shift-down")?,
+            Keystroke {
+                key: "down".into(),
+                ctrl: false,
+                alt: true,
+                shift: true,
+                cmd: false,
+                function: false,
+            }
+        );
+
+        assert_eq!(
+            Keystroke::parse("shift-cmd--")?,
+            Keystroke {
+                key: "-".into(),
+                ctrl: false,
+                alt: false,
+                shift: true,
+                cmd: true,
+                function: false,
+            }
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_context_predicate_parsing() -> Result<()> {
+        use KeymapContextPredicate::*;
+
+        assert_eq!(
+            KeymapContextPredicate::parse("a && (b == c || d != e)")?,
+            And(
+                Box::new(Identifier("a".into())),
+                Box::new(Or(
+                    Box::new(Equal("b".into(), "c".into())),
+                    Box::new(NotEqual("d".into(), "e".into())),
+                ))
+            )
+        );
+
+        assert_eq!(
+            KeymapContextPredicate::parse("!a")?,
+            Not(Box::new(Identifier("a".into())),)
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_context_predicate_eval() {
+        let predicate = KeymapContextPredicate::parse("a && b || c == d").unwrap();
+
+        let mut context = KeymapContext::default();
+        context.set.insert("a".into());
+        assert!(!predicate.eval(&[context]));
+
+        let mut context = KeymapContext::default();
+        context.set.insert("a".into());
+        context.set.insert("b".into());
+        assert!(predicate.eval(&[context]));
+
+        let mut context = KeymapContext::default();
+        context.set.insert("a".into());
+        context.map.insert("c".into(), "x".into());
+        assert!(!predicate.eval(&[context]));
+
+        let mut context = KeymapContext::default();
+        context.set.insert("a".into());
+        context.map.insert("c".into(), "d".into());
+        assert!(predicate.eval(&[context]));
+
+        let predicate = KeymapContextPredicate::parse("!a").unwrap();
+        assert!(predicate.eval(&[KeymapContext::default()]));
+    }
+
+    #[test]
+    fn test_context_child_predicate_eval() {
+        let predicate = KeymapContextPredicate::parse("a && b > c").unwrap();
+        let contexts = [
+            context_set(&["e", "f"]),
+            context_set(&["c", "d"]), // match this context
+            context_set(&["a", "b"]),
+        ];
+
+        assert!(!predicate.eval(&contexts[0..]));
+        assert!(predicate.eval(&contexts[1..]));
+        assert!(!predicate.eval(&contexts[2..]));
+
+        let predicate = KeymapContextPredicate::parse("a && b > c && !d > e").unwrap();
+        let contexts = [
+            context_set(&["f"]),
+            context_set(&["e"]), // only match this context
+            context_set(&["c"]),
+            context_set(&["a", "b"]),
+            context_set(&["e"]),
+            context_set(&["c", "d"]),
+            context_set(&["a", "b"]),
+        ];
+
+        assert!(!predicate.eval(&contexts[0..]));
+        assert!(predicate.eval(&contexts[1..]));
+        assert!(!predicate.eval(&contexts[2..]));
+        assert!(!predicate.eval(&contexts[3..]));
+        assert!(!predicate.eval(&contexts[4..]));
+        assert!(!predicate.eval(&contexts[5..]));
+        assert!(!predicate.eval(&contexts[6..]));
+
+        fn context_set(names: &[&str]) -> KeymapContext {
+            KeymapContext {
+                set: names.iter().copied().map(str::to_string).collect(),
+                ..Default::default()
+            }
+        }
+    }
+
+    #[test]
+    fn test_matcher() -> Result<()> {
+        #[derive(Clone, Deserialize, PartialEq, Eq, Debug)]
+        pub struct A(pub String);
+        impl_actions!(test, [A]);
+        actions!(test, [B, Ab]);
+
+        #[derive(Clone, Debug, Eq, PartialEq)]
+        struct ActionArg {
+            a: &'static str,
+        }
+
+        let keymap = Keymap::new(vec![
+            Binding::new("a", A("x".to_string()), Some("a")),
+            Binding::new("b", B, Some("a")),
+            Binding::new("a b", Ab, Some("a || b")),
+        ]);
+
+        let mut context_a = KeymapContext::default();
+        context_a.set.insert("a".into());
+
+        let mut context_b = KeymapContext::default();
+        context_b.set.insert("b".into());
+
+        let mut matcher = KeymapMatcher::new(keymap);
+
+        // Basic match
+        assert_eq!(
+            matcher.push_keystroke(Keystroke::parse("a")?, vec![(1, context_a.clone())]),
+            MatchResult::Matches(vec![(1, Box::new(A("x".to_string())))])
+        );
+        matcher.clear_pending();
+
+        // Multi-keystroke match
+        assert_eq!(
+            matcher.push_keystroke(Keystroke::parse("a")?, vec![(1, context_b.clone())]),
+            MatchResult::Pending
+        );
+        assert_eq!(
+            matcher.push_keystroke(Keystroke::parse("b")?, vec![(1, context_b.clone())]),
+            MatchResult::Matches(vec![(1, Box::new(Ab))])
+        );
+        matcher.clear_pending();
+
+        // Failed matches don't interfere with matching subsequent keys
+        assert_eq!(
+            matcher.push_keystroke(Keystroke::parse("x")?, vec![(1, context_a.clone())]),
+            MatchResult::None
+        );
+        assert_eq!(
+            matcher.push_keystroke(Keystroke::parse("a")?, vec![(1, context_a.clone())]),
+            MatchResult::Matches(vec![(1, Box::new(A("x".to_string())))])
+        );
+        matcher.clear_pending();
+
+        // Pending keystrokes are cleared when the context changes
+        assert_eq!(
+            matcher.push_keystroke(Keystroke::parse("a")?, vec![(1, context_b.clone())]),
+            MatchResult::Pending
+        );
+        assert_eq!(
+            matcher.push_keystroke(Keystroke::parse("b")?, vec![(1, context_a.clone())]),
+            MatchResult::None
+        );
+        matcher.clear_pending();
+
+        let mut context_c = KeymapContext::default();
+        context_c.set.insert("c".into());
+
+        // Pending keystrokes are maintained per-view
+        assert_eq!(
+            matcher.push_keystroke(
+                Keystroke::parse("a")?,
+                vec![(1, context_b.clone()), (2, context_c.clone())]
+            ),
+            MatchResult::Pending
+        );
+        assert_eq!(
+            matcher.push_keystroke(Keystroke::parse("b")?, vec![(1, context_b.clone())]),
+            MatchResult::Matches(vec![(1, Box::new(Ab))])
+        );
+
+        Ok(())
+    }
+}

crates/gpui/src/keymap_matcher/binding.rs

@@ -0,0 +1,104 @@
+use anyhow::Result;
+use smallvec::SmallVec;
+
+use crate::Action;
+
+use super::{KeymapContext, KeymapContextPredicate, Keystroke};
+
+pub struct Binding {
+    action: Box<dyn Action>,
+    keystrokes: Option<SmallVec<[Keystroke; 2]>>,
+    context_predicate: Option<KeymapContextPredicate>,
+}
+
+impl Binding {
+    pub fn new<A: Action>(keystrokes: &str, action: A, context: Option<&str>) -> Self {
+        Self::load(keystrokes, Box::new(action), context).unwrap()
+    }
+
+    pub fn load(keystrokes: &str, action: Box<dyn Action>, context: Option<&str>) -> Result<Self> {
+        let context = if let Some(context) = context {
+            Some(KeymapContextPredicate::parse(context)?)
+        } else {
+            None
+        };
+
+        let keystrokes = if keystrokes == "*" {
+            None // Catch all context
+        } else {
+            Some(
+                keystrokes
+                    .split_whitespace()
+                    .map(Keystroke::parse)
+                    .collect::<Result<_>>()?,
+            )
+        };
+
+        Ok(Self {
+            keystrokes,
+            action,
+            context_predicate: context,
+        })
+    }
+
+    fn match_context(&self, contexts: &[KeymapContext]) -> bool {
+        self.context_predicate
+            .as_ref()
+            .map(|predicate| predicate.eval(contexts))
+            .unwrap_or(true)
+    }
+
+    pub fn match_keys_and_context(
+        &self,
+        pending_keystrokes: &Vec<Keystroke>,
+        contexts: &[KeymapContext],
+    ) -> BindingMatchResult {
+        if self
+            .keystrokes
+            .as_ref()
+            .map(|keystrokes| keystrokes.starts_with(&pending_keystrokes))
+            .unwrap_or(true)
+            && self.match_context(contexts)
+        {
+            // If the binding is completed, push it onto the matches list
+            if self
+                .keystrokes
+                .as_ref()
+                .map(|keystrokes| keystrokes.len() == pending_keystrokes.len())
+                .unwrap_or(true)
+            {
+                BindingMatchResult::Complete(self.action.boxed_clone())
+            } else {
+                BindingMatchResult::Partial
+            }
+        } else {
+            BindingMatchResult::Fail
+        }
+    }
+
+    pub fn keystrokes_for_action(
+        &self,
+        action: &dyn Action,
+        contexts: &[KeymapContext],
+    ) -> Option<SmallVec<[Keystroke; 2]>> {
+        if self.action.eq(action) && self.match_context(contexts) {
+            self.keystrokes.clone()
+        } else {
+            None
+        }
+    }
+
+    pub fn keystrokes(&self) -> Option<&[Keystroke]> {
+        self.keystrokes.as_deref()
+    }
+
+    pub fn action(&self) -> &dyn Action {
+        self.action.as_ref()
+    }
+}
+
+pub enum BindingMatchResult {
+    Complete(Box<dyn Action>),
+    Partial,
+    Fail,
+}

crates/gpui/src/keymap_matcher/keymap.rs

@@ -0,0 +1,61 @@
+use smallvec::SmallVec;
+use std::{
+    any::{Any, TypeId},
+    collections::HashMap,
+};
+
+use super::Binding;
+
+#[derive(Default)]
+pub struct Keymap {
+    bindings: Vec<Binding>,
+    binding_indices_by_action_type: HashMap<TypeId, SmallVec<[usize; 3]>>,
+}
+
+impl Keymap {
+    pub fn new(bindings: Vec<Binding>) -> Self {
+        let mut binding_indices_by_action_type = HashMap::new();
+        for (ix, binding) in bindings.iter().enumerate() {
+            binding_indices_by_action_type
+                .entry(binding.action().type_id())
+                .or_insert_with(SmallVec::new)
+                .push(ix);
+        }
+
+        Self {
+            binding_indices_by_action_type,
+            bindings,
+        }
+    }
+
+    pub(crate) fn bindings_for_action_type(
+        &self,
+        action_type: TypeId,
+    ) -> impl Iterator<Item = &'_ Binding> {
+        self.binding_indices_by_action_type
+            .get(&action_type)
+            .map(SmallVec::as_slice)
+            .unwrap_or(&[])
+            .iter()
+            .map(|ix| &self.bindings[*ix])
+    }
+
+    pub(crate) fn add_bindings<T: IntoIterator<Item = Binding>>(&mut self, bindings: T) {
+        for binding in bindings {
+            self.binding_indices_by_action_type
+                .entry(binding.action().as_any().type_id())
+                .or_default()
+                .push(self.bindings.len());
+            self.bindings.push(binding);
+        }
+    }
+
+    pub(crate) fn clear(&mut self) {
+        self.bindings.clear();
+        self.binding_indices_by_action_type.clear();
+    }
+
+    pub fn bindings(&self) -> &Vec<Binding> {
+        &self.bindings
+    }
+}

crates/gpui/src/keymap_matcher/keymap_context.rs

@@ -0,0 +1,298 @@
+use anyhow::{anyhow, Result};
+use collections::{HashMap, HashSet};
+
+#[derive(Clone, Debug, Default, Eq, PartialEq)]
+pub struct KeymapContext {
+    pub set: HashSet<String>,
+    pub map: HashMap<String, String>,
+}
+
+impl KeymapContext {
+    pub fn extend(&mut self, other: &Self) {
+        for v in &other.set {
+            self.set.insert(v.clone());
+        }
+        for (k, v) in &other.map {
+            self.map.insert(k.clone(), v.clone());
+        }
+    }
+}
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum KeymapContextPredicate {
+    Identifier(String),
+    Equal(String, String),
+    NotEqual(String, String),
+    Child(Box<KeymapContextPredicate>, Box<KeymapContextPredicate>),
+    Not(Box<KeymapContextPredicate>),
+    And(Box<KeymapContextPredicate>, Box<KeymapContextPredicate>),
+    Or(Box<KeymapContextPredicate>, Box<KeymapContextPredicate>),
+}
+
+impl KeymapContextPredicate {
+    pub fn parse(source: &str) -> Result<Self> {
+        let source = Self::skip_whitespace(source);
+        let (predicate, rest) = Self::parse_expr(source, 0)?;
+        if let Some(next) = rest.chars().next() {
+            Err(anyhow!("unexpected character {next:?}"))
+        } else {
+            Ok(predicate)
+        }
+    }
+
+    pub fn eval(&self, contexts: &[KeymapContext]) -> bool {
+        let Some(context) = contexts.first() else { return false };
+        match self {
+            Self::Identifier(name) => context.set.contains(name.as_str()),
+            Self::Equal(left, right) => context
+                .map
+                .get(left)
+                .map(|value| value == right)
+                .unwrap_or(false),
+            Self::NotEqual(left, right) => context
+                .map
+                .get(left)
+                .map(|value| value != right)
+                .unwrap_or(true),
+            Self::Not(pred) => !pred.eval(contexts),
+            Self::Child(parent, child) => parent.eval(&contexts[1..]) && child.eval(contexts),
+            Self::And(left, right) => left.eval(contexts) && right.eval(contexts),
+            Self::Or(left, right) => left.eval(contexts) || right.eval(contexts),
+        }
+    }
+
+    fn parse_expr(mut source: &str, min_precedence: u32) -> anyhow::Result<(Self, &str)> {
+        type Op =
+            fn(KeymapContextPredicate, KeymapContextPredicate) -> Result<KeymapContextPredicate>;
+
+        let (mut predicate, rest) = Self::parse_primary(source)?;
+        source = rest;
+
+        'parse: loop {
+            for (operator, precedence, constructor) in [
+                (">", PRECEDENCE_CHILD, Self::new_child as Op),
+                ("&&", PRECEDENCE_AND, Self::new_and as Op),
+                ("||", PRECEDENCE_OR, Self::new_or as Op),
+                ("==", PRECEDENCE_EQ, Self::new_eq as Op),
+                ("!=", PRECEDENCE_EQ, Self::new_neq as Op),
+            ] {
+                if source.starts_with(operator) && precedence >= min_precedence {
+                    source = Self::skip_whitespace(&source[operator.len()..]);
+                    let (right, rest) = Self::parse_expr(source, precedence + 1)?;
+                    predicate = constructor(predicate, right)?;
+                    source = rest;
+                    continue 'parse;
+                }
+            }
+            break;
+        }
+
+        Ok((predicate, source))
+    }
+
+    fn parse_primary(mut source: &str) -> anyhow::Result<(Self, &str)> {
+        let next = source
+            .chars()
+            .next()
+            .ok_or_else(|| anyhow!("unexpected eof"))?;
+        match next {
+            '(' => {
+                source = Self::skip_whitespace(&source[1..]);
+                let (predicate, rest) = Self::parse_expr(source, 0)?;
+                if rest.starts_with(')') {
+                    source = Self::skip_whitespace(&rest[1..]);
+                    Ok((predicate, source))
+                } else {
+                    Err(anyhow!("expected a ')'"))
+                }
+            }
+            '!' => {
+                let source = Self::skip_whitespace(&source[1..]);
+                let (predicate, source) = Self::parse_expr(&source, PRECEDENCE_NOT)?;
+                Ok((KeymapContextPredicate::Not(Box::new(predicate)), source))
+            }
+            _ if next.is_alphanumeric() || next == '_' => {
+                let len = source
+                    .find(|c: char| !(c.is_alphanumeric() || c == '_'))
+                    .unwrap_or(source.len());
+                let (identifier, rest) = source.split_at(len);
+                source = Self::skip_whitespace(rest);
+                Ok((
+                    KeymapContextPredicate::Identifier(identifier.into()),
+                    source,
+                ))
+            }
+            _ => Err(anyhow!("unexpected character {next:?}")),
+        }
+    }
+
+    fn skip_whitespace(source: &str) -> &str {
+        let len = source
+            .find(|c: char| !c.is_whitespace())
+            .unwrap_or(source.len());
+        &source[len..]
+    }
+
+    fn new_or(self, other: Self) -> Result<Self> {
+        Ok(Self::Or(Box::new(self), Box::new(other)))
+    }
+
+    fn new_and(self, other: Self) -> Result<Self> {
+        Ok(Self::And(Box::new(self), Box::new(other)))
+    }
+
+    fn new_child(self, other: Self) -> Result<Self> {
+        Ok(Self::Child(Box::new(self), Box::new(other)))
+    }
+
+    fn new_eq(self, other: Self) -> Result<Self> {
+        if let (Self::Identifier(left), Self::Identifier(right)) = (self, other) {
+            Ok(Self::Equal(left, right))
+        } else {
+            Err(anyhow!("operands must be identifiers"))
+        }
+    }
+
+    fn new_neq(self, other: Self) -> Result<Self> {
+        if let (Self::Identifier(left), Self::Identifier(right)) = (self, other) {
+            Ok(Self::NotEqual(left, right))
+        } else {
+            Err(anyhow!("operands must be identifiers"))
+        }
+    }
+}
+
+const PRECEDENCE_CHILD: u32 = 1;
+const PRECEDENCE_OR: u32 = 2;
+const PRECEDENCE_AND: u32 = 3;
+const PRECEDENCE_EQ: u32 = 4;
+const PRECEDENCE_NOT: u32 = 5;
+
+#[cfg(test)]
+mod tests {
+    use super::KeymapContextPredicate::{self, *};
+
+    #[test]
+    fn test_parse_identifiers() {
+        // Identifiers
+        assert_eq!(
+            KeymapContextPredicate::parse("abc12").unwrap(),
+            Identifier("abc12".into())
+        );
+        assert_eq!(
+            KeymapContextPredicate::parse("_1a").unwrap(),
+            Identifier("_1a".into())
+        );
+    }
+
+    #[test]
+    fn test_parse_negations() {
+        assert_eq!(
+            KeymapContextPredicate::parse("!abc").unwrap(),
+            Not(Box::new(Identifier("abc".into())))
+        );
+        assert_eq!(
+            KeymapContextPredicate::parse(" ! ! abc").unwrap(),
+            Not(Box::new(Not(Box::new(Identifier("abc".into())))))
+        );
+    }
+
+    #[test]
+    fn test_parse_equality_operators() {
+        assert_eq!(
+            KeymapContextPredicate::parse("a == b").unwrap(),
+            Equal("a".into(), "b".into())
+        );
+        assert_eq!(
+            KeymapContextPredicate::parse("c!=d").unwrap(),
+            NotEqual("c".into(), "d".into())
+        );
+        assert_eq!(
+            KeymapContextPredicate::parse("c == !d")
+                .unwrap_err()
+                .to_string(),
+            "operands must be identifiers"
+        );
+    }
+
+    #[test]
+    fn test_parse_boolean_operators() {
+        assert_eq!(
+            KeymapContextPredicate::parse("a || b").unwrap(),
+            Or(
+                Box::new(Identifier("a".into())),
+                Box::new(Identifier("b".into()))
+            )
+        );
+        assert_eq!(
+            KeymapContextPredicate::parse("a || !b && c").unwrap(),
+            Or(
+                Box::new(Identifier("a".into())),
+                Box::new(And(
+                    Box::new(Not(Box::new(Identifier("b".into())))),
+                    Box::new(Identifier("c".into()))
+                ))
+            )
+        );
+        assert_eq!(
+            KeymapContextPredicate::parse("a && b || c&&d").unwrap(),
+            Or(
+                Box::new(And(
+                    Box::new(Identifier("a".into())),
+                    Box::new(Identifier("b".into()))
+                )),
+                Box::new(And(
+                    Box::new(Identifier("c".into())),
+                    Box::new(Identifier("d".into()))
+                ))
+            )
+        );
+        assert_eq!(
+            KeymapContextPredicate::parse("a == b && c || d == e && f").unwrap(),
+            Or(
+                Box::new(And(
+                    Box::new(Equal("a".into(), "b".into())),
+                    Box::new(Identifier("c".into()))
+                )),
+                Box::new(And(
+                    Box::new(Equal("d".into(), "e".into())),
+                    Box::new(Identifier("f".into()))
+                ))
+            )
+        );
+        assert_eq!(
+            KeymapContextPredicate::parse("a && b && c && d").unwrap(),
+            And(
+                Box::new(And(
+                    Box::new(And(
+                        Box::new(Identifier("a".into())),
+                        Box::new(Identifier("b".into()))
+                    )),
+                    Box::new(Identifier("c".into())),
+                )),
+                Box::new(Identifier("d".into()))
+            ),
+        );
+    }
+
+    #[test]
+    fn test_parse_parenthesized_expressions() {
+        assert_eq!(
+            KeymapContextPredicate::parse("a && (b == c || d != e)").unwrap(),
+            And(
+                Box::new(Identifier("a".into())),
+                Box::new(Or(
+                    Box::new(Equal("b".into(), "c".into())),
+                    Box::new(NotEqual("d".into(), "e".into())),
+                )),
+            ),
+        );
+        assert_eq!(
+            KeymapContextPredicate::parse(" ( a || b ) ").unwrap(),
+            Or(
+                Box::new(Identifier("a".into())),
+                Box::new(Identifier("b".into())),
+            )
+        );
+    }
+}

crates/gpui/src/keymap_matcher/keystroke.rs

@@ -0,0 +1,97 @@
+use std::fmt::Write;
+
+use anyhow::anyhow;
+use serde::Deserialize;
+
+#[derive(Clone, Debug, Eq, PartialEq, Default, Deserialize)]
+pub struct Keystroke {
+    pub ctrl: bool,
+    pub alt: bool,
+    pub shift: bool,
+    pub cmd: bool,
+    pub function: bool,
+    pub key: String,
+}
+
+impl Keystroke {
+    pub fn parse(source: &str) -> anyhow::Result<Self> {
+        let mut ctrl = false;
+        let mut alt = false;
+        let mut shift = false;
+        let mut cmd = false;
+        let mut function = false;
+        let mut key = None;
+
+        let mut components = source.split('-').peekable();
+        while let Some(component) = components.next() {
+            match component {
+                "ctrl" => ctrl = true,
+                "alt" => alt = true,
+                "shift" => shift = true,
+                "cmd" => cmd = true,
+                "fn" => function = true,
+                _ => {
+                    if let Some(component) = components.peek() {
+                        if component.is_empty() && source.ends_with('-') {
+                            key = Some(String::from("-"));
+                            break;
+                        } else {
+                            return Err(anyhow!("Invalid keystroke `{}`", source));
+                        }
+                    } else {
+                        key = Some(String::from(component));
+                    }
+                }
+            }
+        }
+
+        let key = key.ok_or_else(|| anyhow!("Invalid keystroke `{}`", source))?;
+
+        Ok(Keystroke {
+            ctrl,
+            alt,
+            shift,
+            cmd,
+            function,
+            key,
+        })
+    }
+
+    pub fn modified(&self) -> bool {
+        self.ctrl || self.alt || self.shift || self.cmd
+    }
+}
+
+impl std::fmt::Display for Keystroke {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if self.ctrl {
+            f.write_char('^')?;
+        }
+        if self.alt {
+            f.write_char('⎇')?;
+        }
+        if self.cmd {
+            f.write_char('⌘')?;
+        }
+        if self.shift {
+            f.write_char('⇧')?;
+        }
+        let key = match self.key.as_str() {
+            "backspace" => '⌫',
+            "up" => '↑',
+            "down" => '↓',
+            "left" => '←',
+            "right" => '→',
+            "tab" => '⇥',
+            "escape" => '⎋',
+            key => {
+                if key.len() == 1 {
+                    key.chars().next().unwrap().to_ascii_uppercase()
+                } else {
+                    return f.write_str(key);
+                }
+            }
+        };
+        f.write_char(key)
+    }
+}

crates/gpui/src/platform.rs

@@ -14,7 +14,7 @@ use crate::{
         rect::{RectF, RectI},
         vector::Vector2F,
     },
-    keymap,
+    keymap_matcher::KeymapMatcher,
     text_layout::{LineLayout, RunStyle},
     Action, ClipboardItem, Menu, Scene,
 };
@@ -87,7 +87,7 @@ pub(crate) trait ForegroundPlatform {
     fn on_menu_command(&self, callback: Box<dyn FnMut(&dyn Action)>);
     fn on_validate_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>);
     fn on_will_open_menu(&self, callback: Box<dyn FnMut()>);
-    fn set_menus(&self, menus: Vec<Menu>, matcher: &keymap::Matcher);
+    fn set_menus(&self, menus: Vec<Menu>, matcher: &KeymapMatcher);
     fn prompt_for_paths(
         &self,
         options: PathPromptOptions,

crates/gpui/src/platform/event.rs

@@ -2,7 +2,7 @@ use std::ops::Deref;
 
 use pathfinder_geometry::vector::vec2f;
 
-use crate::{geometry::vector::Vector2F, keymap::Keystroke};
+use crate::{geometry::vector::Vector2F, keymap_matcher::Keystroke};
 
 #[derive(Clone, Debug)]
 pub struct KeyDownEvent {

crates/gpui/src/platform/mac/event.rs

@@ -1,6 +1,6 @@
 use crate::{
     geometry::vector::vec2f,
-    keymap::Keystroke,
+    keymap_matcher::Keystroke,
     platform::{Event, NavigationDirection},
     KeyDownEvent, KeyUpEvent, Modifiers, ModifiersChangedEvent, MouseButton, MouseButtonEvent,
     MouseMovedEvent, ScrollDelta, ScrollWheelEvent, TouchPhase,
@@ -47,6 +47,8 @@ pub fn key_to_native(key: &str) -> Cow<str> {
         "right" => NSRightArrowFunctionKey,
         "pageup" => NSPageUpFunctionKey,
         "pagedown" => NSPageDownFunctionKey,
+        "home" => NSHomeFunctionKey,
+        "end" => NSEndFunctionKey,
         "delete" => NSDeleteFunctionKey,
         "f1" => NSF1FunctionKey,
         "f2" => NSF2FunctionKey,
@@ -258,6 +260,8 @@ unsafe fn parse_keystroke(native_event: id) -> Keystroke {
         Some(NSRightArrowFunctionKey) => "right".to_string(),
         Some(NSPageUpFunctionKey) => "pageup".to_string(),
         Some(NSPageDownFunctionKey) => "pagedown".to_string(),
+        Some(NSHomeFunctionKey) => "home".to_string(),
+        Some(NSEndFunctionKey) => "end".to_string(),
         Some(NSDeleteFunctionKey) => "delete".to_string(),
         Some(NSF1FunctionKey) => "f1".to_string(),
         Some(NSF2FunctionKey) => "f2".to_string(),

crates/gpui/src/platform/mac/platform.rs

@@ -3,7 +3,8 @@ use super::{
     FontSystem, Window,
 };
 use crate::{
-    executor, keymap,
+    executor,
+    keymap_matcher::KeymapMatcher,
     platform::{self, CursorStyle},
     Action, AppVersion, ClipboardItem, Event, Menu, MenuItem,
 };
@@ -135,7 +136,7 @@ impl MacForegroundPlatform {
         menus: Vec<Menu>,
         delegate: id,
         actions: &mut Vec<Box<dyn Action>>,
-        keystroke_matcher: &keymap::Matcher,
+        keystroke_matcher: &KeymapMatcher,
     ) -> id {
         let application_menu = NSMenu::new(nil).autorelease();
         application_menu.setDelegate_(delegate);
@@ -172,7 +173,7 @@ impl MacForegroundPlatform {
         item: MenuItem,
         delegate: id,
         actions: &mut Vec<Box<dyn Action>>,
-        keystroke_matcher: &keymap::Matcher,
+        keystroke_matcher: &KeymapMatcher,
     ) -> id {
         match item {
             MenuItem::Separator => NSMenuItem::separatorItem(nil),
@@ -183,7 +184,7 @@ impl MacForegroundPlatform {
                     .map(|binding| binding.keystrokes());
 
                 let item;
-                if let Some(keystrokes) = keystrokes {
+                if let Some(keystrokes) = keystrokes.flatten() {
                     if keystrokes.len() == 1 {
                         let keystroke = &keystrokes[0];
                         let mut mask = NSEventModifierFlags::empty();
@@ -317,7 +318,7 @@ impl platform::ForegroundPlatform for MacForegroundPlatform {
         self.0.borrow_mut().validate_menu_command = Some(callback);
     }
 
-    fn set_menus(&self, menus: Vec<Menu>, keystroke_matcher: &keymap::Matcher) {
+    fn set_menus(&self, menus: Vec<Menu>, keystroke_matcher: &KeymapMatcher) {
         unsafe {
             let app: id = msg_send![APP_CLASS, sharedApplication];
             let mut state = self.0.borrow_mut();
@@ -647,7 +648,7 @@ impl platform::Platform for MacPlatform {
             attrs.set(kSecReturnAttributes as *const _, cf_true);
             attrs.set(kSecReturnData as *const _, cf_true);
 
-            let mut result = CFTypeRef::from(ptr::null_mut());
+            let mut result = CFTypeRef::from(ptr::null());
             let status = SecItemCopyMatching(attrs.as_concrete_TypeRef(), &mut result);
             match status {
                 security::errSecSuccess => {}

crates/gpui/src/platform/mac/window.rs

@@ -4,7 +4,7 @@ use crate::{
         rect::RectF,
         vector::{vec2f, Vector2F},
     },
-    keymap::Keystroke,
+    keymap_matcher::Keystroke,
     mac::platform::NSViewLayerContentsRedrawDuringViewResize,
     platform::{
         self,

crates/gpui/src/platform/test.rs

@@ -4,7 +4,8 @@ use crate::{
         rect::RectF,
         vector::{vec2f, Vector2F},
     },
-    keymap, Action, ClipboardItem,
+    keymap_matcher::KeymapMatcher,
+    Action, ClipboardItem,
 };
 use anyhow::{anyhow, Result};
 use collections::VecDeque;
@@ -84,7 +85,7 @@ impl super::ForegroundPlatform for ForegroundPlatform {
     fn on_menu_command(&self, _: Box<dyn FnMut(&dyn Action)>) {}
     fn on_validate_menu_command(&self, _: Box<dyn FnMut(&dyn Action) -> bool>) {}
     fn on_will_open_menu(&self, _: Box<dyn FnMut()>) {}
-    fn set_menus(&self, _: Vec<crate::Menu>, _: &keymap::Matcher) {}
+    fn set_menus(&self, _: Vec<crate::Menu>, _: &KeymapMatcher) {}
 
     fn prompt_for_paths(
         &self,

crates/gpui/src/presenter.rs

@@ -4,7 +4,7 @@ use crate::{
     font_cache::FontCache,
     geometry::rect::RectF,
     json::{self, ToJson},
-    keymap::Keystroke,
+    keymap_matcher::Keystroke,
     platform::{CursorStyle, Event},
     scene::{
         CursorRegion, MouseClick, MouseDown, MouseDownOut, MouseDrag, MouseEvent, MouseHover,
@@ -573,7 +573,7 @@ pub struct LayoutContext<'a> {
 
 impl<'a> LayoutContext<'a> {
     pub(crate) fn keystrokes_for_action(
-        &self,
+        &mut self,
         action: &dyn Action,
     ) -> Option<SmallVec<[Keystroke; 2]>> {
         self.app

crates/gpui/src/test.rs

@@ -1,7 +1,10 @@
 use crate::{
-    elements::Empty, executor, platform, util::CwdBacktrace, Element, ElementBox, Entity,
-    FontCache, Handle, LeakDetector, MutableAppContext, Platform, RenderContext, Subscription,
-    TestAppContext, View,
+    elements::Empty,
+    executor::{self, ExecutorEvent},
+    platform,
+    util::CwdBacktrace,
+    Element, ElementBox, Entity, FontCache, Handle, LeakDetector, MutableAppContext, Platform,
+    RenderContext, Subscription, TestAppContext, View,
 };
 use futures::StreamExt;
 use parking_lot::Mutex;
@@ -62,7 +65,7 @@ pub fn run_test(
             let platform = Arc::new(platform::test::platform());
             let font_system = platform.fonts();
             let font_cache = Arc::new(FontCache::new(font_system));
-            let mut prev_runnable_history: Option<Vec<usize>> = None;
+            let mut prev_runnable_history: Option<Vec<ExecutorEvent>> = None;
 
             for _ in 0..num_iterations {
                 let seed = atomic_seed.load(SeqCst);
@@ -73,6 +76,7 @@ pub fn run_test(
 
                 let deterministic = executor::Deterministic::new(seed);
                 if detect_nondeterminism {
+                    deterministic.set_previous_execution_history(prev_runnable_history.clone());
                     deterministic.enable_runnable_backtrace();
                 }
 
@@ -98,7 +102,7 @@ pub fn run_test(
                 leak_detector.lock().detect();
 
                 if detect_nondeterminism {
-                    let curr_runnable_history = deterministic.runnable_history();
+                    let curr_runnable_history = deterministic.execution_history();
                     if let Some(prev_runnable_history) = prev_runnable_history {
                         let mut prev_entries = prev_runnable_history.iter().fuse();
                         let mut curr_entries = curr_runnable_history.iter().fuse();
@@ -138,7 +142,7 @@ pub fn run_test(
 
                             let last_common_backtrace = common_history_prefix
                                 .last()
-                                .map(|runnable_id| deterministic.runnable_backtrace(*runnable_id));
+                                .map(|event| deterministic.runnable_backtrace(event.id()));
 
                             writeln!(
                                 &mut error,

crates/gpui_macros/src/gpui_macros.rs

@@ -162,11 +162,9 @@ pub fn test(args: TokenStream, function: TokenStream) -> TokenStream {
             if let FnArg::Typed(arg) = arg {
                 if let Type::Path(ty) = &*arg.ty {
                     let last_segment = ty.path.segments.last();
-                    match last_segment.map(|s| s.ident.to_string()).as_deref() {
-                        Some("StdRng") => {
-                            inner_fn_args.extend(quote!(rand::SeedableRng::seed_from_u64(seed),));
-                        }
-                        _ => {}
+
+                    if let Some("StdRng") = last_segment.map(|s| s.ident.to_string()).as_deref() {
+                        inner_fn_args.extend(quote!(rand::SeedableRng::seed_from_u64(seed),));
                     }
                 } else {
                     inner_fn_args.extend(quote!(cx,));

crates/language/src/buffer.rs

@@ -385,6 +385,12 @@ impl Buffer {
             rpc::proto::LineEnding::from_i32(message.line_ending)
                 .ok_or_else(|| anyhow!("missing line_ending"))?,
         ));
+        this.saved_version = proto::deserialize_version(message.saved_version);
+        this.saved_version_fingerprint = message.saved_version_fingerprint;
+        this.saved_mtime = message
+            .saved_mtime
+            .ok_or_else(|| anyhow!("invalid saved_mtime"))?
+            .into();
         Ok(this)
     }
 
@@ -395,10 +401,17 @@ impl Buffer {
             base_text: self.base_text().to_string(),
             diff_base: self.diff_base.as_ref().map(|h| h.to_string()),
             line_ending: proto::serialize_line_ending(self.line_ending()) as i32,
+            saved_version: proto::serialize_version(&self.saved_version),
+            saved_version_fingerprint: self.saved_version_fingerprint.clone(),
+            saved_mtime: Some(self.saved_mtime.into()),
         }
     }
 
-    pub fn serialize_ops(&self, cx: &AppContext) -> Task<Vec<proto::Operation>> {
+    pub fn serialize_ops(
+        &self,
+        since: Option<clock::Global>,
+        cx: &AppContext,
+    ) -> Task<Vec<proto::Operation>> {
         let mut operations = Vec::new();
         operations.extend(self.deferred_ops.iter().map(proto::serialize_operation));
         operations.extend(self.remote_selections.iter().map(|(_, set)| {
@@ -422,9 +435,11 @@ impl Buffer {
 
         let text_operations = self.text.operations().clone();
         cx.background().spawn(async move {
+            let since = since.unwrap_or_default();
             operations.extend(
                 text_operations
                     .iter()
+                    .filter(|(_, op)| !since.observed(op.local_timestamp()))
                     .map(|(_, op)| proto::serialize_operation(&Operation::Buffer(op.clone()))),
             );
             operations.sort_unstable_by_key(proto::lamport_timestamp_for_operation);
@@ -508,8 +523,8 @@ impl Buffer {
         self.text.snapshot()
     }
 
-    pub fn file(&self) -> Option<&dyn File> {
-        self.file.as_deref()
+    pub fn file(&self) -> Option<&Arc<dyn File>> {
+        self.file.as_ref()
     }
 
     pub fn save(
@@ -543,6 +558,14 @@ impl Buffer {
         &self.saved_version
     }
 
+    pub fn saved_version_fingerprint(&self) -> &str {
+        &self.saved_version_fingerprint
+    }
+
+    pub fn saved_mtime(&self) -> SystemTime {
+        self.saved_mtime
+    }
+
     pub fn set_language(&mut self, language: Option<Arc<Language>>, cx: &mut ModelContext<Self>) {
         self.syntax_map.lock().clear();
         self.language = language;
@@ -676,7 +699,6 @@ impl Buffer {
         task
     }
 
-    #[cfg(any(test, feature = "test-support"))]
     pub fn diff_base(&self) -> Option<&str> {
         self.diff_base.as_deref()
     }
@@ -1327,13 +1349,6 @@ impl Buffer {
         let edit_id = edit_operation.local_timestamp();
 
         if let Some((before_edit, mode)) = autoindent_request {
-            let (start_columns, is_block_mode) = match mode {
-                AutoindentMode::Block {
-                    original_indent_columns: start_columns,
-                } => (start_columns, true),
-                AutoindentMode::EachLine => (Default::default(), false),
-            };
-
             let mut delta = 0isize;
             let entries = edits
                 .into_iter()
@@ -1347,7 +1362,7 @@ impl Buffer {
 
                     let mut range_of_insertion_to_indent = 0..new_text_len;
                     let mut first_line_is_new = false;
-                    let mut start_column = None;
+                    let mut original_indent_column = None;
 
                     // When inserting an entire line at the beginning of an existing line,
                     // treat the insertion as new.
@@ -1359,14 +1374,23 @@ impl Buffer {
 
                     // When inserting text starting with a newline, avoid auto-indenting the
                     // previous line.
-                    if new_text[range_of_insertion_to_indent.clone()].starts_with('\n') {
+                    if new_text.starts_with('\n') {
                         range_of_insertion_to_indent.start += 1;
                         first_line_is_new = true;
                     }
 
                     // Avoid auto-indenting after the insertion.
-                    if is_block_mode {
-                        start_column = start_columns.get(ix).copied();
+                    if let AutoindentMode::Block {
+                        original_indent_columns,
+                    } = &mode
+                    {
+                        original_indent_column =
+                            Some(original_indent_columns.get(ix).copied().unwrap_or_else(|| {
+                                indent_size_for_text(
+                                    new_text[range_of_insertion_to_indent.clone()].chars(),
+                                )
+                                .len
+                            }));
                         if new_text[range_of_insertion_to_indent.clone()].ends_with('\n') {
                             range_of_insertion_to_indent.end -= 1;
                         }
@@ -1374,7 +1398,7 @@ impl Buffer {
 
                     AutoindentRequestEntry {
                         first_line_is_new,
-                        original_indent_column: start_column,
+                        original_indent_column,
                         indent_size: before_edit.language_indent_size_at(range.start, cx),
                         range: self.anchor_before(new_start + range_of_insertion_to_indent.start)
                             ..self.anchor_after(new_start + range_of_insertion_to_indent.end),
@@ -1385,7 +1409,7 @@ impl Buffer {
             self.autoindent_requests.push(Arc::new(AutoindentRequest {
                 before_edit,
                 entries,
-                is_block_mode,
+                is_block_mode: matches!(mode, AutoindentMode::Block { .. }),
             }));
         }
 
@@ -2310,13 +2334,21 @@ impl BufferSnapshot {
             })
     }
 
-    pub fn git_diff_hunks_in_range<'a>(
+    pub fn git_diff_hunks_in_row_range<'a>(
         &'a self,
-        query_row_range: Range<u32>,
+        range: Range<u32>,
+        reversed: bool,
+    ) -> impl 'a + Iterator<Item = git::diff::DiffHunk<u32>> {
+        self.git_diff.hunks_in_row_range(range, self, reversed)
+    }
+
+    pub fn git_diff_hunks_intersecting_range<'a>(
+        &'a self,
+        range: Range<Anchor>,
         reversed: bool,
     ) -> impl 'a + Iterator<Item = git::diff::DiffHunk<u32>> {
         self.git_diff
-            .hunks_in_range(query_row_range, self, reversed)
+            .hunks_intersecting_range(range, self, reversed)
     }
 
     pub fn diagnostics_in_range<'a, T, O>(
@@ -2359,8 +2391,8 @@ impl BufferSnapshot {
         self.selections_update_count
     }
 
-    pub fn file(&self) -> Option<&dyn File> {
-        self.file.as_deref()
+    pub fn file(&self) -> Option<&Arc<dyn File>> {
+        self.file.as_ref()
     }
 
     pub fn resolve_file_path(&self, cx: &AppContext, include_root: bool) -> Option<PathBuf> {
@@ -2384,7 +2416,7 @@ impl BufferSnapshot {
     }
 }
 
-pub fn indent_size_for_line(text: &text::BufferSnapshot, row: u32) -> IndentSize {
+fn indent_size_for_line(text: &text::BufferSnapshot, row: u32) -> IndentSize {
     indent_size_for_text(text.chars_at(Point::new(row, 0)))
 }
 

crates/language/src/buffer_tests.rs

@@ -289,6 +289,9 @@ async fn test_reparse(cx: &mut gpui::TestAppContext) {
     );
 
     buffer.update(cx, |buf, cx| {
+        buf.undo(cx);
+        buf.undo(cx);
+        buf.undo(cx);
         buf.undo(cx);
         assert_eq!(buf.text(), "fn a() {}");
         assert!(buf.is_parsing());
@@ -304,6 +307,9 @@ async fn test_reparse(cx: &mut gpui::TestAppContext) {
     );
 
     buffer.update(cx, |buf, cx| {
+        buf.redo(cx);
+        buf.redo(cx);
+        buf.redo(cx);
         buf.redo(cx);
         assert_eq!(buf.text(), "fn a(b: C) { d.e::<G>(f); }");
         assert!(buf.is_parsing());
@@ -989,12 +995,17 @@ fn test_autoindent_block_mode(cx: &mut MutableAppContext) {
         .unindent();
         let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
 
+        // When this text was copied, both of the quotation marks were at the same
+        // indent level, but the indentation of the first line was not included in
+        // the copied text. This information is retained in the
+        // 'original_indent_columns' vector.
+        let original_indent_columns = vec![4];
         let inserted_text = r#"
             "
-              c
-                d
-                  e
-            "
+                  c
+                    d
+                      e
+                "
         "#
         .unindent();
 
@@ -1003,7 +1014,7 @@ fn test_autoindent_block_mode(cx: &mut MutableAppContext) {
         buffer.edit(
             [(Point::new(2, 0)..Point::new(2, 0), inserted_text.clone())],
             Some(AutoindentMode::Block {
-                original_indent_columns: vec![0],
+                original_indent_columns: original_indent_columns.clone(),
             }),
             cx,
         );
@@ -1022,13 +1033,16 @@ fn test_autoindent_block_mode(cx: &mut MutableAppContext) {
             .unindent()
         );
 
+        // Grouping is disabled in tests, so we need 2 undos
+        buffer.undo(cx); // Undo the auto-indent
+        buffer.undo(cx); // Undo the original edit
+
         // Insert the block at a deeper indent level. The entire block is outdented.
-        buffer.undo(cx);
         buffer.edit([(Point::new(2, 0)..Point::new(2, 0), "        ")], None, cx);
         buffer.edit(
             [(Point::new(2, 8)..Point::new(2, 8), inserted_text)],
             Some(AutoindentMode::Block {
-                original_indent_columns: vec![0],
+                original_indent_columns: original_indent_columns.clone(),
             }),
             cx,
         );
@@ -1051,6 +1065,84 @@ fn test_autoindent_block_mode(cx: &mut MutableAppContext) {
     });
 }
 
+#[gpui::test]
+fn test_autoindent_block_mode_without_original_indent_columns(cx: &mut MutableAppContext) {
+    cx.set_global(Settings::test(cx));
+    cx.add_model(|cx| {
+        let text = r#"
+            fn a() {
+                if b() {
+
+                }
+            }
+        "#
+        .unindent();
+        let mut buffer = Buffer::new(0, text, cx).with_language(Arc::new(rust_lang()), cx);
+
+        // The original indent columns are not known, so this text is
+        // auto-indented in a block as if the first line was copied in
+        // its entirety.
+        let original_indent_columns = Vec::new();
+        let inserted_text = "    c\n        .d()\n        .e();";
+
+        // Insert the block at column zero. The entire block is indented
+        // so that the first line matches the previous line's indentation.
+        buffer.edit(
+            [(Point::new(2, 0)..Point::new(2, 0), inserted_text.clone())],
+            Some(AutoindentMode::Block {
+                original_indent_columns: original_indent_columns.clone(),
+            }),
+            cx,
+        );
+        assert_eq!(
+            buffer.text(),
+            r#"
+            fn a() {
+                if b() {
+                    c
+                        .d()
+                        .e();
+                }
+            }
+            "#
+            .unindent()
+        );
+
+        // Grouping is disabled in tests, so we need 2 undos
+        buffer.undo(cx); // Undo the auto-indent
+        buffer.undo(cx); // Undo the original edit
+
+        // Insert the block at a deeper indent level. The entire block is outdented.
+        buffer.edit(
+            [(Point::new(2, 0)..Point::new(2, 0), " ".repeat(12))],
+            None,
+            cx,
+        );
+        buffer.edit(
+            [(Point::new(2, 12)..Point::new(2, 12), inserted_text)],
+            Some(AutoindentMode::Block {
+                original_indent_columns: Vec::new(),
+            }),
+            cx,
+        );
+        assert_eq!(
+            buffer.text(),
+            r#"
+            fn a() {
+                if b() {
+                    c
+                        .d()
+                        .e();
+                }
+            }
+            "#
+            .unindent()
+        );
+
+        buffer
+    });
+}
+
 #[gpui::test]
 fn test_autoindent_language_without_indents_query(cx: &mut MutableAppContext) {
     cx.set_global(Settings::test(cx));
@@ -1275,7 +1367,9 @@ fn test_serialization(cx: &mut gpui::MutableAppContext) {
     assert_eq!(buffer1.read(cx).text(), "abcDF");
 
     let state = buffer1.read(cx).to_proto();
-    let ops = cx.background().block(buffer1.read(cx).serialize_ops(cx));
+    let ops = cx
+        .background()
+        .block(buffer1.read(cx).serialize_ops(None, cx));
     let buffer2 = cx.add_model(|cx| {
         let mut buffer = Buffer::from_proto(1, state, None).unwrap();
         buffer
@@ -1316,7 +1410,7 @@ fn test_random_collaboration(cx: &mut MutableAppContext, mut rng: StdRng) {
             let state = base_buffer.read(cx).to_proto();
             let ops = cx
                 .background()
-                .block(base_buffer.read(cx).serialize_ops(cx));
+                .block(base_buffer.read(cx).serialize_ops(None, cx));
             let mut buffer = Buffer::from_proto(i as ReplicaId, state, None).unwrap();
             buffer
                 .apply_ops(
@@ -1413,7 +1507,9 @@ fn test_random_collaboration(cx: &mut MutableAppContext, mut rng: StdRng) {
             }
             50..=59 if replica_ids.len() < max_peers => {
                 let old_buffer_state = buffer.read(cx).to_proto();
-                let old_buffer_ops = cx.background().block(buffer.read(cx).serialize_ops(cx));
+                let old_buffer_ops = cx
+                    .background()
+                    .block(buffer.read(cx).serialize_ops(None, cx));
                 let new_replica_id = (0..=replica_ids.len() as ReplicaId)
                     .filter(|replica_id| *replica_id != buffer.read(cx).replica_id())
                     .choose(&mut rng)

crates/language/src/proto.rs

@@ -9,7 +9,7 @@ use rpc::proto;
 use std::{ops::Range, sync::Arc};
 use text::*;
 
-pub use proto::{BufferState, Operation, SelectionSet};
+pub use proto::{BufferState, Operation};
 
 pub fn deserialize_line_ending(message: proto::LineEnding) -> fs::LineEnding {
     match message {
@@ -122,8 +122,14 @@ pub fn serialize_selections(selections: &Arc<[Selection<Anchor>]>) -> Vec<proto:
 pub fn serialize_selection(selection: &Selection<Anchor>) -> proto::Selection {
     proto::Selection {
         id: selection.id as u64,
-        start: Some(serialize_anchor(&selection.start)),
-        end: Some(serialize_anchor(&selection.end)),
+        start: Some(proto::EditorAnchor {
+            anchor: Some(serialize_anchor(&selection.start)),
+            excerpt_id: 0,
+        }),
+        end: Some(proto::EditorAnchor {
+            anchor: Some(serialize_anchor(&selection.end)),
+            excerpt_id: 0,
+        }),
         reversed: selection.reversed,
     }
 }
@@ -229,8 +235,8 @@ pub fn deserialize_operation(message: proto::Operation) -> Result<crate::Operati
                     .filter_map(|selection| {
                         Some(Selection {
                             id: selection.id as usize,
-                            start: deserialize_anchor(selection.start?)?,
-                            end: deserialize_anchor(selection.end?)?,
+                            start: deserialize_anchor(selection.start?.anchor?)?,
+                            end: deserialize_anchor(selection.end?.anchor?)?,
                             reversed: selection.reversed,
                             goal: SelectionGoal::None,
                         })
@@ -321,8 +327,8 @@ pub fn deserialize_selections(selections: Vec<proto::Selection>) -> Arc<[Selecti
 pub fn deserialize_selection(selection: proto::Selection) -> Option<Selection<Anchor>> {
     Some(Selection {
         id: selection.id as usize,
-        start: deserialize_anchor(selection.start?)?,
-        end: deserialize_anchor(selection.end?)?,
+        start: deserialize_anchor(selection.start?.anchor?)?,
+        end: deserialize_anchor(selection.end?.anchor?)?,
         reversed: selection.reversed,
         goal: SelectionGoal::None,
     })