v0.79.x stable

changed language status bar item to only show on editors

.dockerignore

@@ -8,4 +8,4 @@ crates/collab/static/styles.css
 vendor/bin
 assets/themes/*.json
 assets/themes/internal/*.json
-assets/themes/experiments/*.json
+assets/themes/staff/*.json

.github/pull_request_template.md

@@ -1,6 +1,6 @@
 ## Description of feature or change
 
-## Link to related issues from zed or insiders
+## Link to related issues from zed or community
 
 ## Before Merging 
 

.github/workflows/ci.yml

@@ -4,7 +4,7 @@ on:
   push:
     branches:
       - main
-      - "v*"
+      - "v[0-9]+.[0-9]+.x"
     tags:
       - "v*"
   pull_request:
@@ -17,6 +17,26 @@ env:
   RUST_BACKTRACE: 1
 
 jobs:
+  rustfmt:
+    name: Check formatting
+    runs-on:
+      - self-hosted
+      - test
+    steps:
+      - name: Install Rust
+        run: |
+          rustup set profile minimal
+          rustup update stable
+
+      - name: Checkout repo
+        uses: actions/checkout@v2
+        with:
+          clean: false
+          submodules: 'recursive'
+
+      - name: cargo fmt
+        run: cargo fmt --all -- --check
+
   tests:
     name: Run tests
     runs-on:
@@ -41,16 +61,22 @@ jobs:
         with:
           clean: false
           submodules: 'recursive'
-            
+
+      - name: Run check
+        run: cargo check --workspace
+
       - name: Run tests
         run: cargo test --workspace --no-fail-fast
-    
+
       - name: Build collab
         run: cargo build -p collab
 
       - name: Build other binaries
         run: cargo build --workspace --bins --all-features
 
+      - name: Generate license file
+        run: script/generate-licenses
+
   bundle:
     name: Bundle app
     runs-on:
@@ -109,6 +135,9 @@ jobs:
             exit 1
           fi
 
+      - name: Generate license file
+        run: script/generate-licenses
+
       - name: Create app bundle
         run: script/bundle
 

.github/workflows/release_actions.yml

@@ -13,12 +13,12 @@ jobs:
         webhook-url: ${{ secrets.DISCORD_WEBHOOK_URL }}
         content: |
           📣 Zed ${{ github.event.release.tag_name }} was just released!
-          
+
           Restart your Zed or head to https://zed.dev/releases/latest to grab it.
-        
+
           ```md
           # Changelog
-          
+
           ${{ github.event.release.body }}
           ```
   mixpanel_release:
@@ -31,7 +31,7 @@ jobs:
           architecture: "x64"
           cache: "pip"
       - run: pip install -r script/mixpanel_release/requirements.txt
-      - run: > 
+      - run: >
           python script/mixpanel_release/main.py
           ${{ github.event.release.tag_name }}
           ${{ secrets.MIXPANEL_PROJECT_ID }}

.gitignore

@@ -7,8 +7,8 @@
 /crates/collab/static/styles.css
 /vendor/bin
 /assets/themes/*.json
-/assets/themes/Internal/*.json
-/assets/themes/Experiments/*.json
+/assets/*licenses.md
+/assets/themes/staff/*.json
 **/venv
 .build
 Packages

Cargo.lock

@@ -259,6 +259,21 @@ dependencies = [
  "futures-lite",
 ]
 
+[[package]]
+name = "async-global-executor"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1b6f5d7df27bd294849f8eec66ecfc63d11814df7a4f5d74168a2394467b776"
+dependencies = [
+ "async-channel",
+ "async-executor",
+ "async-io",
+ "async-lock",
+ "blocking",
+ "futures-lite",
+ "once_cell",
+]
+
 [[package]]
 name = "async-io"
 version = "1.12.0"
@@ -350,6 +365,32 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "async-std"
+version = "1.12.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "62565bb4402e926b29953c785397c6dc0391b7b446e45008b0049eb43cec6f5d"
+dependencies = [
+ "async-channel",
+ "async-global-executor",
+ "async-io",
+ "async-lock",
+ "crossbeam-utils 0.8.14",
+ "futures-channel",
+ "futures-core",
+ "futures-io",
+ "futures-lite",
+ "gloo-timers",
+ "kv-log-macro",
+ "log",
+ "memchr",
+ "once_cell",
+ "pin-project-lite 0.2.9",
+ "pin-utils",
+ "slab",
+ "wasm-bindgen-futures",
+]
+
 [[package]]
 name = "async-stream"
 version = "0.3.3"
@@ -371,6 +412,20 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "async-tar"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c49359998a76e32ef6e870dbc079ebad8f1e53e8441c5dd39d27b44493fe331"
+dependencies = [
+ "async-std",
+ "filetime",
+ "libc",
+ "pin-project",
+ "redox_syscall",
+ "xattr",
+]
+
 [[package]]
 name = "async-task"
 version = "4.0.3"
@@ -463,6 +518,7 @@ dependencies = [
  "menu",
  "project",
  "serde",
+ "serde_derive",
  "serde_json",
  "settings",
  "smol",
@@ -739,8 +795,7 @@ dependencies = [
 [[package]]
 name = "bromberg_sl2"
 version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ed88064f69518b7e3ea50ecfc1b61d43f19248618a377b95ae5c8b611134d4d"
+source = "git+https://github.com/zed-industries/bromberg_sl2?rev=950bc5482c216c395049ae33ae4501e08975f17f#950bc5482c216c395049ae33ae4501e08975f17f"
 dependencies = [
  "digest 0.9.0",
  "lazy_static",
@@ -829,6 +884,7 @@ dependencies = [
  "media",
  "postage",
  "project",
+ "settings",
  "util",
 ]
 
@@ -1042,6 +1098,7 @@ dependencies = [
  "ipc-channel",
  "plist",
  "serde",
+ "serde_derive",
 ]
 
 [[package]]
@@ -1064,6 +1121,7 @@ dependencies = [
  "rand 0.8.5",
  "rpc",
  "serde",
+ "serde_derive",
  "settings",
  "smol",
  "sum_tree",
@@ -1133,7 +1191,7 @@ dependencies = [
 
 [[package]]
 name = "collab"
-version = "0.4.2"
+version = "0.8.2"
 dependencies = [
  "anyhow",
  "async-tungstenite",
@@ -1173,6 +1231,7 @@ dependencies = [
  "sea-orm",
  "sea-query",
  "serde",
+ "serde_derive",
  "serde_json",
  "settings",
  "sha-1 0.9.8",
@@ -1197,11 +1256,14 @@ name = "collab_ui"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "auto_update",
  "call",
  "client",
  "clock",
  "collections",
+ "context_menu",
  "editor",
+ "feedback",
  "futures 0.3.25",
  "fuzzy",
  "gpui",
@@ -1211,6 +1273,7 @@ dependencies = [
  "postage",
  "project",
  "serde",
+ "serde_derive",
  "settings",
  "theme",
  "util",
@@ -1276,6 +1339,7 @@ source = "git+https://github.com/servo/core-foundation-rs?rev=079665882507dd5e2f
 dependencies = [
  "core-foundation-sys",
  "libc",
+ "uuid 0.5.1",
 ]
 
 [[package]]
@@ -1680,6 +1744,7 @@ dependencies = [
  "log",
  "parking_lot 0.11.2",
  "serde",
+ "serde_derive",
  "smol",
  "sqlez",
  "sqlez_macros",
@@ -1888,6 +1953,7 @@ dependencies = [
  "rand 0.8.5",
  "rpc",
  "serde",
+ "serde_derive",
  "settings",
  "smallvec",
  "smol",
@@ -1900,6 +1966,7 @@ dependencies = [
  "tree-sitter-html",
  "tree-sitter-javascript",
  "tree-sitter-rust",
+ "tree-sitter-typescript 0.20.2",
  "unindent",
  "util",
  "workspace",
@@ -2022,6 +2089,34 @@ dependencies = [
  "instant",
 ]
 
+[[package]]
+name = "feedback"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "client",
+ "editor",
+ "futures 0.3.25",
+ "gpui",
+ "human_bytes",
+ "isahc",
+ "language",
+ "lazy_static",
+ "log",
+ "postage",
+ "project",
+ "search",
+ "serde",
+ "serde_derive",
+ "settings",
+ "sysinfo",
+ "theme",
+ "tree-sitter-markdown",
+ "urlencoding",
+ "util",
+ "workspace",
+]
+
 [[package]]
 name = "file-per-thread-logger"
 version = "0.1.5"
@@ -2052,6 +2147,18 @@ dependencies = [
  "workspace",
 ]
 
+[[package]]
+name = "filetime"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e884668cd0c7480504233e951174ddc3b382f7c2666e3b7310b5c4e7b0c37f9"
+dependencies = [
+ "cfg-if 1.0.0",
+ "libc",
+ "redox_syscall",
+ "windows-sys 0.42.0",
+]
+
 [[package]]
 name = "fixedbitset"
 version = "0.4.2"
@@ -2197,6 +2304,7 @@ dependencies = [
  "regex",
  "rope",
  "serde",
+ "serde_derive",
  "serde_json",
  "smol",
  "tempfile",
@@ -2500,6 +2608,18 @@ dependencies = [
  "regex",
 ]
 
+[[package]]
+name = "gloo-timers"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b995a66bb87bebce9a0f4a95aed01daca4872c050bfcb21653361c03bc35e5c"
+dependencies = [
+ "futures-channel",
+ "futures-core",
+ "js-sys",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "go_to_line"
 version = "0.1.0"
@@ -2553,8 +2673,10 @@ dependencies = [
  "postage",
  "rand 0.8.5",
  "resvg",
+ "schemars",
  "seahash",
  "serde",
+ "serde_derive",
  "serde_json",
  "simplelog",
  "smallvec",
@@ -2563,9 +2685,9 @@ dependencies = [
  "sum_tree",
  "time 0.3.17",
  "tiny-skia",
- "tree-sitter",
  "usvg",
  "util",
+ "uuid 1.2.2",
  "waker-fn",
 ]
 
@@ -2908,6 +3030,17 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "adab1eaa3408fb7f0c777a73e7465fd5656136fc93b670eb6df3c88c2c1344e3"
 
+[[package]]
+name = "install_cli"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "gpui",
+ "log",
+ "smol",
+ "util",
+]
+
 [[package]]
 name = "instant"
 version = "0.1.12"
@@ -3047,6 +3180,7 @@ dependencies = [
 name = "journal"
 version = "0.1.0"
 dependencies = [
+ "anyhow",
  "chrono",
  "dirs 4.0.0",
  "editor",
@@ -3116,6 +3250,15 @@ dependencies = [
  "arrayvec 0.7.2",
 ]
 
+[[package]]
+name = "kv-log-macro"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0de8b303297635ad57c9f5059fd9cee7a47f8e8daa09df0fcd07dd39fb22977f"
+dependencies = [
+ "log",
+]
+
 [[package]]
 name = "language"
 version = "0.1.0"
@@ -3133,6 +3276,7 @@ dependencies = [
  "fuzzy",
  "git",
  "gpui",
+ "indoc",
  "lazy_static",
  "log",
  "lsp",
@@ -3142,6 +3286,7 @@ dependencies = [
  "regex",
  "rpc",
  "serde",
+ "serde_derive",
  "serde_json",
  "settings",
  "similar",
@@ -3155,14 +3300,32 @@ dependencies = [
  "tree-sitter-html",
  "tree-sitter-javascript",
  "tree-sitter-json 0.19.0",
+ "tree-sitter-markdown",
  "tree-sitter-python",
  "tree-sitter-ruby",
  "tree-sitter-rust",
- "tree-sitter-typescript",
+ "tree-sitter-typescript 0.20.1",
+ "unicase",
  "unindent",
  "util",
 ]
 
+[[package]]
+name = "language_selector"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "editor",
+ "fuzzy",
+ "gpui",
+ "language",
+ "picker",
+ "project",
+ "settings",
+ "theme",
+ "workspace",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -3319,6 +3482,7 @@ dependencies = [
  "parking_lot 0.11.2",
  "postage",
  "serde",
+ "serde_derive",
  "serde_json",
  "sha2 0.10.6",
  "simplelog",
@@ -3339,6 +3503,7 @@ dependencies = [
  "prost-types 0.8.0",
  "reqwest",
  "serde",
+ "serde_derive",
  "sha2 0.10.6",
 ]
 
@@ -3379,6 +3544,7 @@ dependencies = [
  "parking_lot 0.11.2",
  "postage",
  "serde",
+ "serde_derive",
  "serde_json",
  "smol",
  "unindent",
@@ -4298,6 +4464,7 @@ dependencies = [
  "bincode",
  "plugin_macros",
  "serde",
+ "serde_derive",
 ]
 
 [[package]]
@@ -4308,6 +4475,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "serde",
+ "serde_derive",
  "syn",
 ]
 
@@ -4319,6 +4487,7 @@ dependencies = [
  "bincode",
  "pollster",
  "serde",
+ "serde_derive",
  "serde_json",
  "smol",
  "wasi-common",
@@ -4470,11 +4639,13 @@ dependencies = [
  "lsp",
  "parking_lot 0.11.2",
  "postage",
+ "pretty_assertions",
  "pulldown-cmark",
  "rand 0.8.5",
  "regex",
  "rpc",
  "serde",
+ "serde_derive",
  "serde_json",
  "settings",
  "sha2 0.10.6",
@@ -5097,6 +5268,7 @@ dependencies = [
  "rand 0.8.5",
  "rsa",
  "serde",
+ "serde_derive",
  "smol",
  "smol-timeout",
  "tempdir",
@@ -5512,6 +5684,7 @@ dependencies = [
  "anyhow",
  "collections",
  "editor",
+ "futures 0.3.25",
  "gpui",
  "language",
  "log",
@@ -5519,9 +5692,11 @@ dependencies = [
  "postage",
  "project",
  "serde",
+ "serde_derive",
  "serde_json",
  "settings",
  "smallvec",
+ "smol",
  "theme",
  "unindent",
  "util",
@@ -5706,6 +5881,7 @@ dependencies = [
  "postage",
  "schemars",
  "serde",
+ "serde_derive",
  "serde_json",
  "serde_path_to_error",
  "sqlez",
@@ -5985,6 +6161,7 @@ dependencies = [
  "parking_lot 0.11.2",
  "smol",
  "thread_local",
+ "uuid 1.2.2",
 ]
 
 [[package]]
@@ -6239,9 +6416,9 @@ dependencies = [
 
 [[package]]
 name = "sysinfo"
-version = "0.27.1"
+version = "0.27.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccb297c0afb439440834b4bcf02c5c9da8ec2e808e70f36b0d8e815ff403bd24"
+checksum = "1620f9573034c573376acc550f3b9a2be96daeb08abb3c12c8523e1cee06e80f"
 dependencies = [
  "cfg-if 1.0.0",
  "core-foundation-sys",
@@ -6325,6 +6502,7 @@ dependencies = [
  "procinfo",
  "rand 0.8.5",
  "serde",
+ "serde_derive",
  "settings",
  "shellexpand",
  "smallvec",
@@ -6356,6 +6534,7 @@ dependencies = [
  "project",
  "rand 0.8.5",
  "serde",
+ "serde_derive",
  "settings",
  "shellexpand",
  "smallvec",
@@ -6415,6 +6594,7 @@ dependencies = [
  "indexmap",
  "parking_lot 0.11.2",
  "serde",
+ "serde_derive",
  "serde_json",
  "serde_path_to_error",
  "toml",
@@ -6434,6 +6614,7 @@ dependencies = [
  "settings",
  "smol",
  "theme",
+ "util",
  "workspace",
 ]
 
@@ -6880,7 +7061,7 @@ dependencies = [
 [[package]]
 name = "tree-sitter"
 version = "0.20.9"
-source = "git+https://github.com/tree-sitter/tree-sitter?rev=36b5b6c89e55ad1a502f8b3234bb3e12ec83a5da#36b5b6c89e55ad1a502f8b3234bb3e12ec83a5da"
+source = "git+https://github.com/tree-sitter/tree-sitter?rev=c51896d32dcc11a38e41f36e3deb1a6a9c4f4b14#c51896d32dcc11a38e41f36e3deb1a6a9c4f4b14"
 dependencies = [
  "cc",
  "regex",
@@ -6982,6 +7163,16 @@ dependencies = [
  "tree-sitter",
 ]
 
+[[package]]
+name = "tree-sitter-lua"
+version = "0.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d489873fd1a2fa6d5f04930bfc5c081c96f0c038c1437104518b5b842c69b282"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
 [[package]]
 name = "tree-sitter-markdown"
 version = "0.0.1"
@@ -7058,6 +7249,24 @@ dependencies = [
  "tree-sitter",
 ]
 
+[[package]]
+name = "tree-sitter-typescript"
+version = "0.20.2"
+source = "git+https://github.com/tree-sitter/tree-sitter-typescript?rev=5d20856f34315b068c41edaee2ac8a100081d259#5d20856f34315b068c41edaee2ac8a100081d259"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
+[[package]]
+name = "tree-sitter-yaml"
+version = "0.0.1"
+source = "git+https://github.com/zed-industries/tree-sitter-yaml?rev=9050a4a4a847ed29e25485b1292a36eab8ae3492#9050a4a4a847ed29e25485b1292a36eab8ae3492"
+dependencies = [
+ "cc",
+ "tree-sitter",
+]
+
 [[package]]
 name = "try-lock"
 version = "0.2.3"
@@ -7295,6 +7504,12 @@ dependencies = [
  "tempdir",
 ]
 
+[[package]]
+name = "uuid"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bcc7e3b898aa6f6c08e5295b6c89258d1331e9ac578cc992fb818759951bdc22"
+
 [[package]]
 name = "uuid"
 version = "0.8.2"
@@ -7373,6 +7588,7 @@ dependencies = [
  "project",
  "search",
  "serde",
+ "serde_derive",
  "serde_json",
  "settings",
  "tokio",
@@ -7852,6 +8068,26 @@ version = "0.1.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9193164d4de03a926d909d3bc7c30543cecb35400c02114792c2cae20d5e2dbb"
 
+[[package]]
+name = "welcome"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "db",
+ "editor",
+ "fuzzy",
+ "gpui",
+ "install_cli",
+ "log",
+ "picker",
+ "project",
+ "settings",
+ "theme",
+ "theme_selector",
+ "util",
+ "workspace",
+]
+
 [[package]]
 name = "wepoll-ffi"
 version = "0.1.2"
@@ -8127,6 +8363,7 @@ dependencies = [
  "futures 0.3.25",
  "gpui",
  "indoc",
+ "install_cli",
  "language",
  "lazy_static",
  "log",
@@ -8135,11 +8372,14 @@ dependencies = [
  "postage",
  "project",
  "serde",
+ "serde_derive",
  "serde_json",
  "settings",
  "smallvec",
+ "terminal",
  "theme",
  "util",
+ "uuid 1.2.2",
 ]
 
 [[package]]
@@ -8152,6 +8392,15 @@ dependencies = [
  "winapi-build",
 ]
 
+[[package]]
+name = "xattr"
+version = "0.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d1526bbe5aaeb5eb06885f4d987bcdfa5e23187055de9b83fe00156a821fabc"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "xml-rs"
 version = "0.8.4"
@@ -8187,13 +8436,14 @@ checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
 
 [[package]]
 name = "zed"
-version = "0.69.2"
+version = "0.79.1"
 dependencies = [
  "activity_indicator",
  "anyhow",
  "assets",
  "async-compression",
  "async-recursion 0.3.2",
+ "async-tar",
  "async-trait",
  "auto_update",
  "backtrace",
@@ -8208,10 +8458,12 @@ dependencies = [
  "command_palette",
  "context_menu",
  "ctor",
+ "db",
  "diagnostics",
  "easy-parallel",
  "editor",
  "env_logger",
+ "feedback",
  "file_finder",
  "fs",
  "fsevent",
@@ -8219,13 +8471,14 @@ dependencies = [
  "fuzzy",
  "go_to_line",
  "gpui",
- "human_bytes",
  "ignore",
  "image",
  "indexmap",
+ "install_cli",
  "isahc",
  "journal",
  "language",
+ "language_selector",
  "lazy_static",
  "libc",
  "log",
@@ -8246,6 +8499,7 @@ dependencies = [
  "rust-embed",
  "search",
  "serde",
+ "serde_derive",
  "serde_json",
  "serde_path_to_error",
  "settings",
@@ -8253,7 +8507,6 @@ dependencies = [
  "smallvec",
  "smol",
  "sum_tree",
- "sysinfo",
  "tempdir",
  "terminal_view",
  "text",
@@ -8272,6 +8525,7 @@ dependencies = [
  "tree-sitter-go",
  "tree-sitter-html",
  "tree-sitter-json 0.20.0",
+ "tree-sitter-lua",
  "tree-sitter-markdown",
  "tree-sitter-python",
  "tree-sitter-racket",
@@ -8279,12 +8533,15 @@ dependencies = [
  "tree-sitter-rust",
  "tree-sitter-scheme",
  "tree-sitter-toml",
- "tree-sitter-typescript",
+ "tree-sitter-typescript 0.20.2",
+ "tree-sitter-yaml",
  "unindent",
  "url",
  "urlencoding",
  "util",
+ "uuid 1.2.2",
  "vim",
+ "welcome",
  "workspace",
 ]
 

Cargo.toml

@@ -17,6 +17,7 @@ members = [
     "crates/diagnostics",
     "crates/drag_and_drop",
     "crates/editor",
+    "crates/feedback",
     "crates/file_finder",
     "crates/fs",
     "crates/fsevent",
@@ -25,8 +26,10 @@ members = [
     "crates/go_to_line",
     "crates/gpui",
     "crates/gpui_macros",
+    "crates/install_cli",
     "crates/journal",
     "crates/language",
+    "crates/language_selector",
     "crates/live_kit_client",
     "crates/live_kit_server",
     "crates/lsp",
@@ -57,6 +60,7 @@ members = [
     "crates/util",
     "crates/vim",
     "crates/workspace",
+    "crates/welcome",
     "crates/zed",
 ]
 default-members = ["crates/zed"]
@@ -64,11 +68,12 @@ resolver = "2"
 
 [workspace.dependencies]
 serde = { version = "1.0", features = ["derive", "rc"] }
+serde_derive = { version = "1.0", features = ["deserialize_in_place"] }
 serde_json = { version = "1.0", features = ["preserve_order", "raw_value"] }
 rand = { version = "0.8" }
 
 [patch.crates-io]
-tree-sitter = { git = "https://github.com/tree-sitter/tree-sitter", rev = "36b5b6c89e55ad1a502f8b3234bb3e12ec83a5da" }
+tree-sitter = { git = "https://github.com/tree-sitter/tree-sitter", rev = "c51896d32dcc11a38e41f36e3deb1a6a9c4f4b14" }
 async-task = { git = "https://github.com/zed-industries/async-task", rev = "341b57d6de98cdfd7b418567b8de2022ca993a6e" }
 
 # TODO - Remove when a version is released with this PR: https://github.com/servo/core-foundation-rs/pull/457
@@ -83,5 +88,3 @@ split-debuginfo = "unpacked"
 
 [profile.release]
 debug = true
-
-

Dockerfile

@@ -5,6 +5,7 @@ WORKDIR app
 COPY . .
 
 # Compile collab server
+ARG CARGO_PROFILE_RELEASE_PANIC=abort
 RUN --mount=type=cache,target=./script/node_modules \
     --mount=type=cache,target=/usr/local/cargo/registry \
     --mount=type=cache,target=./target \

README.md

@@ -23,10 +23,18 @@ Welcome to Zed, a lightning-fast, collaborative code editor that makes your drea
     git clone https://github.com/zed-industries/zed.dev
     ```
 
-* Set up a local `zed` database and seed it with some initial users:
+* Initialize submodules
 
     ```
-    script/bootstrap
+    git submodule update --init --recursive
+    ```
+
+* Set up a local `zed` database and seed it with some initial users:
+
+    Create a personal GitHub token to run `script/bootstrap` once successfully. Then delete that token.
+
+    ```
+    GITHUB_TOKEN=<$token> script/bootstrap
     ```
 
 ### Testing against locally-running servers
@@ -49,30 +57,14 @@ script/zed-with-local-servers --release
 
 If you trigger `cmd-alt-i`, Zed will copy a JSON representation of the current window contents to the clipboard. You can paste this in a tool like [DJSON](https://chrome.google.com/webstore/detail/djson-json-viewer-formatt/chaeijjekipecdajnijdldjjipaegdjc?hl=en) to navigate the state of on-screen elements in a structured way.
 
-### Staff Only Features
+### Licensing
 
-Many features (e.g. the terminal) take significant time and effort before they are polished enough to be released to even Alpha users. But Zed's team workflow relies on fast, daily PRs and there can be large merge conflicts for feature branchs that diverge for a few days. To bridge this gap, there is a `staff_mode` field in the Settings that staff can set to enable these unpolished or incomplete features. Note that this setting isn't leaked via autocompletion, but there is no mechanism to stop users from setting this anyway. As initilization of Zed components is only done once, on startup, setting `staff_mode` may require a restart to take effect. You can set staff only key bindings in the `assets/keymaps/internal.json` file, and add staff only themes in the `styles/src/themes/internal` directory
+We use [`cargo-about`](https://github.com/EmbarkStudios/cargo-about) to automatically comply with open source licenses. If CI is failing, check the following:
 
-### Experimental Features
+- Is it showing a `no license specified` error for a crate you've created? If so, add `publish = false` under `[package]` in your crate's Cargo.toml.
+- Is the error `failed to satisfy license requirements` for a dependency? If so, first determine what license the project has and whether this system is sufficient to comply with this license's requirements. If you're unsure, ask a lawyer. Once you've verified that this system is acceptable add the license's SPDX identifier to the `accepted` array in `script/licenses/zed-licenses.toml`.
+- Is `cargo-about` unable to find the license for a dependency? If so, add a clarification field at the end of `script/licenses/zed-licenses.toml`, as specified in the [cargo-about book](https://embarkstudios.github.io/cargo-about/cli/generate/config.html#crate-configuration).
 
-A user facing feature flag can be added to Zed by:
-
-* Adding a setting to the crates/settings/src/settings.rs FeatureFlags struct. Use a boolean for a simple on/off, or use a struct to experiment with different configuration options. 
-* If the feature needs keybindings, add a file to the `assets/keymaps/experiments/` folder, then update the `FeatureFlags::keymap_files()` method to check for your feature's flag and add it's keybindings's path to the method's list. 
-* If you want to add an experimental theme, add it to the `styles/src/themes/experiments` folder
-
-The Settings global should be initialized with the user's feature flags by the time the feature's `init(cx)` equivalent is called.
-
-To promote an experimental feature to a full feature: 
-
-* If this is an experimental theme, move the theme file from the `styles/src/themes/experiments` folder to the `styles/src/themes/` folder
-* Take the features settings (if any) and add them under a new variable in the Settings struct. Don't forget to add a `merge()` call in `set_user_settings()`!
-* Take the feature's keybindings and add them to the default.json (or equivalent) file
-* Remove the file from the `FeatureFlags::keymap_files()` method
-* Remove the conditional in the feature's `init(cx)` equivalent.
-
-
-That's it 😸
 
 ### Wasm Plugins
 

assets/icons/ellipsis_14.svg

@@ -0,0 +1,3 @@
+<svg width="14" height="4" viewBox="0 0 14 4" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M3.125 2C3.125 2.62132 2.62132 3.125 2 3.125C1.37868 3.125 0.875 2.62132 0.875 2C0.875 1.37868 1.37868 0.875 2 0.875C2.62132 0.875 3.125 1.37868 3.125 2ZM8.125 2C8.125 2.62132 7.62132 3.125 7 3.125C6.37868 3.125 5.875 2.62132 5.875 2C5.875 1.37868 6.37868 0.875 7 0.875C7.62132 0.875 8.125 1.37868 8.125 2ZM12 3.125C12.6213 3.125 13.125 2.62132 13.125 2C13.125 1.37868 12.6213 0.875 12 0.875C11.3787 0.875 10.875 1.37868 10.875 2C10.875 2.62132 11.3787 3.125 12 3.125Z" fill="#ABB2BF"/>
+</svg>

assets/icons/feedback_16.svg

@@ -0,0 +1,3 @@
+<svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M15.9083 3.19699L7.99999 10.3949L0.0916311 3.1969C0.346537 2.49164 1.10447 1.98018 2 1.98018H14C14.8943 1.98018 15.653 2.49168 15.9083 3.19699ZM16 4.7153L12.1526 8.21715L16 11.688V4.7153ZM8.52024 11.5232L11.4199 8.88404L15.9081 12.933C15.6528 13.6378 14.8941 14.1501 14 14.1501H2C1.10461 14.1501 0.346779 13.6378 0.0917535 12.9331L4.58012 8.88404L7.47975 11.5232L7.99999 11.9967L8.52024 11.5232ZM3.84742 8.21715L0 4.71532V11.688L3.84742 8.21715Z" fill="white"/>
+</svg>

assets/icons/leave_12.svg

@@ -0,0 +1,3 @@
+<svg width="12" height="12" viewBox="0 0 12 12" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M0 1C0 0.585786 0.335786 0.25 0.75 0.25H7.25C7.66421 0.25 8 0.585786 8 1C8 1.41421 7.66421 1.75 7.25 1.75H1.5V10.25H7.25C7.66421 10.25 8 10.5858 8 11C8 11.4142 7.66421 11.75 7.25 11.75H0.75C0.335786 11.75 0 11.4142 0 11V1ZM8.78148 2.91435C9.10493 2.65559 9.57689 2.70803 9.83565 3.03148L11.8357 5.53148C12.0548 5.80539 12.0548 6.19461 11.8357 6.46852L9.83565 8.96852C9.57689 9.29197 9.10493 9.34441 8.78148 9.08565C8.45803 8.82689 8.40559 8.35493 8.66435 8.03148L9.68953 6.75H3.75C3.33579 6.75 3 6.41421 3 6C3 5.58579 3.33579 5.25 3.75 5.25H9.68953L8.66435 3.96852C8.40559 3.64507 8.45803 3.17311 8.78148 2.91435Z" fill="#ABB2BF"/>
+</svg>

assets/icons/logo_96.svg

@@ -0,0 +1,3 @@
+<svg width="96" height="96" viewBox="0 0 96 96" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path fill-rule="evenodd" clip-rule="evenodd" d="M9 6C7.34315 6 6 7.34315 6 9V75H0V9C0 4.02944 4.02944 0 9 0H89.3787C93.3878 0 95.3955 4.84715 92.5607 7.68198L43.0551 57.1875H57V51H63V58.6875C63 61.1728 60.9853 63.1875 58.5 63.1875H37.0551L26.7426 73.5H73.5V36H79.5V73.5C79.5 76.8137 76.8137 79.5 73.5 79.5H20.7426L10.2426 90H87C88.6569 90 90 88.6569 90 87V21H96V87C96 91.9706 91.9706 96 87 96H6.62132C2.61224 96 0.604504 91.1529 3.43934 88.318L52.7574 39H39V45H33V37.5C33 35.0147 35.0147 33 37.5 33H58.7574L69.2574 22.5H22.5V60H16.5V22.5C16.5 19.1863 19.1863 16.5 22.5 16.5H75.2574L85.7574 6H9Z" fill="white"/>
+</svg>

assets/icons/speech_bubble_12.svg

@@ -0,0 +1,3 @@
+<svg width="12" height="12" viewBox="0 0 12 12" fill="none" xmlns="http://www.w3.org/2000/svg">
+<path d="M10.6667 0.400196H1.33346C0.819658 0.400196 0.399658 0.820196 0.399658 1.3326V10.6658C0.399658 11.181 0.816998 11.5982 1.33206 11.5982C1.58966 11.5982 1.82206 11.4932 1.99146 11.3238L4.51706 8.79684H10.6639C11.1763 8.79684 11.5963 8.37544 11.5963 7.86304V1.3298C11.5963 0.815996 11.1749 0.395996 10.6625 0.395996L10.6667 0.400196ZM2.2667 2.2664H6.00008V3.1988H2.26628V2.265L2.2667 2.2664ZM7.8667 6.93316H2.2667V5.99936H7.8667V6.93176V6.93316ZM9.7329 5.06556H2.26488V4.13176H9.73164V5.06416L9.7329 5.06556Z" fill="#282C34"/>
+</svg>

assets/icons/user_plus_12.svg

@@ -1,3 +1,5 @@
 <svg width="12" height="12" viewBox="0 0 12 12" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M4.2 6.00001C5.52563 6.00001 6.6 4.92545 6.6 3.60001C6.6 2.27457 5.52563 1.20001 4.2 1.20001C2.87438 1.20001 1.8 2.27457 1.8 3.60001C1.8 4.92545 2.87438 6.00001 4.2 6.00001ZM5.15063 6.90001H3.24938C1.45519 6.90001 0 8.35501 0 10.1494C0 10.5094 0.291 10.8 0.649875 10.8H7.7505C8.10938 10.8 8.4 10.5094 8.4 10.1494C8.4 8.35501 6.945 6.90001 5.15063 6.90001ZM11.55 4.95001H10.65V4.05001C10.65 3.80251 10.4494 3.60001 10.2 3.60001C9.95063 3.60001 9.75 3.80157 9.75 4.05001V4.95001H8.85C8.6025 4.95001 8.4 5.15251 8.4 5.40001C8.4 5.64751 8.60156 5.85001 8.85 5.85001H9.75V6.75001C9.75 6.99939 9.9525 7.20001 10.2 7.20001C10.4475 7.20001 10.65 6.99845 10.65 6.75001V5.85001H11.55C11.7994 5.85001 12 5.64939 12 5.40001C12 5.15064 11.7994 4.95001 11.55 4.95001Z" fill="white"/>
+<path d="M5.75062 7.09998H3.24938C1.45519 7.09998 0 8.55498 0 10.3493C0 10.7093 0.291 11 0.649875 11H8.3505C8.70938 11 9 10.7093 9 10.3493C9 8.55498 7.545 7.09998 5.75062 7.09998Z" fill="white"/>
+<path d="M7 3.5C7 4.82544 5.82562 6 4.5 6C3.17438 6 2 4.82544 2 3.5C2 2.17456 3.17438 1 4.5 1C5.82562 1 7 2.17456 7 3.5Z" fill="white"/>
+<path d="M9.5 3.75V5.5M9.5 7.25V5.5M9.5 5.5H11.25M9.5 5.5H7.75" stroke="white" stroke-linecap="round" stroke-linejoin="round"/>
 </svg>

assets/icons/user_plus_16.svg

@@ -1,3 +1,5 @@
 <svg width="16" height="16" viewBox="0 0 16 16" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M5.9 8.00002C7.44656 8.00002 8.7 6.74637 8.7 5.20002C8.7 3.65368 7.44656 2.40002 5.9 2.40002C4.35344 2.40002 3.1 3.65368 3.1 5.20002C3.1 6.74637 4.35344 8.00002 5.9 8.00002ZM7.00906 9.05002H4.79094C2.69772 9.05002 1 10.7475 1 12.841C1 13.261 1.3395 13.6 1.75819 13.6H10.0422C10.4609 13.6 10.8 13.261 10.8 12.841C10.8 10.7475 9.1025 9.05002 7.00906 9.05002ZM14.475 6.77502H13.425V5.72502C13.425 5.43627 13.1909 5.20002 12.9 5.20002C12.6091 5.20002 12.375 5.43518 12.375 5.72502V6.77502H11.325C11.0363 6.77502 10.8 7.01127 10.8 7.30002C10.8 7.58877 11.0352 7.82502 11.325 7.82502H12.375V8.87502C12.375 9.16596 12.6112 9.40002 12.9 9.40002C13.1887 9.40002 13.425 9.16487 13.425 8.87502V7.82502H14.475C14.7659 7.82502 15 7.59096 15 7.30002C15 7.00909 14.7659 6.77502 14.475 6.77502Z" fill="white"/>
+<path d="M7.00906 8.99999H4.79094C2.69772 8.99999 1 11.1475 1 13.2409C1 13.6609 1.3395 14 1.75819 14H10.0422C10.4609 14 10.8 13.6609 10.8 13.2409C10.8 11.1475 9.1025 8.99999 7.00906 8.99999Z" fill="white"/>
+<path d="M9 5C9 6.54634 7.44657 7.99998 5.90001 7.99998C4.35344 7.99998 3 6.54634 3 5C3 3.45366 4.45344 2 6 2C7.54656 2 9 3.45366 9 5Z" fill="white"/>
+<path d="M13.025 6H14.475C14.7659 6 15 6.20906 15 6.5C15 6.79094 14.7659 7 14.475 7H13V8.49995C13 8.7898 12.7638 9.02495 12.475 9.02495C12.1863 9.02495 11.95 8.79089 11.95 8.49995V7H10.525C10.2352 7 10 6.78875 10 6.5C10 6.21125 10.2362 6 10.525 6H11.975V4.525C11.975 4.23516 12.2091 4 12.5 4C12.7909 4 13.025 4.23625 13.025 4.525V6Z" fill="white"/>
 </svg>

assets/keymaps/atom.json

@@ -0,0 +1,68 @@
+[
+  {
+    "bindings": {
+      "cmd-k cmd-p": "workspace::ActivatePreviousPane",
+      "cmd-k cmd-n": "workspace::ActivateNextPane"
+    }
+  },
+  {
+    "context": "Editor",
+    "bindings": {
+      "cmd-b": "editor::GoToDefinition",
+      "cmd-<": "editor::ScrollCursorCenter",
+      "cmd-g": [
+        "editor::SelectNext",
+        {
+          "replace_newest": true
+        }
+      ],
+      "ctrl-shift-down": "editor::AddSelectionBelow",
+      "ctrl-shift-up": "editor::AddSelectionAbove",
+      "cmd-shift-backspace": "editor::DeleteToBeginningOfLine"
+    }
+  },
+  {
+    "context": "Editor && mode == full",
+    "bindings": {
+      "cmd-r": "outline::Toggle"
+    }
+  },
+  {
+    "context": "BufferSearchBar",
+    "bindings": {
+      "cmd-f3": "search::SelectNextMatch",
+      "cmd-shift-f3": "search::SelectPrevMatch"
+    }
+  },
+  {
+    "context": "Workspace",
+    "bindings": {
+      "cmd-\\": "workspace::ToggleLeftSidebar",
+      "cmd-k cmd-b": "workspace::ToggleLeftSidebar",
+      "cmd-t": "file_finder::Toggle",
+      "cmd-shift-r": "project_symbols::Toggle"
+    }
+  },
+  {
+    "context": "Pane",
+    "bindings": {
+      "alt-cmd-/": "search::ToggleRegex",
+      "ctrl-0": "project_panel::ToggleFocus"
+    }
+  },
+  {
+    "context": "ProjectPanel",
+    "bindings": {
+      "ctrl-[": "project_panel::CollapseSelectedEntry",
+      "ctrl-b": "project_panel::CollapseSelectedEntry",
+      "alt-b": "project_panel::CollapseSelectedEntry",
+      "ctrl-]": "project_panel::ExpandSelectedEntry",
+      "ctrl-f": "project_panel::ExpandSelectedEntry",
+      "ctrl-shift-c": "project_panel::CopyPath"
+    }
+  },
+  {
+    "context": "Dock",
+    "bindings": {}
+  }
+]

assets/keymaps/default.json

@@ -38,7 +38,7 @@
             "cmd-n": "workspace::NewFile",
             "cmd-shift-n": "workspace::NewWindow",
             "cmd-o": "workspace::Open",
-            "alt-cmd-o": "recent_projects::Toggle",
+            "alt-cmd-o": "projects::OpenRecent",
             "ctrl-`": "workspace::NewTerminal"
         }
     },
@@ -164,6 +164,7 @@
         "bindings": {
             "enter": "editor::Newline",
             "cmd-enter": "editor::NewlineBelow",
+            "alt-z": "editor::ToggleSoftWrap",
             "cmd-f": [
                 "buffer_search::Deploy",
                 {
@@ -186,10 +187,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"
         }
@@ -227,7 +228,13 @@
                     "replace_newest": true
                 }
             ],
-            "cmd-/": "editor::ToggleComments",
+            "cmd-k cmd-i": "editor::Hover",
+            "cmd-/": [
+                "editor::ToggleComments",
+                {
+                    "advance_downwards": false
+                }
+            ],
             "alt-up": "editor::SelectLargerSyntaxNode",
             "alt-down": "editor::SelectSmallerSyntaxNode",
             "cmd-u": "editor::UndoSelection",
@@ -242,7 +249,8 @@
             "alt-cmd-[": "editor::Fold",
             "alt-cmd-]": "editor::UnfoldLines",
             "ctrl-space": "editor::ShowCompletions",
-            "cmd-.": "editor::ToggleCodeActions"
+            "cmd-.": "editor::ToggleCodeActions",
+            "alt-cmd-r": "editor::RevealInFinder"
         }
     },
     {
@@ -346,7 +354,8 @@
             "cmd-shift-p": "command_palette::Toggle",
             "cmd-shift-m": "diagnostics::Deploy",
             "cmd-shift-e": "project_panel::ToggleFocus",
-            "cmd-alt-s": "workspace::SaveAll"
+            "cmd-alt-s": "workspace::SaveAll",
+            "cmd-k m": "language_selector::Toggle"
         }
     },
     // Bindings from Sublime Text
@@ -412,7 +421,7 @@
     {
         "bindings": {
             "ctrl-alt-cmd-f": "workspace::FollowNextCollaborator",
-            "cmd-shift-c": "collab::ToggleCollaborationMenu",
+            "cmd-shift-c": "collab::ToggleContactsMenu",
             "cmd-alt-i": "zed::DebugElements"
         }
     },
@@ -433,8 +442,7 @@
     {
         "context": "Workspace",
         "bindings": {
-            "shift-escape": "dock::FocusDock",
-            "cmd-shift-b": "workspace::ToggleRightSidebar"
+            "shift-escape": "dock::FocusDock"
         }
     },
     {
@@ -445,15 +453,16 @@
         }
     },
     {
-        "context": "Dock",
+        "context": "Pane",
         "bindings": {
-            "shift-escape": "dock::HideDock"
+            "cmd-escape": "dock::AddTabToDock"
         }
     },
     {
-        "context": "Pane",
+        "context": "Pane && docked",
         "bindings": {
-            "cmd-escape": "dock::MoveActiveItemToDock"
+            "shift-escape": "dock::HideDock",
+            "cmd-escape": "dock::RemoveTabFromDock"
         }
     },
     {
@@ -466,7 +475,8 @@
             "cmd-v": "project_panel::Paste",
             "cmd-alt-c": "project_panel::CopyPath",
             "f2": "project_panel::Rename",
-            "backspace": "project_panel::Delete"
+            "backspace": "project_panel::Delete",
+            "alt-cmd-r": "project_panel::RevealInFinder"
         }
     },
     {
@@ -530,4 +540,4 @@
             ]
         }
     }
-]
+]

assets/keymaps/internal.json

@@ -1 +0,0 @@
-[]

assets/keymaps/jetbrains.json

@@ -0,0 +1,78 @@
+[
+  {
+    "bindings": {
+      "cmd-shift-[": "pane::ActivatePrevItem",
+      "cmd-shift-]": "pane::ActivateNextItem"
+    }
+  },
+  {
+    "context": "Editor",
+    "bindings": {
+      "ctrl->": "zed::IncreaseBufferFontSize",
+      "ctrl-<": "zed::DecreaseBufferFontSize",
+      "cmd-d": "editor::DuplicateLine",
+      "cmd-pagedown": "editor::MovePageDown",
+      "cmd-pageup": "editor::MovePageUp",
+      "ctrl-alt-shift-b": "editor::SelectToPreviousWordStart",
+      "shift-enter": "editor::NewlineBelow",
+      "cmd--": "editor::Fold",
+      "cmd-=": "editor::UnfoldLines",
+      "alt-shift-g": "editor::SplitSelectionIntoLines",
+      "ctrl-g": [
+        "editor::SelectNext",
+        {
+          "replace_newest": false
+        }
+      ],
+      "cmd-/": [
+        "editor::ToggleComments",
+        {
+          "advance_downwards": true
+        }
+      ],
+      "shift-alt-up": "editor::MoveLineUp",
+      "shift-alt-down": "editor::MoveLineDown",
+      "cmd-[": "pane::GoBack",
+      "cmd-]": "pane::GoForward",
+      "alt-f7": "editor::FindAllReferences",
+      "cmd-alt-f7": "editor::FindAllReferences",
+      "cmd-b": "editor::GoToDefinition",
+      "cmd-alt-b": "editor::GoToDefinition",
+      "cmd-shift-b": "editor::GoToTypeDefinition",
+      "alt-enter": "editor::ToggleCodeActions",
+      "f2": "editor::GoToDiagnostic",
+      "cmd-f2": "editor::GoToPrevDiagnostic",
+      "ctrl-alt-shift-down": "editor::GoToHunk",
+      "ctrl-alt-shift-up": "editor::GoToPrevHunk",
+      "cmd-home": "editor::MoveToBeginning",
+      "cmd-end": "editor::MoveToEnd",
+      "cmd-shift-home": "editor::SelectToBeginning",
+      "cmd-shift-end": "editor::SelectToEnd"
+    }
+  },
+  {
+    "context": "Editor && mode == full",
+    "bindings": {
+      "cmd-f12": "outline::Toggle",
+      "cmd-7": "outline::Toggle",
+      "cmd-shift-o": "file_finder::Toggle",
+      "cmd-l": "go_to_line::Toggle"
+    }
+  },
+  {
+    "context": "Workspace",
+    "bindings": {
+      "cmd-shift-a": "command_palette::Toggle",
+      "cmd-alt-o": "project_symbols::Toggle",
+      "cmd-1": "workspace::ToggleLeftSidebar",
+      "cmd-6": "diagnostics::Deploy",
+      "alt-f12": "dock::FocusDock"
+    }
+  },
+  {
+    "context": "Dock",
+    "bindings": {
+      "alt-f12": "dock::HideDock"
+    }
+  }
+]

assets/keymaps/sublime_text.json

@@ -0,0 +1,60 @@
+[
+  {
+    "bindings": {
+      "cmd-shift-[": "pane::ActivatePrevItem",
+      "cmd-shift-]": "pane::ActivateNextItem",
+      "ctrl-pagedown": "pane::ActivatePrevItem",
+      "ctrl-pageup": "pane::ActivateNextItem",
+      "ctrl-shift-tab": "pane::ActivateNextItem",
+      "ctrl-tab": "pane::ActivatePrevItem",
+      "cmd-+": "zed::IncreaseBufferFontSize"
+    }
+  },
+  {
+    "context": "Editor",
+    "bindings": {
+      "ctrl-shift-up": "editor::AddSelectionAbove",
+      "ctrl-shift-down": "editor::AddSelectionBelow",
+      "cmd-shift-space": "editor::SelectAll",
+      "ctrl-shift-m": "editor::SelectLargerSyntaxNode",
+      "cmd-shift-a": "editor::SelectLargerSyntaxNode",
+      "shift-f12": "editor::FindAllReferences",
+      "alt-cmd-down": "editor::GoToDefinition",
+      "alt-shift-cmd-down": "editor::FindAllReferences",
+      "ctrl-.": "editor::GoToHunk",
+      "ctrl-,": "editor::GoToPrevHunk",
+      "ctrl-backspace": "editor::DeleteToPreviousWordStart",
+      "ctrl-delete": "editor::DeleteToNextWordEnd"
+    }
+  },
+  {
+    "context": "Editor && mode == full",
+    "bindings": {
+      "cmd-r": "outline::Toggle"
+    }
+  },
+  {
+    "context": "Pane",
+    "bindings": {
+      "f4": "search::SelectNextMatch",
+      "shift-f4": "search::SelectPrevMatch"
+    }
+  },
+  {
+    "context": "Workspace",
+    "bindings": {
+      "ctrl-`": "dock::FocusDock",
+      "cmd-k cmd-b": "workspace::ToggleLeftSidebar",
+      "cmd-t": "file_finder::Toggle",
+      "shift-cmd-r": "project_symbols::Toggle",
+      // Currently busted: https://github.com/zed-industries/feedback/issues/898
+      "ctrl-0": "project_panel::ToggleFocus"
+    }
+  },
+  {
+    "context": "Dock",
+    "bindings": {
+      "ctrl-`": "dock::HideDock"
+    }
+  }
+]

assets/keymaps/textmate.json

@@ -0,0 +1,90 @@
+[
+  {
+    "bindings": {
+      "cmd-shift-o": "projects::OpenRecent",
+      "cmd-alt-tab": "project_panel::ToggleFocus"
+    }
+  },
+  {
+    "context": "Editor",
+    "bindings": {
+      "cmd-l": "go_to_line::Toggle",
+      "ctrl-shift-d": "editor::DuplicateLine",
+      "cmd-b": "editor::GoToDefinition",
+      "cmd-j": "editor::ScrollCursorCenter",
+      "cmd-enter": "editor::NewlineBelow",
+      "cmd-shift-l": "editor::SelectLine",
+      "cmd-shift-t": "outline::Toggle",
+      "alt-backspace": "editor::DeleteToPreviousWordStart",
+      "alt-shift-backspace": "editor::DeleteToNextWordEnd",
+      "alt-delete": "editor::DeleteToNextWordEnd",
+      "alt-shift-delete": "editor::DeleteToNextWordEnd",
+      "ctrl-backspace": "editor::DeleteToPreviousSubwordStart",
+      "ctrl-delete": "editor::DeleteToNextSubwordEnd",
+      "alt-left": [
+        "editor::MoveToPreviousWordStart",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
+      "alt-right": [
+        "editor::MoveToNextWordEnd",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
+      "ctrl-left": "editor::MoveToPreviousSubwordStart",
+      "ctrl-right": "editor::MoveToNextSubwordEnd",
+      "cmd-shift-left": "editor::SelectToBeginningOfLine",
+      "cmd-shift-right": "editor::SelectToEndOfLine",
+      "alt-shift-left": [
+        "editor::SelectToBeginningOfLine",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
+      "alt-shift-right": [
+        "editor::SelectToEndOfLine",
+        {
+          "stop_at_soft_wraps": true
+        }
+      ],
+      "ctrl-shift-left": "editor::SelectToPreviousSubwordStart",
+      "ctrl-shift-right": "editor::SelectToNextSubwordEnd"
+    }
+  },
+  {
+    "context": "Editor && mode == full",
+    "bindings": {}
+  },
+  {
+    "context": "BufferSearchBar",
+    "bindings": {
+      "ctrl-s": "search::SelectNextMatch",
+      "ctrl-shift-s": "search::SelectPrevMatch"
+    }
+  },
+  {
+    "context": "Workspace",
+    "bindings": {
+      "cmd-alt-ctrl-d": "workspace::ToggleLeftSidebar",
+      "cmd-t": "file_finder::Toggle",
+      "cmd-shift-t": "project_symbols::Toggle"
+    }
+  },
+  {
+    "context": "Pane",
+    "bindings": {
+      "alt-cmd-r": "search::ToggleRegex",
+      "ctrl-tab": "project_panel::ToggleFocus"
+    }
+  },
+  {
+    "context": "ProjectPanel",
+    "bindings": {}
+  },
+  {
+    "context": "Dock",
+    "bindings": {}
+  }
+]

assets/keymaps/vim.json

@@ -27,6 +27,7 @@
             "h": "vim::Left",
             "backspace": "vim::Backspace",
             "j": "vim::Down",
+            "enter": "vim::NextLineStart",
             "k": "vim::Up",
             "l": "vim::Right",
             "$": "vim::EndOfLine",
@@ -209,6 +210,10 @@
             "ctrl-e": [
                 "vim::Scroll",
                 "LineDown"
+            ],
+            "r": [
+                "vim::PushOperator",
+                "Replace"
             ]
         }
     },
@@ -229,7 +234,8 @@
             "escape": [
                 "vim::SwitchMode",
                 "Normal"
-            ]
+            ],
+            "d": "editor::GoToDefinition"
         }
     },
     {
@@ -294,7 +300,11 @@
             "d": "vim::VisualDelete",
             "x": "vim::VisualDelete",
             "y": "vim::VisualYank",
-            "p": "vim::VisualPaste"
+            "p": "vim::VisualPaste",
+            "r": [
+                "vim::PushOperator",
+                "Replace"
+            ]
         }
     },
     {
@@ -307,7 +317,9 @@
     {
         "context": "Editor && VimWaiting",
         "bindings": {
-            "*": "gpui::KeyPressed"
+            "tab": "vim::Tab",
+            "enter": "vim::Enter",
+            "escape": "editor::Cancel"
         }
     }
 ]

assets/settings/default.json

@@ -3,6 +3,11 @@
     "theme": "One Dark",
     // The name of a font to use for rendering text in the editor
     "buffer_font_family": "Zed Mono",
+    // The OpenType features to enable for text in the editor.
+    "buffer_font_features": {
+        // Disable ligatures:
+        // "calt": false
+    },
     // The default font size for text in the editor
     "buffer_font_size": 15,
     // The factor to grow the active pane by. Defaults to 1.0
@@ -13,16 +18,15 @@
     // Whether to show the informational hover box when moving the mouse
     // over symbols in the editor.
     "hover_popover_enabled": true,
+    // Whether to confirm before quitting Zed.
+    "confirm_quit": false,
     // Whether the cursor blinks in the editor.
     "cursor_blink": true,
     // Whether to pop the completions menu while typing in an editor without
     // explicitly requesting it.
     "show_completions_on_input": true,
-    // Whether new projects should start out 'online'. Online projects
-    // appear in the contacts panel under your name, so that your contacts
-    // can see which projects you are working on. Regardless of this
-    // setting, projects keep their last online status when you reopen them.
-    "projects_online_by_default": true,
+    // Whether the screen sharing icon is shown in the os status bar.
+    "show_call_status_icon": true,
     // Whether to use language servers to provide code intelligence.
     "enable_language_server": true,
     // When to automatically save edited buffers. This setting can
@@ -46,7 +50,13 @@
     //     "default_dock_anchor": "right"
     // 3. Position the dock full screen over the entire workspace"
     //     "default_dock_anchor": "expanded"
-    "default_dock_anchor": "right",
+    "default_dock_anchor": "bottom",
+    // Whether or not to remove any trailing whitespace from lines of a buffer
+    // before saving it.
+    "remove_trailing_whitespace_on_save": true,
+    // Whether or not to ensure there's a single newline at the end of a buffer
+    // when saving it.
+    "ensure_final_newline_on_save": true,
     // Whether or not to perform a buffer format before saving
     "format_on_save": "on",
     // How to perform a buffer format. This setting can take two values:
@@ -79,13 +89,15 @@
     "hard_tabs": false,
     // How many columns a tab should occupy.
     "tab_size": 4,
-    // Control what info Zed sends to our servers
+    // Control what info is collected by Zed.
     "telemetry": {
         // Send debug info like crash reports.
         "diagnostics": true,
         // Send anonymized usage data like what languages you're using Zed with.
         "metrics": true
     },
+    // Automatically update Zed
+    "auto_update": true,
     // Git gutter behavior configuration.
     "git": {
         // Control whether the git gutter is shown. May take 2 values:
@@ -190,12 +202,6 @@
         "Plain Text": {
             "soft_wrap": "preferred_line_length"
         },
-        "C": {
-            "tab_size": 2
-        },
-        "C++": {
-            "tab_size": 2
-        },
         "Elixir": {
             "tab_size": 2
         },
@@ -206,9 +212,6 @@
         "Markdown": {
             "soft_wrap": "preferred_line_length"
         },
-        "Rust": {
-            "tab_size": 4
-        },
         "JavaScript": {
             "tab_size": 2
         },
@@ -217,6 +220,9 @@
         },
         "TSX": {
             "tab_size": 2
+        },
+        "YAML": {
+            "tab_size": 2
         }
     },
     // LSP Specific settings.

crates/activity_indicator/Cargo.toml

@@ -2,6 +2,7 @@
 name = "activity_indicator"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/activity_indicator.rs"

crates/activity_indicator/src/activity_indicator.rs

@@ -33,6 +33,19 @@ struct LspStatus {
     status: LanguageServerBinaryStatus,
 }
 
+struct PendingWork<'a> {
+    language_server_name: &'a str,
+    progress_token: &'a str,
+    progress: &'a LanguageServerProgress,
+}
+
+#[derive(Default)]
+struct Content {
+    icon: Option<&'static str>,
+    message: String,
+    action: Option<Box<dyn Action>>,
+}
+
 pub fn init(cx: &mut MutableAppContext) {
     cx.add_action(ActivityIndicator::show_error_message);
     cx.add_action(ActivityIndicator::dismiss_error_message);
@@ -69,6 +82,8 @@ impl ActivityIndicator {
             if let Some(auto_updater) = auto_updater.as_ref() {
                 cx.observe(auto_updater, |_, _, cx| cx.notify()).detach();
             }
+            cx.observe_active_labeled_tasks(|_, cx| cx.notify())
+                .detach();
 
             Self {
                 statuses: Default::default(),
@@ -130,7 +145,7 @@ impl ActivityIndicator {
     fn pending_language_server_work<'a>(
         &self,
         cx: &'a AppContext,
-    ) -> impl Iterator<Item = (&'a str, &'a str, &'a LanguageServerProgress)> {
+    ) -> impl Iterator<Item = PendingWork<'a>> {
         self.project
             .read(cx)
             .language_server_statuses()
@@ -142,23 +157,29 @@ impl ActivityIndicator {
                     let mut pending_work = status
                         .pending_work
                         .iter()
-                        .map(|(token, progress)| (status.name.as_str(), token.as_str(), progress))
+                        .map(|(token, progress)| PendingWork {
+                            language_server_name: status.name.as_str(),
+                            progress_token: token.as_str(),
+                            progress,
+                        })
                         .collect::<SmallVec<[_; 4]>>();
-                    pending_work.sort_by_key(|(_, _, progress)| Reverse(progress.last_update_at));
+                    pending_work.sort_by_key(|work| Reverse(work.progress.last_update_at));
                     Some(pending_work)
                 }
             })
             .flatten()
     }
 
-    fn content_to_render(
-        &mut self,
-        cx: &mut RenderContext<Self>,
-    ) -> (Option<&'static str>, String, Option<Box<dyn Action>>) {
+    fn content_to_render(&mut self, cx: &mut RenderContext<Self>) -> Content {
         // Show any language server has pending activity.
         let mut pending_work = self.pending_language_server_work(cx);
-        if let Some((lang_server_name, progress_token, progress)) = pending_work.next() {
-            let mut message = lang_server_name.to_string();
+        if let Some(PendingWork {
+            language_server_name,
+            progress_token,
+            progress,
+        }) = pending_work.next()
+        {
+            let mut message = language_server_name.to_string();
 
             message.push_str(": ");
             if let Some(progress_message) = progress.message.as_ref() {
@@ -176,7 +197,11 @@ impl ActivityIndicator {
                 write!(&mut message, " + {} more", additional_work_count).unwrap();
             }
 
-            return (None, message, None);
+            return Content {
+                icon: None,
+                message,
+                action: None,
+            };
         }
 
         // Show any language server installation info.
@@ -199,19 +224,19 @@ impl ActivityIndicator {
         }
 
         if !downloading.is_empty() {
-            return (
-                Some(DOWNLOAD_ICON),
-                format!(
+            return Content {
+                icon: Some(DOWNLOAD_ICON),
+                message: format!(
                     "Downloading {} language server{}...",
                     downloading.join(", "),
                     if downloading.len() > 1 { "s" } else { "" }
                 ),
-                None,
-            );
+                action: None,
+            };
         } else if !checking_for_update.is_empty() {
-            return (
-                Some(DOWNLOAD_ICON),
-                format!(
+            return Content {
+                icon: Some(DOWNLOAD_ICON),
+                message: format!(
                     "Checking for updates to {} language server{}...",
                     checking_for_update.join(", "),
                     if checking_for_update.len() > 1 {
@@ -220,49 +245,61 @@ impl ActivityIndicator {
                         ""
                     }
                 ),
-                None,
-            );
+                action: None,
+            };
         } else if !failed.is_empty() {
-            return (
-                Some(WARNING_ICON),
-                format!(
+            return Content {
+                icon: Some(WARNING_ICON),
+                message: format!(
                     "Failed to download {} language server{}. Click to show error.",
                     failed.join(", "),
                     if failed.len() > 1 { "s" } else { "" }
                 ),
-                Some(Box::new(ShowErrorMessage)),
-            );
+                action: Some(Box::new(ShowErrorMessage)),
+            };
         }
 
         // Show any application auto-update info.
         if let Some(updater) = &self.auto_updater {
-            match &updater.read(cx).status() {
-                AutoUpdateStatus::Checking => (
-                    Some(DOWNLOAD_ICON),
-                    "Checking for Zed updates…".to_string(),
-                    None,
-                ),
-                AutoUpdateStatus::Downloading => (
-                    Some(DOWNLOAD_ICON),
-                    "Downloading Zed update…".to_string(),
-                    None,
-                ),
-                AutoUpdateStatus::Installing => (
-                    Some(DOWNLOAD_ICON),
-                    "Installing Zed update…".to_string(),
-                    None,
-                ),
-                AutoUpdateStatus::Updated => (None, "Restart to update Zed".to_string(), None),
-                AutoUpdateStatus::Errored => (
-                    Some(WARNING_ICON),
-                    "Auto update failed".to_string(),
-                    Some(Box::new(DismissErrorMessage)),
-                ),
+            return match &updater.read(cx).status() {
+                AutoUpdateStatus::Checking => Content {
+                    icon: Some(DOWNLOAD_ICON),
+                    message: "Checking for Zed updates…".to_string(),
+                    action: None,
+                },
+                AutoUpdateStatus::Downloading => Content {
+                    icon: Some(DOWNLOAD_ICON),
+                    message: "Downloading Zed update…".to_string(),
+                    action: None,
+                },
+                AutoUpdateStatus::Installing => Content {
+                    icon: Some(DOWNLOAD_ICON),
+                    message: "Installing Zed update…".to_string(),
+                    action: None,
+                },
+                AutoUpdateStatus::Updated => Content {
+                    icon: None,
+                    message: "Click to restart and update Zed".to_string(),
+                    action: Some(Box::new(workspace::Restart)),
+                },
+                AutoUpdateStatus::Errored => Content {
+                    icon: Some(WARNING_ICON),
+                    message: "Auto update failed".to_string(),
+                    action: Some(Box::new(DismissErrorMessage)),
+                },
                 AutoUpdateStatus::Idle => Default::default(),
-            }
-        } else {
-            Default::default()
+            };
         }
+
+        if let Some(most_recent_active_task) = cx.active_labeled_tasks().last() {
+            return Content {
+                icon: None,
+                message: most_recent_active_task.to_string(),
+                action: None,
+            };
+        }
+
+        Default::default()
     }
 }
 
@@ -276,7 +313,11 @@ impl View for ActivityIndicator {
     }
 
     fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
-        let (icon, message, action) = self.content_to_render(cx);
+        let Content {
+            icon,
+            message,
+            action,
+        } = self.content_to_render(cx);
 
         let mut element = MouseEventHandler::<Self>::new(0, cx, |state, cx| {
             let theme = &cx

crates/assets/Cargo.toml

@@ -2,6 +2,7 @@
 name = "assets"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/assets.rs"

crates/auto_update/Cargo.toml

@@ -2,6 +2,7 @@
 name = "auto_update"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/auto_update.rs"
@@ -22,6 +23,7 @@ isahc = "1.7"
 lazy_static = "1.4"
 log = "0.4"
 serde = { version = "1.0", features = ["derive", "rc"] }
+serde_derive = { version = "1.0", features = ["deserialize_in_place"] }
 serde_json = { version = "1.0", features = ["preserve_order"] }
 smol = "1.2.5"
 tempdir = "0.3.7"

crates/auto_update/src/auto_update.rs

@@ -2,15 +2,16 @@ mod update_notification;
 
 use anyhow::{anyhow, Context, Result};
 use client::{http::HttpClient, ZED_SECRET_CLIENT_TOKEN};
+use client::{ZED_APP_PATH, ZED_APP_VERSION};
 use db::kvp::KEY_VALUE_STORE;
 use gpui::{
     actions, platform::AppVersion, AppContext, AsyncAppContext, Entity, ModelContext, ModelHandle,
     MutableAppContext, Task, WeakViewHandle,
 };
-use lazy_static::lazy_static;
 use serde::Deserialize;
+use settings::Settings;
 use smol::{fs::File, io::AsyncReadExt, process::Command};
-use std::{env, ffi::OsString, path::PathBuf, sync::Arc, time::Duration};
+use std::{ffi::OsString, sync::Arc, time::Duration};
 use update_notification::UpdateNotification;
 use util::channel::ReleaseChannel;
 use workspace::Workspace;
@@ -18,13 +19,6 @@ use workspace::Workspace;
 const SHOULD_SHOW_UPDATE_NOTIFICATION_KEY: &str = "auto-updater-should-show-updated-notification";
 const POLL_INTERVAL: Duration = Duration::from_secs(60 * 60);
 
-lazy_static! {
-    pub static ref ZED_APP_VERSION: Option<AppVersion> = env::var("ZED_APP_VERSION")
-        .ok()
-        .and_then(|v| v.parse().ok());
-    pub static ref ZED_APP_PATH: Option<PathBuf> = env::var("ZED_APP_PATH").ok().map(PathBuf::from);
-}
-
 actions!(auto_update, [Check, DismissErrorMessage, ViewReleaseNotes]);
 
 #[derive(Clone, Copy, PartialEq, Eq)]
@@ -60,7 +54,23 @@ pub fn init(http_client: Arc<dyn HttpClient>, server_url: String, cx: &mut Mutab
         let server_url = server_url;
         let auto_updater = cx.add_model(|cx| {
             let updater = AutoUpdater::new(version, http_client, server_url.clone());
-            updater.start_polling(cx).detach();
+
+            let mut update_subscription = cx
+                .global::<Settings>()
+                .auto_update
+                .then(|| updater.start_polling(cx));
+
+            cx.observe_global::<Settings, _>(move |updater, cx| {
+                if cx.global::<Settings>().auto_update {
+                    if update_subscription.is_none() {
+                        *(&mut update_subscription) = Some(updater.start_polling(cx))
+                    }
+                } else {
+                    (&mut update_subscription).take();
+                }
+            })
+            .detach();
+
             updater
         });
         cx.set_global(Some(auto_updater));

crates/auto_update/src/update_notification.rs

@@ -78,7 +78,7 @@ impl View for UpdateNotification {
                 )
                 .with_child({
                     let style = theme.action_message.style_for(state, false);
-                    Text::new("View the release notes".to_string(), style.text.clone())
+                    Text::new("View the release notes", style.text.clone())
                         .contained()
                         .with_style(style.container)
                         .boxed()

crates/breadcrumbs/Cargo.toml

@@ -2,6 +2,7 @@
 name = "breadcrumbs"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/breadcrumbs.rs"

crates/breadcrumbs/src/breadcrumbs.rs

@@ -47,7 +47,7 @@ impl View for Breadcrumbs {
         {
             Flex::row()
                 .with_children(Itertools::intersperse_with(breadcrumbs.into_iter(), || {
-                    Label::new(" 〉 ".to_string(), theme.breadcrumbs.text.clone()).boxed()
+                    Label::new(" 〉 ", theme.breadcrumbs.text.clone()).boxed()
                 }))
                 .contained()
                 .with_style(theme.breadcrumbs.container)

crates/call/Cargo.toml

@@ -2,6 +2,7 @@
 name = "call"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/call.rs"
@@ -27,6 +28,7 @@ fs = { path = "../fs" }
 language = { path = "../language" }
 media = { path = "../media" }
 project = { path = "../project" }
+settings = { path = "../settings" }
 util = { path = "../util" }
 
 anyhow = "1.0.38"

crates/call/src/call.rs

@@ -1,18 +1,22 @@
 pub mod participant;
 pub mod room;
 
+use std::sync::Arc;
+
 use anyhow::{anyhow, Result};
 use client::{proto, Client, TypedEnvelope, User, UserStore};
 use collections::HashSet;
+use futures::{future::Shared, FutureExt};
+use postage::watch;
+
 use gpui::{
     AppContext, AsyncAppContext, Entity, ModelContext, ModelHandle, MutableAppContext,
     Subscription, Task, WeakModelHandle,
 };
-pub use participant::ParticipantLocation;
-use postage::watch;
 use project::Project;
+
+pub use participant::ParticipantLocation;
 pub use room::Room;
-use std::sync::Arc;
 
 pub fn init(client: Arc<Client>, user_store: ModelHandle<UserStore>, cx: &mut MutableAppContext) {
     let active_call = cx.add_model(|cx| ActiveCall::new(client, user_store, cx));
@@ -27,8 +31,10 @@ pub struct IncomingCall {
     pub initial_project: Option<proto::ParticipantProject>,
 }
 
+/// Singleton global maintaining the user's participation in a room across workspaces.
 pub struct ActiveCall {
     room: Option<(ModelHandle<Room>, Vec<Subscription>)>,
+    pending_room_creation: Option<Shared<Task<Result<ModelHandle<Room>, Arc<anyhow::Error>>>>>,
     location: Option<WeakModelHandle<Project>>,
     pending_invites: HashSet<u64>,
     incoming_call: (
@@ -52,6 +58,7 @@ impl ActiveCall {
     ) -> Self {
         Self {
             room: None,
+            pending_room_creation: None,
             location: None,
             pending_invites: Default::default(),
             incoming_call: watch::channel(),
@@ -120,45 +127,74 @@ impl ActiveCall {
         initial_project: Option<ModelHandle<Project>>,
         cx: &mut ModelContext<Self>,
     ) -> Task<Result<()>> {
-        let client = self.client.clone();
-        let user_store = self.user_store.clone();
         if !self.pending_invites.insert(called_user_id) {
             return Task::ready(Err(anyhow!("user was already invited")));
         }
-
         cx.notify();
-        cx.spawn(|this, mut cx| async move {
-            let invite = async {
-                if let Some(room) = this.read_with(&cx, |this, _| this.room().cloned()) {
-                    let initial_project_id = if let Some(initial_project) = initial_project {
-                        Some(
-                            room.update(&mut cx, |room, cx| {
-                                room.share_project(initial_project, cx)
-                            })
+
+        let room = if let Some(room) = self.room().cloned() {
+            Some(Task::ready(Ok(room)).shared())
+        } else {
+            self.pending_room_creation.clone()
+        };
+
+        let invite = if let Some(room) = room {
+            cx.spawn_weak(|_, mut cx| async move {
+                let room = room.await.map_err(|err| anyhow!("{:?}", err))?;
+
+                let initial_project_id = if let Some(initial_project) = initial_project {
+                    Some(
+                        room.update(&mut cx, |room, cx| room.share_project(initial_project, cx))
                             .await?,
-                        )
-                    } else {
-                        None
-                    };
-
-                    room.update(&mut cx, |room, cx| {
-                        room.call(called_user_id, initial_project_id, cx)
-                    })
-                    .await?;
+                    )
                 } else {
-                    let room = cx
-                        .update(|cx| {
-                            Room::create(called_user_id, initial_project, client, user_store, cx)
-                        })
-                        .await?;
-
-                    this.update(&mut cx, |this, cx| this.set_room(Some(room), cx))
-                        .await?;
+                    None
                 };
 
-                Ok(())
-            };
+                room.update(&mut cx, |room, cx| {
+                    room.call(called_user_id, initial_project_id, cx)
+                })
+                .await?;
 
+                anyhow::Ok(())
+            })
+        } else {
+            let client = self.client.clone();
+            let user_store = self.user_store.clone();
+            let room = cx
+                .spawn(|this, mut cx| async move {
+                    let create_room = async {
+                        let room = cx
+                            .update(|cx| {
+                                Room::create(
+                                    called_user_id,
+                                    initial_project,
+                                    client,
+                                    user_store,
+                                    cx,
+                                )
+                            })
+                            .await?;
+
+                        this.update(&mut cx, |this, cx| this.set_room(Some(room.clone()), cx))
+                            .await?;
+
+                        anyhow::Ok(room)
+                    };
+
+                    let room = create_room.await;
+                    this.update(&mut cx, |this, _| this.pending_room_creation = None);
+                    room.map_err(Arc::new)
+                })
+                .shared();
+            self.pending_room_creation = Some(room.clone());
+            cx.foreground().spawn(async move {
+                room.await.map_err(|err| anyhow!("{:?}", err))?;
+                anyhow::Ok(())
+            })
+        };
+
+        cx.spawn(|this, mut cx| async move {
             let result = invite.await;
             this.update(&mut cx, |this, cx| {
                 this.pending_invites.remove(&called_user_id);
@@ -228,12 +264,13 @@ impl ActiveCall {
         Ok(())
     }
 
-    pub fn hang_up(&mut self, cx: &mut ModelContext<Self>) -> Result<()> {
+    pub fn hang_up(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
+        cx.notify();
         if let Some((room, _)) = self.room.take() {
-            room.update(cx, |room, cx| room.leave(cx))?;
-            cx.notify();
+            room.update(cx, |room, cx| room.leave(cx))
+        } else {
+            Task::ready(Ok(()))
         }
-        Ok(())
     }
 
     pub fn share_project(
@@ -248,6 +285,18 @@ impl ActiveCall {
         }
     }
 
+    pub fn unshare_project(
+        &mut self,
+        project: ModelHandle<Project>,
+        cx: &mut ModelContext<Self>,
+    ) -> Result<()> {
+        if let Some((room, _)) = self.room.as_ref() {
+            room.update(cx, |room, cx| room.unshare_project(project, cx))
+        } else {
+            Err(anyhow!("no active call"))
+        }
+    }
+
     pub fn set_location(
         &mut self,
         project: Option<&ModelHandle<Project>>,

crates/call/src/room.rs

@@ -17,10 +17,10 @@ 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 std::{future::Future, mem, pin::Pin, sync::Arc, time::Duration};
 use util::{post_inc, ResultExt, TryFutureExt};
 
-pub const RECONNECT_TIMEOUT: Duration = client::RECEIVE_TIMEOUT;
+pub const RECONNECT_TIMEOUT: Duration = Duration::from_secs(30);
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum Event {
@@ -55,6 +55,7 @@ pub struct Room {
     leave_when_empty: bool,
     client: Arc<Client>,
     user_store: ModelHandle<UserStore>,
+    follows_by_leader_id_project_id: HashMap<(PeerId, u64), Vec<PeerId>>,
     subscriptions: Vec<client::Subscription>,
     pending_room_update: Option<Task<()>>,
     maintain_connection: Option<Task<Option<()>>>,
@@ -63,10 +64,27 @@ pub struct Room {
 impl Entity for Room {
     type Event = Event;
 
-    fn release(&mut self, _: &mut MutableAppContext) {
+    fn release(&mut self, cx: &mut MutableAppContext) {
         if self.status.is_online() {
-            log::info!("room was released, sending leave message");
-            let _ = self.client.send(proto::LeaveRoom {});
+            self.leave_internal(cx).detach_and_log_err(cx);
+        }
+    }
+
+    fn app_will_quit(
+        &mut self,
+        cx: &mut MutableAppContext,
+    ) -> Option<Pin<Box<dyn Future<Output = ()>>>> {
+        if self.status.is_online() {
+            let leave = self.leave_internal(cx);
+            Some(
+                cx.background()
+                    .spawn(async move {
+                        leave.await.log_err();
+                    })
+                    .boxed(),
+            )
+        } else {
+            None
         }
     }
 }
@@ -148,6 +166,7 @@ impl Room {
             pending_room_update: None,
             client,
             user_store,
+            follows_by_leader_id_project_id: Default::default(),
             maintain_connection: Some(maintain_connection),
         }
     }
@@ -232,13 +251,17 @@ impl Room {
             && self.pending_call_count == 0
     }
 
-    pub(crate) fn leave(&mut self, cx: &mut ModelContext<Self>) -> Result<()> {
-        if self.status.is_offline() {
-            return Err(anyhow!("room is offline"));
-        }
-
+    pub(crate) fn leave(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
         cx.notify();
         cx.emit(Event::Left);
+        self.leave_internal(cx)
+    }
+
+    fn leave_internal(&mut self, cx: &mut MutableAppContext) -> Task<Result<()>> {
+        if self.status.is_offline() {
+            return Task::ready(Err(anyhow!("room is offline")));
+        }
+
         log::info!("leaving room");
 
         for project in self.shared_projects.drain() {
@@ -252,6 +275,7 @@ impl Room {
             if let Some(project) = project.upgrade(cx) {
                 project.update(cx, |project, cx| {
                     project.disconnected_from_host(cx);
+                    project.close(cx);
                 });
             }
         }
@@ -264,8 +288,12 @@ impl Room {
         self.live_kit.take();
         self.pending_room_update.take();
         self.maintain_connection.take();
-        self.client.send(proto::LeaveRoom {})?;
-        Ok(())
+
+        let leave_room = self.client.request(proto::LeaveRoom {});
+        cx.background().spawn(async move {
+            leave_room.await?;
+            anyhow::Ok(())
+        })
     }
 
     async fn maintain_connection(
@@ -275,14 +303,12 @@ impl Room {
     ) -> Result<()> {
         let mut client_status = client.status();
         loop {
-            let is_connected = client_status
-                .next()
-                .await
-                .map_or(false, |s| s.is_connected());
-
+            let _ = client_status.try_recv();
+            let is_connected = client_status.borrow().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() {
                 log::info!("detected client disconnection");
+
                 this.upgrade(&cx)
                     .ok_or_else(|| anyhow!("room was dropped"))?
                     .update(&mut cx, |this, cx| {
@@ -296,12 +322,7 @@ impl Room {
                     let client_reconnection = async {
                         let mut remaining_attempts = 3;
                         while remaining_attempts > 0 {
-                            log::info!(
-                                "waiting for client status change, remaining attempts {}",
-                                remaining_attempts
-                            );
-                            let Some(status) = client_status.next().await else { break };
-                            if status.is_connected() {
+                            if client_status.borrow().is_connected() {
                                 log::info!("client reconnected, attempting to rejoin room");
 
                                 let Some(this) = this.upgrade(&cx) else { break };
@@ -315,7 +336,15 @@ impl Room {
                                 } else {
                                     remaining_attempts -= 1;
                                 }
+                            } else if client_status.borrow().is_signed_out() {
+                                return false;
                             }
+
+                            log::info!(
+                                "waiting for client status change, remaining attempts {}",
+                                remaining_attempts
+                            );
+                            client_status.next().await;
                         }
                         false
                     }
@@ -337,18 +366,20 @@ impl Room {
                     }
                 }
 
-                // The client failed to re-establish a connection to the server
-                // 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!(
-                    "can't reconnect to room: client failed to re-establish connection"
-                ));
+                break;
             }
         }
+
+        // The client failed to re-establish a connection to the server
+        // 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));
+        }
+        Err(anyhow!(
+            "can't reconnect to room: client failed to re-establish connection"
+        ))
     }
 
     fn rejoin(&mut self, cx: &mut ModelContext<Self>) -> Task<Result<()>> {
@@ -457,6 +488,12 @@ impl Room {
         self.participant_user_ids.contains(&user_id)
     }
 
+    pub fn followers_for(&self, leader_id: PeerId, project_id: u64) -> &[PeerId] {
+        self.follows_by_leader_id_project_id
+            .get(&(leader_id, project_id))
+            .map_or(&[], |v| v.as_slice())
+    }
+
     async fn handle_room_updated(
         this: ModelHandle<Self>,
         envelope: TypedEnvelope<proto::RoomUpdated>,
@@ -487,11 +524,13 @@ impl Room {
             .iter()
             .map(|p| p.user_id)
             .collect::<Vec<_>>();
+
         let remote_participant_user_ids = room
             .participants
             .iter()
             .map(|p| p.user_id)
             .collect::<Vec<_>>();
+
         let (remote_participants, pending_participants) =
             self.user_store.update(cx, move |user_store, cx| {
                 (
@@ -499,6 +538,7 @@ impl Room {
                     user_store.get_users(pending_participant_user_ids, cx),
                 )
             });
+
         self.pending_room_update = Some(cx.spawn(|this, mut cx| async move {
             let (remote_participants, pending_participants) =
                 futures::join!(remote_participants, pending_participants);
@@ -587,7 +627,7 @@ impl Room {
 
                             if let Some(live_kit) = this.live_kit.as_ref() {
                                 let tracks =
-                                    live_kit.room.remote_video_tracks(&peer_id.to_string());
+                                    live_kit.room.remote_video_tracks(&user.id.to_string());
                                 for track in tracks {
                                     this.remote_video_track_updated(
                                         RemoteVideoTrackUpdate::Subscribed(track),
@@ -620,6 +660,27 @@ impl Room {
                     }
                 }
 
+                this.follows_by_leader_id_project_id.clear();
+                for follower in room.followers {
+                    let project_id = follower.project_id;
+                    let (leader, follower) = match (follower.leader_id, follower.follower_id) {
+                        (Some(leader), Some(follower)) => (leader, follower),
+
+                        _ => {
+                            log::error!("Follower message {follower:?} missing some state");
+                            continue;
+                        }
+                    };
+
+                    let list = this
+                        .follows_by_leader_id_project_id
+                        .entry((leader, project_id))
+                        .or_insert(Vec::new());
+                    if !list.contains(&follower) {
+                        list.push(follower);
+                    }
+                }
+
                 this.pending_room_update.take();
                 if this.should_leave() {
                     log::info!("room is empty, leaving");
@@ -723,10 +784,10 @@ impl Room {
             this.update(&mut cx, |this, cx| {
                 this.pending_call_count -= 1;
                 if this.should_leave() {
-                    this.leave(cx)?;
+                    this.leave(cx).detach_and_log_err(cx);
                 }
-                result
-            })?;
+            });
+            result?;
             Ok(())
         })
     }
@@ -793,6 +854,20 @@ impl Room {
         })
     }
 
+    pub(crate) fn unshare_project(
+        &mut self,
+        project: ModelHandle<Project>,
+        cx: &mut ModelContext<Self>,
+    ) -> Result<()> {
+        let project_id = match project.read(cx).remote_id() {
+            Some(project_id) => project_id,
+            None => return Ok(()),
+        };
+
+        self.client.send(proto::UnshareProject { project_id })?;
+        project.update(cx, |this, cx| this.unshare(cx))
+    }
+
     pub(crate) fn set_location(
         &mut self,
         project: Option<&ModelHandle<Project>>,

crates/cli/Cargo.toml

@@ -2,6 +2,7 @@
 name = "cli"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/cli.rs"
@@ -17,6 +18,7 @@ clap = { version = "3.1", features = ["derive"] }
 dirs = "3.0"
 ipc-channel = "0.16"
 serde = { version = "1.0", features = ["derive", "rc"] }
+serde_derive = { version = "1.0", features = ["deserialize_in_place"] }
 
 [target.'cfg(target_os = "macos")'.dependencies]
 core-foundation = "0.9"

crates/cli/src/main.rs

@@ -9,7 +9,13 @@ use core_foundation::{
 use core_services::{kLSLaunchDefaults, LSLaunchURLSpec, LSOpenFromURLSpec, TCFType};
 use ipc_channel::ipc::{IpcOneShotServer, IpcReceiver, IpcSender};
 use serde::Deserialize;
-use std::{ffi::OsStr, fs, path::PathBuf, ptr};
+use std::{
+    ffi::OsStr,
+    fs::{self, OpenOptions},
+    io,
+    path::{Path, PathBuf},
+    ptr,
+};
 
 #[derive(Parser)]
 #[clap(name = "zed", global_setting(clap::AppSettings::NoAutoVersion))]
@@ -54,6 +60,12 @@ fn main() -> Result<()> {
         return Ok(());
     }
 
+    for path in args.paths.iter() {
+        if !path.exists() {
+            touch(path.as_path())?;
+        }
+    }
+
     let (tx, rx) = launch_app(bundle_path)?;
 
     tx.send(CliRequest::Open {
@@ -77,6 +89,13 @@ fn main() -> Result<()> {
     Ok(())
 }
 
+fn touch(path: &Path) -> io::Result<()> {
+    match OpenOptions::new().create(true).write(true).open(path) {
+        Ok(_) => Ok(()),
+        Err(e) => Err(e),
+    }
+}
+
 fn locate_bundle() -> Result<PathBuf> {
     let cli_path = std::env::current_exe()?.canonicalize()?;
     let mut app_path = cli_path.clone();

crates/client/Cargo.toml

@@ -2,6 +2,7 @@
 name = "client"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/client.rs"
@@ -34,7 +35,8 @@ time = { version = "0.3", features = ["serde", "serde-well-known"] }
 tiny_http = "0.8"
 uuid = { version = "1.1.2", features = ["v4"] }
 url = "2.2"
-serde = { version = "*", features = ["derive"] }
+serde = { version = "*", features = ["derive", "rc"] }
+serde_derive = { version = "1.0", features = ["deserialize_in_place"] }
 settings = { path = "../settings" }
 tempfile = "3"
 

crates/client/src/client.rs

@@ -15,7 +15,7 @@ use futures::{future::LocalBoxFuture, AsyncReadExt, FutureExt, SinkExt, StreamEx
 use gpui::{
     actions,
     serde_json::{self, Value},
-    AnyModelHandle, AnyViewHandle, AnyWeakModelHandle, AnyWeakViewHandle, AppContext,
+    AnyModelHandle, AnyViewHandle, AnyWeakModelHandle, AnyWeakViewHandle, AppContext, AppVersion,
     AsyncAppContext, Entity, ModelHandle, MutableAppContext, Task, View, ViewContext, ViewHandle,
 };
 use http::HttpClient;
@@ -55,18 +55,23 @@ lazy_static! {
     pub static ref ADMIN_API_TOKEN: Option<String> = std::env::var("ZED_ADMIN_API_TOKEN")
         .ok()
         .and_then(|s| if s.is_empty() { None } else { Some(s) });
+    pub static ref ZED_APP_VERSION: Option<AppVersion> = std::env::var("ZED_APP_VERSION")
+        .ok()
+        .and_then(|v| v.parse().ok());
+    pub static ref ZED_APP_PATH: Option<PathBuf> =
+        std::env::var("ZED_APP_PATH").ok().map(PathBuf::from);
 }
 
 pub const ZED_SECRET_CLIENT_TOKEN: &str = "618033988749894";
 pub const INITIAL_RECONNECTION_DELAY: Duration = Duration::from_millis(100);
 pub const CONNECTION_TIMEOUT: Duration = Duration::from_secs(5);
 
-actions!(client, [Authenticate]);
+actions!(client, [SignIn, SignOut]);
 
 pub fn init(client: Arc<Client>, cx: &mut MutableAppContext) {
     cx.add_global_action({
         let client = client.clone();
-        move |_: &Authenticate, cx| {
+        move |_: &SignIn, cx| {
             let client = client.clone();
             cx.spawn(
                 |cx| async move { client.authenticate_and_connect(true, &cx).log_err().await },
@@ -74,6 +79,16 @@ pub fn init(client: Arc<Client>, cx: &mut MutableAppContext) {
             .detach();
         }
     });
+    cx.add_global_action({
+        let client = client.clone();
+        move |_: &SignOut, cx| {
+            let client = client.clone();
+            cx.spawn(|cx| async move {
+                client.disconnect(&cx);
+            })
+            .detach();
+        }
+    });
 }
 
 pub struct Client {
@@ -164,6 +179,10 @@ impl Status {
     pub fn is_connected(&self) -> bool {
         matches!(self, Self::Connected { .. })
     }
+
+    pub fn is_signed_out(&self) -> bool {
+        matches!(self, Self::SignedOut | Self::UpgradeRequired)
+    }
 }
 
 struct ClientState {
@@ -1147,11 +1166,9 @@ impl Client {
         })
     }
 
-    pub fn disconnect(self: &Arc<Self>, cx: &AsyncAppContext) -> Result<()> {
-        let conn_id = self.connection_id()?;
-        self.peer.disconnect(conn_id);
+    pub fn disconnect(self: &Arc<Self>, cx: &AsyncAppContext) {
+        self.peer.teardown();
         self.set_status(Status::SignedOut, cx);
-        Ok(())
     }
 
     fn connection_id(&self) -> Result<ConnectionId> {
@@ -1315,6 +1332,14 @@ impl Client {
     pub fn telemetry_log_file_path(&self) -> Option<PathBuf> {
         self.telemetry.log_file_path()
     }
+
+    pub fn metrics_id(&self) -> Option<Arc<str>> {
+        self.telemetry.metrics_id()
+    }
+
+    pub fn is_staff(&self) -> Option<bool> {
+        self.telemetry.is_staff()
+    }
 }
 
 impl WeakSubscriber {

crates/client/src/http.rs

@@ -9,7 +9,7 @@ pub use isahc::{
     Error,
 };
 use smol::future::FutureExt;
-use std::sync::Arc;
+use std::{sync::Arc, time::Duration};
 pub use url::Url;
 
 pub type Request = isahc::Request<AsyncBody>;
@@ -41,7 +41,13 @@ pub trait HttpClient: Send + Sync {
 }
 
 pub fn client() -> Arc<dyn HttpClient> {
-    Arc::new(isahc::HttpClient::builder().build().unwrap())
+    Arc::new(
+        isahc::HttpClient::builder()
+            .connect_timeout(Duration::from_secs(5))
+            .low_speed_timeout(100, Duration::from_secs(5))
+            .build()
+            .unwrap(),
+    )
 }
 
 impl HttpClient for isahc::HttpClient {

crates/client/src/telemetry.rs

@@ -40,6 +40,7 @@ struct TelemetryState {
     next_event_id: usize,
     flush_task: Option<Task<()>>,
     log_file: Option<NamedTempFile>,
+    is_staff: Option<bool>,
 }
 
 const MIXPANEL_EVENTS_URL: &'static str = "https://api.mixpanel.com/track";
@@ -125,6 +126,7 @@ impl Telemetry {
                 flush_task: Default::default(),
                 next_event_id: 0,
                 log_file: None,
+                is_staff: None,
             }),
         });
 
@@ -202,6 +204,7 @@ impl Telemetry {
         let device_id = state.device_id.clone();
         let metrics_id: Option<Arc<str>> = metrics_id.map(|id| id.into());
         state.metrics_id = metrics_id.clone();
+        state.is_staff = Some(is_staff);
         drop(state);
 
         if let Some((token, device_id)) = MIXPANEL_TOKEN.as_ref().zip(device_id) {
@@ -221,7 +224,7 @@ impl Telemetry {
                             .header("Content-Type", "application/json")
                             .body(json_bytes.into())?;
                         this.http_client.send(request).await?;
-                        Ok(())
+                        anyhow::Ok(())
                     }
                     .log_err(),
                 )
@@ -278,6 +281,14 @@ impl Telemetry {
         }
     }
 
+    pub fn metrics_id(self: &Arc<Self>) -> Option<Arc<str>> {
+        self.state.lock().metrics_id.clone()
+    }
+
+    pub fn is_staff(self: &Arc<Self>) -> Option<bool> {
+        self.state.lock().is_staff
+    }
+
     fn flush(self: &Arc<Self>) {
         let mut state = self.state.lock();
         let mut events = mem::take(&mut state.queue);
@@ -309,7 +320,7 @@ impl Telemetry {
                             .header("Content-Type", "application/json")
                             .body(json_bytes.into())?;
                         this.http_client.send(request).await?;
-                        Ok(())
+                        anyhow::Ok(())
                     }
                     .log_err(),
                 )

crates/client/src/user.rs

@@ -7,7 +7,7 @@ use postage::{sink::Sink, watch};
 use rpc::proto::{RequestMessage, UsersResponse};
 use settings::Settings;
 use std::sync::{Arc, Weak};
-use util::TryFutureExt as _;
+use util::{StaffMode, TryFutureExt as _};
 
 #[derive(Default, Debug)]
 pub struct User {
@@ -148,6 +148,19 @@ impl UserStore {
                                     cx.read(|cx| cx.global::<Settings>().telemetry()),
                                 );
 
+                                cx.update(|cx| {
+                                    cx.update_default_global(|staff_mode: &mut StaffMode, _| {
+                                        if !staff_mode.0 {
+                                            *staff_mode = StaffMode(
+                                                info.as_ref()
+                                                    .map(|info| info.staff)
+                                                    .unwrap_or_default(),
+                                            )
+                                        }
+                                        ()
+                                    });
+                                });
+
                                 current_user_tx.send(user).await.ok();
                             }
                         }
@@ -170,6 +183,11 @@ impl UserStore {
         }
     }
 
+    #[cfg(feature = "test-support")]
+    pub fn clear_cache(&mut self) {
+        self.users.clear();
+    }
+
     async fn handle_update_invite_info(
         this: ModelHandle<Self>,
         message: TypedEnvelope<proto::UpdateInviteInfo>,

crates/clock/Cargo.toml

@@ -2,6 +2,7 @@
 name = "clock"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/clock.rs"

crates/collab/.env.toml

@@ -1,4 +1,5 @@
 DATABASE_URL = "postgres://postgres@localhost/zed"
+DATABASE_MAX_CONNECTIONS = 5
 HTTP_PORT = 8080
 API_TOKEN = "secret"
 INVITE_LINK_PREFIX = "http://localhost:3000/invites/"

crates/collab/Cargo.toml

@@ -3,7 +3,8 @@ authors = ["Nathan Sobo <nathan@zed.dev>"]
 default-run = "collab"
 edition = "2021"
 name = "collab"
-version = "0.4.2"
+version = "0.8.2"
+publish = false
 
 [[bin]]
 name = "collab"
@@ -30,6 +31,7 @@ futures = "0.3"
 hyper = "0.14"
 lazy_static = "1.4"
 lipsum = { version = "0.8", optional = true }
+log = { version = "0.4.16", features = ["kv_unstable_serde"] }
 nanoid = "0.4"
 parking_lot = "0.11.1"
 prometheus = "0.13"
@@ -40,6 +42,7 @@ scrypt = "0.7"
 sea-orm = { git = "https://github.com/zed-industries/sea-orm", rev = "18f4c691085712ad014a51792af75a9044bacee6", features = ["sqlx-postgres", "postgres-array", "runtime-tokio-rustls"] }
 sea-query = "0.27"
 serde = { version = "1.0", features = ["derive", "rc"] }
+serde_derive = { version = "1.0", features = ["deserialize_in_place"] }
 serde_json = "1.0"
 sha-1 = "0.9"
 sqlx = { version = "0.6", features = ["runtime-tokio-rustls", "postgres", "json", "time", "uuid", "any"] }
@@ -73,7 +76,6 @@ workspace = { path = "../workspace", features = ["test-support"] }
 
 ctor = "0.1"
 env_logger = "0.9"
-log = { version = "0.4.16", features = ["kv_unstable_serde"] }
 util = { path = "../util" }
 lazy_static = "1.4"
 sea-orm = { git = "https://github.com/zed-industries/sea-orm", rev = "18f4c691085712ad014a51792af75a9044bacee6", features = ["sqlx-sqlite"] }

crates/collab/k8s/environments/preview.sh

@@ -1,3 +1,4 @@
 ZED_ENVIRONMENT=preview
 RUST_LOG=info
 INVITE_LINK_PREFIX=https://zed.dev/invites/
+DATABASE_MAX_CONNECTIONS=10

crates/collab/k8s/environments/production.sh

@@ -1,3 +1,4 @@
 ZED_ENVIRONMENT=production
 RUST_LOG=info
 INVITE_LINK_PREFIX=https://zed.dev/invites/
+DATABASE_MAX_CONNECTIONS=85

crates/collab/k8s/environments/staging.sh

@@ -1,3 +1,4 @@
 ZED_ENVIRONMENT=staging
 RUST_LOG=info
 INVITE_LINK_PREFIX=https://staging.zed.dev/invites/
+DATABASE_MAX_CONNECTIONS=5

crates/collab/k8s/manifest.template.yml

@@ -59,6 +59,13 @@ spec:
           ports:
             - containerPort: 8080
               protocol: TCP
+          livenessProbe:
+            httpGet:
+              path: /healthz
+              port: 8080
+            initialDelaySeconds: 5
+            periodSeconds: 5
+            timeoutSeconds: 5
           readinessProbe:
             httpGet:
               path: /
@@ -73,6 +80,8 @@ spec:
                 secretKeyRef:
                   name: database
                   key: url
+            - name: DATABASE_MAX_CONNECTIONS
+              value: "${DATABASE_MAX_CONNECTIONS}"
             - name: API_TOKEN
               valueFrom:
                 secretKeyRef:

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

@@ -57,6 +57,7 @@ CREATE TABLE "worktrees" (
     "abs_path" VARCHAR NOT NULL,
     "visible" BOOL NOT NULL,
     "scan_id" INTEGER NOT NULL,
+    "is_complete" BOOL NOT NULL DEFAULT FALSE,
     "completed_scan_id" INTEGER NOT NULL,
     PRIMARY KEY(project_id, id)
 );
@@ -142,3 +143,17 @@ CREATE TABLE "servers" (
     "id" INTEGER PRIMARY KEY AUTOINCREMENT,
     "environment" VARCHAR NOT NULL
 );
+
+CREATE TABLE "followers" (
+    "id" INTEGER PRIMARY KEY AUTOINCREMENT,
+    "room_id" INTEGER NOT NULL REFERENCES rooms (id) ON DELETE CASCADE,
+    "project_id" INTEGER NOT NULL REFERENCES projects (id) ON DELETE CASCADE,
+    "leader_connection_server_id" INTEGER NOT NULL REFERENCES servers (id) ON DELETE CASCADE,
+    "leader_connection_id" INTEGER NOT NULL,
+    "follower_connection_server_id" INTEGER NOT NULL REFERENCES servers (id) ON DELETE CASCADE,
+    "follower_connection_id" INTEGER NOT NULL
+);
+CREATE UNIQUE INDEX 
+    "index_followers_on_project_id_and_leader_connection_server_id_and_leader_connection_id_and_follower_connection_server_id_and_follower_connection_id"
+ON "followers" ("project_id", "leader_connection_server_id", "leader_connection_id", "follower_connection_server_id", "follower_connection_id");
+CREATE INDEX "index_followers_on_room_id" ON "followers" ("room_id");

crates/collab/migrations/20230103200902_replace_is_completed_with_completed_scan_id.sql

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

crates/collab/migrations/20230202155735_followers.sql

@@ -0,0 +1,15 @@
+CREATE TABLE IF NOT EXISTS "followers" (
+    "id" SERIAL PRIMARY KEY,
+    "room_id" INTEGER NOT NULL REFERENCES rooms (id) ON DELETE CASCADE,
+    "project_id" INTEGER NOT NULL REFERENCES projects (id) ON DELETE CASCADE,
+    "leader_connection_server_id" INTEGER NOT NULL REFERENCES servers (id) ON DELETE CASCADE,
+    "leader_connection_id" INTEGER NOT NULL,
+    "follower_connection_server_id" INTEGER NOT NULL REFERENCES servers (id) ON DELETE CASCADE,
+    "follower_connection_id" INTEGER NOT NULL
+);
+
+CREATE UNIQUE INDEX 
+    "index_followers_on_project_id_and_leader_connection_server_id_and_leader_connection_id_and_follower_connection_server_id_and_follower_connection_id"
+ON "followers" ("project_id", "leader_connection_server_id", "leader_connection_id", "follower_connection_server_id", "follower_connection_id");
+
+CREATE INDEX "index_followers_on_room_id" ON "followers" ("room_id");

crates/collab/src/api.rs

@@ -78,6 +78,7 @@ pub async fn validate_api_token<B>(req: Request<B>, next: Next<B>) -> impl IntoR
 struct AuthenticatedUserParams {
     github_user_id: Option<i32>,
     github_login: String,
+    github_email: Option<String>,
 }
 
 #[derive(Debug, Serialize)]
@@ -92,7 +93,11 @@ async fn get_authenticated_user(
 ) -> Result<Json<AuthenticatedUserResponse>> {
     let user = app
         .db
-        .get_user_by_github_account(&params.github_login, params.github_user_id)
+        .get_or_create_user_by_github_account(
+            &params.github_login,
+            params.github_user_id,
+            params.github_email.as_deref(),
+        )
         .await?
         .ok_or_else(|| Error::Http(StatusCode::NOT_FOUND, "user not found".into()))?;
     let metrics_id = app.db.get_user_metrics_id(user.id).await?;
@@ -297,11 +302,7 @@ async fn create_access_token(
     let mut user_id = user.id;
     if let Some(impersonate) = params.impersonate {
         if user.admin {
-            if let Some(impersonated_user) = app
-                .db
-                .get_user_by_github_account(&impersonate, None)
-                .await?
-            {
+            if let Some(impersonated_user) = app.db.get_user_by_github_login(&impersonate).await? {
                 user_id = impersonated_user.id;
             } else {
                 return Err(Error::Http(
@@ -353,6 +354,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 +368,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/auth.rs

@@ -1,5 +1,5 @@
 use crate::{
-    db::{self, UserId},
+    db::{self, AccessTokenId, Database, UserId},
     AppState, Error, Result,
 };
 use anyhow::{anyhow, Context};
@@ -8,12 +8,24 @@ use axum::{
     middleware::Next,
     response::IntoResponse,
 };
+use lazy_static::lazy_static;
+use prometheus::{exponential_buckets, register_histogram, Histogram};
 use rand::thread_rng;
 use scrypt::{
     password_hash::{PasswordHash, PasswordHasher, PasswordVerifier, SaltString},
     Scrypt,
 };
-use std::sync::Arc;
+use serde::{Deserialize, Serialize};
+use std::{sync::Arc, time::Instant};
+
+lazy_static! {
+    static ref METRIC_ACCESS_TOKEN_HASHING_TIME: Histogram = register_histogram!(
+        "access_token_hashing_time",
+        "time spent hashing access tokens",
+        exponential_buckets(10.0, 2.0, 10).unwrap(),
+    )
+    .unwrap();
+}
 
 pub async fn validate_header<B>(mut req: Request<B>, next: Next<B>) -> impl IntoResponse {
     let mut auth_header = req
@@ -42,20 +54,14 @@ pub async fn validate_header<B>(mut req: Request<B>, next: Next<B>) -> impl Into
         )
     })?;
 
-    let mut credentials_valid = false;
     let state = req.extensions().get::<Arc<AppState>>().unwrap();
-    if let Some(admin_token) = access_token.strip_prefix("ADMIN_TOKEN:") {
-        if state.config.api_token == admin_token {
-            credentials_valid = true;
-        }
+    let credentials_valid = if let Some(admin_token) = access_token.strip_prefix("ADMIN_TOKEN:") {
+        state.config.api_token == admin_token
     } else {
-        for password_hash in state.db.get_access_token_hashes(user_id).await? {
-            if verify_access_token(access_token, &password_hash)? {
-                credentials_valid = true;
-                break;
-            }
-        }
-    }
+        verify_access_token(&access_token, user_id, &state.db)
+            .await
+            .unwrap_or(false)
+    };
 
     if credentials_valid {
         let user = state
@@ -75,13 +81,26 @@ pub async fn validate_header<B>(mut req: Request<B>, next: Next<B>) -> impl Into
 
 const MAX_ACCESS_TOKENS_TO_STORE: usize = 8;
 
+#[derive(Serialize, Deserialize)]
+struct AccessTokenJson {
+    version: usize,
+    id: AccessTokenId,
+    token: String,
+}
+
 pub async fn create_access_token(db: &db::Database, user_id: UserId) -> Result<String> {
+    const VERSION: usize = 1;
     let access_token = rpc::auth::random_token();
     let access_token_hash =
         hash_access_token(&access_token).context("failed to hash access token")?;
-    db.create_access_token_hash(user_id, &access_token_hash, MAX_ACCESS_TOKENS_TO_STORE)
+    let id = db
+        .create_access_token(user_id, &access_token_hash, MAX_ACCESS_TOKENS_TO_STORE)
         .await?;
-    Ok(access_token)
+    Ok(serde_json::to_string(&AccessTokenJson {
+        version: VERSION,
+        id,
+        token: access_token,
+    })?)
 }
 
 fn hash_access_token(token: &str) -> Result<String> {
@@ -89,7 +108,7 @@ fn hash_access_token(token: &str) -> Result<String> {
     let params = if cfg!(debug_assertions) {
         scrypt::Params::new(1, 1, 1).unwrap()
     } else {
-        scrypt::Params::recommended()
+        scrypt::Params::new(14, 8, 1).unwrap()
     };
 
     Ok(Scrypt
@@ -112,7 +131,21 @@ pub fn encrypt_access_token(access_token: &str, public_key: String) -> Result<St
     Ok(encrypted_access_token)
 }
 
-pub fn verify_access_token(token: &str, hash: &str) -> Result<bool> {
-    let hash = PasswordHash::new(hash).map_err(anyhow::Error::new)?;
-    Ok(Scrypt.verify_password(token.as_bytes(), &hash).is_ok())
+pub async fn verify_access_token(token: &str, user_id: UserId, db: &Arc<Database>) -> Result<bool> {
+    let token: AccessTokenJson = serde_json::from_str(&token)?;
+
+    let db_token = db.get_access_token(token.id).await?;
+    if db_token.user_id != user_id {
+        return Err(anyhow!("no such access token"))?;
+    }
+
+    let db_hash = PasswordHash::new(&db_token.hash).map_err(anyhow::Error::new)?;
+    let t0 = Instant::now();
+    let is_valid = Scrypt
+        .verify_password(token.token.as_bytes(), &db_hash)
+        .is_ok();
+    let duration = t0.elapsed();
+    log::info!("hashed access token in {:?}", duration);
+    METRIC_ACCESS_TOKEN_HASHING_TIME.observe(duration.as_millis() as f64);
+    Ok(is_valid)
 }

crates/collab/src/bin/seed.rs

@@ -1,4 +1,4 @@
-use collab::db;
+use collab::{db, executor::Executor};
 use db::{ConnectOptions, Database};
 use serde::{de::DeserializeOwned, Deserialize};
 use std::fmt::Write;
@@ -13,7 +13,7 @@ struct GitHubUser {
 #[tokio::main]
 async fn main() {
     let database_url = std::env::var("DATABASE_URL").expect("missing DATABASE_URL env var");
-    let db = Database::new(ConnectOptions::new(database_url))
+    let db = Database::new(ConnectOptions::new(database_url), Executor::Production)
         .await
         .expect("failed to connect to postgres database");
     let github_token = std::env::var("GITHUB_TOKEN").expect("missing GITHUB_TOKEN env var");
@@ -59,7 +59,7 @@ async fn main() {
 
     for (github_user, admin) in zed_users {
         if db
-            .get_user_by_github_account(&github_user.login, Some(github_user.id))
+            .get_user_by_github_login(&github_user.login)
             .await
             .expect("failed to fetch user")
             .is_none()

crates/collab/src/db.rs

@@ -1,5 +1,6 @@
 mod access_token;
 mod contact;
+mod follower;
 mod language_server;
 mod project;
 mod project_collaborator;
@@ -14,6 +15,7 @@ mod worktree;
 mod worktree_diagnostic_summary;
 mod worktree_entry;
 
+use crate::executor::Executor;
 use crate::{Error, Result};
 use anyhow::anyhow;
 use collections::{BTreeMap, HashMap, HashSet};
@@ -21,6 +23,8 @@ pub use contact::Contact;
 use dashmap::DashMap;
 use futures::StreamExt;
 use hyper::StatusCode;
+use rand::prelude::StdRng;
+use rand::{Rng, SeedableRng};
 use rpc::{proto, ConnectionId};
 use sea_orm::Condition;
 pub use sea_orm::ConnectOptions;
@@ -45,20 +49,20 @@ pub struct Database {
     options: ConnectOptions,
     pool: DatabaseConnection,
     rooms: DashMap<RoomId, Arc<Mutex<()>>>,
-    #[cfg(test)]
-    background: Option<std::sync::Arc<gpui::executor::Background>>,
+    rng: Mutex<StdRng>,
+    executor: Executor,
     #[cfg(test)]
     runtime: Option<tokio::runtime::Runtime>,
 }
 
 impl Database {
-    pub async fn new(options: ConnectOptions) -> Result<Self> {
+    pub async fn new(options: ConnectOptions, executor: Executor) -> Result<Self> {
         Ok(Self {
             options: options.clone(),
             pool: sea_orm::Database::connect(options).await?,
             rooms: DashMap::with_capacity(16384),
-            #[cfg(test)]
-            background: None,
+            rng: Mutex::new(StdRng::seed_from_u64(0)),
+            executor,
             #[cfg(test)]
             runtime: None,
         })
@@ -157,7 +161,7 @@ impl Database {
         room_id: RoomId,
         new_server_id: ServerId,
     ) -> Result<RoomGuard<RefreshedRoom>> {
-        self.room_transaction(|tx| async move {
+        self.room_transaction(room_id, |tx| async move {
             let stale_participant_filter = Condition::all()
                 .add(room_participant::Column::RoomId.eq(room_id))
                 .add(room_participant::Column::AnsweringConnectionId.is_not_null())
@@ -190,17 +194,18 @@ impl Database {
                     .filter(room_participant::Column::RoomId.eq(room_id))
                     .exec(&*tx)
                     .await?;
+                project::Entity::delete_many()
+                    .filter(project::Column::RoomId.eq(room_id))
+                    .exec(&*tx)
+                    .await?;
                 room::Entity::delete_by_id(room_id).exec(&*tx).await?;
             }
 
-            Ok((
-                room_id,
-                RefreshedRoom {
-                    room,
-                    stale_participant_user_ids,
-                    canceled_calls_to_user_ids,
-                },
-            ))
+            Ok(RefreshedRoom {
+                room,
+                stale_participant_user_ids,
+                canceled_calls_to_user_ids,
+            })
         })
         .await
     }
@@ -293,10 +298,21 @@ impl Database {
         .await
     }
 
-    pub async fn get_user_by_github_account(
+    pub async fn get_user_by_github_login(&self, github_login: &str) -> Result<Option<User>> {
+        self.transaction(|tx| async move {
+            Ok(user::Entity::find()
+                .filter(user::Column::GithubLogin.eq(github_login))
+                .one(&*tx)
+                .await?)
+        })
+        .await
+    }
+
+    pub async fn get_or_create_user_by_github_account(
         &self,
         github_login: &str,
         github_user_id: Option<i32>,
+        github_email: Option<&str>,
     ) -> Result<Option<User>> {
         self.transaction(|tx| async move {
             let tx = &*tx;
@@ -318,7 +334,19 @@ impl Database {
                     user_by_github_login.github_user_id = ActiveValue::set(Some(github_user_id));
                     Ok(Some(user_by_github_login.update(tx).await?))
                 } else {
-                    Ok(None)
+                    let user = user::Entity::insert(user::ActiveModel {
+                        email_address: ActiveValue::set(github_email.map(|email| email.into())),
+                        github_login: ActiveValue::set(github_login.into()),
+                        github_user_id: ActiveValue::set(Some(github_user_id)),
+                        admin: ActiveValue::set(false),
+                        invite_count: ActiveValue::set(0),
+                        invite_code: ActiveValue::set(None),
+                        metrics_id: ActiveValue::set(Uuid::new_v4()),
+                        ..Default::default()
+                    })
+                    .exec_with_returning(&*tx)
+                    .await?;
+                    Ok(Some(user))
                 }
             } else {
                 Ok(user::Entity::find()
@@ -595,7 +623,16 @@ impl Database {
         .await
     }
 
-    pub async fn remove_contact(&self, requester_id: UserId, responder_id: UserId) -> Result<()> {
+    /// Returns a bool indicating whether the removed contact had originally accepted or not
+    ///
+    /// Deletes the contact identified by the requester and responder ids, and then returns
+    /// whether the deleted contact had originally accepted or was a pending contact request.
+    ///
+    /// # Arguments
+    ///
+    /// * `requester_id` - The user that initiates this request
+    /// * `responder_id` - The user that will be removed
+    pub async fn remove_contact(&self, requester_id: UserId, responder_id: UserId) -> Result<bool> {
         self.transaction(|tx| async move {
             let (id_a, id_b) = if responder_id < requester_id {
                 (responder_id, requester_id)
@@ -603,20 +640,18 @@ impl Database {
                 (requester_id, responder_id)
             };
 
-            let result = contact::Entity::delete_many()
+            let contact = contact::Entity::find()
                 .filter(
                     contact::Column::UserIdA
                         .eq(id_a)
                         .and(contact::Column::UserIdB.eq(id_b)),
                 )
-                .exec(&*tx)
-                .await?;
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such contact"))?;
 
-            if result.rows_affected == 1 {
-                Ok(())
-            } else {
-                Err(anyhow!("no such contact"))?
-            }
+            contact::Entity::delete_by_id(contact.id).exec(&*tx).await?;
+            Ok(contact.accepted)
         })
         .await
     }
@@ -882,6 +917,7 @@ impl Database {
         code: &str,
         email_address: &str,
         device_id: Option<&str>,
+        added_to_mailing_list: bool,
     ) -> Result<Invite> {
         self.transaction(|tx| async move {
             let existing_user = user::Entity::find()
@@ -933,6 +969,7 @@ impl Database {
                 platform_windows: ActiveValue::set(false),
                 platform_unknown: ActiveValue::set(true),
                 device_id: ActiveValue::set(device_id.map(|device_id| device_id.into())),
+                added_to_mailing_list: ActiveValue::set(added_to_mailing_list),
                 ..Default::default()
             })
             .on_conflict(
@@ -1120,18 +1157,16 @@ impl Database {
         user_id: UserId,
         connection: ConnectionId,
         live_kit_room: &str,
-    ) -> Result<RoomGuard<proto::Room>> {
-        self.room_transaction(|tx| async move {
+    ) -> Result<proto::Room> {
+        self.transaction(|tx| async move {
             let room = room::ActiveModel {
                 live_kit_room: ActiveValue::set(live_kit_room.into()),
                 ..Default::default()
             }
             .insert(&*tx)
             .await?;
-            let room_id = room.id;
-
             room_participant::ActiveModel {
-                room_id: ActiveValue::set(room_id),
+                room_id: ActiveValue::set(room.id),
                 user_id: ActiveValue::set(user_id),
                 answering_connection_id: ActiveValue::set(Some(connection.id as i32)),
                 answering_connection_server_id: ActiveValue::set(Some(ServerId(
@@ -1148,8 +1183,8 @@ impl Database {
             .insert(&*tx)
             .await?;
 
-            let room = self.get_room(room_id, &tx).await?;
-            Ok((room_id, room))
+            let room = self.get_room(room.id, &tx).await?;
+            Ok(room)
         })
         .await
     }
@@ -1162,7 +1197,7 @@ impl Database {
         called_user_id: UserId,
         initial_project_id: Option<ProjectId>,
     ) -> Result<RoomGuard<(proto::Room, proto::IncomingCall)>> {
-        self.room_transaction(|tx| async move {
+        self.room_transaction(room_id, |tx| async move {
             room_participant::ActiveModel {
                 room_id: ActiveValue::set(room_id),
                 user_id: ActiveValue::set(called_user_id),
@@ -1181,7 +1216,7 @@ impl Database {
             let room = self.get_room(room_id, &tx).await?;
             let incoming_call = Self::build_incoming_call(&room, called_user_id)
                 .ok_or_else(|| anyhow!("failed to build incoming call"))?;
-            Ok((room_id, (room, incoming_call)))
+            Ok((room, incoming_call))
         })
         .await
     }
@@ -1191,7 +1226,7 @@ impl Database {
         room_id: RoomId,
         called_user_id: UserId,
     ) -> Result<RoomGuard<proto::Room>> {
-        self.room_transaction(|tx| async move {
+        self.room_transaction(room_id, |tx| async move {
             room_participant::Entity::delete_many()
                 .filter(
                     room_participant::Column::RoomId
@@ -1201,7 +1236,7 @@ impl Database {
                 .exec(&*tx)
                 .await?;
             let room = self.get_room(room_id, &tx).await?;
-            Ok((room_id, room))
+            Ok(room)
         })
         .await
     }
@@ -1248,7 +1283,7 @@ impl Database {
         calling_connection: ConnectionId,
         called_user_id: UserId,
     ) -> Result<RoomGuard<proto::Room>> {
-        self.room_transaction(|tx| async move {
+        self.room_transaction(room_id, |tx| async move {
             let participant = room_participant::Entity::find()
                 .filter(
                     Condition::all()
@@ -1267,14 +1302,13 @@ impl Database {
                 .one(&*tx)
                 .await?
                 .ok_or_else(|| anyhow!("no call to cancel"))?;
-            let room_id = participant.room_id;
 
             room_participant::Entity::delete(participant.into_active_model())
                 .exec(&*tx)
                 .await?;
 
             let room = self.get_room(room_id, &tx).await?;
-            Ok((room_id, room))
+            Ok(room)
         })
         .await
     }
@@ -1285,7 +1319,7 @@ impl Database {
         user_id: UserId,
         connection: ConnectionId,
     ) -> Result<RoomGuard<proto::Room>> {
-        self.room_transaction(|tx| async move {
+        self.room_transaction(room_id, |tx| async move {
             let result = room_participant::Entity::update_many()
                 .filter(
                     Condition::all()
@@ -1307,7 +1341,7 @@ impl Database {
                 Err(anyhow!("room does not exist or was already joined"))?
             } else {
                 let room = self.get_room(room_id, &tx).await?;
-                Ok((room_id, room))
+                Ok(room)
             }
         })
         .await
@@ -1319,9 +1353,9 @@ impl Database {
         user_id: UserId,
         connection: ConnectionId,
     ) -> Result<RoomGuard<RejoinedRoom>> {
-        self.room_transaction(|tx| async {
+        let room_id = RoomId::from_proto(rejoin_room.id);
+        self.room_transaction(room_id, |tx| async {
             let tx = tx;
-            let room_id = RoomId::from_proto(rejoin_room.id);
             let participant_update = room_participant::Entity::update_many()
                 .filter(
                     Condition::all()
@@ -1540,14 +1574,11 @@ impl Database {
             }
 
             let room = self.get_room(room_id, &tx).await?;
-            Ok((
-                room_id,
-                RejoinedRoom {
-                    room,
-                    rejoined_projects,
-                    reshared_projects,
-                },
-            ))
+            Ok(RejoinedRoom {
+                room,
+                rejoined_projects,
+                reshared_projects,
+            })
         })
         .await
     }
@@ -1584,12 +1615,8 @@ impl Database {
                     .filter(
                         Condition::all()
                             .add(
-                                room_participant::Column::CallingConnectionId
-                                    .eq(connection.id as i32),
-                            )
-                            .add(
-                                room_participant::Column::CallingConnectionServerId
-                                    .eq(connection.owner_id as i32),
+                                room_participant::Column::CallingUserId
+                                    .eq(leaving_participant.user_id),
                             )
                             .add(room_participant::Column::AnsweringConnectionId.is_null()),
                     )
@@ -1712,13 +1739,75 @@ impl Database {
         .await
     }
 
+    pub async fn follow(
+        &self,
+        project_id: ProjectId,
+        leader_connection: ConnectionId,
+        follower_connection: ConnectionId,
+    ) -> Result<RoomGuard<proto::Room>> {
+        let room_id = self.room_id_for_project(project_id).await?;
+        self.room_transaction(room_id, |tx| async move {
+            follower::ActiveModel {
+                room_id: ActiveValue::set(room_id),
+                project_id: ActiveValue::set(project_id),
+                leader_connection_server_id: ActiveValue::set(ServerId(
+                    leader_connection.owner_id as i32,
+                )),
+                leader_connection_id: ActiveValue::set(leader_connection.id as i32),
+                follower_connection_server_id: ActiveValue::set(ServerId(
+                    follower_connection.owner_id as i32,
+                )),
+                follower_connection_id: ActiveValue::set(follower_connection.id as i32),
+                ..Default::default()
+            }
+            .insert(&*tx)
+            .await?;
+
+            let room = self.get_room(room_id, &*tx).await?;
+            Ok(room)
+        })
+        .await
+    }
+
+    pub async fn unfollow(
+        &self,
+        project_id: ProjectId,
+        leader_connection: ConnectionId,
+        follower_connection: ConnectionId,
+    ) -> Result<RoomGuard<proto::Room>> {
+        let room_id = self.room_id_for_project(project_id).await?;
+        self.room_transaction(room_id, |tx| async move {
+            follower::Entity::delete_many()
+                .filter(
+                    Condition::all()
+                        .add(follower::Column::ProjectId.eq(project_id))
+                        .add(
+                            follower::Column::LeaderConnectionServerId
+                                .eq(leader_connection.owner_id),
+                        )
+                        .add(follower::Column::LeaderConnectionId.eq(leader_connection.id))
+                        .add(
+                            follower::Column::FollowerConnectionServerId
+                                .eq(follower_connection.owner_id),
+                        )
+                        .add(follower::Column::FollowerConnectionId.eq(follower_connection.id)),
+                )
+                .exec(&*tx)
+                .await?;
+
+            let room = self.get_room(room_id, &*tx).await?;
+            Ok(room)
+        })
+        .await
+    }
+
     pub async fn update_room_participant_location(
         &self,
         room_id: RoomId,
         connection: ConnectionId,
         location: proto::ParticipantLocation,
     ) -> Result<RoomGuard<proto::Room>> {
-        self.room_transaction(|tx| async {
+        self.room_transaction(room_id, |tx| async {
             let tx = tx;
             let location_kind;
             let location_project_id;
@@ -1764,7 +1853,7 @@ impl Database {
 
             if result.rows_affected == 1 {
                 let room = self.get_room(room_id, &tx).await?;
-                Ok((room_id, room))
+                Ok(room)
             } else {
                 Err(anyhow!("could not update room participant location"))?
             }
@@ -1915,16 +2004,31 @@ impl Database {
                 };
 
                 if let Some(db_worktree) = db_worktree {
-                    project.worktree_root_names.push(db_worktree.root_name);
+                    if db_worktree.visible {
+                        project.worktree_root_names.push(db_worktree.root_name);
+                    }
                 }
             }
         }
+        drop(db_projects);
+
+        let mut db_followers = db_room.find_related(follower::Entity).stream(tx).await?;
+        let mut followers = Vec::new();
+        while let Some(db_follower) = db_followers.next().await {
+            let db_follower = db_follower?;
+            followers.push(proto::Follower {
+                leader_id: Some(db_follower.leader_connection().into()),
+                follower_id: Some(db_follower.follower_connection().into()),
+                project_id: db_follower.project_id.to_proto(),
+            });
+        }
 
         Ok(proto::Room {
             id: db_room.id.to_proto(),
             live_kit_room: db_room.live_kit_room,
             participants: participants.into_values().collect(),
             pending_participants,
+            followers,
         })
     }
 
@@ -1956,7 +2060,7 @@ impl Database {
         connection: ConnectionId,
         worktrees: &[proto::WorktreeMetadata],
     ) -> Result<RoomGuard<(ProjectId, proto::Room)>> {
-        self.room_transaction(|tx| async move {
+        self.room_transaction(room_id, |tx| async move {
             let participant = room_participant::Entity::find()
                 .filter(
                     Condition::all()
@@ -2017,7 +2121,7 @@ impl Database {
             .await?;
 
             let room = self.get_room(room_id, &tx).await?;
-            Ok((room_id, (project.id, room)))
+            Ok((project.id, room))
         })
         .await
     }
@@ -2027,7 +2131,8 @@ impl Database {
         project_id: ProjectId,
         connection: ConnectionId,
     ) -> Result<RoomGuard<(proto::Room, Vec<ConnectionId>)>> {
-        self.room_transaction(|tx| async move {
+        let room_id = self.room_id_for_project(project_id).await?;
+        self.room_transaction(room_id, |tx| async move {
             let guest_connection_ids = self.project_guest_connection_ids(project_id, &tx).await?;
 
             let project = project::Entity::find_by_id(project_id)
@@ -2035,12 +2140,11 @@ impl Database {
                 .await?
                 .ok_or_else(|| anyhow!("project not found"))?;
             if project.host_connection()? == connection {
-                let room_id = project.room_id;
                 project::Entity::delete(project.into_active_model())
                     .exec(&*tx)
                     .await?;
                 let room = self.get_room(room_id, &tx).await?;
-                Ok((room_id, (room, guest_connection_ids)))
+                Ok((room, guest_connection_ids))
             } else {
                 Err(anyhow!("cannot unshare a project hosted by another user"))?
             }
@@ -2054,7 +2158,8 @@ impl Database {
         connection: ConnectionId,
         worktrees: &[proto::WorktreeMetadata],
     ) -> Result<RoomGuard<(proto::Room, Vec<ConnectionId>)>> {
-        self.room_transaction(|tx| async move {
+        let room_id = self.room_id_for_project(project_id).await?;
+        self.room_transaction(room_id, |tx| async move {
             let project = project::Entity::find_by_id(project_id)
                 .filter(
                     Condition::all()
@@ -2072,7 +2177,7 @@ impl Database {
 
             let guest_connection_ids = self.project_guest_connection_ids(project.id, &tx).await?;
             let room = self.get_room(project.room_id, &tx).await?;
-            Ok((project.room_id, (room, guest_connection_ids)))
+            Ok((room, guest_connection_ids))
         })
         .await
     }
@@ -2117,12 +2222,12 @@ impl Database {
         update: &proto::UpdateWorktree,
         connection: ConnectionId,
     ) -> Result<RoomGuard<Vec<ConnectionId>>> {
-        self.room_transaction(|tx| async move {
-            let project_id = ProjectId::from_proto(update.project_id);
-            let worktree_id = update.worktree_id as i64;
-
+        let project_id = ProjectId::from_proto(update.project_id);
+        let worktree_id = update.worktree_id as i64;
+        let room_id = self.room_id_for_project(project_id).await?;
+        self.room_transaction(room_id, |tx| async move {
             // Ensure the update comes from the host.
-            let project = project::Entity::find_by_id(project_id)
+            let _project = project::Entity::find_by_id(project_id)
                 .filter(
                     Condition::all()
                         .add(project::Column::HostConnectionId.eq(connection.id as i32))
@@ -2133,7 +2238,6 @@ impl Database {
                 .one(&*tx)
                 .await?
                 .ok_or_else(|| anyhow!("no such project"))?;
-            let room_id = project.room_id;
 
             // Update metadata.
             worktree::Entity::update(worktree::ActiveModel {
@@ -2213,7 +2317,7 @@ impl Database {
             }
 
             let connection_ids = self.project_guest_connection_ids(project_id, &tx).await?;
-            Ok((room_id, connection_ids))
+            Ok(connection_ids)
         })
         .await
     }
@@ -2223,9 +2327,10 @@ impl Database {
         update: &proto::UpdateDiagnosticSummary,
         connection: ConnectionId,
     ) -> Result<RoomGuard<Vec<ConnectionId>>> {
-        self.room_transaction(|tx| async move {
-            let project_id = ProjectId::from_proto(update.project_id);
-            let worktree_id = update.worktree_id as i64;
+        let project_id = ProjectId::from_proto(update.project_id);
+        let worktree_id = update.worktree_id as i64;
+        let room_id = self.room_id_for_project(project_id).await?;
+        self.room_transaction(room_id, |tx| async move {
             let summary = update
                 .summary
                 .as_ref()
@@ -2267,7 +2372,7 @@ impl Database {
             .await?;
 
             let connection_ids = self.project_guest_connection_ids(project_id, &tx).await?;
-            Ok((project.room_id, connection_ids))
+            Ok(connection_ids)
         })
         .await
     }
@@ -2277,8 +2382,9 @@ impl Database {
         update: &proto::StartLanguageServer,
         connection: ConnectionId,
     ) -> Result<RoomGuard<Vec<ConnectionId>>> {
-        self.room_transaction(|tx| async move {
-            let project_id = ProjectId::from_proto(update.project_id);
+        let project_id = ProjectId::from_proto(update.project_id);
+        let room_id = self.room_id_for_project(project_id).await?;
+        self.room_transaction(room_id, |tx| async move {
             let server = update
                 .server
                 .as_ref()
@@ -2312,7 +2418,7 @@ impl Database {
             .await?;
 
             let connection_ids = self.project_guest_connection_ids(project_id, &tx).await?;
-            Ok((project.room_id, connection_ids))
+            Ok(connection_ids)
         })
         .await
     }
@@ -2322,7 +2428,8 @@ impl Database {
         project_id: ProjectId,
         connection: ConnectionId,
     ) -> Result<RoomGuard<(Project, ReplicaId)>> {
-        self.room_transaction(|tx| async move {
+        let room_id = self.room_id_for_project(project_id).await?;
+        self.room_transaction(room_id, |tx| async move {
             let participant = room_participant::Entity::find()
                 .filter(
                     Condition::all()
@@ -2448,7 +2555,6 @@ impl Database {
                 .all(&*tx)
                 .await?;
 
-            let room_id = project.room_id;
             let project = Project {
                 collaborators: collaborators
                     .into_iter()
@@ -2468,7 +2574,7 @@ impl Database {
                     })
                     .collect(),
             };
-            Ok((room_id, (project, replica_id as ReplicaId)))
+            Ok((project, replica_id as ReplicaId))
         })
         .await
     }
@@ -2477,8 +2583,9 @@ impl Database {
         &self,
         project_id: ProjectId,
         connection: ConnectionId,
-    ) -> Result<RoomGuard<LeftProject>> {
-        self.room_transaction(|tx| async move {
+    ) -> Result<RoomGuard<(proto::Room, LeftProject)>> {
+        let room_id = self.room_id_for_project(project_id).await?;
+        self.room_transaction(room_id, |tx| async move {
             let result = project_collaborator::Entity::delete_many()
                 .filter(
                     Condition::all()
@@ -2508,13 +2615,39 @@ impl Database {
                 .map(|collaborator| collaborator.connection())
                 .collect();
 
+            follower::Entity::delete_many()
+                .filter(
+                    Condition::any()
+                        .add(
+                            Condition::all()
+                                .add(follower::Column::ProjectId.eq(project_id))
+                                .add(
+                                    follower::Column::LeaderConnectionServerId
+                                        .eq(connection.owner_id),
+                                )
+                                .add(follower::Column::LeaderConnectionId.eq(connection.id)),
+                        )
+                        .add(
+                            Condition::all()
+                                .add(follower::Column::ProjectId.eq(project_id))
+                                .add(
+                                    follower::Column::FollowerConnectionServerId
+                                        .eq(connection.owner_id),
+                                )
+                                .add(follower::Column::FollowerConnectionId.eq(connection.id)),
+                        ),
+                )
+                .exec(&*tx)
+                .await?;
+
+            let room = self.get_room(project.room_id, &tx).await?;
             let left_project = LeftProject {
                 id: project_id,
                 host_user_id: project.host_user_id,
                 host_connection_id: project.host_connection()?,
                 connection_ids,
             };
-            Ok((project.room_id, left_project))
+            Ok((room, left_project))
         })
         .await
     }
@@ -2524,11 +2657,8 @@ impl Database {
         project_id: ProjectId,
         connection_id: ConnectionId,
     ) -> Result<RoomGuard<Vec<ProjectCollaborator>>> {
-        self.room_transaction(|tx| async move {
-            let project = project::Entity::find_by_id(project_id)
-                .one(&*tx)
-                .await?
-                .ok_or_else(|| anyhow!("no such project"))?;
+        let room_id = self.room_id_for_project(project_id).await?;
+        self.room_transaction(room_id, |tx| async move {
             let collaborators = project_collaborator::Entity::find()
                 .filter(project_collaborator::Column::ProjectId.eq(project_id))
                 .all(&*tx)
@@ -2546,7 +2676,7 @@ impl Database {
                 .iter()
                 .any(|collaborator| collaborator.connection_id == connection_id)
             {
-                Ok((project.room_id, collaborators))
+                Ok(collaborators)
             } else {
                 Err(anyhow!("no such project"))?
             }
@@ -2559,11 +2689,8 @@ impl Database {
         project_id: ProjectId,
         connection_id: ConnectionId,
     ) -> Result<RoomGuard<HashSet<ConnectionId>>> {
-        self.room_transaction(|tx| async move {
-            let project = project::Entity::find_by_id(project_id)
-                .one(&*tx)
-                .await?
-                .ok_or_else(|| anyhow!("no such project"))?;
+        let room_id = self.room_id_for_project(project_id).await?;
+        self.room_transaction(room_id, |tx| async move {
             let mut collaborators = project_collaborator::Entity::find()
                 .filter(project_collaborator::Column::ProjectId.eq(project_id))
                 .stream(&*tx)
@@ -2576,7 +2703,7 @@ impl Database {
             }
 
             if connection_ids.contains(&connection_id) {
-                Ok((project.room_id, connection_ids))
+                Ok(connection_ids)
             } else {
                 Err(anyhow!("no such project"))?
             }
@@ -2606,18 +2733,29 @@ impl Database {
         Ok(guest_connection_ids)
     }
 
+    async fn room_id_for_project(&self, project_id: ProjectId) -> Result<RoomId> {
+        self.transaction(|tx| async move {
+            let project = project::Entity::find_by_id(project_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("project {} not found", project_id))?;
+            Ok(project.room_id)
+        })
+        .await
+    }
+
     // access tokens
 
-    pub async fn create_access_token_hash(
+    pub async fn create_access_token(
         &self,
         user_id: UserId,
         access_token_hash: &str,
         max_access_token_count: usize,
-    ) -> Result<()> {
+    ) -> Result<AccessTokenId> {
         self.transaction(|tx| async {
             let tx = tx;
 
-            access_token::ActiveModel {
+            let token = access_token::ActiveModel {
                 user_id: ActiveValue::set(user_id),
                 hash: ActiveValue::set(access_token_hash.into()),
                 ..Default::default()
@@ -2640,26 +2778,20 @@ impl Database {
                 )
                 .exec(&*tx)
                 .await?;
-            Ok(())
+            Ok(token.id)
         })
         .await
     }
 
-    pub async fn get_access_token_hashes(&self, user_id: UserId) -> Result<Vec<String>> {
-        #[derive(Copy, Clone, Debug, EnumIter, DeriveColumn)]
-        enum QueryAs {
-            Hash,
-        }
-
+    pub async fn get_access_token(
+        &self,
+        access_token_id: AccessTokenId,
+    ) -> Result<access_token::Model> {
         self.transaction(|tx| async move {
-            Ok(access_token::Entity::find()
-                .select_only()
-                .column(access_token::Column::Hash)
-                .filter(access_token::Column::UserId.eq(user_id))
-                .order_by_desc(access_token::Column::Id)
-                .into_values::<_, QueryAs>()
-                .all(&*tx)
-                .await?)
+            Ok(access_token::Entity::find_by_id(access_token_id)
+                .one(&*tx)
+                .await?
+                .ok_or_else(|| anyhow!("no such access token"))?)
         })
         .await
     }
@@ -2670,30 +2802,26 @@ impl Database {
         Fut: Send + Future<Output = Result<T>>,
     {
         let body = async {
+            let mut i = 0;
             loop {
                 let (tx, result) = self.with_transaction(&f).await?;
                 match result {
-                    Ok(result) => {
-                        match tx.commit().await.map_err(Into::into) {
-                            Ok(()) => return Ok(result),
-                            Err(error) => {
-                                if is_serialization_error(&error) {
-                                    // Retry (don't break the loop)
-                                } else {
-                                    return Err(error);
-                                }
+                    Ok(result) => match tx.commit().await.map_err(Into::into) {
+                        Ok(()) => return Ok(result),
+                        Err(error) => {
+                            if !self.retry_on_serialization_error(&error, i).await {
+                                return Err(error);
                             }
                         }
-                    }
+                    },
                     Err(error) => {
                         tx.rollback().await?;
-                        if is_serialization_error(&error) {
-                            // Retry (don't break the loop)
-                        } else {
+                        if !self.retry_on_serialization_error(&error, i).await {
                             return Err(error);
                         }
                     }
                 }
+                i += 1;
             }
         };
 
@@ -2706,6 +2834,7 @@ impl Database {
         Fut: Send + Future<Output = Result<Option<(RoomId, T)>>>,
     {
         let body = async {
+            let mut i = 0;
             loop {
                 let (tx, result) = self.with_transaction(&f).await?;
                 match result {
@@ -2721,56 +2850,72 @@ impl Database {
                                 }));
                             }
                             Err(error) => {
-                                if is_serialization_error(&error) {
-                                    // Retry (don't break the loop)
-                                } else {
+                                if !self.retry_on_serialization_error(&error, i).await {
                                     return Err(error);
                                 }
                             }
                         }
                     }
-                    Ok(None) => {
-                        match tx.commit().await.map_err(Into::into) {
-                            Ok(()) => return Ok(None),
-                            Err(error) => {
-                                if is_serialization_error(&error) {
-                                    // Retry (don't break the loop)
-                                } else {
-                                    return Err(error);
-                                }
+                    Ok(None) => match tx.commit().await.map_err(Into::into) {
+                        Ok(()) => return Ok(None),
+                        Err(error) => {
+                            if !self.retry_on_serialization_error(&error, i).await {
+                                return Err(error);
                             }
                         }
-                    }
+                    },
                     Err(error) => {
                         tx.rollback().await?;
-                        if is_serialization_error(&error) {
-                            // Retry (don't break the loop)
-                        } else {
+                        if !self.retry_on_serialization_error(&error, i).await {
                             return Err(error);
                         }
                     }
                 }
+                i += 1;
             }
         };
 
         self.run(body).await
     }
 
-    async fn room_transaction<F, Fut, T>(&self, f: F) -> Result<RoomGuard<T>>
+    async fn room_transaction<F, Fut, T>(&self, room_id: RoomId, f: F) -> Result<RoomGuard<T>>
     where
         F: Send + Fn(TransactionHandle) -> Fut,
-        Fut: Send + Future<Output = Result<(RoomId, T)>>,
+        Fut: Send + Future<Output = Result<T>>,
     {
-        let data = self
-            .optional_room_transaction(move |tx| {
-                let future = f(tx);
-                async {
-                    let data = future.await?;
-                    Ok(Some(data))
+        let body = async {
+            let mut i = 0;
+            loop {
+                let lock = self.rooms.entry(room_id).or_default().clone();
+                let _guard = lock.lock_owned().await;
+                let (tx, result) = self.with_transaction(&f).await?;
+                match result {
+                    Ok(data) => match tx.commit().await.map_err(Into::into) {
+                        Ok(()) => {
+                            return Ok(RoomGuard {
+                                data,
+                                _guard,
+                                _not_send: PhantomData,
+                            });
+                        }
+                        Err(error) => {
+                            if !self.retry_on_serialization_error(&error, i).await {
+                                return Err(error);
+                            }
+                        }
+                    },
+                    Err(error) => {
+                        tx.rollback().await?;
+                        if !self.retry_on_serialization_error(&error, i).await {
+                            return Err(error);
+                        }
+                    }
                 }
-            })
-            .await?;
-        Ok(data.unwrap())
+                i += 1;
+            }
+        };
+
+        self.run(body).await
     }
 
     async fn with_transaction<F, Fut, T>(&self, f: &F) -> Result<(DatabaseTransaction, Result<T>)>
@@ -2792,14 +2937,14 @@ impl Database {
         Ok((tx, result))
     }
 
-    async fn run<F, T>(&self, future: F) -> T
+    async fn run<F, T>(&self, future: F) -> Result<T>
     where
-        F: Future<Output = T>,
+        F: Future<Output = Result<T>>,
     {
         #[cfg(test)]
         {
-            if let Some(background) = self.background.as_ref() {
-                background.simulate_random_delay().await;
+            if let Executor::Deterministic(executor) = &self.executor {
+                executor.simulate_random_delay().await;
             }
 
             self.runtime.as_ref().unwrap().block_on(future)
@@ -2810,6 +2955,27 @@ impl Database {
             future.await
         }
     }
+
+    async fn retry_on_serialization_error(&self, error: &Error, prev_attempt_count: u32) -> bool {
+        // If the error is due to a failure to serialize concurrent transactions, then retry
+        // this transaction after a delay. With each subsequent retry, double the delay duration.
+        // Also vary the delay randomly in order to ensure different database connections retry
+        // at different times.
+        if is_serialization_error(error) {
+            let base_delay = 4_u64 << prev_attempt_count.min(16);
+            let randomized_delay = base_delay as f32 * self.rng.lock().await.gen_range(0.5..=2.0);
+            log::info!(
+                "retrying transaction after serialization error. delay: {} ms.",
+                randomized_delay
+            );
+            self.executor
+                .sleep(Duration::from_millis(randomized_delay as u64))
+                .await;
+            true
+        } else {
+            false
+        }
+    }
 }
 
 fn is_serialization_error(error: &Error) -> bool {
@@ -3004,6 +3170,7 @@ macro_rules! id_type {
 
 id_type!(AccessTokenId);
 id_type!(ContactId);
+id_type!(FollowerId);
 id_type!(RoomId);
 id_type!(RoomParticipantId);
 id_type!(ProjectId);
@@ -3110,7 +3277,6 @@ mod test {
     use gpui::executor::Background;
     use lazy_static::lazy_static;
     use parking_lot::Mutex;
-    use rand::prelude::*;
     use sea_orm::ConnectionTrait;
     use sqlx::migrate::MigrateDatabase;
     use std::sync::Arc;
@@ -3132,7 +3298,9 @@ mod test {
             let mut db = runtime.block_on(async {
                 let mut options = ConnectOptions::new(url);
                 options.max_connections(5);
-                let db = Database::new(options).await.unwrap();
+                let db = Database::new(options, Executor::Deterministic(background))
+                    .await
+                    .unwrap();
                 let sql = include_str!(concat!(
                     env!("CARGO_MANIFEST_DIR"),
                     "/migrations.sqlite/20221109000000_test_schema.sql"
@@ -3147,7 +3315,6 @@ mod test {
                 db
             });
 
-            db.background = Some(background);
             db.runtime = Some(runtime);
 
             Self {
@@ -3181,13 +3348,14 @@ mod test {
                 options
                     .max_connections(5)
                     .idle_timeout(Duration::from_secs(0));
-                let db = Database::new(options).await.unwrap();
+                let db = Database::new(options, Executor::Deterministic(background))
+                    .await
+                    .unwrap();
                 let migrations_path = concat!(env!("CARGO_MANIFEST_DIR"), "/migrations");
                 db.migrate(Path::new(migrations_path), false).await.unwrap();
                 db
             });
 
-            db.background = Some(background);
             db.runtime = Some(runtime);
 
             Self {

crates/collab/src/db/follower.rs

@@ -0,0 +1,51 @@
+use super::{FollowerId, ProjectId, RoomId, ServerId};
+use rpc::ConnectionId;
+use sea_orm::entity::prelude::*;
+use serde::Serialize;
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, DeriveEntityModel, Serialize)]
+#[sea_orm(table_name = "followers")]
+pub struct Model {
+    #[sea_orm(primary_key)]
+    pub id: FollowerId,
+    pub room_id: RoomId,
+    pub project_id: ProjectId,
+    pub leader_connection_server_id: ServerId,
+    pub leader_connection_id: i32,
+    pub follower_connection_server_id: ServerId,
+    pub follower_connection_id: i32,
+}
+
+impl Model {
+    pub fn leader_connection(&self) -> ConnectionId {
+        ConnectionId {
+            owner_id: self.leader_connection_server_id.0 as u32,
+            id: self.leader_connection_id as u32,
+        }
+    }
+
+    pub fn follower_connection(&self) -> ConnectionId {
+        ConnectionId {
+            owner_id: self.follower_connection_server_id.0 as u32,
+            id: self.follower_connection_id as u32,
+        }
+    }
+}
+
+#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
+pub enum Relation {
+    #[sea_orm(
+        belongs_to = "super::room::Entity",
+        from = "Column::RoomId",
+        to = "super::room::Column::Id"
+    )]
+    Room,
+}
+
+impl Related<super::room::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Room.def()
+    }
+}
+
+impl ActiveModelBehavior for ActiveModel {}

crates/collab/src/db/room.rs

@@ -15,6 +15,8 @@ pub enum Relation {
     RoomParticipant,
     #[sea_orm(has_many = "super::project::Entity")]
     Project,
+    #[sea_orm(has_many = "super::follower::Entity")]
+    Follower,
 }
 
 impl Related<super::room_participant::Entity> for Entity {
@@ -29,4 +31,10 @@ impl Related<super::project::Entity> for Entity {
     }
 }
 
+impl Related<super::follower::Entity> for Entity {
+    fn to() -> RelationDef {
+        Relation::Follower.def()
+    }
+}
+
 impl ActiveModelBehavior for ActiveModel {}

crates/collab/src/db/tests.rs

@@ -92,8 +92,8 @@ test_both_dbs!(
 );
 
 test_both_dbs!(
-    test_get_user_by_github_account_postgres,
-    test_get_user_by_github_account_sqlite,
+    test_get_or_create_user_by_github_account_postgres,
+    test_get_or_create_user_by_github_account_sqlite,
     db,
     {
         let user_id1 = db
@@ -124,7 +124,7 @@ test_both_dbs!(
             .user_id;
 
         let user = db
-            .get_user_by_github_account("login1", None)
+            .get_or_create_user_by_github_account("login1", None, None)
             .await
             .unwrap()
             .unwrap();
@@ -133,19 +133,28 @@ test_both_dbs!(
         assert_eq!(user.github_user_id, Some(101));
 
         assert!(db
-            .get_user_by_github_account("non-existent-login", None)
+            .get_or_create_user_by_github_account("non-existent-login", None, None)
             .await
             .unwrap()
             .is_none());
 
         let user = db
-            .get_user_by_github_account("the-new-login2", Some(102))
+            .get_or_create_user_by_github_account("the-new-login2", Some(102), None)
             .await
             .unwrap()
             .unwrap();
         assert_eq!(user.id, user_id2);
         assert_eq!(&user.github_login, "the-new-login2");
         assert_eq!(user.github_user_id, Some(102));
+
+        let user = db
+            .get_or_create_user_by_github_account("login3", Some(103), Some("user3@example.com"))
+            .await
+            .unwrap()
+            .unwrap();
+        assert_eq!(&user.github_login, "login3");
+        assert_eq!(user.github_user_id, Some(103));
+        assert_eq!(user.email_address, Some("user3@example.com".into()));
     }
 );
 
@@ -168,30 +177,63 @@ test_both_dbs!(
             .unwrap()
             .user_id;
 
-        db.create_access_token_hash(user, "h1", 3).await.unwrap();
-        db.create_access_token_hash(user, "h2", 3).await.unwrap();
+        let token_1 = db.create_access_token(user, "h1", 2).await.unwrap();
+        let token_2 = db.create_access_token(user, "h2", 2).await.unwrap();
         assert_eq!(
-            db.get_access_token_hashes(user).await.unwrap(),
-            &["h2".to_string(), "h1".to_string()]
+            db.get_access_token(token_1).await.unwrap(),
+            access_token::Model {
+                id: token_1,
+                user_id: user,
+                hash: "h1".into(),
+            }
+        );
+        assert_eq!(
+            db.get_access_token(token_2).await.unwrap(),
+            access_token::Model {
+                id: token_2,
+                user_id: user,
+                hash: "h2".into()
+            }
         );
 
-        db.create_access_token_hash(user, "h3", 3).await.unwrap();
+        let token_3 = db.create_access_token(user, "h3", 2).await.unwrap();
         assert_eq!(
-            db.get_access_token_hashes(user).await.unwrap(),
-            &["h3".to_string(), "h2".to_string(), "h1".to_string(),]
+            db.get_access_token(token_3).await.unwrap(),
+            access_token::Model {
+                id: token_3,
+                user_id: user,
+                hash: "h3".into()
+            }
         );
+        assert_eq!(
+            db.get_access_token(token_2).await.unwrap(),
+            access_token::Model {
+                id: token_2,
+                user_id: user,
+                hash: "h2".into()
+            }
+        );
+        assert!(db.get_access_token(token_1).await.is_err());
 
-        db.create_access_token_hash(user, "h4", 3).await.unwrap();
+        let token_4 = db.create_access_token(user, "h4", 2).await.unwrap();
         assert_eq!(
-            db.get_access_token_hashes(user).await.unwrap(),
-            &["h4".to_string(), "h3".to_string(), "h2".to_string(),]
+            db.get_access_token(token_4).await.unwrap(),
+            access_token::Model {
+                id: token_4,
+                user_id: user,
+                hash: "h4".into()
+            }
         );
-
-        db.create_access_token_hash(user, "h5", 3).await.unwrap();
         assert_eq!(
-            db.get_access_token_hashes(user).await.unwrap(),
-            &["h5".to_string(), "h4".to_string(), "h3".to_string()]
+            db.get_access_token(token_3).await.unwrap(),
+            access_token::Model {
+                id: token_3,
+                user_id: user,
+                hash: "h3".into()
+            }
         );
+        assert!(db.get_access_token(token_2).await.is_err());
+        assert!(db.get_access_token(token_1).await.is_err());
     }
 );
 
@@ -567,7 +609,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 {
@@ -617,7 +664,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 {
@@ -672,9 +719,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();
@@ -684,7 +736,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
@@ -739,9 +796,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);
 
@@ -763,7 +825,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/lib.rs

@@ -10,6 +10,7 @@ mod tests;
 
 use axum::{http::StatusCode, response::IntoResponse};
 use db::Database;
+use executor::Executor;
 use serde::Deserialize;
 use std::{path::PathBuf, sync::Arc};
 
@@ -91,6 +92,7 @@ impl std::error::Error for Error {}
 pub struct Config {
     pub http_port: u16,
     pub database_url: String,
+    pub database_max_connections: u32,
     pub api_token: String,
     pub invite_link_prefix: String,
     pub live_kit_server: Option<String>,
@@ -116,8 +118,8 @@ pub struct AppState {
 impl AppState {
     pub async fn new(config: Config) -> Result<Arc<Self>> {
         let mut db_options = db::ConnectOptions::new(config.database_url.clone());
-        db_options.max_connections(5);
-        let db = Database::new(db_options).await?;
+        db_options.max_connections(config.database_max_connections);
+        let db = Database::new(db_options, Executor::Production).await?;
         let live_kit_client = if let Some(((server, key), secret)) = config
             .live_kit_server
             .as_ref()

crates/collab/src/main.rs

@@ -1,11 +1,12 @@
 use anyhow::anyhow;
-use axum::{routing::get, Router};
+use axum::{routing::get, Extension, Router};
 use collab::{db, env, executor::Executor, AppState, Config, MigrateConfig, Result};
 use db::Database;
 use std::{
     env::args,
     net::{SocketAddr, TcpListener},
     path::Path,
+    sync::Arc,
 };
 use tokio::signal::unix::SignalKind;
 use tracing_log::LogTracer;
@@ -31,7 +32,7 @@ async fn main() -> Result<()> {
             let config = envy::from_env::<MigrateConfig>().expect("error loading config");
             let mut db_options = db::ConnectOptions::new(config.database_url.clone());
             db_options.max_connections(5);
-            let db = Database::new(db_options).await?;
+            let db = Database::new(db_options, Executor::Production).await?;
 
             let migrations_path = config
                 .migrations_path
@@ -66,7 +67,12 @@ async fn main() -> Result<()> {
 
             let app = collab::api::routes(rpc_server.clone(), state.clone())
                 .merge(collab::rpc::routes(rpc_server.clone()))
-                .merge(Router::new().route("/", get(handle_root)));
+                .merge(
+                    Router::new()
+                        .route("/", get(handle_root))
+                        .route("/healthz", get(handle_liveness_probe))
+                        .layer(Extension(state.clone())),
+                );
 
             axum::Server::from_tcp(listener)?
                 .serve(app.into_make_service_with_connect_info::<SocketAddr>())
@@ -95,6 +101,11 @@ async fn handle_root() -> String {
     format!("collab v{VERSION}")
 }
 
+async fn handle_liveness_probe(Extension(state): Extension<Arc<AppState>>) -> Result<String> {
+    state.db.get_all_users(0, 1).await?;
+    Ok("ok".to_string())
+}
+
 pub fn init_tracing(config: &Config) -> Option<()> {
     use std::str::FromStr;
     use tracing_subscriber::layer::SubscriberExt;

crates/collab/src/rpc.rs

@@ -53,11 +53,11 @@ use std::{
     },
     time::Duration,
 };
-use tokio::sync::watch;
+use tokio::sync::{watch, Semaphore};
 use tower::ServiceBuilder;
 use tracing::{info_span, instrument, Instrument};
 
-pub const RECONNECT_TIMEOUT: Duration = Duration::from_secs(5);
+pub const RECONNECT_TIMEOUT: Duration = Duration::from_secs(30);
 pub const CLEANUP_TIMEOUT: Duration = Duration::from_secs(10);
 
 lazy_static! {
@@ -186,7 +186,7 @@ impl Server {
             .add_request_handler(create_room)
             .add_request_handler(join_room)
             .add_request_handler(rejoin_room)
-            .add_message_handler(leave_room)
+            .add_request_handler(leave_room)
             .add_request_handler(call)
             .add_request_handler(cancel_call)
             .add_message_handler(decline_call)
@@ -270,8 +270,11 @@ impl Server {
                         let mut live_kit_room = String::new();
                         let mut delete_live_kit_room = false;
 
-                        if let Ok(mut refreshed_room) =
-                            app_state.db.refresh_room(room_id, server_id).await
+                        if let Some(mut refreshed_room) = app_state
+                            .db
+                            .refresh_room(room_id, server_id)
+                            .await
+                            .trace_err()
                         {
                             tracing::info!(
                                 room_id = room_id.0,
@@ -539,8 +542,13 @@ impl Server {
             // This arrangement ensures we will attempt to process earlier messages first, but fall
             // back to processing messages arrived later in the spirit of making progress.
             let mut foreground_message_handlers = FuturesUnordered::new();
+            let concurrent_handlers = Arc::new(Semaphore::new(256));
             loop {
-                let next_message = incoming_rx.next().fuse();
+                let next_message = async {
+                    let permit = concurrent_handlers.clone().acquire_owned().await.unwrap();
+                    let message = incoming_rx.next().await;
+                    (permit, message)
+                }.fuse();
                 futures::pin_mut!(next_message);
                 futures::select_biased! {
                     _ = teardown.changed().fuse() => return Ok(()),
@@ -551,7 +559,8 @@ impl Server {
                         break;
                     }
                     _ = foreground_message_handlers.next() => {}
-                    message = next_message => {
+                    next_message = next_message => {
+                        let (permit, message) = next_message;
                         if let Some(message) = message {
                             let type_name = message.payload_type_name();
                             let span = tracing::info_span!("receive message", %user_id, %login, %connection_id, %address, type_name);
@@ -561,7 +570,10 @@ impl Server {
                                 let handle_message = (handler)(message, session.clone());
                                 drop(span_enter);
 
-                                let handle_message = handle_message.instrument(span);
+                                let handle_message = async move {
+                                    handle_message.await;
+                                    drop(permit);
+                                }.instrument(span);
                                 if is_background {
                                     executor.spawn_detached(handle_message);
                                 } else {
@@ -1090,8 +1102,14 @@ async fn rejoin_room(
     Ok(())
 }
 
-async fn leave_room(_message: proto::LeaveRoom, session: Session) -> Result<()> {
-    leave_room_for_session(&session).await
+async fn leave_room(
+    _: proto::LeaveRoom,
+    response: Response<proto::LeaveRoom>,
+    session: Session,
+) -> Result<()> {
+    leave_room_for_session(&session).await?;
+    response.send(proto::Ack {})?;
+    Ok(())
 }
 
 async fn call(
@@ -1312,6 +1330,7 @@ async fn join_project(
         .filter(|collaborator| collaborator.connection_id != session.connection_id)
         .map(|collaborator| collaborator.to_proto())
         .collect::<Vec<_>>();
+
     let worktrees = project
         .worktrees
         .iter()
@@ -1404,7 +1423,7 @@ async fn leave_project(request: proto::LeaveProject, session: Session) -> Result
     let sender_id = session.connection_id;
     let project_id = ProjectId::from_proto(request.project_id);
 
-    let project = session
+    let (room, project) = &*session
         .db()
         .await
         .leave_project(project_id, sender_id)
@@ -1415,7 +1434,9 @@ async fn leave_project(request: proto::LeaveProject, session: Session) -> Result
         host_connection_id = %project.host_connection_id,
         "leave project"
     );
+
     project_left(&project, &session);
+    room_updated(&room, &session.peer);
 
     Ok(())
 }
@@ -1724,6 +1745,7 @@ async fn follow(
         .ok_or_else(|| anyhow!("invalid leader id"))?
         .into();
     let follower_id = session.connection_id;
+
     {
         let project_connection_ids = session
             .db()
@@ -1744,6 +1766,14 @@ async fn follow(
         .views
         .retain(|view| view.leader_id != Some(follower_id.into()));
     response.send(response_payload)?;
+
+    let room = session
+        .db()
+        .await
+        .follow(project_id, leader_id, follower_id)
+        .await?;
+    room_updated(&room, &session.peer);
+
     Ok(())
 }
 
@@ -1753,17 +1783,29 @@ async fn unfollow(request: proto::Unfollow, session: Session) -> Result<()> {
         .leader_id
         .ok_or_else(|| anyhow!("invalid leader id"))?
         .into();
-    let project_connection_ids = session
+    let follower_id = session.connection_id;
+
+    if !session
         .db()
         .await
         .project_connection_ids(project_id, session.connection_id)
-        .await?;
-    if !project_connection_ids.contains(&leader_id) {
+        .await?
+        .contains(&leader_id)
+    {
         Err(anyhow!("no such peer"))?;
     }
+
     session
         .peer
         .forward_send(session.connection_id, leader_id, request)?;
+
+    let room = session
+        .db()
+        .await
+        .unfollow(project_id, leader_id, follower_id)
+        .await?;
+    room_updated(&room, &session.peer);
+
     Ok(())
 }
 
@@ -1833,7 +1875,7 @@ async fn fuzzy_search_users(
         1 | 2 => session
             .db()
             .await
-            .get_user_by_github_account(&query, None)
+            .get_user_by_github_login(&query)
             .await?
             .into_iter()
             .collect(),
@@ -1961,23 +2003,31 @@ async fn remove_contact(
     let requester_id = session.user_id;
     let responder_id = UserId::from_proto(request.user_id);
     let db = session.db().await;
-    db.remove_contact(requester_id, responder_id).await?;
+    let contact_accepted = db.remove_contact(requester_id, responder_id).await?;
 
     let pool = session.connection_pool().await;
     // Update outgoing contact requests of requester
     let mut update = proto::UpdateContacts::default();
-    update
-        .remove_outgoing_requests
-        .push(responder_id.to_proto());
+    if contact_accepted {
+        update.remove_contacts.push(responder_id.to_proto());
+    } else {
+        update
+            .remove_outgoing_requests
+            .push(responder_id.to_proto());
+    }
     for connection_id in pool.user_connection_ids(requester_id) {
         session.peer.send(connection_id, update.clone())?;
     }
 
     // Update incoming contact requests of responder
     let mut update = proto::UpdateContacts::default();
-    update
-        .remove_incoming_requests
-        .push(requester_id.to_proto());
+    if contact_accepted {
+        update.remove_contacts.push(requester_id.to_proto());
+    } else {
+        update
+            .remove_incoming_requests
+            .push(requester_id.to_proto());
+    }
     for connection_id in pool.user_connection_ids(responder_id) {
         session.peer.send(connection_id, update.clone())?;
     }

crates/collab/src/tests.rs

@@ -11,7 +11,7 @@ use client::{
     EstablishConnectionError, UserStore,
 };
 use collections::{HashMap, HashSet};
-use fs::{FakeFs, HomeDir};
+use fs::FakeFs;
 use futures::{channel::oneshot, StreamExt as _};
 use gpui::{
     executor::Deterministic, test::EmptyView, ModelHandle, Task, TestAppContext, ViewHandle,
@@ -100,19 +100,11 @@ impl TestServer {
 
     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);
+            cx.set_global(Settings::test(cx));
         });
 
         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
+        let user_id = if let Ok(Some(user)) = self.app_state.db.get_user_by_github_login(name).await
         {
             user.id
         } else {
@@ -199,9 +191,10 @@ impl TestServer {
             languages: Arc::new(LanguageRegistry::new(Task::ready(()))),
             themes: ThemeRegistry::new((), cx.font_cache()),
             fs: fs.clone(),
-            build_window_options: Default::default,
+            build_window_options: |_, _, _| Default::default(),
             initialize_workspace: |_, _, _| unimplemented!(),
-            dock_default_item_factory: |_, _| unimplemented!(),
+            dock_default_item_factory: |_, _| None,
+            background_actions: || &[],
         });
 
         Project::init(&client);
@@ -438,15 +431,7 @@ impl TestClient {
         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,
-            )
-        })
+        cx.add_view(&root_view, |cx| Workspace::test_new(project.clone(), cx))
     }
 
     fn create_new_root_dir(&mut self) -> PathBuf {

crates/collab/src/tests/integration_tests.rs

@@ -32,7 +32,9 @@ use std::{
     sync::Arc,
 };
 use unindent::Unindent as _;
-use workspace::{item::Item, shared_screen::SharedScreen, SplitDirection, ToggleFollow, Workspace};
+use workspace::{
+    item::ItemHandle as _, shared_screen::SharedScreen, SplitDirection, ToggleFollow, Workspace,
+};
 
 #[ctor::ctor]
 fn init_logger() {
@@ -164,9 +166,67 @@ async fn test_basic_calls(
         }
     );
 
+    // Call user C again from user A.
+    active_call_a
+        .update(cx_a, |call, cx| {
+            call.invite(client_c.user_id().unwrap(), None, cx)
+        })
+        .await
+        .unwrap();
+
+    deterministic.run_until_parked();
+    assert_eq!(
+        room_participants(&room_a, cx_a),
+        RoomParticipants {
+            remote: vec!["user_b".to_string()],
+            pending: vec!["user_c".to_string()]
+        }
+    );
+    assert_eq!(
+        room_participants(&room_b, cx_b),
+        RoomParticipants {
+            remote: vec!["user_a".to_string()],
+            pending: vec!["user_c".to_string()]
+        }
+    );
+
+    // User C accepts the call.
+    let call_c = incoming_call_c.next().await.unwrap().unwrap();
+    assert_eq!(call_c.calling_user.github_login, "user_a");
+    active_call_c
+        .update(cx_c, |call, cx| call.accept_incoming(cx))
+        .await
+        .unwrap();
+    assert!(incoming_call_c.next().await.unwrap().is_none());
+    let room_c = active_call_c.read_with(cx_c, |call, _| call.room().unwrap().clone());
+
+    deterministic.run_until_parked();
+    assert_eq!(
+        room_participants(&room_a, cx_a),
+        RoomParticipants {
+            remote: vec!["user_b".to_string(), "user_c".to_string()],
+            pending: Default::default()
+        }
+    );
+    assert_eq!(
+        room_participants(&room_b, cx_b),
+        RoomParticipants {
+            remote: vec!["user_a".to_string(), "user_c".to_string()],
+            pending: Default::default()
+        }
+    );
+    assert_eq!(
+        room_participants(&room_c, cx_c),
+        RoomParticipants {
+            remote: vec!["user_a".to_string(), "user_b".to_string()],
+            pending: Default::default()
+        }
+    );
+
     // User A shares their screen
     let display = MacOSDisplay::new();
     let events_b = active_call_events(cx_b);
+    let events_c = active_call_events(cx_c);
     active_call_a
         .update(cx_a, |call, cx| {
             call.room().unwrap().update(cx, |room, cx| {
@@ -179,9 +239,10 @@ async fn test_basic_calls(
 
     deterministic.run_until_parked();
 
+    // User B observes the remote screen sharing track.
     assert_eq!(events_b.borrow().len(), 1);
-    let event = events_b.borrow().first().unwrap().clone();
-    if let call::room::Event::RemoteVideoTracksChanged { participant_id } = event {
+    let event_b = events_b.borrow().first().unwrap().clone();
+    if let call::room::Event::RemoteVideoTracksChanged { participant_id } = event_b {
         assert_eq!(participant_id, client_a.peer_id().unwrap());
         room_b.read_with(cx_b, |room, _| {
             assert_eq!(
@@ -195,11 +256,32 @@ async fn test_basic_calls(
         panic!("unexpected event")
     }
 
+    // User C observes the remote screen sharing track.
+    assert_eq!(events_c.borrow().len(), 1);
+    let event_c = events_c.borrow().first().unwrap().clone();
+    if let call::room::Event::RemoteVideoTracksChanged { participant_id } = event_c {
+        assert_eq!(participant_id, client_a.peer_id().unwrap());
+        room_c.read_with(cx_c, |room, _| {
+            assert_eq!(
+                room.remote_participants()[&client_a.user_id().unwrap()]
+                    .tracks
+                    .len(),
+                1
+            );
+        });
+    } else {
+        panic!("unexpected event")
+    }
+
     // User A leaves the room.
-    active_call_a.update(cx_a, |call, cx| {
-        call.hang_up(cx).unwrap();
-        assert!(call.room().is_none());
-    });
+    active_call_a
+        .update(cx_a, |call, cx| {
+            let hang_up = call.hang_up(cx);
+            assert!(call.room().is_none());
+            hang_up
+        })
+        .await
+        .unwrap();
     deterministic.run_until_parked();
     assert_eq!(
         room_participants(&room_a, cx_a),
@@ -211,18 +293,28 @@ async fn test_basic_calls(
     assert_eq!(
         room_participants(&room_b, cx_b),
         RoomParticipants {
-            remote: Default::default(),
+            remote: vec!["user_c".to_string()],
+            pending: Default::default()
+        }
+    );
+    assert_eq!(
+        room_participants(&room_c, cx_c),
+        RoomParticipants {
+            remote: vec!["user_b".to_string()],
             pending: Default::default()
         }
     );
 
     // User B gets disconnected from the LiveKit server, which causes them
-    // to automatically leave the room.
+    // to automatically leave the room. User C leaves the room as well because
+    // nobody else is in there.
     server
         .test_live_kit_server
-        .disconnect_client(client_b.peer_id().unwrap().to_string())
+        .disconnect_client(client_b.user_id().unwrap().to_string())
         .await;
-    active_call_b.update(cx_b, |call, _| assert!(call.room().is_none()));
+    deterministic.run_until_parked();
+    active_call_b.read_with(cx_b, |call, _| assert!(call.room().is_none()));
+    active_call_c.read_with(cx_c, |call, _| assert!(call.room().is_none()));
     assert_eq!(
         room_participants(&room_a, cx_a),
         RoomParticipants {
@@ -237,6 +329,141 @@ async fn test_basic_calls(
             pending: Default::default()
         }
     );
+    assert_eq!(
+        room_participants(&room_c, cx_c),
+        RoomParticipants {
+            remote: Default::default(),
+            pending: Default::default()
+        }
+    );
+}
+
+#[gpui::test(iterations = 10)]
+async fn test_calling_multiple_users_simultaneously(
+    deterministic: Arc<Deterministic>,
+    cx_a: &mut TestAppContext,
+    cx_b: &mut TestAppContext,
+    cx_c: &mut TestAppContext,
+    cx_d: &mut TestAppContext,
+) {
+    deterministic.forbid_parking();
+    let mut server = TestServer::start(&deterministic).await;
+
+    let client_a = server.create_client(cx_a, "user_a").await;
+    let client_b = server.create_client(cx_b, "user_b").await;
+    let client_c = server.create_client(cx_c, "user_c").await;
+    let client_d = server.create_client(cx_d, "user_d").await;
+    server
+        .make_contacts(&mut [
+            (&client_a, cx_a),
+            (&client_b, cx_b),
+            (&client_c, cx_c),
+            (&client_d, cx_d),
+        ])
+        .await;
+
+    let active_call_a = cx_a.read(ActiveCall::global);
+    let active_call_b = cx_b.read(ActiveCall::global);
+    let active_call_c = cx_c.read(ActiveCall::global);
+    let active_call_d = cx_d.read(ActiveCall::global);
+
+    // Simultaneously call user B and user C from client A.
+    let b_invite = active_call_a.update(cx_a, |call, cx| {
+        call.invite(client_b.user_id().unwrap(), None, cx)
+    });
+    let c_invite = active_call_a.update(cx_a, |call, cx| {
+        call.invite(client_c.user_id().unwrap(), None, cx)
+    });
+    b_invite.await.unwrap();
+    c_invite.await.unwrap();
+
+    let room_a = active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
+    deterministic.run_until_parked();
+    assert_eq!(
+        room_participants(&room_a, cx_a),
+        RoomParticipants {
+            remote: Default::default(),
+            pending: vec!["user_b".to_string(), "user_c".to_string()]
+        }
+    );
+
+    // Call client D from client A.
+    active_call_a
+        .update(cx_a, |call, cx| {
+            call.invite(client_d.user_id().unwrap(), None, cx)
+        })
+        .await
+        .unwrap();
+    deterministic.run_until_parked();
+    assert_eq!(
+        room_participants(&room_a, cx_a),
+        RoomParticipants {
+            remote: Default::default(),
+            pending: vec![
+                "user_b".to_string(),
+                "user_c".to_string(),
+                "user_d".to_string()
+            ]
+        }
+    );
+
+    // Accept the call on all clients simultaneously.
+    let accept_b = active_call_b.update(cx_b, |call, cx| call.accept_incoming(cx));
+    let accept_c = active_call_c.update(cx_c, |call, cx| call.accept_incoming(cx));
+    let accept_d = active_call_d.update(cx_d, |call, cx| call.accept_incoming(cx));
+    accept_b.await.unwrap();
+    accept_c.await.unwrap();
+    accept_d.await.unwrap();
+
+    deterministic.run_until_parked();
+
+    let room_b = active_call_b.read_with(cx_b, |call, _| call.room().unwrap().clone());
+    let room_c = active_call_c.read_with(cx_c, |call, _| call.room().unwrap().clone());
+    let room_d = active_call_d.read_with(cx_d, |call, _| call.room().unwrap().clone());
+    assert_eq!(
+        room_participants(&room_a, cx_a),
+        RoomParticipants {
+            remote: vec![
+                "user_b".to_string(),
+                "user_c".to_string(),
+                "user_d".to_string(),
+            ],
+            pending: Default::default()
+        }
+    );
+    assert_eq!(
+        room_participants(&room_b, cx_b),
+        RoomParticipants {
+            remote: vec![
+                "user_a".to_string(),
+                "user_c".to_string(),
+                "user_d".to_string(),
+            ],
+            pending: Default::default()
+        }
+    );
+    assert_eq!(
+        room_participants(&room_c, cx_c),
+        RoomParticipants {
+            remote: vec![
+                "user_a".to_string(),
+                "user_b".to_string(),
+                "user_d".to_string(),
+            ],
+            pending: Default::default()
+        }
+    );
+    assert_eq!(
+        room_participants(&room_d, cx_d),
+        RoomParticipants {
+            remote: vec![
+                "user_a".to_string(),
+                "user_b".to_string(),
+                "user_c".to_string(),
+            ],
+            pending: Default::default()
+        }
+    );
 }
 
 #[gpui::test(iterations = 10)]
@@ -334,6 +561,7 @@ async fn test_room_uniqueness(
     // Client C can successfully call client B after client B leaves the room.
     active_call_b
         .update(cx_b, |call, cx| call.hang_up(cx))
+        .await
         .unwrap();
     deterministic.run_until_parked();
     active_call_c
@@ -510,6 +738,14 @@ async fn test_server_restarts(
     deterministic.forbid_parking();
     let mut server = TestServer::start(&deterministic).await;
     let client_a = server.create_client(cx_a, "user_a").await;
+    client_a
+        .fs
+        .insert_tree("/a", json!({ "a.txt": "a-contents" }))
+        .await;
+
+    // Invite client B to collaborate on a project
+    let (project_a, _) = client_a.build_local_project("/a", cx_a).await;
+
     let client_b = server.create_client(cx_b, "user_b").await;
     let client_c = server.create_client(cx_c, "user_c").await;
     let client_d = server.create_client(cx_d, "user_d").await;
@@ -530,19 +766,19 @@ async fn test_server_restarts(
     // User A calls users B, C, and D.
     active_call_a
         .update(cx_a, |call, cx| {
-            call.invite(client_b.user_id().unwrap(), None, cx)
+            call.invite(client_b.user_id().unwrap(), Some(project_a.clone()), cx)
         })
         .await
         .unwrap();
     active_call_a
         .update(cx_a, |call, cx| {
-            call.invite(client_c.user_id().unwrap(), None, cx)
+            call.invite(client_c.user_id().unwrap(), Some(project_a.clone()), cx)
         })
         .await
         .unwrap();
     active_call_a
         .update(cx_a, |call, cx| {
-            call.invite(client_d.user_id().unwrap(), None, cx)
+            call.invite(client_d.user_id().unwrap(), Some(project_a.clone()), cx)
         })
         .await
         .unwrap();
@@ -598,7 +834,7 @@ async fn test_server_restarts(
 
     // Users A and B reconnect to the call. User C has troubles reconnecting, so it leaves the room.
     client_c.override_establish_connection(|_, cx| cx.spawn(|_| future::pending()));
-    deterministic.advance_clock(RECEIVE_TIMEOUT);
+    deterministic.advance_clock(RECONNECT_TIMEOUT);
     assert_eq!(
         room_participants(&room_a, cx_a),
         RoomParticipants {
@@ -705,6 +941,7 @@ async fn test_server_restarts(
     // User D hangs up.
     active_call_d
         .update(cx_d, |call, cx| call.hang_up(cx))
+        .await
         .unwrap();
     deterministic.run_until_parked();
     assert_eq!(
@@ -770,7 +1007,7 @@ async fn test_server_restarts(
     client_a.override_establish_connection(|_, cx| cx.spawn(|_| future::pending()));
     client_b.override_establish_connection(|_, cx| cx.spawn(|_| future::pending()));
     client_c.override_establish_connection(|_, cx| cx.spawn(|_| future::pending()));
-    deterministic.advance_clock(RECEIVE_TIMEOUT);
+    deterministic.advance_clock(RECONNECT_TIMEOUT);
     assert_eq!(
         room_participants(&room_a, cx_a),
         RoomParticipants {
@@ -860,7 +1097,7 @@ async fn test_calls_on_multiple_connections(
     assert!(incoming_call_b2.next().await.unwrap().is_none());
 
     // User B disconnects the client that is not on the call. Everything should be fine.
-    client_b1.disconnect(&cx_b1.to_async()).unwrap();
+    client_b1.disconnect(&cx_b1.to_async());
     deterministic.advance_clock(RECEIVE_TIMEOUT);
     client_b1
         .authenticate_and_connect(false, &cx_b1.to_async())
@@ -868,7 +1105,10 @@ async fn test_calls_on_multiple_connections(
         .unwrap();
 
     // User B hangs up, and user A calls them again.
-    active_call_b2.update(cx_b2, |call, cx| call.hang_up(cx).unwrap());
+    active_call_b2
+        .update(cx_b2, |call, cx| call.hang_up(cx))
+        .await
+        .unwrap();
     deterministic.run_until_parked();
     active_call_a
         .update(cx_a, |call, cx| {
@@ -903,7 +1143,10 @@ async fn test_calls_on_multiple_connections(
     assert!(incoming_call_b2.next().await.unwrap().is_some());
 
     // User A hangs up, causing both connections to stop ringing.
-    active_call_a.update(cx_a, |call, cx| call.hang_up(cx).unwrap());
+    active_call_a
+        .update(cx_a, |call, cx| call.hang_up(cx))
+        .await
+        .unwrap();
     deterministic.run_until_parked();
     assert!(incoming_call_b1.next().await.unwrap().is_none());
     assert!(incoming_call_b2.next().await.unwrap().is_none());
@@ -1140,7 +1383,10 @@ async fn test_unshare_project(
         .unwrap();
 
     // When client B leaves the room, the project becomes read-only.
-    active_call_b.update(cx_b, |call, cx| call.hang_up(cx).unwrap());
+    active_call_b
+        .update(cx_b, |call, cx| call.hang_up(cx))
+        .await
+        .unwrap();
     deterministic.run_until_parked();
     assert!(project_b.read_with(cx_b, |project, _| project.is_read_only()));
 
@@ -1169,7 +1415,10 @@ async fn test_unshare_project(
         .unwrap();
 
     // When client A (the host) leaves the room, the project gets unshared and guests are notified.
-    active_call_a.update(cx_a, |call, cx| call.hang_up(cx).unwrap());
+    active_call_a
+        .update(cx_a, |call, cx| call.hang_up(cx))
+        .await
+        .unwrap();
     deterministic.run_until_parked();
     project_a.read_with(cx_a, |project, _| assert!(!project.is_shared()));
     project_c2.read_with(cx_c, |project, _| {
@@ -1218,15 +1467,7 @@ async fn test_host_disconnect(
     deterministic.run_until_parked();
     assert!(worktree_a.read_with(cx_a, |tree, _| tree.as_local().unwrap().is_shared()));
 
-    let (_, workspace_b) = cx_b.add_window(|cx| {
-        Workspace::new(
-            Default::default(),
-            0,
-            project_b.clone(),
-            |_, _| unimplemented!(),
-            cx,
-        )
-    });
+    let (_, workspace_b) = cx_b.add_window(|cx| Workspace::test_new(project_b.clone(), cx));
     let editor_b = workspace_b
         .update(cx_b, |workspace, cx| {
             workspace.open_path((worktree_id, "b.txt"), None, true, cx)
@@ -2021,7 +2262,9 @@ async fn test_propagate_saves_and_fs_changes(
     });
 
     // Edit the buffer as the host and concurrently save as guest B.
-    let save_b = buffer_b.update(cx_b, |buf, cx| buf.save(cx));
+    let save_b = project_b.update(cx_b, |project, cx| {
+        project.save_buffer(buffer_b.clone(), cx)
+    });
     buffer_a.update(cx_a, |buf, cx| buf.edit([(0..0, "hi-a, ")], None, cx));
     save_b.await.unwrap();
     assert_eq!(
@@ -2090,6 +2333,41 @@ async fn test_propagate_saves_and_fs_changes(
         assert_eq!(buffer.file().unwrap().path().to_str(), Some("file1.js"));
         assert_eq!(&*buffer.language().unwrap().name(), "JavaScript");
     });
+
+    let new_buffer_a = project_a
+        .update(cx_a, |p, cx| p.create_buffer("", None, cx))
+        .unwrap();
+    let new_buffer_id = new_buffer_a.read_with(cx_a, |buffer, _| buffer.remote_id());
+    let new_buffer_b = project_b
+        .update(cx_b, |p, cx| p.open_buffer_by_id(new_buffer_id, cx))
+        .await
+        .unwrap();
+    new_buffer_b.read_with(cx_b, |buffer, _| {
+        assert!(buffer.file().is_none());
+    });
+
+    new_buffer_a.update(cx_a, |buffer, cx| {
+        buffer.edit([(0..0, "ok")], None, cx);
+    });
+    project_a
+        .update(cx_a, |project, cx| {
+            project.save_buffer_as(new_buffer_a.clone(), "/a/file3.rs".into(), cx)
+        })
+        .await
+        .unwrap();
+
+    deterministic.run_until_parked();
+    new_buffer_b.read_with(cx_b, |buffer_b, _| {
+        assert_eq!(
+            buffer_b.file().unwrap().path().as_ref(),
+            Path::new("file3.rs")
+        );
+
+        new_buffer_a.read_with(cx_a, |buffer_a, _| {
+            assert_eq!(buffer_b.saved_mtime(), buffer_a.saved_mtime());
+            assert_eq!(buffer_b.saved_version(), buffer_a.saved_version());
+        });
+    });
 }
 
 #[gpui::test(iterations = 10)]
@@ -2569,6 +2847,8 @@ async fn test_fs_operations(
         })
         .await
         .unwrap();
+    deterministic.run_until_parked();
+
     worktree_a.read_with(cx_a, |worktree, _| {
         assert_eq!(
             worktree
@@ -2657,7 +2937,12 @@ async fn test_buffer_conflict_after_save(
         assert!(!buf.has_conflict());
     });
 
-    buffer_b.update(cx_b, |buf, cx| buf.save(cx)).await.unwrap();
+    project_b
+        .update(cx_b, |project, cx| {
+            project.save_buffer(buffer_b.clone(), cx)
+        })
+        .await
+        .unwrap();
     cx_a.foreground().forbid_parking();
     buffer_b.read_with(cx_b, |buffer_b, _| assert!(!buffer_b.is_dirty()));
     buffer_b.read_with(cx_b, |buf, _| {
@@ -2960,7 +3245,7 @@ async fn test_leaving_project(
     buffer_b2.read_with(cx_b, |buffer, _| assert_eq!(buffer.text(), "a-contents"));
 
     // Drop client B's connection and ensure client A and client C observe client B leaving.
-    client_b.disconnect(&cx_b.to_async()).unwrap();
+    client_b.disconnect(&cx_b.to_async());
     deterministic.advance_clock(RECONNECT_TIMEOUT);
     project_a.read_with(cx_a, |project, _| {
         assert_eq!(project.collaborators().len(), 1);
@@ -3617,9 +3902,11 @@ async fn test_formatting_buffer(
         })
         .await
         .unwrap();
+
+    // The edits from the LSP are applied, and a final newline is added.
     assert_eq!(
         buffer_b.read_with(cx_b, |buffer, _| buffer.text()),
-        "let honey = \"two\""
+        "let honey = \"two\"\n"
     );
 
     // Ensure buffer can be formatted using an external command. Notice how the
@@ -4429,15 +4716,7 @@ async fn test_collaborating_with_code_actions(
 
     // Join the project as client B.
     let project_b = client_b.build_remote_project(project_id, cx_b).await;
-    let (_window_b, workspace_b) = cx_b.add_window(|cx| {
-        Workspace::new(
-            Default::default(),
-            0,
-            project_b.clone(),
-            |_, _| unimplemented!(),
-            cx,
-        )
-    });
+    let (_window_b, workspace_b) = cx_b.add_window(|cx| Workspace::test_new(project_b.clone(), cx));
     let editor_b = workspace_b
         .update(cx_b, |workspace, cx| {
             workspace.open_path((worktree_id, "main.rs"), None, true, cx)
@@ -4660,15 +4939,7 @@ async fn test_collaborating_with_renames(
         .unwrap();
     let project_b = client_b.build_remote_project(project_id, cx_b).await;
 
-    let (_window_b, workspace_b) = cx_b.add_window(|cx| {
-        Workspace::new(
-            Default::default(),
-            0,
-            project_b.clone(),
-            |_, _| unimplemented!(),
-            cx,
-        )
-    });
+    let (_window_b, workspace_b) = cx_b.add_window(|cx| Workspace::test_new(project_b.clone(), cx));
     let editor_b = workspace_b
         .update(cx_b, |workspace, cx| {
             workspace.open_path((worktree_id, "one.rs"), None, true, cx)
@@ -5202,7 +5473,10 @@ async fn test_contacts(
         [("user_b".to_string(), "online", "busy")]
     );
 
-    active_call_a.update(cx_a, |call, cx| call.hang_up(cx).unwrap());
+    active_call_a
+        .update(cx_a, |call, cx| call.hang_up(cx))
+        .await
+        .unwrap();
     deterministic.run_until_parked();
     assert_eq!(
         contacts(&client_a, cx_a),
@@ -5289,6 +5563,27 @@ async fn test_contacts(
         [("user_b".to_string(), "online", "free")]
     );
 
+    // Test removing a contact
+    client_b
+        .user_store
+        .update(cx_b, |store, cx| {
+            store.remove_contact(client_c.user_id().unwrap(), cx)
+        })
+        .await
+        .unwrap();
+    deterministic.run_until_parked();
+    assert_eq!(
+        contacts(&client_b, cx_b),
+        [
+            ("user_a".to_string(), "offline", "free"),
+            ("user_d".to_string(), "online", "free")
+        ]
+    );
+    assert_eq!(
+        contacts(&client_c, cx_c),
+        [("user_a".to_string(), "offline", "free"),]
+    );
+
     fn contacts(
         client: &TestClient,
         cx: &TestAppContext,
@@ -5484,7 +5779,7 @@ async fn test_contact_requests(
         .is_empty());
 
     async fn disconnect_and_reconnect(client: &TestClient, cx: &mut TestAppContext) {
-        client.disconnect(&cx.to_async()).unwrap();
+        client.disconnect(&cx.to_async());
         client.clear_contacts(cx).await;
         client
             .authenticate_and_connect(false, &cx.to_async())
@@ -5494,10 +5789,12 @@ async fn test_contact_requests(
 }
 
 #[gpui::test(iterations = 10)]
-async fn test_following(
+async fn test_basic_following(
     deterministic: Arc<Deterministic>,
     cx_a: &mut TestAppContext,
     cx_b: &mut TestAppContext,
+    cx_c: &mut TestAppContext,
+    cx_d: &mut TestAppContext,
 ) {
     deterministic.forbid_parking();
     cx_a.update(editor::init);
@@ -5506,8 +5803,15 @@ async fn test_following(
     let mut server = TestServer::start(&deterministic).await;
     let client_a = server.create_client(cx_a, "user_a").await;
     let client_b = server.create_client(cx_b, "user_b").await;
+    let client_c = server.create_client(cx_c, "user_c").await;
+    let client_d = server.create_client(cx_d, "user_d").await;
     server
-        .create_room(&mut [(&client_a, cx_a), (&client_b, cx_b)])
+        .create_room(&mut [
+            (&client_a, cx_a),
+            (&client_b, cx_b),
+            (&client_c, cx_c),
+            (&client_d, cx_d),
+        ])
         .await;
     let active_call_a = cx_a.read(ActiveCall::global);
     let active_call_b = cx_b.read(ActiveCall::global);
@@ -5539,8 +5843,10 @@ async fn test_following(
         .await
         .unwrap();
 
-    // Client A opens some editors.
     let workspace_a = client_a.build_workspace(&project_a, cx_a);
+    let workspace_b = client_b.build_workspace(&project_b, cx_b);
+
+    // Client A opens some editors.
     let pane_a = workspace_a.read_with(cx_a, |workspace, _| workspace.active_pane().clone());
     let editor_a1 = workspace_a
         .update(cx_a, |workspace, cx| {
@@ -5560,7 +5866,6 @@ async fn test_following(
         .unwrap();
 
     // Client B opens an editor.
-    let workspace_b = client_b.build_workspace(&project_b, cx_b);
     let editor_b1 = workspace_b
         .update(cx_b, |workspace, cx| {
             workspace.open_path((worktree_id, "1.txt"), None, true, cx)
@@ -5570,29 +5875,184 @@ async fn test_following(
         .downcast::<Editor>()
         .unwrap();
 
-    let client_a_id = project_b.read_with(cx_b, |project, _| {
-        project.collaborators().values().next().unwrap().peer_id
-    });
-    let client_b_id = project_a.read_with(cx_a, |project, _| {
-        project.collaborators().values().next().unwrap().peer_id
-    });
+    let peer_id_a = client_a.peer_id().unwrap();
+    let peer_id_b = client_b.peer_id().unwrap();
+    let peer_id_c = client_c.peer_id().unwrap();
+    let peer_id_d = client_d.peer_id().unwrap();
 
-    // When client B starts following client A, all visible view states are replicated to client B.
+    // Client A updates their selections in those editors
     editor_a1.update(cx_a, |editor, cx| {
         editor.change_selections(None, cx, |s| s.select_ranges([0..1]))
     });
     editor_a2.update(cx_a, |editor, cx| {
         editor.change_selections(None, cx, |s| s.select_ranges([2..3]))
     });
+
+    // When client B starts following client A, all visible view states are replicated to client B.
     workspace_b
         .update(cx_b, |workspace, cx| {
             workspace
-                .toggle_follow(&ToggleFollow(client_a_id), cx)
+                .toggle_follow(&ToggleFollow(peer_id_a), cx)
                 .unwrap()
         })
         .await
         .unwrap();
 
+    cx_c.foreground().run_until_parked();
+    let active_call_c = cx_c.read(ActiveCall::global);
+    let project_c = client_c.build_remote_project(project_id, cx_c).await;
+    let workspace_c = client_c.build_workspace(&project_c, cx_c);
+    active_call_c
+        .update(cx_c, |call, cx| call.set_location(Some(&project_c), cx))
+        .await
+        .unwrap();
+    drop(project_c);
+
+    // Client C also follows client A.
+    workspace_c
+        .update(cx_c, |workspace, cx| {
+            workspace
+                .toggle_follow(&ToggleFollow(peer_id_a), cx)
+                .unwrap()
+        })
+        .await
+        .unwrap();
+
+    cx_d.foreground().run_until_parked();
+    let active_call_d = cx_d.read(ActiveCall::global);
+    let project_d = client_d.build_remote_project(project_id, cx_d).await;
+    let workspace_d = client_d.build_workspace(&project_d, cx_d);
+    active_call_d
+        .update(cx_d, |call, cx| call.set_location(Some(&project_d), cx))
+        .await
+        .unwrap();
+    drop(project_d);
+
+    // All clients see that clients B and C are following client A.
+    cx_c.foreground().run_until_parked();
+    for (name, active_call, cx) in [
+        ("A", &active_call_a, &cx_a),
+        ("B", &active_call_b, &cx_b),
+        ("C", &active_call_c, &cx_c),
+        ("D", &active_call_d, &cx_d),
+    ] {
+        active_call.read_with(*cx, |call, cx| {
+            let room = call.room().unwrap().read(cx);
+            assert_eq!(
+                room.followers_for(peer_id_a, project_id),
+                &[peer_id_b, peer_id_c],
+                "checking followers for A as {name}"
+            );
+        });
+    }
+
+    // Client C unfollows client A.
+    workspace_c.update(cx_c, |workspace, cx| {
+        workspace.toggle_follow(&ToggleFollow(peer_id_a), cx);
+    });
+
+    // All clients see that clients B is following client A.
+    cx_c.foreground().run_until_parked();
+    for (name, active_call, cx) in [
+        ("A", &active_call_a, &cx_a),
+        ("B", &active_call_b, &cx_b),
+        ("C", &active_call_c, &cx_c),
+        ("D", &active_call_d, &cx_d),
+    ] {
+        active_call.read_with(*cx, |call, cx| {
+            let room = call.room().unwrap().read(cx);
+            assert_eq!(
+                room.followers_for(peer_id_a, project_id),
+                &[peer_id_b],
+                "checking followers for A as {name}"
+            );
+        });
+    }
+
+    // Client C re-follows client A.
+    workspace_c.update(cx_c, |workspace, cx| {
+        workspace.toggle_follow(&ToggleFollow(peer_id_a), cx);
+    });
+
+    // All clients see that clients B and C are following client A.
+    cx_c.foreground().run_until_parked();
+    for (name, active_call, cx) in [
+        ("A", &active_call_a, &cx_a),
+        ("B", &active_call_b, &cx_b),
+        ("C", &active_call_c, &cx_c),
+        ("D", &active_call_d, &cx_d),
+    ] {
+        active_call.read_with(*cx, |call, cx| {
+            let room = call.room().unwrap().read(cx);
+            assert_eq!(
+                room.followers_for(peer_id_a, project_id),
+                &[peer_id_b, peer_id_c],
+                "checking followers for A as {name}"
+            );
+        });
+    }
+
+    // Client D follows client C.
+    workspace_d
+        .update(cx_d, |workspace, cx| {
+            workspace
+                .toggle_follow(&ToggleFollow(peer_id_c), cx)
+                .unwrap()
+        })
+        .await
+        .unwrap();
+
+    // All clients see that D is following C
+    cx_d.foreground().run_until_parked();
+    for (name, active_call, cx) in [
+        ("A", &active_call_a, &cx_a),
+        ("B", &active_call_b, &cx_b),
+        ("C", &active_call_c, &cx_c),
+        ("D", &active_call_d, &cx_d),
+    ] {
+        active_call.read_with(*cx, |call, cx| {
+            let room = call.room().unwrap().read(cx);
+            assert_eq!(
+                room.followers_for(peer_id_c, project_id),
+                &[peer_id_d],
+                "checking followers for C as {name}"
+            );
+        });
+    }
+
+    // Client C closes the project.
+    cx_c.drop_last(workspace_c);
+
+    // Clients A and B see that client B is following A, and client C is not present in the followers.
+    cx_c.foreground().run_until_parked();
+    for (name, active_call, cx) in [("A", &active_call_a, &cx_a), ("B", &active_call_b, &cx_b)] {
+        active_call.read_with(*cx, |call, cx| {
+            let room = call.room().unwrap().read(cx);
+            assert_eq!(
+                room.followers_for(peer_id_a, project_id),
+                &[peer_id_b],
+                "checking followers for A as {name}"
+            );
+        });
+    }
+
+    // All clients see that no-one is following C
+    for (name, active_call, cx) in [
+        ("A", &active_call_a, &cx_a),
+        ("B", &active_call_b, &cx_b),
+        ("C", &active_call_c, &cx_c),
+        ("D", &active_call_d, &cx_d),
+    ] {
+        active_call.read_with(*cx, |call, cx| {
+            let room = call.room().unwrap().read(cx);
+            assert_eq!(
+                room.followers_for(peer_id_c, project_id),
+                &[],
+                "checking followers for C as {name}"
+            );
+        });
+    }
+
     let editor_b2 = workspace_b.read_with(cx_b, |workspace, cx| {
         workspace
             .active_item(cx)
@@ -5600,9 +6060,8 @@ async fn test_following(
             .downcast::<Editor>()
             .unwrap()
     });
-    assert!(cx_b.read(|cx| editor_b2.is_focused(cx)));
     assert_eq!(
-        editor_b2.read_with(cx_b, |editor, cx| editor.project_path(cx)),
+        cx_b.read(|cx| editor_b2.project_path(cx)),
         Some((worktree_id, "2.txt").into())
     );
     assert_eq!(
@@ -5746,14 +6205,14 @@ async fn test_following(
     workspace_a
         .update(cx_a, |workspace, cx| {
             workspace
-                .toggle_follow(&ToggleFollow(client_b_id), cx)
+                .toggle_follow(&ToggleFollow(peer_id_b), cx)
                 .unwrap()
         })
         .await
         .unwrap();
     assert_eq!(
         workspace_a.read_with(cx_a, |workspace, _| workspace.leader_for_pane(&pane_a)),
-        Some(client_b_id)
+        Some(peer_id_b)
     );
     assert_eq!(
         workspace_a.read_with(cx_a, |workspace, cx| workspace
@@ -5825,7 +6284,7 @@ async fn test_following(
     );
 
     // Following interrupts when client B disconnects.
-    client_b.disconnect(&cx_b.to_async()).unwrap();
+    client_b.disconnect(&cx_b.to_async());
     deterministic.advance_clock(RECONNECT_TIMEOUT);
     assert_eq!(
         workspace_a.read_with(cx_a, |workspace, _| workspace.leader_for_pane(&pane_a)),
@@ -5833,6 +6292,99 @@ async fn test_following(
     );
 }
 
+#[gpui::test(iterations = 10)]
+async fn test_join_call_after_screen_was_shared(
+    deterministic: Arc<Deterministic>,
+    cx_a: &mut TestAppContext,
+    cx_b: &mut TestAppContext,
+) {
+    deterministic.forbid_parking();
+    let mut server = TestServer::start(&deterministic).await;
+
+    let client_a = server.create_client(cx_a, "user_a").await;
+    let client_b = server.create_client(cx_b, "user_b").await;
+    server
+        .make_contacts(&mut [(&client_a, cx_a), (&client_b, cx_b)])
+        .await;
+
+    let active_call_a = cx_a.read(ActiveCall::global);
+    let active_call_b = cx_b.read(ActiveCall::global);
+
+    // Call users B and C from client A.
+    active_call_a
+        .update(cx_a, |call, cx| {
+            call.invite(client_b.user_id().unwrap(), None, cx)
+        })
+        .await
+        .unwrap();
+    let room_a = active_call_a.read_with(cx_a, |call, _| call.room().unwrap().clone());
+    deterministic.run_until_parked();
+    assert_eq!(
+        room_participants(&room_a, cx_a),
+        RoomParticipants {
+            remote: Default::default(),
+            pending: vec!["user_b".to_string()]
+        }
+    );
+
+    // User B receives the call.
+    let mut incoming_call_b = active_call_b.read_with(cx_b, |call, _| call.incoming());
+    let call_b = incoming_call_b.next().await.unwrap().unwrap();
+    assert_eq!(call_b.calling_user.github_login, "user_a");
+
+    // User A shares their screen
+    let display = MacOSDisplay::new();
+    active_call_a
+        .update(cx_a, |call, cx| {
+            call.room().unwrap().update(cx, |room, cx| {
+                room.set_display_sources(vec![display.clone()]);
+                room.share_screen(cx)
+            })
+        })
+        .await
+        .unwrap();
+
+    client_b.user_store.update(cx_b, |user_store, _| {
+        user_store.clear_cache();
+    });
+
+    // User B joins the room
+    active_call_b
+        .update(cx_b, |call, cx| call.accept_incoming(cx))
+        .await
+        .unwrap();
+    let room_b = active_call_b.read_with(cx_b, |call, _| call.room().unwrap().clone());
+    assert!(incoming_call_b.next().await.unwrap().is_none());
+
+    deterministic.run_until_parked();
+    assert_eq!(
+        room_participants(&room_a, cx_a),
+        RoomParticipants {
+            remote: vec!["user_b".to_string()],
+            pending: vec![],
+        }
+    );
+    assert_eq!(
+        room_participants(&room_b, cx_b),
+        RoomParticipants {
+            remote: vec!["user_a".to_string()],
+            pending: vec![],
+        }
+    );
+
+    // Ensure User B sees User A's screenshare.
+    room_b.read_with(cx_b, |room, _| {
+        assert_eq!(
+            room.remote_participants()
+                .get(&client_a.user_id().unwrap())
+                .unwrap()
+                .tracks
+                .len(),
+            1
+        );
+    });
+}
+
 #[gpui::test]
 async fn test_following_tab_order(
     deterministic: Arc<Deterministic>,

crates/collab/src/tests/randomized_integration_tests.rs

@@ -10,7 +10,7 @@ use collections::BTreeMap;
 use fs::{FakeFs, Fs as _};
 use futures::StreamExt as _;
 use gpui::{executor::Deterministic, ModelHandle, TestAppContext};
-use language::{range_to_lsp, FakeLspAdapter, Language, LanguageConfig, PointUtf16};
+use language::{range_to_lsp, FakeLspAdapter, Language, LanguageConfig, PointUtf16, Rope};
 use lsp::FakeLanguageServer;
 use parking_lot::Mutex;
 use project::{search::SearchQuery, Project};
@@ -19,7 +19,12 @@ use rand::{
     prelude::*,
 };
 use settings::Settings;
-use std::{env, ffi::OsStr, path::PathBuf, sync::Arc};
+use std::{
+    env,
+    ffi::OsStr,
+    path::{Path, PathBuf},
+    sync::Arc,
+};
 
 #[gpui::test(iterations = 100)]
 async fn test_random_collaboration(
@@ -161,12 +166,10 @@ async fn test_random_collaboration(
                     let contacts = server.app_state.db.get_contacts(*user_id).await.unwrap();
                     let pool = server.connection_pool.lock();
                     for contact in contacts {
-                        if let db::Contact::Accepted { user_id, .. } = contact {
-                            if pool.is_user_online(user_id) {
-                                assert_ne!(
-                                    user_id, removed_user_id,
-                                    "removed client is still a contact of another peer"
-                                );
+                        if let db::Contact::Accepted { user_id, busy, .. } = contact {
+                            if user_id == removed_user_id {
+                                assert!(!pool.is_user_online(user_id));
+                                assert!(!busy);
                             }
                         }
                     }
@@ -398,6 +401,33 @@ async fn test_random_collaboration(
                 let guest_diff_base = guest_buffer
                     .read_with(client_cx, |b, _| b.diff_base().map(ToString::to_string));
                 assert_eq!(guest_diff_base, host_diff_base);
+
+                let host_saved_version =
+                    host_buffer.read_with(host_cx, |b, _| b.saved_version().clone());
+                let guest_saved_version =
+                    guest_buffer.read_with(client_cx, |b, _| b.saved_version().clone());
+                assert_eq!(guest_saved_version, host_saved_version);
+
+                let host_saved_version_fingerprint =
+                    host_buffer.read_with(host_cx, |b, _| b.saved_version_fingerprint());
+                let guest_saved_version_fingerprint =
+                    guest_buffer.read_with(client_cx, |b, _| b.saved_version_fingerprint());
+                assert_eq!(
+                    guest_saved_version_fingerprint,
+                    host_saved_version_fingerprint
+                );
+
+                let host_saved_mtime = host_buffer.read_with(host_cx, |b, _| b.saved_mtime());
+                let guest_saved_mtime = guest_buffer.read_with(client_cx, |b, _| b.saved_mtime());
+                assert_eq!(guest_saved_mtime, host_saved_mtime);
+
+                let host_is_dirty = host_buffer.read_with(host_cx, |b, _| b.is_dirty());
+                let guest_is_dirty = guest_buffer.read_with(client_cx, |b, _| b.is_dirty());
+                assert_eq!(guest_is_dirty, host_is_dirty);
+
+                let host_has_conflict = host_buffer.read_with(host_cx, |b, _| b.has_conflict());
+                let guest_has_conflict = guest_buffer.read_with(client_cx, |b, _| b.has_conflict());
+                assert_eq!(guest_has_conflict, host_has_conflict);
             }
         }
     }
@@ -611,7 +641,7 @@ async fn randomly_mutate_active_call(
                 if can_hang_up && active_call.read_with(cx, |call, _| call.room().is_some()) =>
             {
                 log::info!("{}: hanging up", client.username);
-                active_call.update(cx, |call, cx| call.hang_up(cx))?;
+                active_call.update(cx, |call, cx| call.hang_up(cx)).await?;
             }
             _ => {}
         }
@@ -638,14 +668,7 @@ async fn randomly_mutate_git(client: &mut TestClient, rng: &Mutex<StdRng>) {
         client.fs.create_dir(&git_dir_path).await.unwrap();
     }
 
-    let mut child_paths = client.fs.read_dir(&dir_path).await.unwrap();
-    let mut child_file_paths = Vec::new();
-    while let Some(child_path) = child_paths.next().await {
-        let child_path = child_path.unwrap();
-        if client.fs.is_file(&child_path).await {
-            child_file_paths.push(child_path);
-        }
-    }
+    let mut child_file_paths = child_file_paths(client, &dir_path).await;
     let count = rng.lock().gen_range(0..=child_file_paths.len());
     child_file_paths.shuffle(&mut *rng.lock());
     child_file_paths.truncate(count);
@@ -669,26 +692,63 @@ async fn randomly_mutate_git(client: &mut TestClient, rng: &Mutex<StdRng>) {
 }
 
 async fn randomly_mutate_fs(client: &mut TestClient, rng: &Mutex<StdRng>) {
-    let is_dir = rng.lock().gen::<bool>();
-    let mut new_path = client
+    let parent_dir_path = client
         .fs
         .directories()
         .await
         .choose(&mut *rng.lock())
         .unwrap()
         .clone();
-    new_path.push(gen_file_name(rng));
+
+    let is_dir = rng.lock().gen::<bool>();
     if is_dir {
-        log::info!("{}: creating local dir at {:?}", client.username, new_path);
-        client.fs.create_dir(&new_path).await.unwrap();
+        let mut dir_path = parent_dir_path.clone();
+        dir_path.push(gen_file_name(rng));
+        log::info!("{}: creating local dir at {:?}", client.username, dir_path);
+        client.fs.create_dir(&dir_path).await.unwrap();
     } else {
-        new_path.set_extension("rs");
-        log::info!("{}: creating local file at {:?}", client.username, new_path);
-        client
-            .fs
-            .create_file(&new_path, Default::default())
-            .await
-            .unwrap();
+        let child_file_paths = child_file_paths(client, &parent_dir_path).await;
+        let create_new_file = child_file_paths.is_empty() || rng.lock().gen();
+        let text = Alphanumeric.sample_string(&mut *rng.lock(), 16);
+        if create_new_file {
+            let mut file_path = parent_dir_path.clone();
+            file_path.push(gen_file_name(rng));
+            file_path.set_extension("rs");
+            log::info!(
+                "{}: creating local file at {:?}",
+                client.username,
+                file_path
+            );
+            client
+                .fs
+                .create_file(&file_path, Default::default())
+                .await
+                .unwrap();
+            log::info!(
+                "{}: setting local file {:?} text to {:?}",
+                client.username,
+                file_path,
+                text
+            );
+            client
+                .fs
+                .save(&file_path, &Rope::from(text.as_str()), fs::LineEnding::Unix)
+                .await
+                .unwrap();
+        } else {
+            let file_path = child_file_paths.choose(&mut *rng.lock()).unwrap();
+            log::info!(
+                "{}: setting local file {:?} text to {:?}",
+                client.username,
+                file_path,
+                text
+            );
+            client
+                .fs
+                .save(file_path, &Rope::from(text.as_str()), fs::LineEnding::Unix)
+                .await
+                .unwrap();
+        }
     }
 }
 
@@ -1004,15 +1064,16 @@ async fn randomly_query_and_mutate_buffers(
             }
         }
         30..=39 if buffer.read_with(cx, |buffer, _| buffer.is_dirty()) => {
-            let (requested_version, save) = buffer.update(cx, |buffer, cx| {
+            let requested_version = buffer.update(cx, |buffer, cx| {
                 log::info!(
                     "{}: saving buffer {} ({:?})",
                     client.username,
                     buffer.remote_id(),
                     buffer.file().unwrap().full_path(cx)
                 );
-                (buffer.version(), buffer.save(cx))
+                buffer.version()
             });
+            let save = project.update(cx, |project, cx| project.save_buffer(buffer, cx));
             let save = cx.background().spawn(async move {
                 let (saved_version, _, _) = save
                     .await
@@ -1154,3 +1215,15 @@ fn gen_file_name(rng: &Mutex<StdRng>) -> String {
     }
     name
 }
+
+async fn child_file_paths(client: &TestClient, dir_path: &Path) -> Vec<PathBuf> {
+    let mut child_paths = client.fs.read_dir(dir_path).await.unwrap();
+    let mut child_file_paths = Vec::new();
+    while let Some(child_path) = child_paths.next().await {
+        let child_path = child_path.unwrap();
+        if client.fs.is_file(&child_path).await {
+            child_file_paths.push(child_path);
+        }
+    }
+    child_file_paths
+}

crates/collab_ui/Cargo.toml

@@ -2,6 +2,7 @@
 name = "collab_ui"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/collab_ui.rs"
@@ -21,11 +22,14 @@ test-support = [
 ]
 
 [dependencies]
+auto_update = { path = "../auto_update" }
 call = { path = "../call" }
 client = { path = "../client" }
 clock = { path = "../clock" }
 collections = { path = "../collections" }
+context_menu = { path = "../context_menu" }
 editor = { path = "../editor" }
+feedback = { path = "../feedback" }
 fuzzy = { path = "../fuzzy" }
 gpui = { path = "../gpui" }
 menu = { path = "../menu" }
@@ -40,6 +44,7 @@ futures = "0.3"
 log = "0.4"
 postage = { version = "0.4.1", features = ["futures-traits"] }
 serde = { version = "1.0", features = ["derive", "rc"] }
+serde_derive = { version = "1.0", features = ["deserialize_in_place"] }
 
 [dev-dependencies]
 call = { path = "../call", features = ["test-support"] }

crates/collab_ui/src/collab_ui.rs

@@ -1,19 +1,24 @@
 mod collab_titlebar_item;
+mod collaborator_list_popover;
 mod contact_finder;
 mod contact_list;
 mod contact_notification;
 mod contacts_popover;
+mod face_pile;
 mod incoming_call_notification;
 mod notifications;
 mod project_shared_notification;
+mod sharing_status_indicator;
 
 use anyhow::anyhow;
 use call::ActiveCall;
-pub use collab_titlebar_item::{CollabTitlebarItem, ToggleCollaborationMenu};
-use gpui::MutableAppContext;
+pub use collab_titlebar_item::{CollabTitlebarItem, ToggleContactsMenu};
+use gpui::{actions, MutableAppContext, Task};
 use std::sync::Arc;
 use workspace::{AppState, JoinProject, ToggleFollow, Workspace};
 
+actions!(collab, [ToggleScreenSharing]);
+
 pub fn init(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
     collab_titlebar_item::init(cx);
     contact_notification::init(cx);
@@ -22,86 +27,108 @@ pub fn init(app_state: Arc<AppState>, cx: &mut MutableAppContext) {
     contacts_popover::init(cx);
     incoming_call_notification::init(cx);
     project_shared_notification::init(cx);
+    sharing_status_indicator::init(cx);
 
+    cx.add_global_action(toggle_screen_sharing);
     cx.add_global_action(move |action: &JoinProject, cx| {
-        let project_id = action.project_id;
-        let follow_user_id = action.follow_user_id;
-        let app_state = app_state.clone();
-        cx.spawn(|mut cx| async move {
-            let existing_workspace = cx.update(|cx| {
-                cx.window_ids()
-                    .filter_map(|window_id| cx.root_view::<Workspace>(window_id))
-                    .find(|workspace| {
-                        workspace.read(cx).project().read(cx).remote_id() == Some(project_id)
-                    })
-            });
+        join_project(action, app_state.clone(), cx);
+    });
+}
 
-            let workspace = if let Some(existing_workspace) = existing_workspace {
-                existing_workspace
+pub fn toggle_screen_sharing(_: &ToggleScreenSharing, cx: &mut MutableAppContext) {
+    if let Some(room) = ActiveCall::global(cx).read(cx).room().cloned() {
+        let toggle_screen_sharing = room.update(cx, |room, cx| {
+            if room.is_screen_sharing() {
+                Task::ready(room.unshare_screen(cx))
             } else {
-                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?;
+                room.share_screen(cx)
+            }
+        });
+        toggle_screen_sharing.detach_and_log_err(cx);
+    }
+}
 
-                let (_, workspace) = cx.add_window((app_state.build_window_options)(), |cx| {
+fn join_project(action: &JoinProject, app_state: Arc<AppState>, cx: &mut MutableAppContext) {
+    let project_id = action.project_id;
+    let follow_user_id = action.follow_user_id;
+    cx.spawn(|mut cx| async move {
+        let existing_workspace = cx.update(|cx| {
+            cx.window_ids()
+                .filter_map(|window_id| cx.root_view::<Workspace>(window_id))
+                .find(|workspace| {
+                    workspace.read(cx).project().read(cx).remote_id() == Some(project_id)
+                })
+        });
+
+        let workspace = if let Some(existing_workspace) = existing_workspace {
+            existing_workspace
+        } else {
+            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)(None, None, cx.platform().as_ref()),
+                |cx| {
                     let mut workspace = Workspace::new(
                         Default::default(),
                         0,
                         project,
                         app_state.dock_default_item_factory,
+                        app_state.background_actions,
                         cx,
                     );
                     (app_state.initialize_workspace)(&mut workspace, &app_state, cx);
                     workspace
-                });
-                workspace
-            };
+                },
+            );
+            workspace
+        };
 
-            cx.activate_window(workspace.window_id());
-            cx.platform().activate(true);
+        cx.activate_window(workspace.window_id());
+        cx.platform().activate(true);
 
-            workspace.update(&mut cx, |workspace, cx| {
-                if let Some(room) = ActiveCall::global(cx).read(cx).room().cloned() {
-                    let follow_peer_id = room
-                        .read(cx)
-                        .remote_participants()
-                        .iter()
-                        .find(|(_, participant)| participant.user.id == follow_user_id)
-                        .map(|(_, p)| p.peer_id)
-                        .or_else(|| {
-                            // If we couldn't follow the given user, follow the host instead.
-                            let collaborator = workspace
-                                .project()
-                                .read(cx)
-                                .collaborators()
-                                .values()
-                                .find(|collaborator| collaborator.replica_id == 0)?;
-                            Some(collaborator.peer_id)
-                        });
+        workspace.update(&mut cx, |workspace, cx| {
+            if let Some(room) = ActiveCall::global(cx).read(cx).room().cloned() {
+                let follow_peer_id = room
+                    .read(cx)
+                    .remote_participants()
+                    .iter()
+                    .find(|(_, participant)| participant.user.id == follow_user_id)
+                    .map(|(_, p)| p.peer_id)
+                    .or_else(|| {
+                        // If we couldn't follow the given user, follow the host instead.
+                        let collaborator = workspace
+                            .project()
+                            .read(cx)
+                            .collaborators()
+                            .values()
+                            .find(|collaborator| collaborator.replica_id == 0)?;
+                        Some(collaborator.peer_id)
+                    });
 
-                    if let Some(follow_peer_id) = follow_peer_id {
-                        if !workspace.is_following(follow_peer_id) {
-                            workspace
-                                .toggle_follow(&ToggleFollow(follow_peer_id), cx)
-                                .map(|follow| follow.detach_and_log_err(cx));
-                        }
+                if let Some(follow_peer_id) = follow_peer_id {
+                    if !workspace.is_being_followed(follow_peer_id) {
+                        workspace
+                            .toggle_follow(&ToggleFollow(follow_peer_id), cx)
+                            .map(|follow| follow.detach_and_log_err(cx));
                     }
                 }
-            });
+            }
+        });
 
-            anyhow::Ok(())
-        })
-        .detach_and_log_err(cx);
-    });
+        anyhow::Ok(())
+    })
+    .detach_and_log_err(cx);
 }

crates/collab_ui/src/collaborator_list_popover.rs

@@ -0,0 +1,165 @@
+use call::ActiveCall;
+use client::UserStore;
+use gpui::Action;
+use gpui::{
+    actions, elements::*, Entity, ModelHandle, MouseButton, RenderContext, View, ViewContext,
+};
+use settings::Settings;
+
+use crate::collab_titlebar_item::ToggleCollaboratorList;
+
+pub(crate) enum Event {
+    Dismissed,
+}
+
+enum Collaborator {
+    SelfUser { username: String },
+    RemoteUser { username: String },
+}
+
+actions!(collaborator_list_popover, [NoOp]);
+
+pub(crate) struct CollaboratorListPopover {
+    list_state: ListState,
+}
+
+impl Entity for CollaboratorListPopover {
+    type Event = Event;
+}
+
+impl View for CollaboratorListPopover {
+    fn ui_name() -> &'static str {
+        "CollaboratorListPopover"
+    }
+
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
+        let theme = cx.global::<Settings>().theme.clone();
+
+        MouseEventHandler::<Self>::new(0, cx, |_, _| {
+            List::new(self.list_state.clone())
+                .contained()
+                .with_style(theme.contacts_popover.container) //TODO: Change the name of this theme key
+                .constrained()
+                .with_width(theme.contacts_popover.width)
+                .with_height(theme.contacts_popover.height)
+                .boxed()
+        })
+        .on_down_out(MouseButton::Left, move |_, cx| {
+            cx.dispatch_action(ToggleCollaboratorList);
+        })
+        .boxed()
+    }
+
+    fn focus_out(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
+        cx.emit(Event::Dismissed);
+    }
+}
+
+impl CollaboratorListPopover {
+    pub fn new(user_store: ModelHandle<UserStore>, cx: &mut ViewContext<Self>) -> Self {
+        let active_call = ActiveCall::global(cx);
+
+        let mut collaborators = user_store
+            .read(cx)
+            .current_user()
+            .map(|u| Collaborator::SelfUser {
+                username: u.github_login.clone(),
+            })
+            .into_iter()
+            .collect::<Vec<_>>();
+
+        //TODO: What should the canonical sort here look like, consult contacts list implementation
+        if let Some(room) = active_call.read(cx).room() {
+            for participant in room.read(cx).remote_participants() {
+                collaborators.push(Collaborator::RemoteUser {
+                    username: participant.1.user.github_login.clone(),
+                });
+            }
+        }
+
+        Self {
+            list_state: ListState::new(
+                collaborators.len(),
+                Orientation::Top,
+                0.,
+                cx,
+                move |_, index, cx| match &collaborators[index] {
+                    Collaborator::SelfUser { username } => render_collaborator_list_entry(
+                        index,
+                        username,
+                        None::<NoOp>,
+                        None,
+                        Svg::new("icons/chevron_right_12.svg"),
+                        NoOp,
+                        "Leave call".to_owned(),
+                        cx,
+                    ),
+
+                    Collaborator::RemoteUser { username } => render_collaborator_list_entry(
+                        index,
+                        username,
+                        Some(NoOp),
+                        Some(format!("Follow {username}")),
+                        Svg::new("icons/x_mark_12.svg"),
+                        NoOp,
+                        format!("Remove {username} from call"),
+                        cx,
+                    ),
+                },
+            ),
+        }
+    }
+}
+
+fn render_collaborator_list_entry<UA: Action + Clone, IA: Action + Clone>(
+    index: usize,
+    username: &str,
+    username_action: Option<UA>,
+    username_tooltip: Option<String>,
+    icon: Svg,
+    icon_action: IA,
+    icon_tooltip: String,
+    cx: &mut RenderContext<CollaboratorListPopover>,
+) -> ElementBox {
+    enum Username {}
+    enum UsernameTooltip {}
+    enum Icon {}
+    enum IconTooltip {}
+
+    let theme = &cx.global::<Settings>().theme;
+    let username_theme = theme.contact_list.contact_username.text.clone();
+    let tooltip_theme = theme.tooltip.clone();
+
+    let username = MouseEventHandler::<Username>::new(index, cx, |_, _| {
+        Label::new(username.to_owned(), username_theme.clone()).boxed()
+    })
+    .on_click(MouseButton::Left, move |_, cx| {
+        if let Some(username_action) = username_action.clone() {
+            cx.dispatch_action(username_action);
+        }
+    });
+
+    Flex::row()
+        .with_child(if let Some(username_tooltip) = username_tooltip {
+            username
+                .with_tooltip::<UsernameTooltip, _>(
+                    index,
+                    username_tooltip,
+                    None,
+                    tooltip_theme.clone(),
+                    cx,
+                )
+                .boxed()
+        } else {
+            username.boxed()
+        })
+        .with_child(
+            MouseEventHandler::<Icon>::new(index, cx, |_, _| icon.boxed())
+                .on_click(MouseButton::Left, move |_, cx| {
+                    cx.dispatch_action(icon_action.clone())
+                })
+                .with_tooltip::<IconTooltip, _>(index, icon_tooltip, None, tooltip_theme, cx)
+                .boxed(),
+        )
+        .boxed()
+}

crates/collab_ui/src/contact_finder.rs

@@ -1,7 +1,7 @@
 use client::{ContactRequestStatus, User, UserStore};
 use gpui::{
-    elements::*, AnyViewHandle, Entity, ModelHandle, MouseState, MutableAppContext, RenderContext,
-    Task, View, ViewContext, ViewHandle,
+    elements::*, AnyViewHandle, AppContext, Entity, ModelHandle, MouseState, MutableAppContext,
+    RenderContext, Task, View, ViewContext, ViewHandle,
 };
 use picker::{Picker, PickerDelegate};
 use settings::Settings;
@@ -68,7 +68,7 @@ impl PickerDelegate for ContactFinder {
                     this.potential_contacts = potential_contacts.into();
                     cx.notify();
                 });
-                Ok(())
+                anyhow::Ok(())
             }
             .log_err()
             .await;
@@ -128,7 +128,7 @@ impl PickerDelegate for ContactFinder {
             .style_for(mouse_state, selected);
         Flex::row()
             .with_children(user.avatar.clone().map(|avatar| {
-                Image::new(avatar)
+                Image::from_data(avatar)
                     .with_style(theme.contact_finder.contact_avatar)
                     .aligned()
                     .left()
@@ -178,4 +178,14 @@ impl ContactFinder {
             selected_index: 0,
         }
     }
+
+    pub fn editor_text(&self, cx: &AppContext) -> String {
+        self.picker.read(cx).query(cx)
+    }
+
+    pub fn with_editor_text(self, editor_text: String, cx: &mut ViewContext<Self>) -> Self {
+        self.picker
+            .update(cx, |picker, cx| picker.set_query(editor_text, cx));
+        self
+    }
 }

crates/collab_ui/src/contact_list.rs

@@ -1,39 +1,38 @@
-use std::{mem, sync::Arc};
-
+use super::collab_titlebar_item::LeaveCall;
 use crate::contacts_popover;
 use call::ActiveCall;
 use client::{proto::PeerId, Contact, User, UserStore};
 use editor::{Cancel, Editor};
+use futures::StreamExt;
 use fuzzy::{match_strings, StringMatchCandidate};
 use gpui::{
     elements::*,
     geometry::{rect::RectF, vector::vec2f},
     impl_actions, impl_internal_actions,
     keymap_matcher::KeymapContext,
-    AppContext, CursorStyle, Entity, ModelHandle, MouseButton, MutableAppContext, RenderContext,
-    Subscription, View, ViewContext, ViewHandle,
+    AppContext, CursorStyle, Entity, ModelHandle, MouseButton, MutableAppContext, PromptLevel,
+    RenderContext, Subscription, View, ViewContext, ViewHandle,
 };
 use menu::{Confirm, SelectNext, SelectPrev};
 use project::Project;
 use serde::Deserialize;
 use settings::Settings;
+use std::{mem, sync::Arc};
 use theme::IconButton;
-use util::ResultExt;
 use workspace::{JoinProject, OpenSharedScreen};
 
 impl_actions!(contact_list, [RemoveContact, RespondToContactRequest]);
-impl_internal_actions!(contact_list, [ToggleExpanded, Call, LeaveCall]);
+impl_internal_actions!(contact_list, [ToggleExpanded, Call]);
 
 pub fn init(cx: &mut MutableAppContext) {
     cx.add_action(ContactList::remove_contact);
     cx.add_action(ContactList::respond_to_contact_request);
-    cx.add_action(ContactList::clear_filter);
+    cx.add_action(ContactList::cancel);
     cx.add_action(ContactList::select_next);
     cx.add_action(ContactList::select_prev);
     cx.add_action(ContactList::confirm);
     cx.add_action(ContactList::toggle_expanded);
     cx.add_action(ContactList::call);
-    cx.add_action(ContactList::leave_call);
 }
 
 #[derive(Clone, PartialEq)]
@@ -45,9 +44,6 @@ struct Call {
     initial_project: Option<ModelHandle<Project>>,
 }
 
-#[derive(Copy, Clone, PartialEq)]
-struct LeaveCall;
-
 #[derive(Clone, Copy, PartialEq, Eq, Debug, PartialOrd, Ord)]
 enum Section {
     ActiveCall,
@@ -145,7 +141,10 @@ impl PartialEq for ContactEntry {
 pub struct RequestContact(pub u64);
 
 #[derive(Clone, Deserialize, PartialEq)]
-pub struct RemoveContact(pub u64);
+pub struct RemoveContact {
+    user_id: u64,
+    github_login: String,
+}
 
 #[derive(Clone, Deserialize, PartialEq)]
 pub struct RespondToContactRequest {
@@ -298,10 +297,42 @@ impl ContactList {
         this
     }
 
+    pub fn editor_text(&self, cx: &AppContext) -> String {
+        self.filter_editor.read(cx).text(cx)
+    }
+
+    pub fn with_editor_text(self, editor_text: String, cx: &mut ViewContext<Self>) -> Self {
+        self.filter_editor
+            .update(cx, |picker, cx| picker.set_text(editor_text, cx));
+        self
+    }
+
     fn remove_contact(&mut self, request: &RemoveContact, cx: &mut ViewContext<Self>) {
-        self.user_store
-            .update(cx, |store, cx| store.remove_contact(request.0, cx))
-            .detach();
+        let user_id = request.user_id;
+        let github_login = &request.github_login;
+        let user_store = self.user_store.clone();
+        let prompt_message = format!(
+            "Are you sure you want to remove \"{}\" from your contacts?",
+            github_login
+        );
+        let mut answer = cx.prompt(PromptLevel::Warning, &prompt_message, &["Remove", "Cancel"]);
+        let window_id = cx.window_id();
+        cx.spawn(|_, mut cx| async move {
+            if answer.next().await == Some(0) {
+                if let Err(e) = user_store
+                    .update(&mut cx, |store, cx| store.remove_contact(user_id, cx))
+                    .await
+                {
+                    cx.prompt(
+                        window_id,
+                        PromptLevel::Info,
+                        &format!("Failed to remove contact: {}", e),
+                        &["Ok"],
+                    );
+                }
+            }
+        })
+        .detach();
     }
 
     fn respond_to_contact_request(
@@ -316,7 +347,7 @@ impl ContactList {
             .detach();
     }
 
-    fn clear_filter(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) {
+    fn cancel(&mut self, _: &Cancel, cx: &mut ViewContext<Self>) {
         let did_clear = self.filter_editor.update(cx, |editor, cx| {
             if editor.buffer().read(cx).len(cx) > 0 {
                 editor.set_text("", cx);
@@ -325,6 +356,7 @@ impl ContactList {
                 false
             }
         });
+
         if !did_clear {
             cx.emit(Event::Dismissed);
         }
@@ -719,7 +751,7 @@ impl ContactList {
     ) -> ElementBox {
         Flex::row()
             .with_children(user.avatar.clone().map(|avatar| {
-                Image::new(avatar)
+                Image::from_data(avatar)
                     .with_style(theme.contact_avatar)
                     .aligned()
                     .left()
@@ -739,7 +771,7 @@ impl ContactList {
             )
             .with_children(if is_pending {
                 Some(
-                    Label::new("Calling".to_string(), theme.calling_indicator.text.clone())
+                    Label::new("Calling", theme.calling_indicator.text.clone())
                         .contained()
                         .with_style(theme.calling_indicator.container)
                         .aligned()
@@ -940,7 +972,7 @@ impl ContactList {
                             .boxed(),
                     )
                     .with_child(
-                        Label::new("Screen".into(), row.name.text.clone())
+                        Label::new("Screen", row.name.text.clone())
                             .aligned()
                             .left()
                             .contained()
@@ -970,6 +1002,7 @@ impl ContactList {
         cx: &mut RenderContext<Self>,
     ) -> ElementBox {
         enum Header {}
+        enum LeaveCallContactList {}
 
         let header_style = theme
             .header_row
@@ -982,9 +1015,9 @@ impl ContactList {
         };
         let leave_call = if section == Section::ActiveCall {
             Some(
-                MouseEventHandler::<LeaveCall>::new(0, cx, |state, _| {
+                MouseEventHandler::<LeaveCallContactList>::new(0, cx, |state, _| {
                     let style = theme.leave_call.style_for(state, false);
-                    Label::new("Leave Session".into(), style.text.clone())
+                    Label::new("Leave Call", style.text.clone())
                         .contained()
                         .with_style(style.container)
                         .boxed()
@@ -1016,7 +1049,7 @@ impl ContactList {
                     .boxed(),
                 )
                 .with_child(
-                    Label::new(text.to_string(), header_style.text.clone())
+                    Label::new(text, header_style.text.clone())
                         .aligned()
                         .left()
                         .contained()
@@ -1049,9 +1082,10 @@ impl ContactList {
         let online = contact.online;
         let busy = contact.busy || calling;
         let user_id = contact.user.id;
+        let github_login = contact.user.github_login.clone();
         let initial_project = project.clone();
         let mut element =
-            MouseEventHandler::<Contact>::new(contact.user.id as usize, cx, |_, _| {
+            MouseEventHandler::<Contact>::new(contact.user.id as usize, cx, |_, cx| {
                 Flex::row()
                     .with_children(contact.user.avatar.clone().map(|avatar| {
                         let status_badge = if contact.online {
@@ -1072,7 +1106,7 @@ impl ContactList {
                         };
                         Stack::new()
                             .with_child(
-                                Image::new(avatar)
+                                Image::from_data(avatar)
                                     .with_style(theme.contact_avatar)
                                     .aligned()
                                     .left()
@@ -1093,9 +1127,33 @@ impl ContactList {
                         .flex(1., true)
                         .boxed(),
                     )
+                    .with_child(
+                        MouseEventHandler::<Cancel>::new(
+                            contact.user.id as usize,
+                            cx,
+                            |mouse_state, _| {
+                                let button_style =
+                                    theme.contact_button.style_for(mouse_state, false);
+                                render_icon_button(button_style, "icons/x_mark_8.svg")
+                                    .aligned()
+                                    .flex_float()
+                                    .boxed()
+                            },
+                        )
+                        .with_padding(Padding::uniform(2.))
+                        .with_cursor_style(CursorStyle::PointingHand)
+                        .on_click(MouseButton::Left, move |_, cx| {
+                            cx.dispatch_action(RemoveContact {
+                                user_id,
+                                github_login: github_login.clone(),
+                            })
+                        })
+                        .flex_float()
+                        .boxed(),
+                    )
                     .with_children(if calling {
                         Some(
-                            Label::new("Calling".to_string(), theme.calling_indicator.text.clone())
+                            Label::new("Calling", theme.calling_indicator.text.clone())
                                 .contained()
                                 .with_style(theme.calling_indicator.container)
                                 .aligned()
@@ -1144,7 +1202,7 @@ impl ContactList {
 
         let mut row = Flex::row()
             .with_children(user.avatar.clone().map(|avatar| {
-                Image::new(avatar)
+                Image::from_data(avatar)
                     .with_style(theme.contact_avatar)
                     .aligned()
                     .left()
@@ -1164,6 +1222,7 @@ impl ContactList {
             );
 
         let user_id = user.id;
+        let github_login = user.github_login.clone();
         let is_contact_request_pending = user_store.read(cx).is_contact_request_pending(&user);
         let button_spacing = theme.contact_button_spacing;
 
@@ -1225,7 +1284,10 @@ impl ContactList {
                 .with_padding(Padding::uniform(2.))
                 .with_cursor_style(CursorStyle::PointingHand)
                 .on_click(MouseButton::Left, move |_, cx| {
-                    cx.dispatch_action(RemoveContact(user_id))
+                    cx.dispatch_action(RemoveContact {
+                        user_id,
+                        github_login: github_login.clone(),
+                    })
                 })
                 .flex_float()
                 .boxed(),
@@ -1252,12 +1314,6 @@ impl ContactList {
             })
             .detach_and_log_err(cx);
     }
-
-    fn leave_call(&mut self, _: &LeaveCall, cx: &mut ViewContext<Self>) {
-        ActiveCall::global(cx)
-            .update(cx, |call, cx| call.hang_up(cx))
-            .log_err();
-    }
 }
 
 impl Entity for ContactList {
@@ -1271,7 +1327,7 @@ impl View for ContactList {
 
     fn keymap_context(&self, _: &AppContext) -> KeymapContext {
         let mut cx = Self::default_keymap_context();
-        cx.set.insert("menu".into());
+        cx.add_identifier("menu");
         cx
     }
 
@@ -1303,7 +1359,7 @@ impl View for ContactList {
                         })
                         .with_tooltip::<AddContact, _>(
                             0,
-                            "Add contact".into(),
+                            "Search for new contact".into(),
                             None,
                             theme.tooltip.clone(),
                             cx,

crates/collab_ui/src/contact_notification.rs

@@ -48,7 +48,7 @@ impl View for ContactNotification {
             ContactEventKind::Requested => render_user_notification(
                 self.user.clone(),
                 "wants to add you as a contact",
-                Some("They won't know if you decline."),
+                Some("They won't be alerted if you decline."),
                 Dismiss(self.user.id),
                 vec![
                     (

crates/collab_ui/src/contacts_popover.rs

@@ -1,8 +1,8 @@
-use crate::{contact_finder::ContactFinder, contact_list::ContactList, ToggleCollaborationMenu};
+use crate::{contact_finder::ContactFinder, contact_list::ContactList, ToggleContactsMenu};
 use client::UserStore;
 use gpui::{
-    actions, elements::*, ClipboardItem, CursorStyle, Entity, ModelHandle, MouseButton,
-    MutableAppContext, RenderContext, View, ViewContext, ViewHandle,
+    actions, elements::*, Entity, ModelHandle, MouseButton, MutableAppContext, RenderContext, View,
+    ViewContext, ViewHandle,
 };
 use project::Project;
 use settings::Settings;
@@ -43,19 +43,23 @@ impl ContactsPopover {
             user_store,
             _subscription: None,
         };
-        this.show_contact_list(cx);
+        this.show_contact_list(String::new(), cx);
         this
     }
 
     fn toggle_contact_finder(&mut self, _: &ToggleContactFinder, cx: &mut ViewContext<Self>) {
         match &self.child {
-            Child::ContactList(_) => self.show_contact_finder(cx),
-            Child::ContactFinder(_) => self.show_contact_list(cx),
+            Child::ContactList(list) => self.show_contact_finder(list.read(cx).editor_text(cx), cx),
+            Child::ContactFinder(finder) => {
+                self.show_contact_list(finder.read(cx).editor_text(cx), cx)
+            }
         }
     }
 
-    fn show_contact_finder(&mut self, cx: &mut ViewContext<ContactsPopover>) {
-        let child = cx.add_view(|cx| ContactFinder::new(self.user_store.clone(), cx));
+    fn show_contact_finder(&mut self, editor_text: String, cx: &mut ViewContext<ContactsPopover>) {
+        let child = cx.add_view(|cx| {
+            ContactFinder::new(self.user_store.clone(), cx).with_editor_text(editor_text, cx)
+        });
         cx.focus(&child);
         self._subscription = Some(cx.subscribe(&child, |_, _, event, cx| match event {
             crate::contact_finder::Event::Dismissed => cx.emit(Event::Dismissed),
@@ -64,9 +68,11 @@ impl ContactsPopover {
         cx.notify();
     }
 
-    fn show_contact_list(&mut self, cx: &mut ViewContext<ContactsPopover>) {
-        let child =
-            cx.add_view(|cx| ContactList::new(self.project.clone(), self.user_store.clone(), cx));
+    fn show_contact_list(&mut self, editor_text: String, cx: &mut ViewContext<ContactsPopover>) {
+        let child = cx.add_view(|cx| {
+            ContactList::new(self.project.clone(), self.user_store.clone(), cx)
+                .with_editor_text(editor_text, cx)
+        });
         cx.focus(&child);
         self._subscription = Some(cx.subscribe(&child, |_, _, event, cx| match event {
             crate::contact_list::Event::Dismissed => cx.emit(Event::Dismissed),
@@ -92,61 +98,9 @@ impl View for ContactsPopover {
             Child::ContactFinder(child) => ChildView::new(child, cx),
         };
 
-        MouseEventHandler::<ContactsPopover>::new(0, cx, |_, cx| {
+        MouseEventHandler::<ContactsPopover>::new(0, cx, |_, _| {
             Flex::column()
                 .with_child(child.flex(1., true).boxed())
-                .with_children(
-                    self.user_store
-                        .read(cx)
-                        .invite_info()
-                        .cloned()
-                        .and_then(|info| {
-                            enum InviteLink {}
-
-                            if info.count > 0 {
-                                Some(
-                                    MouseEventHandler::<InviteLink>::new(0, cx, |state, cx| {
-                                        let style = theme
-                                            .contacts_popover
-                                            .invite_row
-                                            .style_for(state, false)
-                                            .clone();
-
-                                        let copied =
-                                            cx.read_from_clipboard().map_or(false, |item| {
-                                                item.text().as_str() == info.url.as_ref()
-                                            });
-
-                                        Label::new(
-                                            format!(
-                                                "{} invite link ({} left)",
-                                                if copied { "Copied" } else { "Copy" },
-                                                info.count
-                                            ),
-                                            style.label.clone(),
-                                        )
-                                        .aligned()
-                                        .left()
-                                        .constrained()
-                                        .with_height(theme.contacts_popover.invite_row_height)
-                                        .contained()
-                                        .with_style(style.container)
-                                        .boxed()
-                                    })
-                                    .with_cursor_style(CursorStyle::PointingHand)
-                                    .on_click(MouseButton::Left, move |_, cx| {
-                                        cx.write_to_clipboard(ClipboardItem::new(
-                                            info.url.to_string(),
-                                        ));
-                                        cx.notify();
-                                    })
-                                    .boxed(),
-                                )
-                            } else {
-                                None
-                            }
-                        }),
-                )
                 .contained()
                 .with_style(theme.contacts_popover.container)
                 .constrained()
@@ -155,7 +109,7 @@ impl View for ContactsPopover {
                 .boxed()
         })
         .on_down_out(MouseButton::Left, move |_, cx| {
-            cx.dispatch_action(ToggleCollaborationMenu);
+            cx.dispatch_action(ToggleContactsMenu);
         })
         .boxed()
     }

crates/collab_ui/src/face_pile.rs

@@ -0,0 +1,101 @@
+use std::ops::Range;
+
+use gpui::{
+    geometry::{
+        rect::RectF,
+        vector::{vec2f, Vector2F},
+    },
+    json::ToJson,
+    serde_json::{self, json},
+    Axis, DebugContext, Element, ElementBox, MeasurementContext, PaintContext,
+};
+
+pub(crate) struct FacePile {
+    overlap: f32,
+    faces: Vec<ElementBox>,
+}
+
+impl FacePile {
+    pub fn new(overlap: f32) -> FacePile {
+        FacePile {
+            overlap,
+            faces: Vec::new(),
+        }
+    }
+}
+
+impl Element for FacePile {
+    type LayoutState = ();
+    type PaintState = ();
+
+    fn layout(
+        &mut self,
+        constraint: gpui::SizeConstraint,
+        cx: &mut gpui::LayoutContext,
+    ) -> (Vector2F, Self::LayoutState) {
+        debug_assert!(constraint.max_along(Axis::Horizontal) == f32::INFINITY);
+
+        let mut width = 0.;
+        for face in &mut self.faces {
+            width += face.layout(constraint, cx).x();
+        }
+        width -= self.overlap * self.faces.len().saturating_sub(1) as f32;
+
+        (Vector2F::new(width, constraint.max.y()), ())
+    }
+
+    fn paint(
+        &mut self,
+        bounds: RectF,
+        visible_bounds: RectF,
+        _layout: &mut Self::LayoutState,
+        cx: &mut PaintContext,
+    ) -> Self::PaintState {
+        let visible_bounds = bounds.intersection(visible_bounds).unwrap_or_default();
+
+        let origin_y = bounds.upper_right().y();
+        let mut origin_x = bounds.upper_right().x();
+
+        for face in self.faces.iter_mut().rev() {
+            let size = face.size();
+            origin_x -= size.x();
+            cx.paint_layer(None, |cx| {
+                face.paint(vec2f(origin_x, origin_y), visible_bounds, cx);
+            });
+            origin_x += self.overlap;
+        }
+
+        ()
+    }
+
+    fn rect_for_text_range(
+        &self,
+        _: Range<usize>,
+        _: RectF,
+        _: RectF,
+        _: &Self::LayoutState,
+        _: &Self::PaintState,
+        _: &MeasurementContext,
+    ) -> Option<RectF> {
+        None
+    }
+
+    fn debug(
+        &self,
+        bounds: RectF,
+        _: &Self::LayoutState,
+        _: &Self::PaintState,
+        _: &DebugContext,
+    ) -> serde_json::Value {
+        json!({
+            "type": "FacePile",
+            "bounds": bounds.to_json()
+        })
+    }
+}
+
+impl Extend<ElementBox> for FacePile {
+    fn extend<T: IntoIterator<Item = ElementBox>>(&mut self, children: T) {
+        self.faces.extend(children);
+    }
+}

crates/collab_ui/src/incoming_call_notification.rs

@@ -32,11 +32,12 @@ pub fn init(cx: &mut MutableAppContext) {
                 });
 
                 for screen in cx.platform().screens() {
-                    let screen_size = screen.size();
+                    let screen_bounds = screen.bounds();
                     let (window_id, _) = cx.add_window(
                         WindowOptions {
                             bounds: WindowBounds::Fixed(RectF::new(
-                                vec2f(screen_size.x() - window_size.x() - PADDING, PADDING),
+                                screen_bounds.upper_right()
+                                    - vec2f(PADDING + window_size.x(), PADDING),
                                 window_size,
                             )),
                             titlebar: None,
@@ -48,6 +49,7 @@ pub fn init(cx: &mut MutableAppContext) {
                         },
                         |_| IncomingCallNotification::new(incoming_call.clone()),
                     );
+
                     notification_windows.push(window_id);
                 }
             }
@@ -106,7 +108,7 @@ impl IncomingCallNotification {
             .unwrap_or(&default_project);
         Flex::row()
             .with_children(self.call.calling_user.avatar.clone().map(|avatar| {
-                Image::new(avatar)
+                Image::from_data(avatar)
                     .with_style(theme.caller_avatar)
                     .aligned()
                     .boxed()
@@ -170,7 +172,7 @@ impl IncomingCallNotification {
             .with_child(
                 MouseEventHandler::<Accept>::new(0, cx, |_, cx| {
                     let theme = &cx.global::<Settings>().theme.incoming_call_notification;
-                    Label::new("Accept".to_string(), theme.accept_button.text.clone())
+                    Label::new("Accept", theme.accept_button.text.clone())
                         .aligned()
                         .contained()
                         .with_style(theme.accept_button.container)
@@ -186,7 +188,7 @@ impl IncomingCallNotification {
             .with_child(
                 MouseEventHandler::<Decline>::new(0, cx, |_, cx| {
                     let theme = &cx.global::<Settings>().theme.incoming_call_notification;
-                    Label::new("Decline".to_string(), theme.decline_button.text.clone())
+                    Label::new("Decline", theme.decline_button.text.clone())
                         .aligned()
                         .contained()
                         .with_style(theme.decline_button.container)
@@ -225,6 +227,7 @@ impl View for IncomingCallNotification {
             .theme
             .incoming_call_notification
             .background;
+
         Flex::row()
             .with_child(self.render_caller(cx))
             .with_child(self.render_buttons(cx))

crates/collab_ui/src/notifications.rs

@@ -11,8 +11,8 @@ enum Button {}
 
 pub fn render_user_notification<V: View, A: Action + Clone>(
     user: Arc<User>,
-    title: &str,
-    body: Option<&str>,
+    title: &'static str,
+    body: Option<&'static str>,
     dismiss_action: A,
     buttons: Vec<(&'static str, Box<dyn Action>)>,
     cx: &mut RenderContext<V>,
@@ -24,7 +24,7 @@ pub fn render_user_notification<V: View, A: Action + Clone>(
         .with_child(
             Flex::row()
                 .with_children(user.avatar.clone().map(|avatar| {
-                    Image::new(avatar)
+                    Image::from_data(avatar)
                         .with_style(theme.header_avatar)
                         .aligned()
                         .constrained()
@@ -83,7 +83,7 @@ pub fn render_user_notification<V: View, A: Action + Clone>(
                 .named("contact notification header"),
         )
         .with_children(body.map(|body| {
-            Label::new(body.to_string(), theme.body_message.text.clone())
+            Label::new(body, theme.body_message.text.clone())
                 .contained()
                 .with_style(theme.body_message.container)
                 .boxed()
@@ -97,7 +97,7 @@ pub fn render_user_notification<V: View, A: Action + Clone>(
                         |(ix, (message, action))| {
                             MouseEventHandler::<Button>::new(ix, cx, |state, _| {
                                 let button = theme.button.style_for(state, false);
-                                Label::new(message.to_string(), button.text.clone())
+                                Label::new(message, button.text.clone())
                                     .contained()
                                     .with_style(button.container)
                                     .boxed()

crates/collab_ui/src/project_shared_notification.rs

@@ -31,11 +31,11 @@ pub fn init(cx: &mut MutableAppContext) {
             let window_size = vec2f(theme.window_width, theme.window_height);
 
             for screen in cx.platform().screens() {
-                let screen_size = screen.size();
+                let screen_bounds = screen.bounds();
                 let (window_id, _) = cx.add_window(
                     WindowOptions {
                         bounds: WindowBounds::Fixed(RectF::new(
-                            vec2f(screen_size.x() - window_size.x() - PADDING, PADDING),
+                            screen_bounds.upper_right() - vec2f(PADDING + window_size.x(), PADDING),
                             window_size,
                         )),
                         titlebar: None,
@@ -108,7 +108,7 @@ impl ProjectSharedNotification {
         let theme = &cx.global::<Settings>().theme.project_shared_notification;
         Flex::row()
             .with_children(self.owner.avatar.clone().map(|avatar| {
-                Image::new(avatar)
+                Image::from_data(avatar)
                     .with_style(theme.owner_avatar)
                     .aligned()
                     .boxed()
@@ -175,7 +175,7 @@ impl ProjectSharedNotification {
             .with_child(
                 MouseEventHandler::<Open>::new(0, cx, |_, cx| {
                     let theme = &cx.global::<Settings>().theme.project_shared_notification;
-                    Label::new("Open".to_string(), theme.open_button.text.clone())
+                    Label::new("Open", theme.open_button.text.clone())
                         .aligned()
                         .contained()
                         .with_style(theme.open_button.container)
@@ -194,7 +194,7 @@ impl ProjectSharedNotification {
             .with_child(
                 MouseEventHandler::<Dismiss>::new(0, cx, |_, cx| {
                     let theme = &cx.global::<Settings>().theme.project_shared_notification;
-                    Label::new("Dismiss".to_string(), theme.dismiss_button.text.clone())
+                    Label::new("Dismiss", theme.dismiss_button.text.clone())
                         .aligned()
                         .contained()
                         .with_style(theme.dismiss_button.container)

crates/collab_ui/src/sharing_status_indicator.rs

@@ -0,0 +1,61 @@
+use call::ActiveCall;
+use gpui::{
+    color::Color,
+    elements::{MouseEventHandler, Svg},
+    Appearance, Element, ElementBox, Entity, MouseButton, MutableAppContext, RenderContext, View,
+};
+use settings::Settings;
+
+use crate::ToggleScreenSharing;
+
+pub fn init(cx: &mut MutableAppContext) {
+    let active_call = ActiveCall::global(cx);
+
+    let mut status_indicator = None;
+    cx.observe(&active_call, move |call, cx| {
+        if let Some(room) = call.read(cx).room() {
+            if room.read(cx).is_screen_sharing() {
+                if status_indicator.is_none() && cx.global::<Settings>().show_call_status_icon {
+                    status_indicator = Some(cx.add_status_bar_item(|_| SharingStatusIndicator));
+                }
+            } else if let Some((window_id, _)) = status_indicator.take() {
+                cx.remove_status_bar_item(window_id);
+            }
+        } else if let Some((window_id, _)) = status_indicator.take() {
+            cx.remove_status_bar_item(window_id);
+        }
+    })
+    .detach();
+}
+
+pub struct SharingStatusIndicator;
+
+impl Entity for SharingStatusIndicator {
+    type Event = ();
+}
+
+impl View for SharingStatusIndicator {
+    fn ui_name() -> &'static str {
+        "SharingStatusIndicator"
+    }
+
+    fn render(&mut self, cx: &mut RenderContext<'_, Self>) -> ElementBox {
+        let color = match cx.appearance {
+            Appearance::Light | Appearance::VibrantLight => Color::black(),
+            Appearance::Dark | Appearance::VibrantDark => Color::white(),
+        };
+
+        MouseEventHandler::<Self>::new(0, cx, |_, _| {
+            Svg::new("icons/disable_screen_sharing_12.svg")
+                .with_color(color)
+                .constrained()
+                .with_width(18.)
+                .aligned()
+                .boxed()
+        })
+        .on_click(MouseButton::Left, |_, cx| {
+            cx.dispatch_action(ToggleScreenSharing);
+        })
+        .boxed()
+    }
+}

crates/collections/Cargo.toml

@@ -2,6 +2,7 @@
 name = "collections"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/collections.rs"

crates/command_palette/Cargo.toml

@@ -2,6 +2,7 @@
 name = "command_palette"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/command_palette.rs"

crates/command_palette/src/command_palette.rs

@@ -65,7 +65,7 @@ impl CommandPalette {
                     action,
                     keystrokes: bindings
                         .iter()
-                        .filter_map(|binding| binding.keystrokes())
+                        .map(|binding| binding.keystrokes())
                         .last()
                         .map_or(Vec::new(), |keystrokes| keystrokes.to_vec()),
                 })
@@ -257,7 +257,7 @@ impl PickerDelegate for CommandPalette {
                         .filter_map(|(modifier, label)| {
                             if modifier {
                                 Some(
-                                    Label::new(label.into(), key_style.label.clone())
+                                    Label::new(label, key_style.label.clone())
                                         .contained()
                                         .with_style(key_style.container)
                                         .boxed(),
@@ -352,9 +352,7 @@ mod tests {
         });
 
         let project = Project::test(app_state.fs.clone(), [], cx).await;
-        let (_, workspace) = cx.add_window(|cx| {
-            Workspace::new(Default::default(), 0, project, |_, _| unimplemented!(), cx)
-        });
+        let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
         let editor = cx.add_view(&workspace, |cx| {
             let mut editor = Editor::single_line(None, cx);
             editor.set_text("abc", cx);

crates/context_menu/Cargo.toml

@@ -2,6 +2,7 @@
 name = "context_menu"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/context_menu.rs"

crates/context_menu/src/context_menu.rs

@@ -5,7 +5,9 @@ use gpui::{
 };
 use menu::*;
 use settings::Settings;
-use std::{any::TypeId, time::Duration};
+use std::{any::TypeId, borrow::Cow, time::Duration};
+
+pub type StaticItem = Box<dyn Fn(&mut MutableAppContext) -> ElementBox>;
 
 #[derive(Copy, Clone, PartialEq)]
 struct Clicked;
@@ -24,16 +26,17 @@ pub fn init(cx: &mut MutableAppContext) {
 
 pub enum ContextMenuItem {
     Item {
-        label: String,
+        label: Cow<'static, str>,
         action: Box<dyn Action>,
     },
+    Static(StaticItem),
     Separator,
 }
 
 impl ContextMenuItem {
-    pub fn item(label: impl ToString, action: impl 'static + Action) -> Self {
+    pub fn item(label: impl Into<Cow<'static, str>>, action: impl 'static + Action) -> Self {
         Self::Item {
-            label: label.to_string(),
+            label: label.into(),
             action: Box::new(action),
         }
     }
@@ -42,14 +45,14 @@ impl ContextMenuItem {
         Self::Separator
     }
 
-    fn is_separator(&self) -> bool {
-        matches!(self, Self::Separator)
+    fn is_action(&self) -> bool {
+        matches!(self, Self::Item { .. })
     }
 
     fn action_id(&self) -> Option<TypeId> {
         match self {
             ContextMenuItem::Item { action, .. } => Some(action.id()),
-            ContextMenuItem::Separator => None,
+            ContextMenuItem::Static(..) | ContextMenuItem::Separator => None,
         }
     }
 }
@@ -58,11 +61,13 @@ pub struct ContextMenu {
     show_count: usize,
     anchor_position: Vector2F,
     anchor_corner: AnchorCorner,
+    position_mode: OverlayPositionMode,
     items: Vec<ContextMenuItem>,
     selected_index: Option<usize>,
     visible: bool,
     previously_focused_view_id: Option<usize>,
     clicked: bool,
+    parent_view_id: usize,
     _actions_observation: Subscription,
 }
 
@@ -77,7 +82,7 @@ impl View for ContextMenu {
 
     fn keymap_context(&self, _: &AppContext) -> KeymapContext {
         let mut cx = Self::default_keymap_context();
-        cx.set.insert("menu".into());
+        cx.add_identifier("menu");
         cx
     }
 
@@ -104,6 +109,7 @@ impl View for ContextMenu {
             .with_fit_mode(OverlayFitMode::SnapToWindow)
             .with_anchor_position(self.anchor_position)
             .with_anchor_corner(self.anchor_corner)
+            .with_position_mode(self.position_mode)
             .boxed()
     }
 
@@ -114,15 +120,19 @@ impl View for ContextMenu {
 
 impl ContextMenu {
     pub fn new(cx: &mut ViewContext<Self>) -> Self {
+        let parent_view_id = cx.parent().unwrap();
+
         Self {
             show_count: 0,
             anchor_position: Default::default(),
             anchor_corner: AnchorCorner::TopLeft,
+            position_mode: OverlayPositionMode::Window,
             items: Default::default(),
             selected_index: Default::default(),
             visible: Default::default(),
             previously_focused_view_id: Default::default(),
             clicked: false,
+            parent_view_id,
             _actions_observation: cx.observe_actions(Self::action_dispatched),
         }
     }
@@ -184,13 +194,13 @@ impl ContextMenu {
     }
 
     fn select_first(&mut self, _: &SelectFirst, cx: &mut ViewContext<Self>) {
-        self.selected_index = self.items.iter().position(|item| !item.is_separator());
+        self.selected_index = self.items.iter().position(|item| item.is_action());
         cx.notify();
     }
 
     fn select_last(&mut self, _: &SelectLast, cx: &mut ViewContext<Self>) {
         for (ix, item) in self.items.iter().enumerate().rev() {
-            if !item.is_separator() {
+            if item.is_action() {
                 self.selected_index = Some(ix);
                 cx.notify();
                 break;
@@ -201,7 +211,7 @@ impl ContextMenu {
     fn select_next(&mut self, _: &SelectNext, cx: &mut ViewContext<Self>) {
         if let Some(ix) = self.selected_index {
             for (ix, item) in self.items.iter().enumerate().skip(ix + 1) {
-                if !item.is_separator() {
+                if item.is_action() {
                     self.selected_index = Some(ix);
                     cx.notify();
                     break;
@@ -215,7 +225,7 @@ impl ContextMenu {
     fn select_prev(&mut self, _: &SelectPrev, cx: &mut ViewContext<Self>) {
         if let Some(ix) = self.selected_index {
             for (ix, item) in self.items.iter().enumerate().take(ix).rev() {
-                if !item.is_separator() {
+                if item.is_action() {
                     self.selected_index = Some(ix);
                     cx.notify();
                     break;
@@ -230,7 +240,7 @@ impl ContextMenu {
         &mut self,
         anchor_position: Vector2F,
         anchor_corner: AnchorCorner,
-        items: impl IntoIterator<Item = ContextMenuItem>,
+        items: Vec<ContextMenuItem>,
         cx: &mut ViewContext<Self>,
     ) {
         let mut items = items.into_iter().peekable();
@@ -250,7 +260,12 @@ impl ContextMenu {
         cx.notify();
     }
 
+    pub fn set_position_mode(&mut self, mode: OverlayPositionMode) {
+        self.position_mode = mode;
+    }
+
     fn render_menu_for_measurement(&self, cx: &mut RenderContext<Self>) -> impl Element {
+        let window_id = cx.window_id();
         let style = cx.global::<Settings>().theme.context_menu.clone();
         Flex::row()
             .with_child(
@@ -268,6 +283,9 @@ impl ContextMenu {
                                     .with_style(style.container)
                                     .boxed()
                             }
+
+                            ContextMenuItem::Static(f) => f(cx),
+
                             ContextMenuItem::Separator => Empty::new()
                                 .collapsed()
                                 .contained()
@@ -289,12 +307,17 @@ impl ContextMenu {
                                     Some(ix) == self.selected_index,
                                 );
                                 KeystrokeLabel::new(
+                                    window_id,
+                                    self.parent_view_id,
                                     action.boxed_clone(),
                                     style.keystroke.container,
                                     style.keystroke.text.clone(),
                                 )
                                 .boxed()
                             }
+
+                            ContextMenuItem::Static(_) => Empty::new().boxed(),
+
                             ContextMenuItem::Separator => Empty::new()
                                 .collapsed()
                                 .constrained()
@@ -318,6 +341,7 @@ impl ContextMenu {
 
         let style = cx.global::<Settings>().theme.context_menu.clone();
 
+        let window_id = cx.window_id();
         MouseEventHandler::<Menu>::new(0, cx, |_, cx| {
             Flex::column()
                 .with_children(self.items.iter().enumerate().map(|(ix, item)| {
@@ -331,12 +355,14 @@ impl ContextMenu {
 
                                 Flex::row()
                                     .with_child(
-                                        Label::new(label.to_string(), style.label.clone())
+                                        Label::new(label.clone(), style.label.clone())
                                             .contained()
                                             .boxed(),
                                     )
                                     .with_child({
                                         KeystrokeLabel::new(
+                                            window_id,
+                                            self.parent_view_id,
                                             action.boxed_clone(),
                                             style.keystroke.container,
                                             style.keystroke.text.clone(),
@@ -356,6 +382,9 @@ impl ContextMenu {
                             .on_drag(MouseButton::Left, |_, _| {})
                             .boxed()
                         }
+
+                        ContextMenuItem::Static(f) => f(cx),
+
                         ContextMenuItem::Separator => Empty::new()
                             .constrained()
                             .with_height(1.)

crates/db/Cargo.toml

@@ -2,6 +2,7 @@
 name = "db"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/db.rs"
@@ -23,6 +24,7 @@ lazy_static = "1.4.0"
 log = { version = "0.4.16", features = ["kv_unstable_serde"] }
 parking_lot = "0.11.1"
 serde = { version = "1.0", features = ["derive"] }
+serde_derive = { version = "1.0", features = ["deserialize_in_place"] }
 smol = "1.2"
 
 [dev-dependencies]

crates/db/src/db.rs

@@ -4,6 +4,7 @@ pub mod query;
 // Re-export
 pub use anyhow;
 use anyhow::Context;
+use gpui::MutableAppContext;
 pub use indoc::indoc;
 pub use lazy_static;
 use parking_lot::{Mutex, RwLock};
@@ -17,6 +18,7 @@ use sqlez::domain::Migrator;
 use sqlez::thread_safe_connection::ThreadSafeConnection;
 use sqlez_macros::sql;
 use std::fs::create_dir_all;
+use std::future::Future;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicBool, Ordering};
 use std::time::{SystemTime, UNIX_EPOCH};
@@ -39,6 +41,7 @@ const FALLBACK_DB_NAME: &'static str = "FALLBACK_MEMORY_DB";
 const DB_FILE_NAME: &'static str = "db.sqlite";
 
 lazy_static::lazy_static! {
+    // !!!!!!! CHANGE BACK TO DEFAULT FALSE BEFORE SHIPPING
     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);
@@ -63,11 +66,11 @@ pub async fn open_db<M: Migrator + 'static>(
     let connection = async_iife!({
         // Note: This still has a race condition where 1 set of migrations succeeds
         // (e.g. (Workspace, Editor)) and another fails (e.g. (Workspace, Terminal))
-        // This will cause the first connection to have the database taken out 
+        // This will cause the first connection to have the database taken out
         // from under it. This *should* be fine though. The second dabatase failure will
         // cause errors in the log and so should be observed by developers while writing
         // soon-to-be good migrations. If user databases are corrupted, we toss them out
-        // and try again from a blank. As long as running all migrations from start to end 
+        // and try again from a blank. As long as running all migrations from start to end
         // on a blank database is ok, this race condition will never be triggered.
         //
         // Basically: Don't ever push invalid migrations to stable or everyone will have
@@ -85,7 +88,7 @@ pub async fn open_db<M: Migrator + 'static>(
             };
         }
 
-        // Take a lock in the failure case so that we move the db once per process instead 
+        // 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
         let _lock = DB_FILE_OPERATIONS.lock();
@@ -236,6 +239,15 @@ macro_rules! define_connection {
     };
 }
 
+pub fn write_and_log<F>(cx: &mut MutableAppContext, db_write: impl FnOnce() -> F + Send + 'static)
+where
+    F: Future<Output = anyhow::Result<()>> + Send,
+{
+    cx.background()
+        .spawn(async move { db_write().await.log_err() })
+        .detach()
+}
+
 #[cfg(test)]
 mod tests {
     use std::{fs, thread};

crates/diagnostics/Cargo.toml

@@ -2,6 +2,7 @@
 name = "diagnostics"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/diagnostics.rs"

crates/diagnostics/src/diagnostics.rs

@@ -90,14 +90,11 @@ impl View for ProjectDiagnosticsEditor {
     fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
         if self.path_states.is_empty() {
             let theme = &cx.global::<Settings>().theme.project_diagnostics;
-            Label::new(
-                "No problems in workspace".to_string(),
-                theme.empty_message.clone(),
-            )
-            .aligned()
-            .contained()
-            .with_style(theme.container)
-            .boxed()
+            Label::new("No problems in workspace", theme.empty_message.clone())
+                .aligned()
+                .contained()
+                .with_style(theme.container)
+                .boxed()
         } else {
             ChildView::new(&self.editor, cx).boxed()
         }
@@ -521,12 +518,8 @@ impl Item for ProjectDiagnosticsEditor {
         )
     }
 
-    fn project_path(&self, _: &AppContext) -> Option<project::ProjectPath> {
-        None
-    }
-
-    fn project_entry_ids(&self, cx: &AppContext) -> SmallVec<[project::ProjectEntryId; 3]> {
-        self.editor.project_entry_ids(cx)
+    fn for_each_project_item(&self, cx: &AppContext, f: &mut dyn FnMut(usize, &dyn project::Item)) {
+        self.editor.for_each_project_item(cx, f)
     }
 
     fn is_singleton(&self, _: &AppContext) -> bool {
@@ -584,7 +577,7 @@ impl Item for ProjectDiagnosticsEditor {
             .update(cx, |editor, cx| editor.git_diff_recalc(project, cx))
     }
 
-    fn to_item_events(event: &Self::Event) -> Vec<ItemEvent> {
+    fn to_item_events(event: &Self::Event) -> SmallVec<[ItemEvent; 2]> {
         Editor::to_item_events(event)
     }
 
@@ -701,7 +694,7 @@ pub(crate) fn render_summary(
     theme: &theme::ProjectDiagnostics,
 ) -> ElementBox {
     if summary.error_count == 0 && summary.warning_count == 0 {
-        Label::new("No problems".to_string(), text_style.clone()).boxed()
+        Label::new("No problems", text_style.clone()).boxed()
     } else {
         let icon_width = theme.tab_icon_width;
         let icon_spacing = theme.tab_icon_spacing;
@@ -812,15 +805,7 @@ mod tests {
             .await;
 
         let project = Project::test(app_state.fs.clone(), ["/test".as_ref()], cx).await;
-        let (_, workspace) = cx.add_window(|cx| {
-            Workspace::new(
-                Default::default(),
-                0,
-                project.clone(),
-                |_, _| unimplemented!(),
-                cx,
-            )
-        });
+        let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
 
         // Create some diagnostics
         project.update(cx, |project, cx| {

crates/diagnostics/src/items.rs

@@ -178,14 +178,11 @@ impl View for DiagnosticIndicator {
 
         if in_progress {
             element.add_child(
-                Label::new(
-                    "Checking…".into(),
-                    style.diagnostic_message.default.text.clone(),
-                )
-                .aligned()
-                .contained()
-                .with_margin_left(item_spacing)
-                .boxed(),
+                Label::new("Checking…", style.diagnostic_message.default.text.clone())
+                    .aligned()
+                    .contained()
+                    .with_margin_left(item_spacing)
+                    .boxed(),
             );
         } else if let Some(diagnostic) = &self.current_diagnostic {
             let message_style = style.diagnostic_message.clone();

crates/drag_and_drop/Cargo.toml

@@ -2,6 +2,7 @@
 name = "drag_and_drop"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/drag_and_drop.rs"

crates/editor/Cargo.toml

@@ -2,6 +2,7 @@
 name = "editor"
 version = "0.1.0"
 edition = "2021"
+publish = false
 
 [lib]
 path = "src/editor.rs"
@@ -16,7 +17,8 @@ test-support = [
     "project/test-support",
     "util/test-support",
     "workspace/test-support",
-    "tree-sitter-rust"
+    "tree-sitter-rust",
+    "tree-sitter-typescript"
 ]
 
 [dependencies]
@@ -52,11 +54,13 @@ parking_lot = "0.11"
 postage = { version = "0.4", features = ["futures-traits"] }
 rand = { version = "0.8.3", optional = true }
 serde = { workspace = true }
+serde_derive = { version = "1.0", features = ["deserialize_in_place"] }
 smallvec = { version = "1.6", features = ["union"] }
 smol = "1.2"
 tree-sitter-rust = { version = "*", optional = true }
 tree-sitter-html = { version = "*", optional = true }
 tree-sitter-javascript = { version = "*", optional = true }
+tree-sitter-typescript = { git = "https://github.com/tree-sitter/tree-sitter-typescript", rev = "5d20856f34315b068c41edaee2ac8a100081d259", optional = true }
 
 [dev-dependencies]
 text = { path = "../text", features = ["test-support"] }
@@ -74,4 +78,5 @@ unindent = "0.1.7"
 tree-sitter = "0.20"
 tree-sitter-rust = "0.20"
 tree-sitter-html = "0.19"
+tree-sitter-typescript = { git = "https://github.com/tree-sitter/tree-sitter-typescript", rev = "5d20856f34315b068c41edaee2ac8a100081d259" }
 tree-sitter-javascript = "0.20"

crates/editor/src/display_map.rs

@@ -1,21 +1,25 @@
 mod block_map;
 mod fold_map;
+mod suggestion_map;
 mod tab_map;
 mod wrap_map;
 
 use crate::{Anchor, AnchorRangeExt, MultiBuffer, MultiBufferSnapshot, ToOffset, ToPoint};
-use block_map::{BlockMap, BlockPoint};
+pub use block_map::{BlockMap, BlockPoint};
 use collections::{HashMap, HashSet};
 use fold_map::FoldMap;
 use gpui::{
+    color::Color,
     fonts::{FontId, HighlightStyle},
     Entity, ModelContext, ModelHandle,
 };
 use language::{OffsetUtf16, Point, Subscription as BufferSubscription};
 use settings::Settings;
 use std::{any::TypeId, fmt::Debug, num::NonZeroU32, ops::Range, sync::Arc};
+pub use suggestion_map::Suggestion;
+use suggestion_map::SuggestionMap;
 use sum_tree::{Bias, TreeMap};
-use tab_map::TabMap;
+use tab_map::{TabMap, TabSnapshot};
 use wrap_map::WrapMap;
 
 pub use block_map::{
@@ -23,6 +27,12 @@ pub use block_map::{
     BlockDisposition, BlockId, BlockProperties, BlockStyle, RenderBlock, TransformBlock,
 };
 
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum FoldStatus {
+    Folded,
+    Foldable,
+}
+
 pub trait ToDisplayPoint {
     fn to_display_point(&self, map: &DisplaySnapshot) -> DisplayPoint;
 }
@@ -33,6 +43,7 @@ pub struct DisplayMap {
     buffer: ModelHandle<MultiBuffer>,
     buffer_subscription: BufferSubscription,
     fold_map: FoldMap,
+    suggestion_map: SuggestionMap,
     tab_map: TabMap,
     wrap_map: ModelHandle<WrapMap>,
     block_map: BlockMap,
@@ -58,6 +69,7 @@ impl DisplayMap {
 
         let tab_size = Self::tab_size(&buffer, cx);
         let (fold_map, snapshot) = FoldMap::new(buffer.read(cx).snapshot(cx));
+        let (suggestion_map, snapshot) = SuggestionMap::new(snapshot);
         let (tab_map, snapshot) = TabMap::new(snapshot, tab_size);
         let (wrap_map, snapshot) = WrapMap::new(snapshot, font_id, font_size, wrap_width, cx);
         let block_map = BlockMap::new(snapshot, buffer_header_height, excerpt_header_height);
@@ -66,6 +78,7 @@ impl DisplayMap {
             buffer,
             buffer_subscription,
             fold_map,
+            suggestion_map,
             tab_map,
             wrap_map,
             block_map,
@@ -77,21 +90,25 @@ impl DisplayMap {
     pub fn snapshot(&self, cx: &mut ModelContext<Self>) -> DisplaySnapshot {
         let buffer_snapshot = self.buffer.read(cx).snapshot(cx);
         let edits = self.buffer_subscription.consume().into_inner();
-        let (folds_snapshot, edits) = self.fold_map.read(buffer_snapshot, edits);
+        let (fold_snapshot, edits) = self.fold_map.read(buffer_snapshot, edits);
+        let (suggestion_snapshot, edits) = self.suggestion_map.sync(fold_snapshot.clone(), edits);
 
         let tab_size = Self::tab_size(&self.buffer, cx);
-        let (tabs_snapshot, edits) = self.tab_map.sync(folds_snapshot.clone(), edits, tab_size);
-        let (wraps_snapshot, edits) = self
+        let (tab_snapshot, edits) = self
+            .tab_map
+            .sync(suggestion_snapshot.clone(), edits, tab_size);
+        let (wrap_snapshot, edits) = self
             .wrap_map
-            .update(cx, |map, cx| map.sync(tabs_snapshot.clone(), edits, cx));
-        let blocks_snapshot = self.block_map.read(wraps_snapshot.clone(), edits);
+            .update(cx, |map, cx| map.sync(tab_snapshot.clone(), edits, cx));
+        let block_snapshot = self.block_map.read(wrap_snapshot.clone(), edits);
 
         DisplaySnapshot {
             buffer_snapshot: self.buffer.read(cx).snapshot(cx),
-            folds_snapshot,
-            tabs_snapshot,
-            wraps_snapshot,
-            blocks_snapshot,
+            fold_snapshot,
+            suggestion_snapshot,
+            tab_snapshot,
+            wrap_snapshot,
+            block_snapshot,
             text_highlights: self.text_highlights.clone(),
             clip_at_line_ends: self.clip_at_line_ends,
         }
@@ -115,12 +132,14 @@ impl DisplayMap {
         let edits = self.buffer_subscription.consume().into_inner();
         let tab_size = Self::tab_size(&self.buffer, cx);
         let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits);
+        let (snapshot, edits) = self.suggestion_map.sync(snapshot, edits);
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
         let (snapshot, edits) = self
             .wrap_map
             .update(cx, |map, cx| map.sync(snapshot, edits, cx));
         self.block_map.read(snapshot, edits);
         let (snapshot, edits) = fold_map.fold(ranges);
+        let (snapshot, edits) = self.suggestion_map.sync(snapshot, edits);
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
         let (snapshot, edits) = self
             .wrap_map
@@ -138,12 +157,14 @@ impl DisplayMap {
         let edits = self.buffer_subscription.consume().into_inner();
         let tab_size = Self::tab_size(&self.buffer, cx);
         let (mut fold_map, snapshot, edits) = self.fold_map.write(snapshot, edits);
+        let (snapshot, edits) = self.suggestion_map.sync(snapshot, edits);
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
         let (snapshot, edits) = self
             .wrap_map
             .update(cx, |map, cx| map.sync(snapshot, edits, cx));
         self.block_map.read(snapshot, edits);
         let (snapshot, edits) = fold_map.unfold(ranges, inclusive);
+        let (snapshot, edits) = self.suggestion_map.sync(snapshot, edits);
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
         let (snapshot, edits) = self
             .wrap_map
@@ -160,6 +181,7 @@ impl DisplayMap {
         let edits = self.buffer_subscription.consume().into_inner();
         let tab_size = Self::tab_size(&self.buffer, cx);
         let (snapshot, edits) = self.fold_map.read(snapshot, edits);
+        let (snapshot, edits) = self.suggestion_map.sync(snapshot, edits);
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
         let (snapshot, edits) = self
             .wrap_map
@@ -177,6 +199,7 @@ impl DisplayMap {
         let edits = self.buffer_subscription.consume().into_inner();
         let tab_size = Self::tab_size(&self.buffer, cx);
         let (snapshot, edits) = self.fold_map.read(snapshot, edits);
+        let (snapshot, edits) = self.suggestion_map.sync(snapshot, edits);
         let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
         let (snapshot, edits) = self
             .wrap_map
@@ -207,11 +230,34 @@ impl DisplayMap {
         self.text_highlights.remove(&Some(type_id))
     }
 
+    pub fn replace_suggestion<T>(
+        &self,
+        new_suggestion: Option<Suggestion<T>>,
+        cx: &mut ModelContext<Self>,
+    ) where
+        T: ToPoint,
+    {
+        let snapshot = self.buffer.read(cx).snapshot(cx);
+        let edits = self.buffer_subscription.consume().into_inner();
+        let tab_size = Self::tab_size(&self.buffer, cx);
+        let (snapshot, edits) = self.fold_map.read(snapshot, edits);
+        let (snapshot, edits) = self.suggestion_map.replace(new_suggestion, snapshot, edits);
+        let (snapshot, edits) = self.tab_map.sync(snapshot, edits, tab_size);
+        let (snapshot, edits) = self
+            .wrap_map
+            .update(cx, |map, cx| map.sync(snapshot, edits, cx));
+        self.block_map.read(snapshot, edits);
+    }
+
     pub fn set_font(&self, font_id: FontId, font_size: f32, cx: &mut ModelContext<Self>) -> bool {
         self.wrap_map
             .update(cx, |map, cx| map.set_font(font_id, font_size, cx))
     }
 
+    pub fn set_fold_ellipses_color(&mut self, color: Color) -> bool {
+        self.fold_map.set_ellipses_color(color)
+    }
+
     pub fn set_wrap_width(&self, width: Option<f32>, cx: &mut ModelContext<Self>) -> bool {
         self.wrap_map
             .update(cx, |map, cx| map.set_wrap_width(width, cx))
@@ -235,10 +281,11 @@ impl DisplayMap {
 
 pub struct DisplaySnapshot {
     pub buffer_snapshot: MultiBufferSnapshot,
-    folds_snapshot: fold_map::FoldSnapshot,
-    tabs_snapshot: tab_map::TabSnapshot,
-    wraps_snapshot: wrap_map::WrapSnapshot,
-    blocks_snapshot: block_map::BlockSnapshot,
+    fold_snapshot: fold_map::FoldSnapshot,
+    suggestion_snapshot: suggestion_map::SuggestionSnapshot,
+    tab_snapshot: tab_map::TabSnapshot,
+    wrap_snapshot: wrap_map::WrapSnapshot,
+    block_snapshot: block_map::BlockSnapshot,
     text_highlights: TextHighlights,
     clip_at_line_ends: bool,
 }
@@ -246,7 +293,7 @@ pub struct DisplaySnapshot {
 impl DisplaySnapshot {
     #[cfg(test)]
     pub fn fold_count(&self) -> usize {
-        self.folds_snapshot.fold_count()
+        self.fold_snapshot.fold_count()
     }
 
     pub fn is_empty(&self) -> bool {
@@ -254,7 +301,7 @@ impl DisplaySnapshot {
     }
 
     pub fn buffer_rows(&self, start_row: u32) -> DisplayBufferRows {
-        self.blocks_snapshot.buffer_rows(start_row)
+        self.block_snapshot.buffer_rows(start_row)
     }
 
     pub fn max_buffer_row(&self) -> u32 {
@@ -263,9 +310,9 @@ impl DisplaySnapshot {
 
     pub fn prev_line_boundary(&self, mut point: Point) -> (Point, DisplayPoint) {
         loop {
-            let mut fold_point = self.folds_snapshot.to_fold_point(point, Bias::Left);
+            let mut fold_point = self.fold_snapshot.to_fold_point(point, Bias::Left);
             *fold_point.column_mut() = 0;
-            point = fold_point.to_buffer_point(&self.folds_snapshot);
+            point = fold_point.to_buffer_point(&self.fold_snapshot);
 
             let mut display_point = self.point_to_display_point(point, Bias::Left);
             *display_point.column_mut() = 0;
@@ -279,9 +326,9 @@ impl DisplaySnapshot {
 
     pub fn next_line_boundary(&self, mut point: Point) -> (Point, DisplayPoint) {
         loop {
-            let mut fold_point = self.folds_snapshot.to_fold_point(point, Bias::Right);
-            *fold_point.column_mut() = self.folds_snapshot.line_len(fold_point.row());
-            point = fold_point.to_buffer_point(&self.folds_snapshot);
+            let mut fold_point = self.fold_snapshot.to_fold_point(point, Bias::Right);
+            *fold_point.column_mut() = self.fold_snapshot.line_len(fold_point.row());
+            point = fold_point.to_buffer_point(&self.fold_snapshot);
 
             let mut display_point = self.point_to_display_point(point, Bias::Right);
             *display_point.column_mut() = self.line_len(display_point.row());
@@ -311,36 +358,38 @@ impl DisplaySnapshot {
     }
 
     fn point_to_display_point(&self, point: Point, bias: Bias) -> DisplayPoint {
-        let fold_point = self.folds_snapshot.to_fold_point(point, bias);
-        let tab_point = self.tabs_snapshot.to_tab_point(fold_point);
-        let wrap_point = self.wraps_snapshot.tab_point_to_wrap_point(tab_point);
-        let block_point = self.blocks_snapshot.to_block_point(wrap_point);
+        let fold_point = self.fold_snapshot.to_fold_point(point, bias);
+        let suggestion_point = self.suggestion_snapshot.to_suggestion_point(fold_point);
+        let tab_point = self.tab_snapshot.to_tab_point(suggestion_point);
+        let wrap_point = self.wrap_snapshot.tab_point_to_wrap_point(tab_point);
+        let block_point = self.block_snapshot.to_block_point(wrap_point);
         DisplayPoint(block_point)
     }
 
     fn display_point_to_point(&self, point: DisplayPoint, bias: Bias) -> Point {
         let block_point = point.0;
-        let wrap_point = self.blocks_snapshot.to_wrap_point(block_point);
-        let tab_point = self.wraps_snapshot.to_tab_point(wrap_point);
-        let fold_point = self.tabs_snapshot.to_fold_point(tab_point, bias).0;
-        fold_point.to_buffer_point(&self.folds_snapshot)
+        let wrap_point = self.block_snapshot.to_wrap_point(block_point);
+        let tab_point = self.wrap_snapshot.to_tab_point(wrap_point);
+        let suggestion_point = self.tab_snapshot.to_suggestion_point(tab_point, bias).0;
+        let fold_point = self.suggestion_snapshot.to_fold_point(suggestion_point);
+        fold_point.to_buffer_point(&self.fold_snapshot)
     }
 
     pub fn max_point(&self) -> DisplayPoint {
-        DisplayPoint(self.blocks_snapshot.max_point())
+        DisplayPoint(self.block_snapshot.max_point())
     }
 
     /// Returns text chunks starting at the given display row until the end of the file
     pub fn text_chunks(&self, display_row: u32) -> impl Iterator<Item = &str> {
-        self.blocks_snapshot
+        self.block_snapshot
             .chunks(display_row..self.max_point().row() + 1, false, None)
             .map(|h| h.text)
     }
 
-    // Returns text chunks starting at the end of the given display row in reverse until the start of the file
+    /// Returns text chunks starting at the end of the given display row in reverse until the start of the file
     pub fn reverse_text_chunks(&self, display_row: u32) -> impl Iterator<Item = &str> {
         (0..=display_row).into_iter().rev().flat_map(|row| {
-            self.blocks_snapshot
+            self.block_snapshot
                 .chunks(row..row + 1, false, None)
                 .map(|h| h.text)
                 .collect::<Vec<_>>()
@@ -350,7 +399,7 @@ impl DisplaySnapshot {
     }
 
     pub fn chunks(&self, display_rows: Range<u32>, language_aware: bool) -> DisplayChunks<'_> {
-        self.blocks_snapshot
+        self.block_snapshot
             .chunks(display_rows, language_aware, Some(&self.text_highlights))
     }
 
@@ -358,7 +407,7 @@ impl DisplaySnapshot {
         &self,
         mut point: DisplayPoint,
     ) -> impl Iterator<Item = (char, DisplayPoint)> + '_ {
-        point = DisplayPoint(self.blocks_snapshot.clip_point(point.0, Bias::Left));
+        point = DisplayPoint(self.block_snapshot.clip_point(point.0, Bias::Left));
         self.text_chunks(point.row())
             .flat_map(str::chars)
             .skip_while({
@@ -385,7 +434,7 @@ impl DisplaySnapshot {
         &self,
         mut point: DisplayPoint,
     ) -> impl Iterator<Item = (char, DisplayPoint)> + '_ {
-        point = DisplayPoint(self.blocks_snapshot.clip_point(point.0, Bias::Left));
+        point = DisplayPoint(self.block_snapshot.clip_point(point.0, Bias::Left));
         self.reverse_text_chunks(point.row())
             .flat_map(|chunk| chunk.chars().rev())
             .skip_while({
@@ -411,6 +460,67 @@ impl DisplaySnapshot {
             })
     }
 
+    /// Returns an iterator of the start positions of the occurances of `target` in the `self` after `from`
+    /// Stops if `condition` returns false for any of the character position pairs observed.
+    pub fn find_while<'a>(
+        &'a self,
+        from: DisplayPoint,
+        target: &str,
+        condition: impl FnMut(char, DisplayPoint) -> bool + 'a,
+    ) -> impl Iterator<Item = DisplayPoint> + 'a {
+        Self::find_internal(self.chars_at(from), target.chars().collect(), condition)
+    }
+
+    /// Returns an iterator of the end positions of the occurances of `target` in the `self` before `from`
+    /// Stops if `condition` returns false for any of the character position pairs observed.
+    pub fn reverse_find_while<'a>(
+        &'a self,
+        from: DisplayPoint,
+        target: &str,
+        condition: impl FnMut(char, DisplayPoint) -> bool + 'a,
+    ) -> impl Iterator<Item = DisplayPoint> + 'a {
+        Self::find_internal(
+            self.reverse_chars_at(from),
+            target.chars().rev().collect(),
+            condition,
+        )
+    }
+
+    fn find_internal<'a>(
+        iterator: impl Iterator<Item = (char, DisplayPoint)> + 'a,
+        target: Vec<char>,
+        mut condition: impl FnMut(char, DisplayPoint) -> bool + 'a,
+    ) -> impl Iterator<Item = DisplayPoint> + 'a {
+        // List of partial matches with the index of the last seen character in target and the starting point of the match
+        let mut partial_matches: Vec<(usize, DisplayPoint)> = Vec::new();
+        iterator
+            .take_while(move |(ch, point)| condition(*ch, *point))
+            .filter_map(move |(ch, point)| {
+                if Some(&ch) == target.get(0) {
+                    partial_matches.push((0, point));
+                }
+
+                let mut found = None;
+                // Keep partial matches that have the correct next character
+                partial_matches.retain_mut(|(match_position, match_start)| {
+                    if target.get(*match_position) == Some(&ch) {
+                        *match_position += 1;
+                        if *match_position == target.len() {
+                            found = Some(match_start.clone());
+                            // This match is completed. No need to keep tracking it
+                            false
+                        } else {
+                            true
+                        }
+                    } else {
+                        false
+                    }
+                });
+
+                found
+            })
+    }
+
     pub fn column_to_chars(&self, display_row: u32, target: u32) -> u32 {
         let mut count = 0;
         let mut column = 0;
@@ -438,7 +548,7 @@ impl DisplaySnapshot {
     }
 
     pub fn clip_point(&self, point: DisplayPoint, bias: Bias) -> DisplayPoint {
-        let mut clipped = self.blocks_snapshot.clip_point(point.0, bias);
+        let mut clipped = self.block_snapshot.clip_point(point.0, bias);
         if self.clip_at_line_ends {
             clipped = self.clip_at_line_end(DisplayPoint(clipped)).0
         }
@@ -449,7 +559,7 @@ impl DisplaySnapshot {
         let mut point = point.0;
         if point.column == self.line_len(point.row) {
             point.column = point.column.saturating_sub(1);
-            point = self.blocks_snapshot.clip_point(point, Bias::Left);
+            point = self.block_snapshot.clip_point(point, Bias::Left);
         }
         DisplayPoint(point)
     }
@@ -458,37 +568,34 @@ impl DisplaySnapshot {
     where
         T: ToOffset,
     {
-        self.folds_snapshot.folds_in_range(range)
+        self.fold_snapshot.folds_in_range(range)
     }
 
     pub fn blocks_in_range(
         &self,
         rows: Range<u32>,
     ) -> impl Iterator<Item = (u32, &TransformBlock)> {
-        self.blocks_snapshot.blocks_in_range(rows)
+        self.block_snapshot.blocks_in_range(rows)
     }
 
     pub fn intersects_fold<T: ToOffset>(&self, offset: T) -> bool {
-        self.folds_snapshot.intersects_fold(offset)
+        self.fold_snapshot.intersects_fold(offset)
     }
 
-    pub fn is_line_folded(&self, display_row: u32) -> bool {
-        let block_point = BlockPoint(Point::new(display_row, 0));
-        let wrap_point = self.blocks_snapshot.to_wrap_point(block_point);
-        let tab_point = self.wraps_snapshot.to_tab_point(wrap_point);
-        self.folds_snapshot.is_line_folded(tab_point.row())
+    pub fn is_line_folded(&self, buffer_row: u32) -> bool {
+        self.fold_snapshot.is_line_folded(buffer_row)
     }
 
     pub fn is_block_line(&self, display_row: u32) -> bool {
-        self.blocks_snapshot.is_block_line(display_row)
+        self.block_snapshot.is_block_line(display_row)
     }
 
     pub fn soft_wrap_indent(&self, display_row: u32) -> Option<u32> {
         let wrap_row = self
-            .blocks_snapshot
+            .block_snapshot
             .to_wrap_point(BlockPoint::new(display_row, 0))
             .row();
-        self.wraps_snapshot.soft_wrap_indent(wrap_row)
+        self.wrap_snapshot.soft_wrap_indent(wrap_row)
     }
 
     pub fn text(&self) -> String {
@@ -522,12 +629,96 @@ impl DisplaySnapshot {
         (indent, is_blank)
     }
 
+    pub fn line_indent_for_buffer_row(&self, buffer_row: u32) -> (u32, bool) {
+        let (buffer, range) = self
+            .buffer_snapshot
+            .buffer_line_for_row(buffer_row)
+            .unwrap();
+        let chars = buffer.chars_at(Point::new(range.start.row, 0));
+
+        let mut is_blank = false;
+        let indent_size = TabSnapshot::expand_tabs(
+            chars.take_while(|c| {
+                if *c == ' ' || *c == '\t' {
+                    true
+                } else {
+                    if *c == '\n' {
+                        is_blank = true;
+                    }
+                    false
+                }
+            }),
+            buffer.line_len(buffer_row) as usize, // Never collapse
+            self.tab_snapshot.tab_size,
+        );
+
+        (indent_size as u32, is_blank)
+    }
+
     pub fn line_len(&self, row: u32) -> u32 {
-        self.blocks_snapshot.line_len(row)
+        self.block_snapshot.line_len(row)
     }
 
     pub fn longest_row(&self) -> u32 {
-        self.blocks_snapshot.longest_row()
+        self.block_snapshot.longest_row()
+    }
+
+    pub fn fold_for_line(self: &Self, buffer_row: u32) -> Option<FoldStatus> {
+        if self.is_line_folded(buffer_row) {
+            Some(FoldStatus::Folded)
+        } else if self.is_foldable(buffer_row) {
+            Some(FoldStatus::Foldable)
+        } else {
+            None
+        }
+    }
+
+    pub fn is_foldable(self: &Self, buffer_row: u32) -> bool {
+        let max_row = self.buffer_snapshot.max_buffer_row();
+        if buffer_row >= max_row {
+            return false;
+        }
+
+        let (indent_size, is_blank) = self.line_indent_for_buffer_row(buffer_row);
+        if is_blank {
+            return false;
+        }
+
+        for next_row in (buffer_row + 1)..=max_row {
+            let (next_indent_size, next_line_is_blank) = self.line_indent_for_buffer_row(next_row);
+            if next_indent_size > indent_size {
+                return true;
+            } else if !next_line_is_blank {
+                break;
+            }
+        }
+
+        false
+    }
+
+    pub fn foldable_range(self: &Self, buffer_row: u32) -> Option<Range<Point>> {
+        let start = Point::new(buffer_row, self.buffer_snapshot.line_len(buffer_row));
+        if self.is_foldable(start.row) && !self.is_line_folded(start.row) {
+            let (start_indent, _) = self.line_indent_for_buffer_row(buffer_row);
+            let max_point = self.buffer_snapshot.max_point();
+            let mut end = None;
+
+            for row in (buffer_row + 1)..=max_point.row {
+                let (indent, is_blank) = self.line_indent_for_buffer_row(row);
+                if !is_blank && indent <= start_indent {
+                    let prev_row = row - 1;
+                    end = Some(Point::new(
+                        prev_row,
+                        self.buffer_snapshot.line_len(prev_row),
+                    ));
+                    break;
+                }
+            }
+            let end = end.unwrap_or(max_point);
+            Some(start..end)
+        } else {
+            None
+        }
     }
 
     #[cfg(any(test, feature = "test-support"))]
@@ -586,10 +777,11 @@ impl DisplayPoint {
     }
 
     pub fn to_offset(self, map: &DisplaySnapshot, bias: Bias) -> usize {
-        let unblocked_point = map.blocks_snapshot.to_wrap_point(self.0);
-        let unwrapped_point = map.wraps_snapshot.to_tab_point(unblocked_point);
-        let unexpanded_point = map.tabs_snapshot.to_fold_point(unwrapped_point, bias).0;
-        unexpanded_point.to_buffer_offset(&map.folds_snapshot)
+        let wrap_point = map.block_snapshot.to_wrap_point(self.0);
+        let tab_point = map.wrap_snapshot.to_tab_point(wrap_point);
+        let suggestion_point = map.tab_snapshot.to_suggestion_point(tab_point, bias).0;
+        let fold_point = map.suggestion_snapshot.to_fold_point(suggestion_point);
+        fold_point.to_buffer_offset(&map.fold_snapshot)
     }
 }
 
@@ -617,6 +809,24 @@ impl ToDisplayPoint for Anchor {
     }
 }
 
+pub fn next_rows(display_row: u32, display_map: &DisplaySnapshot) -> impl Iterator<Item = u32> {
+    let max_row = display_map.max_point().row();
+    let start_row = display_row + 1;
+    let mut current = None;
+    std::iter::from_fn(move || {
+        if current == None {
+            current = Some(start_row);
+        } else {
+            current = Some(current.unwrap() + 1)
+        }
+        if current.unwrap() > max_row {
+            None
+        } else {
+            current
+        }
+    })
+}
+
 #[cfg(test)]
 pub mod tests {
     use super::*;
@@ -627,7 +837,7 @@ pub mod tests {
     use smol::stream::StreamExt;
     use std::{env, sync::Arc};
     use theme::SyntaxTheme;
-    use util::test::{marked_text_ranges, sample_text};
+    use util::test::{marked_text_offsets, marked_text_ranges, sample_text};
     use Bias::*;
 
     #[gpui::test(iterations = 100)]
@@ -642,7 +852,9 @@ pub mod tests {
         let mut tab_size = rng.gen_range(1..=4);
         let buffer_start_excerpt_header_height = rng.gen_range(1..=5);
         let excerpt_header_height = rng.gen_range(1..=5);
-        let family_id = font_cache.load_family(&["Helvetica"]).unwrap();
+        let family_id = font_cache
+            .load_family(&["Helvetica"], &Default::default())
+            .unwrap();
         let font_id = font_cache
             .select_font(family_id, &Default::default())
             .unwrap();
@@ -692,10 +904,10 @@ pub mod tests {
 
         let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
         log::info!("buffer text: {:?}", snapshot.buffer_snapshot.text());
-        log::info!("fold text: {:?}", snapshot.folds_snapshot.text());
-        log::info!("tab text: {:?}", snapshot.tabs_snapshot.text());
-        log::info!("wrap text: {:?}", snapshot.wraps_snapshot.text());
-        log::info!("block text: {:?}", snapshot.blocks_snapshot.text());
+        log::info!("fold text: {:?}", snapshot.fold_snapshot.text());
+        log::info!("tab text: {:?}", snapshot.tab_snapshot.text());
+        log::info!("wrap text: {:?}", snapshot.wrap_snapshot.text());
+        log::info!("block text: {:?}", snapshot.block_snapshot.text());
         log::info!("display text: {:?}", snapshot.text());
 
         for _i in 0..operations {
@@ -800,10 +1012,10 @@ pub mod tests {
             let snapshot = map.update(cx, |map, cx| map.snapshot(cx));
             fold_count = snapshot.fold_count();
             log::info!("buffer text: {:?}", snapshot.buffer_snapshot.text());
-            log::info!("fold text: {:?}", snapshot.folds_snapshot.text());
-            log::info!("tab text: {:?}", snapshot.tabs_snapshot.text());
-            log::info!("wrap text: {:?}", snapshot.wraps_snapshot.text());
-            log::info!("block text: {:?}", snapshot.blocks_snapshot.text());
+            log::info!("fold text: {:?}", snapshot.fold_snapshot.text());
+            log::info!("tab text: {:?}", snapshot.tab_snapshot.text());
+            log::info!("wrap text: {:?}", snapshot.wrap_snapshot.text());
+            log::info!("block text: {:?}", snapshot.block_snapshot.text());
             log::info!("display text: {:?}", snapshot.text());
 
             // Line boundaries
@@ -899,7 +1111,9 @@ pub mod tests {
 
         let font_cache = cx.font_cache();
 
-        let family_id = font_cache.load_family(&["Helvetica"]).unwrap();
+        let family_id = font_cache
+            .load_family(&["Helvetica"], &Default::default())
+            .unwrap();
         let font_id = font_cache
             .select_font(family_id, &Default::default())
             .unwrap();
@@ -988,7 +1202,10 @@ pub mod tests {
         cx.set_global(Settings::test(cx));
         let text = sample_text(6, 6, 'a');
         let buffer = MultiBuffer::build_simple(&text, cx);
-        let family_id = cx.font_cache().load_family(&["Helvetica"]).unwrap();
+        let family_id = cx
+            .font_cache()
+            .load_family(&["Helvetica"], &Default::default())
+            .unwrap();
         let font_id = cx
             .font_cache()
             .select_font(family_id, &Default::default())
@@ -1071,7 +1288,9 @@ pub mod tests {
         let buffer = cx.add_model(|cx| MultiBuffer::singleton(buffer, cx));
 
         let font_cache = cx.font_cache();
-        let family_id = font_cache.load_family(&["Helvetica"]).unwrap();
+        let family_id = font_cache
+            .load_family(&["Helvetica"], &Default::default())
+            .unwrap();
         let font_id = font_cache
             .select_font(family_id, &Default::default())
             .unwrap();
@@ -1106,7 +1325,7 @@ pub mod tests {
             vec![
                 ("fn ".to_string(), None),
                 ("out".to_string(), Some(Color::blue())),
-                ("…".to_string(), None),
+                ("⋯".to_string(), None),
                 ("  fn ".to_string(), Some(Color::red())),
                 ("inner".to_string(), Some(Color::blue())),
                 ("() {}\n}".to_string(), Some(Color::red())),
@@ -1159,7 +1378,9 @@ pub mod tests {
 
         let font_cache = cx.font_cache();
 
-        let family_id = font_cache.load_family(&["Courier"]).unwrap();
+        let family_id = font_cache
+            .load_family(&["Courier"], &Default::default())
+            .unwrap();
         let font_id = font_cache
             .select_font(family_id, &Default::default())
             .unwrap();
@@ -1187,7 +1408,7 @@ pub mod tests {
             cx.update(|cx| syntax_chunks(1..4, &map, &theme, cx)),
             [
                 ("out".to_string(), Some(Color::blue())),
-                ("…\n".to_string(), None),
+                ("⋯\n".to_string(), None),
                 ("  \nfn ".to_string(), Some(Color::red())),
                 ("i\n".to_string(), Some(Color::blue()))
             ]
@@ -1231,7 +1452,9 @@ pub mod tests {
         let buffer_snapshot = buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
 
         let font_cache = cx.font_cache();
-        let family_id = font_cache.load_family(&["Courier"]).unwrap();
+        let family_id = font_cache
+            .load_family(&["Courier"], &Default::default())
+            .unwrap();
         let font_id = font_cache
             .select_font(family_id, &Default::default())
             .unwrap();
@@ -1347,7 +1570,9 @@ pub mod tests {
         let text = "✅\t\tα\nβ\t\n🏀β\t\tγ";
         let buffer = MultiBuffer::build_simple(text, cx);
         let font_cache = cx.font_cache();
-        let family_id = font_cache.load_family(&["Helvetica"]).unwrap();
+        let family_id = font_cache
+            .load_family(&["Helvetica"], &Default::default())
+            .unwrap();
         let font_id = font_cache
             .select_font(family_id, &Default::default())
             .unwrap();
@@ -1405,7 +1630,9 @@ pub mod tests {
         cx.set_global(Settings::test(cx));
         let buffer = MultiBuffer::build_simple("aaa\n\t\tbbb", cx);
         let font_cache = cx.font_cache();
-        let family_id = font_cache.load_family(&["Helvetica"]).unwrap();
+        let family_id = font_cache
+            .load_family(&["Helvetica"], &Default::default())
+            .unwrap();
         let font_id = font_cache
             .select_font(family_id, &Default::default())
             .unwrap();
@@ -1418,6 +1645,32 @@ pub mod tests {
         )
     }
 
+    #[test]
+    fn test_find_internal() {
+        assert("This is a ˇtest of find internal", "test");
+        assert("Some text ˇaˇaˇaa with repeated characters", "aa");
+
+        fn assert(marked_text: &str, target: &str) {
+            let (text, expected_offsets) = marked_text_offsets(marked_text);
+
+            let chars = text
+                .chars()
+                .enumerate()
+                .map(|(index, ch)| (ch, DisplayPoint::new(0, index as u32)));
+            let target = target.chars();
+
+            assert_eq!(
+                expected_offsets
+                    .into_iter()
+                    .map(|offset| offset as u32)
+                    .collect::<Vec<_>>(),
+                DisplaySnapshot::find_internal(chars, target.collect(), |_, _| true)
+                    .map(|point| point.column())
+                    .collect::<Vec<_>>()
+            )
+        }
+    }
+
     fn syntax_chunks<'a>(
         rows: Range<u32>,
         map: &ModelHandle<DisplayMap>,

crates/editor/src/display_map/block_map.rs

@@ -989,6 +989,7 @@ fn offset_for_row(s: &str, target: u32) -> (u32, usize) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::display_map::suggestion_map::SuggestionMap;
     use crate::display_map::{fold_map::FoldMap, tab_map::TabMap, wrap_map::WrapMap};
     use crate::multi_buffer::MultiBuffer;
     use gpui::{elements::Empty, Element};
@@ -1015,7 +1016,10 @@ mod tests {
     fn test_basic_blocks(cx: &mut gpui::MutableAppContext) {
         cx.set_global(Settings::test(cx));
 
-        let family_id = cx.font_cache().load_family(&["Helvetica"]).unwrap();
+        let family_id = cx
+            .font_cache()
+            .load_family(&["Helvetica"], &Default::default())
+            .unwrap();
         let font_id = cx
             .font_cache()
             .select_font(family_id, &Default::default())
@@ -1026,9 +1030,10 @@ mod tests {
         let buffer = MultiBuffer::build_simple(text, cx);
         let buffer_snapshot = buffer.read(cx).snapshot(cx);
         let subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
-        let (fold_map, folds_snapshot) = FoldMap::new(buffer_snapshot.clone());
-        let (tab_map, tabs_snapshot) = TabMap::new(folds_snapshot, 1.try_into().unwrap());
-        let (wrap_map, wraps_snapshot) = WrapMap::new(tabs_snapshot, font_id, 14.0, None, cx);
+        let (fold_map, fold_snapshot) = FoldMap::new(buffer_snapshot.clone());
+        let (suggestion_map, suggestion_snapshot) = SuggestionMap::new(fold_snapshot);
+        let (tab_map, tab_snapshot) = TabMap::new(suggestion_snapshot, 1.try_into().unwrap());
+        let (wrap_map, wraps_snapshot) = WrapMap::new(tab_snapshot, font_id, 14.0, None, cx);
         let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
 
         let mut writer = block_map.write(wraps_snapshot.clone(), Default::default());
@@ -1170,12 +1175,14 @@ mod tests {
             buffer.snapshot(cx)
         });
 
-        let (folds_snapshot, fold_edits) =
+        let (fold_snapshot, fold_edits) =
             fold_map.read(buffer_snapshot, subscription.consume().into_inner());
-        let (tabs_snapshot, tab_edits) =
-            tab_map.sync(folds_snapshot, fold_edits, 4.try_into().unwrap());
+        let (suggestion_snapshot, suggestion_edits) =
+            suggestion_map.sync(fold_snapshot, fold_edits);
+        let (tab_snapshot, tab_edits) =
+            tab_map.sync(suggestion_snapshot, suggestion_edits, 4.try_into().unwrap());
         let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
-            wrap_map.sync(tabs_snapshot, tab_edits, cx)
+            wrap_map.sync(tab_snapshot, tab_edits, cx)
         });
         let snapshot = block_map.read(wraps_snapshot, wrap_edits);
         assert_eq!(snapshot.text(), "aaa\n\nb!!!\n\n\nbb\nccc\nddd\n\n\n");
@@ -1185,7 +1192,10 @@ mod tests {
     fn test_blocks_on_wrapped_lines(cx: &mut gpui::MutableAppContext) {
         cx.set_global(Settings::test(cx));
 
-        let family_id = cx.font_cache().load_family(&["Helvetica"]).unwrap();
+        let family_id = cx
+            .font_cache()
+            .load_family(&["Helvetica"], &Default::default())
+            .unwrap();
         let font_id = cx
             .font_cache()
             .select_font(family_id, &Default::default())
@@ -1195,9 +1205,10 @@ mod tests {
 
         let buffer = MultiBuffer::build_simple(text, cx);
         let buffer_snapshot = buffer.read(cx).snapshot(cx);
-        let (_, folds_snapshot) = FoldMap::new(buffer_snapshot.clone());
-        let (_, tabs_snapshot) = TabMap::new(folds_snapshot, 1.try_into().unwrap());
-        let (_, wraps_snapshot) = WrapMap::new(tabs_snapshot, font_id, 14.0, Some(60.), cx);
+        let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone());
+        let (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot);
+        let (_, tab_snapshot) = TabMap::new(suggestion_snapshot, 1.try_into().unwrap());
+        let (_, wraps_snapshot) = WrapMap::new(tab_snapshot, font_id, 14.0, Some(60.), cx);
         let mut block_map = BlockMap::new(wraps_snapshot.clone(), 1, 1);
 
         let mut writer = block_map.write(wraps_snapshot.clone(), Default::default());
@@ -1241,7 +1252,10 @@ mod tests {
             Some(rng.gen_range(0.0..=100.0))
         };
         let tab_size = 1.try_into().unwrap();
-        let family_id = cx.font_cache().load_family(&["Helvetica"]).unwrap();
+        let family_id = cx
+            .font_cache()
+            .load_family(&["Helvetica"], &Default::default())
+            .unwrap();
         let font_id = cx
             .font_cache()
             .select_font(family_id, &Default::default())
@@ -1263,10 +1277,11 @@ mod tests {
         };
 
         let mut buffer_snapshot = buffer.read(cx).snapshot(cx);
-        let (fold_map, folds_snapshot) = FoldMap::new(buffer_snapshot.clone());
-        let (tab_map, tabs_snapshot) = TabMap::new(folds_snapshot, tab_size);
+        let (fold_map, fold_snapshot) = FoldMap::new(buffer_snapshot.clone());
+        let (suggestion_map, suggestion_snapshot) = SuggestionMap::new(fold_snapshot);
+        let (tab_map, tab_snapshot) = TabMap::new(suggestion_snapshot, tab_size);
         let (wrap_map, wraps_snapshot) =
-            WrapMap::new(tabs_snapshot, font_id, font_size, wrap_width, cx);
+            WrapMap::new(tab_snapshot, font_id, font_size, wrap_width, cx);
         let mut block_map = BlockMap::new(
             wraps_snapshot,
             buffer_start_header_height,
@@ -1317,12 +1332,14 @@ mod tests {
                         })
                         .collect::<Vec<_>>();
 
-                    let (folds_snapshot, fold_edits) =
+                    let (fold_snapshot, fold_edits) =
                         fold_map.read(buffer_snapshot.clone(), vec![]);
-                    let (tabs_snapshot, tab_edits) =
-                        tab_map.sync(folds_snapshot, fold_edits, tab_size);
+                    let (suggestion_snapshot, suggestion_edits) =
+                        suggestion_map.sync(fold_snapshot, fold_edits);
+                    let (tab_snapshot, tab_edits) =
+                        tab_map.sync(suggestion_snapshot, suggestion_edits, tab_size);
                     let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
-                        wrap_map.sync(tabs_snapshot, tab_edits, cx)
+                        wrap_map.sync(tab_snapshot, tab_edits, cx)
                     });
                     let mut block_map = block_map.write(wraps_snapshot, wrap_edits);
                     let block_ids = block_map.insert(block_properties.clone());
@@ -1340,12 +1357,14 @@ mod tests {
                         })
                         .collect();
 
-                    let (folds_snapshot, fold_edits) =
+                    let (fold_snapshot, fold_edits) =
                         fold_map.read(buffer_snapshot.clone(), vec![]);
-                    let (tabs_snapshot, tab_edits) =
-                        tab_map.sync(folds_snapshot, fold_edits, tab_size);
+                    let (suggestion_snapshot, suggestion_edits) =
+                        suggestion_map.sync(fold_snapshot, fold_edits);
+                    let (tab_snapshot, tab_edits) =
+                        tab_map.sync(suggestion_snapshot, suggestion_edits, tab_size);
                     let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
-                        wrap_map.sync(tabs_snapshot, tab_edits, cx)
+                        wrap_map.sync(tab_snapshot, tab_edits, cx)
                     });
                     let mut block_map = block_map.write(wraps_snapshot, wrap_edits);
                     block_map.remove(block_ids_to_remove);
@@ -1362,10 +1381,13 @@ mod tests {
                 }
             }
 
-            let (folds_snapshot, fold_edits) = fold_map.read(buffer_snapshot.clone(), buffer_edits);
-            let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits, tab_size);
+            let (fold_snapshot, fold_edits) = fold_map.read(buffer_snapshot.clone(), buffer_edits);
+            let (suggestion_snapshot, suggestion_edits) =
+                suggestion_map.sync(fold_snapshot, fold_edits);
+            let (tab_snapshot, tab_edits) =
+                tab_map.sync(suggestion_snapshot, suggestion_edits, tab_size);
             let (wraps_snapshot, wrap_edits) = wrap_map.update(cx, |wrap_map, cx| {
-                wrap_map.sync(tabs_snapshot, tab_edits, cx)
+                wrap_map.sync(tab_snapshot, tab_edits, cx)
             });
             let blocks_snapshot = block_map.read(wraps_snapshot.clone(), wrap_edits);
             assert_eq!(

crates/editor/src/display_map/fold_map.rs

@@ -4,7 +4,7 @@ use crate::{
     ToOffset,
 };
 use collections::BTreeMap;
-use gpui::fonts::HighlightStyle;
+use gpui::{color::Color, fonts::HighlightStyle};
 use language::{Chunk, Edit, Point, TextSummary};
 use parking_lot::Mutex;
 use std::{
@@ -29,10 +29,6 @@ impl FoldPoint {
         self.0.row
     }
 
-    pub fn column(self) -> u32 {
-        self.0.column
-    }
-
     pub fn row_mut(&mut self) -> &mut u32 {
         &mut self.0.row
     }
@@ -133,6 +129,7 @@ impl<'a> FoldMapWriter<'a> {
             folds: self.0.folds.clone(),
             buffer_snapshot: buffer,
             version: self.0.version.load(SeqCst),
+            ellipses_color: self.0.ellipses_color,
         };
         (snapshot, edits)
     }
@@ -182,6 +179,7 @@ impl<'a> FoldMapWriter<'a> {
             folds: self.0.folds.clone(),
             buffer_snapshot: buffer,
             version: self.0.version.load(SeqCst),
+            ellipses_color: self.0.ellipses_color,
         };
         (snapshot, edits)
     }
@@ -192,6 +190,7 @@ pub struct FoldMap {
     transforms: Mutex<SumTree<Transform>>,
     folds: SumTree<Fold>,
     version: AtomicUsize,
+    ellipses_color: Option<Color>,
 }
 
 impl FoldMap {
@@ -209,6 +208,7 @@ impl FoldMap {
                 },
                 &(),
             )),
+            ellipses_color: None,
             version: Default::default(),
         };
 
@@ -217,6 +217,7 @@ impl FoldMap {
             folds: this.folds.clone(),
             buffer_snapshot: this.buffer.lock().clone(),
             version: this.version.load(SeqCst),
+            ellipses_color: None,
         };
         (this, snapshot)
     }
@@ -233,6 +234,7 @@ impl FoldMap {
             folds: self.folds.clone(),
             buffer_snapshot: self.buffer.lock().clone(),
             version: self.version.load(SeqCst),
+            ellipses_color: self.ellipses_color,
         };
         (snapshot, edits)
     }
@@ -246,6 +248,15 @@ impl FoldMap {
         (FoldMapWriter(self), snapshot, edits)
     }
 
+    pub fn set_ellipses_color(&mut self, color: Color) -> bool {
+        if self.ellipses_color != Some(color) {
+            self.ellipses_color = Some(color);
+            true
+        } else {
+            false
+        }
+    }
+
     fn check_invariants(&self) {
         if cfg!(test) {
             assert_eq!(
@@ -370,7 +381,7 @@ impl FoldMap {
                     }
 
                     if fold.end > fold.start {
-                        let output_text = "…";
+                        let output_text = "⋯";
                         new_transforms.push(
                             Transform {
                                 summary: TransformSummary {
@@ -477,6 +488,7 @@ pub struct FoldSnapshot {
     folds: SumTree<Fold>,
     buffer_snapshot: MultiBufferSnapshot,
     pub version: usize,
+    pub ellipses_color: Option<Color>,
 }
 
 impl FoldSnapshot {
@@ -623,14 +635,14 @@ impl FoldSnapshot {
         cursor.item().map_or(false, |t| t.output_text.is_some())
     }
 
-    pub fn is_line_folded(&self, output_row: u32) -> bool {
-        let mut cursor = self.transforms.cursor::<FoldPoint>();
-        cursor.seek(&FoldPoint::new(output_row, 0), Bias::Right, &());
+    pub fn is_line_folded(&self, buffer_row: u32) -> bool {
+        let mut cursor = self.transforms.cursor::<Point>();
+        cursor.seek(&Point::new(buffer_row, 0), Bias::Right, &());
         while let Some(transform) = cursor.item() {
             if transform.output_text.is_some() {
                 return true;
             }
-            if cursor.end(&()).row() == output_row {
+            if cursor.end(&()).row == buffer_row {
                 cursor.next(&())
             } else {
                 break;
@@ -639,12 +651,6 @@ impl FoldSnapshot {
         false
     }
 
-    pub fn chars_at(&self, start: FoldPoint) -> impl '_ + Iterator<Item = char> {
-        let start = start.to_offset(self);
-        self.chunks(start..self.len(), false, None)
-            .flat_map(|chunk| chunk.text.chars())
-    }
-
     pub fn chunks<'a>(
         &'a self,
         range: Range<FoldOffset>,
@@ -739,6 +745,7 @@ impl FoldSnapshot {
             max_output_offset: range.end.0,
             highlight_endpoints: highlight_endpoints.into_iter().peekable(),
             active_highlights: Default::default(),
+            ellipses_color: self.ellipses_color,
         }
     }
 
@@ -1029,6 +1036,7 @@ pub struct FoldChunks<'a> {
     max_output_offset: usize,
     highlight_endpoints: Peekable<vec::IntoIter<HighlightEndpoint>>,
     active_highlights: BTreeMap<Option<TypeId>, HighlightStyle>,
+    ellipses_color: Option<Color>,
 }
 
 impl<'a> Iterator for FoldChunks<'a> {
@@ -1058,7 +1066,10 @@ impl<'a> Iterator for FoldChunks<'a> {
             return Some(Chunk {
                 text: output_text,
                 syntax_highlight_id: None,
-                highlight_style: None,
+                highlight_style: self.ellipses_color.map(|color| HighlightStyle {
+                    color: Some(color),
+                    ..Default::default()
+                }),
                 diagnostic_severity: None,
                 is_unnecessary: false,
             });
@@ -1193,6 +1204,7 @@ pub type FoldEdit = Edit<FoldOffset>;
 mod tests {
     use super::*;
     use crate::{MultiBuffer, ToPoint};
+    use collections::HashSet;
     use rand::prelude::*;
     use settings::Settings;
     use std::{cmp::Reverse, env, mem, sync::Arc};
@@ -1214,7 +1226,7 @@ mod tests {
             Point::new(0, 2)..Point::new(2, 2),
             Point::new(2, 4)..Point::new(4, 1),
         ]);
-        assert_eq!(snapshot2.text(), "aa…cc…eeeee");
+        assert_eq!(snapshot2.text(), "aa⋯cc⋯eeeee");
         assert_eq!(
             edits,
             &[
@@ -1241,7 +1253,7 @@ mod tests {
             buffer.snapshot(cx)
         });
         let (snapshot3, edits) = map.read(buffer_snapshot, subscription.consume().into_inner());
-        assert_eq!(snapshot3.text(), "123a…c123c…eeeee");
+        assert_eq!(snapshot3.text(), "123a⋯c123c⋯eeeee");
         assert_eq!(
             edits,
             &[
@@ -1261,12 +1273,12 @@ mod tests {
             buffer.snapshot(cx)
         });
         let (snapshot4, _) = map.read(buffer_snapshot.clone(), subscription.consume().into_inner());
-        assert_eq!(snapshot4.text(), "123a…c123456eee");
+        assert_eq!(snapshot4.text(), "123a⋯c123456eee");
 
         let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
         writer.unfold(Some(Point::new(0, 4)..Point::new(0, 4)), false);
         let (snapshot5, _) = map.read(buffer_snapshot.clone(), vec![]);
-        assert_eq!(snapshot5.text(), "123a…c123456eee");
+        assert_eq!(snapshot5.text(), "123a⋯c123456eee");
 
         let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
         writer.unfold(Some(Point::new(0, 4)..Point::new(0, 4)), true);
@@ -1287,19 +1299,19 @@ mod tests {
             let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
             writer.fold(vec![5..8]);
             let (snapshot, _) = map.read(buffer_snapshot.clone(), vec![]);
-            assert_eq!(snapshot.text(), "abcde…ijkl");
+            assert_eq!(snapshot.text(), "abcde⋯ijkl");
 
             // Create an fold adjacent to the start of the first fold.
             let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
             writer.fold(vec![0..1, 2..5]);
             let (snapshot, _) = map.read(buffer_snapshot.clone(), vec![]);
-            assert_eq!(snapshot.text(), "…b…ijkl");
+            assert_eq!(snapshot.text(), "⋯b⋯ijkl");
 
             // Create an fold adjacent to the end of the first fold.
             let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
             writer.fold(vec![11..11, 8..10]);
             let (snapshot, _) = map.read(buffer_snapshot.clone(), vec![]);
-            assert_eq!(snapshot.text(), "…b…kl");
+            assert_eq!(snapshot.text(), "⋯b⋯kl");
         }
 
         {
@@ -1309,7 +1321,7 @@ mod tests {
             let (mut writer, _, _) = map.write(buffer_snapshot.clone(), vec![]);
             writer.fold(vec![0..2, 2..5]);
             let (snapshot, _) = map.read(buffer_snapshot, vec![]);
-            assert_eq!(snapshot.text(), "…fghijkl");
+            assert_eq!(snapshot.text(), "⋯fghijkl");
 
             // Edit within one of the folds.
             let buffer_snapshot = buffer.update(cx, |buffer, cx| {
@@ -1317,7 +1329,7 @@ mod tests {
                 buffer.snapshot(cx)
             });
             let (snapshot, _) = map.read(buffer_snapshot, subscription.consume().into_inner());
-            assert_eq!(snapshot.text(), "12345…fghijkl");
+            assert_eq!(snapshot.text(), "12345⋯fghijkl");
         }
     }
 
@@ -1334,7 +1346,7 @@ mod tests {
             Point::new(3, 1)..Point::new(4, 1),
         ]);
         let (snapshot, _) = map.read(buffer_snapshot, vec![]);
-        assert_eq!(snapshot.text(), "aa…eeeee");
+        assert_eq!(snapshot.text(), "aa⋯eeeee");
     }
 
     #[gpui::test]
@@ -1351,14 +1363,14 @@ mod tests {
             Point::new(3, 1)..Point::new(4, 1),
         ]);
         let (snapshot, _) = map.read(buffer_snapshot, vec![]);
-        assert_eq!(snapshot.text(), "aa…cccc\nd…eeeee");
+        assert_eq!(snapshot.text(), "aa⋯cccc\nd⋯eeeee");
 
         let buffer_snapshot = buffer.update(cx, |buffer, cx| {
             buffer.edit([(Point::new(2, 2)..Point::new(3, 1), "")], None, cx);
             buffer.snapshot(cx)
         });
         let (snapshot, _) = map.read(buffer_snapshot, subscription.consume().into_inner());
-        assert_eq!(snapshot.text(), "aa…eeeee");
+        assert_eq!(snapshot.text(), "aa⋯eeeee");
     }
 
     #[gpui::test]
@@ -1450,7 +1462,7 @@ mod tests {
 
             let mut expected_text: String = buffer_snapshot.text().to_string();
             for fold_range in map.merged_fold_ranges().into_iter().rev() {
-                expected_text.replace_range(fold_range.start..fold_range.end, "…");
+                expected_text.replace_range(fold_range.start..fold_range.end, "⋯");
             }
 
             assert_eq!(snapshot.text(), expected_text);
@@ -1572,10 +1584,13 @@ mod tests {
                 fold_row += 1;
             }
 
-            for fold_range in map.merged_fold_ranges() {
-                let fold_point =
-                    snapshot.to_fold_point(fold_range.start.to_point(&buffer_snapshot), Right);
-                assert!(snapshot.is_line_folded(fold_point.row()));
+            let fold_start_rows = map
+                .merged_fold_ranges()
+                .iter()
+                .map(|range| range.start.to_point(&buffer_snapshot).row)
+                .collect::<HashSet<_>>();
+            for row in fold_start_rows {
+                assert!(snapshot.is_line_folded(row));
             }
 
             for _ in 0..5 {
@@ -1655,7 +1670,7 @@ mod tests {
         ]);
 
         let (snapshot, _) = map.read(buffer_snapshot, vec![]);
-        assert_eq!(snapshot.text(), "aa…cccc\nd…eeeee\nffffff\n");
+        assert_eq!(snapshot.text(), "aa⋯cccc\nd⋯eeeee\nffffff\n");
         assert_eq!(
             snapshot.buffer_rows(0).collect::<Vec<_>>(),
             [Some(0), Some(3), Some(5), Some(6)]

crates/editor/src/display_map/suggestion_map.rs

@@ -0,0 +1,827 @@
+use super::{
+    fold_map::{FoldBufferRows, FoldChunks, FoldEdit, FoldOffset, FoldPoint, FoldSnapshot},
+    TextHighlights,
+};
+use crate::{MultiBufferSnapshot, ToPoint};
+use gpui::fonts::HighlightStyle;
+use language::{Bias, Chunk, Edit, Patch, Point, Rope, TextSummary};
+use parking_lot::Mutex;
+use std::{
+    cmp,
+    ops::{Add, AddAssign, Range, Sub},
+};
+use util::post_inc;
+
+pub type SuggestionEdit = Edit<SuggestionOffset>;
+
+#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
+pub struct SuggestionOffset(pub usize);
+
+impl Add for SuggestionOffset {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self(self.0 + rhs.0)
+    }
+}
+
+impl Sub for SuggestionOffset {
+    type Output = Self;
+
+    fn sub(self, rhs: Self) -> Self::Output {
+        Self(self.0 - rhs.0)
+    }
+}
+
+impl AddAssign for SuggestionOffset {
+    fn add_assign(&mut self, rhs: Self) {
+        self.0 += rhs.0;
+    }
+}
+
+#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
+pub struct SuggestionPoint(pub Point);
+
+impl SuggestionPoint {
+    pub fn new(row: u32, column: u32) -> Self {
+        Self(Point::new(row, column))
+    }
+
+    pub fn row(self) -> u32 {
+        self.0.row
+    }
+
+    pub fn column(self) -> u32 {
+        self.0.column
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Suggestion<T> {
+    pub position: T,
+    pub text: Rope,
+    pub highlight_style: HighlightStyle,
+}
+
+pub struct SuggestionMap(Mutex<SuggestionSnapshot>);
+
+impl SuggestionMap {
+    pub fn new(fold_snapshot: FoldSnapshot) -> (Self, SuggestionSnapshot) {
+        let snapshot = SuggestionSnapshot {
+            fold_snapshot,
+            suggestion: None,
+            version: 0,
+        };
+        (Self(Mutex::new(snapshot.clone())), snapshot)
+    }
+
+    pub fn replace<T>(
+        &self,
+        new_suggestion: Option<Suggestion<T>>,
+        fold_snapshot: FoldSnapshot,
+        fold_edits: Vec<FoldEdit>,
+    ) -> (SuggestionSnapshot, Vec<SuggestionEdit>)
+    where
+        T: ToPoint,
+    {
+        let new_suggestion = new_suggestion.map(|new_suggestion| {
+            let buffer_point = new_suggestion
+                .position
+                .to_point(fold_snapshot.buffer_snapshot());
+            let fold_point = fold_snapshot.to_fold_point(buffer_point, Bias::Left);
+            let fold_offset = fold_point.to_offset(&fold_snapshot);
+            Suggestion {
+                position: fold_offset,
+                text: new_suggestion.text,
+                highlight_style: new_suggestion.highlight_style,
+            }
+        });
+
+        let (_, edits) = self.sync(fold_snapshot, fold_edits);
+        let mut snapshot = self.0.lock();
+
+        let mut patch = Patch::new(edits);
+        if let Some(suggestion) = snapshot.suggestion.take() {
+            patch = patch.compose([SuggestionEdit {
+                old: SuggestionOffset(suggestion.position.0)
+                    ..SuggestionOffset(suggestion.position.0 + suggestion.text.len()),
+                new: SuggestionOffset(suggestion.position.0)
+                    ..SuggestionOffset(suggestion.position.0),
+            }]);
+        }
+
+        if let Some(suggestion) = new_suggestion.as_ref() {
+            patch = patch.compose([SuggestionEdit {
+                old: SuggestionOffset(suggestion.position.0)
+                    ..SuggestionOffset(suggestion.position.0),
+                new: SuggestionOffset(suggestion.position.0)
+                    ..SuggestionOffset(suggestion.position.0 + suggestion.text.len()),
+            }]);
+        }
+
+        snapshot.suggestion = new_suggestion;
+        snapshot.version += 1;
+        (snapshot.clone(), patch.into_inner())
+    }
+
+    pub fn sync(
+        &self,
+        fold_snapshot: FoldSnapshot,
+        fold_edits: Vec<FoldEdit>,
+    ) -> (SuggestionSnapshot, Vec<SuggestionEdit>) {
+        let mut snapshot = self.0.lock();
+
+        if snapshot.fold_snapshot.version != fold_snapshot.version {
+            snapshot.version += 1;
+        }
+
+        let mut suggestion_edits = Vec::new();
+
+        let mut suggestion_old_len = 0;
+        let mut suggestion_new_len = 0;
+        for fold_edit in fold_edits {
+            let start = fold_edit.new.start;
+            let end = FoldOffset(start.0 + fold_edit.old_len().0);
+            if let Some(suggestion) = snapshot.suggestion.as_mut() {
+                if end <= suggestion.position {
+                    suggestion.position.0 += fold_edit.new_len().0;
+                    suggestion.position.0 -= fold_edit.old_len().0;
+                } else if start > suggestion.position {
+                    suggestion_old_len = suggestion.text.len();
+                    suggestion_new_len = suggestion_old_len;
+                } else {
+                    suggestion_old_len = suggestion.text.len();
+                    snapshot.suggestion.take();
+                    suggestion_edits.push(SuggestionEdit {
+                        old: SuggestionOffset(fold_edit.old.start.0)
+                            ..SuggestionOffset(fold_edit.old.end.0 + suggestion_old_len),
+                        new: SuggestionOffset(fold_edit.new.start.0)
+                            ..SuggestionOffset(fold_edit.new.end.0),
+                    });
+                    continue;
+                }
+            }
+
+            suggestion_edits.push(SuggestionEdit {
+                old: SuggestionOffset(fold_edit.old.start.0 + suggestion_old_len)
+                    ..SuggestionOffset(fold_edit.old.end.0 + suggestion_old_len),
+                new: SuggestionOffset(fold_edit.new.start.0 + suggestion_new_len)
+                    ..SuggestionOffset(fold_edit.new.end.0 + suggestion_new_len),
+            });
+        }
+        snapshot.fold_snapshot = fold_snapshot;
+
+        (snapshot.clone(), suggestion_edits)
+    }
+}
+
+#[derive(Clone)]
+pub struct SuggestionSnapshot {
+    pub fold_snapshot: FoldSnapshot,
+    pub suggestion: Option<Suggestion<FoldOffset>>,
+    pub version: usize,
+}
+
+impl SuggestionSnapshot {
+    pub fn buffer_snapshot(&self) -> &MultiBufferSnapshot {
+        self.fold_snapshot.buffer_snapshot()
+    }
+
+    pub fn max_point(&self) -> SuggestionPoint {
+        if let Some(suggestion) = self.suggestion.as_ref() {
+            let suggestion_point = suggestion.position.to_point(&self.fold_snapshot);
+            let mut max_point = suggestion_point.0;
+            max_point += suggestion.text.max_point();
+            max_point += self.fold_snapshot.max_point().0 - suggestion_point.0;
+            SuggestionPoint(max_point)
+        } else {
+            SuggestionPoint(self.fold_snapshot.max_point().0)
+        }
+    }
+
+    pub fn len(&self) -> SuggestionOffset {
+        if let Some(suggestion) = self.suggestion.as_ref() {
+            let mut len = suggestion.position.0;
+            len += suggestion.text.len();
+            len += self.fold_snapshot.len().0 - suggestion.position.0;
+            SuggestionOffset(len)
+        } else {
+            SuggestionOffset(self.fold_snapshot.len().0)
+        }
+    }
+
+    pub fn clip_point(&self, point: SuggestionPoint, bias: Bias) -> SuggestionPoint {
+        if let Some(suggestion) = self.suggestion.as_ref() {
+            let suggestion_start = suggestion.position.to_point(&self.fold_snapshot).0;
+            let suggestion_end = suggestion_start + suggestion.text.max_point();
+            if point.0 <= suggestion_start {
+                SuggestionPoint(self.fold_snapshot.clip_point(FoldPoint(point.0), bias).0)
+            } else if point.0 > suggestion_end {
+                let fold_point = self.fold_snapshot.clip_point(
+                    FoldPoint(suggestion_start + (point.0 - suggestion_end)),
+                    bias,
+                );
+                let suggestion_point = suggestion_end + (fold_point.0 - suggestion_start);
+                if bias == Bias::Left && suggestion_point == suggestion_end {
+                    SuggestionPoint(suggestion_start)
+                } else {
+                    SuggestionPoint(suggestion_point)
+                }
+            } else if bias == Bias::Left || suggestion_start == self.fold_snapshot.max_point().0 {
+                SuggestionPoint(suggestion_start)
+            } else {
+                let fold_point = if self.fold_snapshot.line_len(suggestion_start.row)
+                    > suggestion_start.column
+                {
+                    FoldPoint(suggestion_start + Point::new(0, 1))
+                } else {
+                    FoldPoint(suggestion_start + Point::new(1, 0))
+                };
+                let clipped_fold_point = self.fold_snapshot.clip_point(fold_point, bias);
+                SuggestionPoint(suggestion_end + (clipped_fold_point.0 - suggestion_start))
+            }
+        } else {
+            SuggestionPoint(self.fold_snapshot.clip_point(FoldPoint(point.0), bias).0)
+        }
+    }
+
+    pub fn to_offset(&self, point: SuggestionPoint) -> SuggestionOffset {
+        if let Some(suggestion) = self.suggestion.as_ref() {
+            let suggestion_start = suggestion.position.to_point(&self.fold_snapshot).0;
+            let suggestion_end = suggestion_start + suggestion.text.max_point();
+
+            if point.0 <= suggestion_start {
+                SuggestionOffset(FoldPoint(point.0).to_offset(&self.fold_snapshot).0)
+            } else if point.0 > suggestion_end {
+                let fold_offset = FoldPoint(suggestion_start + (point.0 - suggestion_end))
+                    .to_offset(&self.fold_snapshot);
+                SuggestionOffset(fold_offset.0 + suggestion.text.len())
+            } else {
+                let offset_in_suggestion =
+                    suggestion.text.point_to_offset(point.0 - suggestion_start);
+                SuggestionOffset(suggestion.position.0 + offset_in_suggestion)
+            }
+        } else {
+            SuggestionOffset(FoldPoint(point.0).to_offset(&self.fold_snapshot).0)
+        }
+    }
+
+    pub fn to_point(&self, offset: SuggestionOffset) -> SuggestionPoint {
+        if let Some(suggestion) = self.suggestion.as_ref() {
+            let suggestion_point_start = suggestion.position.to_point(&self.fold_snapshot).0;
+            if offset.0 <= suggestion.position.0 {
+                SuggestionPoint(FoldOffset(offset.0).to_point(&self.fold_snapshot).0)
+            } else if offset.0 > (suggestion.position.0 + suggestion.text.len()) {
+                let fold_point = FoldOffset(offset.0 - suggestion.text.len())
+                    .to_point(&self.fold_snapshot)
+                    .0;
+
+                SuggestionPoint(
+                    suggestion_point_start
+                        + suggestion.text.max_point()
+                        + (fold_point - suggestion_point_start),
+                )
+            } else {
+                let point_in_suggestion = suggestion
+                    .text
+                    .offset_to_point(offset.0 - suggestion.position.0);
+                SuggestionPoint(suggestion_point_start + point_in_suggestion)
+            }
+        } else {
+            SuggestionPoint(FoldOffset(offset.0).to_point(&self.fold_snapshot).0)
+        }
+    }
+
+    pub fn to_fold_point(&self, point: SuggestionPoint) -> FoldPoint {
+        if let Some(suggestion) = self.suggestion.as_ref() {
+            let suggestion_start = suggestion.position.to_point(&self.fold_snapshot).0;
+            let suggestion_end = suggestion_start + suggestion.text.max_point();
+
+            if point.0 <= suggestion_start {
+                FoldPoint(point.0)
+            } else if point.0 > suggestion_end {
+                FoldPoint(suggestion_start + (point.0 - suggestion_end))
+            } else {
+                FoldPoint(suggestion_start)
+            }
+        } else {
+            FoldPoint(point.0)
+        }
+    }
+
+    pub fn to_suggestion_point(&self, point: FoldPoint) -> SuggestionPoint {
+        if let Some(suggestion) = self.suggestion.as_ref() {
+            let suggestion_start = suggestion.position.to_point(&self.fold_snapshot).0;
+
+            if point.0 <= suggestion_start {
+                SuggestionPoint(point.0)
+            } else {
+                let suggestion_end = suggestion_start + suggestion.text.max_point();
+                SuggestionPoint(suggestion_end + (point.0 - suggestion_start))
+            }
+        } else {
+            SuggestionPoint(point.0)
+        }
+    }
+
+    pub fn text_summary_for_range(&self, range: Range<SuggestionPoint>) -> TextSummary {
+        if let Some(suggestion) = self.suggestion.as_ref() {
+            let suggestion_start = suggestion.position.to_point(&self.fold_snapshot).0;
+            let suggestion_end = suggestion_start + suggestion.text.max_point();
+            let mut summary = TextSummary::default();
+
+            let prefix_range =
+                cmp::min(range.start.0, suggestion_start)..cmp::min(range.end.0, suggestion_start);
+            if prefix_range.start < prefix_range.end {
+                summary += self.fold_snapshot.text_summary_for_range(
+                    FoldPoint(prefix_range.start)..FoldPoint(prefix_range.end),
+                );
+            }
+
+            let suggestion_range =
+                cmp::max(range.start.0, suggestion_start)..cmp::min(range.end.0, suggestion_end);
+            if suggestion_range.start < suggestion_range.end {
+                let point_range = suggestion_range.start - suggestion_start
+                    ..suggestion_range.end - suggestion_start;
+                let offset_range = suggestion.text.point_to_offset(point_range.start)
+                    ..suggestion.text.point_to_offset(point_range.end);
+                summary += suggestion
+                    .text
+                    .cursor(offset_range.start)
+                    .summary::<TextSummary>(offset_range.end);
+            }
+
+            let suffix_range = cmp::max(range.start.0, suggestion_end)..range.end.0;
+            if suffix_range.start < suffix_range.end {
+                let start = suggestion_start + (suffix_range.start - suggestion_end);
+                let end = suggestion_start + (suffix_range.end - suggestion_end);
+                summary += self
+                    .fold_snapshot
+                    .text_summary_for_range(FoldPoint(start)..FoldPoint(end));
+            }
+
+            summary
+        } else {
+            self.fold_snapshot
+                .text_summary_for_range(FoldPoint(range.start.0)..FoldPoint(range.end.0))
+        }
+    }
+
+    pub fn chars_at(&self, start: SuggestionPoint) -> impl '_ + Iterator<Item = char> {
+        let start = self.to_offset(start);
+        self.chunks(start..self.len(), false, None)
+            .flat_map(|chunk| chunk.text.chars())
+    }
+
+    pub fn chunks<'a>(
+        &'a self,
+        range: Range<SuggestionOffset>,
+        language_aware: bool,
+        text_highlights: Option<&'a TextHighlights>,
+    ) -> SuggestionChunks<'a> {
+        if let Some(suggestion) = self.suggestion.as_ref() {
+            let suggestion_range =
+                suggestion.position.0..suggestion.position.0 + suggestion.text.len();
+
+            let prefix_chunks = if range.start.0 < suggestion_range.start {
+                Some(self.fold_snapshot.chunks(
+                    FoldOffset(range.start.0)
+                        ..cmp::min(FoldOffset(suggestion_range.start), FoldOffset(range.end.0)),
+                    language_aware,
+                    text_highlights,
+                ))
+            } else {
+                None
+            };
+
+            let clipped_suggestion_range = cmp::max(range.start.0, suggestion_range.start)
+                ..cmp::min(range.end.0, suggestion_range.end);
+            let suggestion_chunks = if clipped_suggestion_range.start < clipped_suggestion_range.end
+            {
+                let start = clipped_suggestion_range.start - suggestion_range.start;
+                let end = clipped_suggestion_range.end - suggestion_range.start;
+                Some(suggestion.text.chunks_in_range(start..end))
+            } else {
+                None
+            };
+
+            let suffix_chunks = if range.end.0 > suggestion_range.end {
+                let start = cmp::max(suggestion_range.end, range.start.0) - suggestion_range.len();
+                let end = range.end.0 - suggestion_range.len();
+                Some(self.fold_snapshot.chunks(
+                    FoldOffset(start)..FoldOffset(end),
+                    language_aware,
+                    text_highlights,
+                ))
+            } else {
+                None
+            };
+
+            SuggestionChunks {
+                prefix_chunks,
+                suggestion_chunks,
+                suffix_chunks,
+                highlight_style: suggestion.highlight_style,
+            }
+        } else {
+            SuggestionChunks {
+                prefix_chunks: Some(self.fold_snapshot.chunks(
+                    FoldOffset(range.start.0)..FoldOffset(range.end.0),
+                    language_aware,
+                    text_highlights,
+                )),
+                suggestion_chunks: None,
+                suffix_chunks: None,
+                highlight_style: Default::default(),
+            }
+        }
+    }
+
+    pub fn buffer_rows<'a>(&'a self, row: u32) -> SuggestionBufferRows<'a> {
+        let suggestion_range = if let Some(suggestion) = self.suggestion.as_ref() {
+            let start = suggestion.position.to_point(&self.fold_snapshot).0;
+            let end = start + suggestion.text.max_point();
+            start.row..end.row
+        } else {
+            u32::MAX..u32::MAX
+        };
+
+        let fold_buffer_rows = if row <= suggestion_range.start {
+            self.fold_snapshot.buffer_rows(row)
+        } else if row > suggestion_range.end {
+            self.fold_snapshot
+                .buffer_rows(row - (suggestion_range.end - suggestion_range.start))
+        } else {
+            let mut rows = self.fold_snapshot.buffer_rows(suggestion_range.start);
+            rows.next();
+            rows
+        };
+
+        SuggestionBufferRows {
+            current_row: row,
+            suggestion_row_start: suggestion_range.start,
+            suggestion_row_end: suggestion_range.end,
+            fold_buffer_rows,
+        }
+    }
+
+    #[cfg(test)]
+    pub fn text(&self) -> String {
+        self.chunks(Default::default()..self.len(), false, None)
+            .map(|chunk| chunk.text)
+            .collect()
+    }
+}
+
+pub struct SuggestionChunks<'a> {
+    prefix_chunks: Option<FoldChunks<'a>>,
+    suggestion_chunks: Option<text::Chunks<'a>>,
+    suffix_chunks: Option<FoldChunks<'a>>,
+    highlight_style: HighlightStyle,
+}
+
+impl<'a> Iterator for SuggestionChunks<'a> {
+    type Item = Chunk<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(chunks) = self.prefix_chunks.as_mut() {
+            if let Some(chunk) = chunks.next() {
+                return Some(chunk);
+            } else {
+                self.prefix_chunks = None;
+            }
+        }
+
+        if let Some(chunks) = self.suggestion_chunks.as_mut() {
+            if let Some(chunk) = chunks.next() {
+                return Some(Chunk {
+                    text: chunk,
+                    syntax_highlight_id: None,
+                    highlight_style: Some(self.highlight_style),
+                    diagnostic_severity: None,
+                    is_unnecessary: false,
+                });
+            } else {
+                self.suggestion_chunks = None;
+            }
+        }
+
+        if let Some(chunks) = self.suffix_chunks.as_mut() {
+            if let Some(chunk) = chunks.next() {
+                return Some(chunk);
+            } else {
+                self.suffix_chunks = None;
+            }
+        }
+
+        None
+    }
+}
+
+#[derive(Clone)]
+pub struct SuggestionBufferRows<'a> {
+    current_row: u32,
+    suggestion_row_start: u32,
+    suggestion_row_end: u32,
+    fold_buffer_rows: FoldBufferRows<'a>,
+}
+
+impl<'a> Iterator for SuggestionBufferRows<'a> {
+    type Item = Option<u32>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let row = post_inc(&mut self.current_row);
+        if row <= self.suggestion_row_start || row > self.suggestion_row_end {
+            self.fold_buffer_rows.next()
+        } else {
+            Some(None)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{display_map::fold_map::FoldMap, MultiBuffer};
+    use gpui::MutableAppContext;
+    use rand::{prelude::StdRng, Rng};
+    use settings::Settings;
+    use std::{
+        env,
+        ops::{Bound, RangeBounds},
+    };
+
+    #[gpui::test]
+    fn test_basic(cx: &mut MutableAppContext) {
+        let buffer = MultiBuffer::build_simple("abcdefghi", cx);
+        let buffer_edits = buffer.update(cx, |buffer, _| buffer.subscribe());
+        let (mut fold_map, fold_snapshot) = FoldMap::new(buffer.read(cx).snapshot(cx));
+        let (suggestion_map, suggestion_snapshot) = SuggestionMap::new(fold_snapshot.clone());
+        assert_eq!(suggestion_snapshot.text(), "abcdefghi");
+
+        let (suggestion_snapshot, _) = suggestion_map.replace(
+            Some(Suggestion {
+                position: 3,
+                text: "123\n456".into(),
+                highlight_style: Default::default(),
+            }),
+            fold_snapshot,
+            Default::default(),
+        );
+        assert_eq!(suggestion_snapshot.text(), "abc123\n456defghi");
+
+        buffer.update(cx, |buffer, cx| {
+            buffer.edit(
+                [(0..0, "ABC"), (3..3, "DEF"), (4..4, "GHI"), (9..9, "JKL")],
+                None,
+                cx,
+            )
+        });
+        let (fold_snapshot, fold_edits) = fold_map.read(
+            buffer.read(cx).snapshot(cx),
+            buffer_edits.consume().into_inner(),
+        );
+        let (suggestion_snapshot, _) = suggestion_map.sync(fold_snapshot.clone(), fold_edits);
+        assert_eq!(suggestion_snapshot.text(), "ABCabcDEF123\n456dGHIefghiJKL");
+
+        let (mut fold_map_writer, _, _) =
+            fold_map.write(buffer.read(cx).snapshot(cx), Default::default());
+        let (fold_snapshot, fold_edits) = fold_map_writer.fold([0..3]);
+        let (suggestion_snapshot, _) = suggestion_map.sync(fold_snapshot, fold_edits);
+        assert_eq!(suggestion_snapshot.text(), "⋯abcDEF123\n456dGHIefghiJKL");
+
+        let (mut fold_map_writer, _, _) =
+            fold_map.write(buffer.read(cx).snapshot(cx), Default::default());
+        let (fold_snapshot, fold_edits) = fold_map_writer.fold([6..10]);
+        let (suggestion_snapshot, _) = suggestion_map.sync(fold_snapshot, fold_edits);
+        assert_eq!(suggestion_snapshot.text(), "⋯abc⋯GHIefghiJKL");
+    }
+
+    #[gpui::test(iterations = 100)]
+    fn test_random_suggestions(cx: &mut MutableAppContext, mut rng: StdRng) {
+        cx.set_global(Settings::test(cx));
+        let operations = env::var("OPERATIONS")
+            .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
+            .unwrap_or(10);
+
+        let len = rng.gen_range(0..30);
+        let buffer = if rng.gen() {
+            let text = util::RandomCharIter::new(&mut rng)
+                .take(len)
+                .collect::<String>();
+            MultiBuffer::build_simple(&text, cx)
+        } else {
+            MultiBuffer::build_random(&mut rng, cx)
+        };
+        let mut buffer_snapshot = buffer.read(cx).snapshot(cx);
+        log::info!("buffer text: {:?}", buffer_snapshot.text());
+
+        let (mut fold_map, mut fold_snapshot) = FoldMap::new(buffer_snapshot.clone());
+        let (suggestion_map, mut suggestion_snapshot) = SuggestionMap::new(fold_snapshot.clone());
+
+        for _ in 0..operations {
+            let mut suggestion_edits = Patch::default();
+
+            let mut prev_suggestion_text = suggestion_snapshot.text();
+            let mut buffer_edits = Vec::new();
+            match rng.gen_range(0..=100) {
+                0..=29 => {
+                    let (_, edits) = suggestion_map.randomly_mutate(&mut rng);
+                    suggestion_edits = suggestion_edits.compose(edits);
+                }
+                30..=59 => {
+                    for (new_fold_snapshot, fold_edits) in fold_map.randomly_mutate(&mut rng) {
+                        fold_snapshot = new_fold_snapshot;
+                        let (_, edits) = suggestion_map.sync(fold_snapshot.clone(), fold_edits);
+                        suggestion_edits = suggestion_edits.compose(edits);
+                    }
+                }
+                _ => buffer.update(cx, |buffer, cx| {
+                    let subscription = buffer.subscribe();
+                    let edit_count = rng.gen_range(1..=5);
+                    buffer.randomly_mutate(&mut rng, edit_count, cx);
+                    buffer_snapshot = buffer.snapshot(cx);
+                    let edits = subscription.consume().into_inner();
+                    log::info!("editing {:?}", edits);
+                    buffer_edits.extend(edits);
+                }),
+            };
+
+            let (new_fold_snapshot, fold_edits) =
+                fold_map.read(buffer_snapshot.clone(), buffer_edits);
+            fold_snapshot = new_fold_snapshot;
+            let (new_suggestion_snapshot, edits) =
+                suggestion_map.sync(fold_snapshot.clone(), fold_edits);
+            suggestion_snapshot = new_suggestion_snapshot;
+            suggestion_edits = suggestion_edits.compose(edits);
+
+            log::info!("buffer text: {:?}", buffer_snapshot.text());
+            log::info!("folds text: {:?}", fold_snapshot.text());
+            log::info!("suggestions text: {:?}", suggestion_snapshot.text());
+
+            let mut expected_text = Rope::from(fold_snapshot.text().as_str());
+            let mut expected_buffer_rows = fold_snapshot.buffer_rows(0).collect::<Vec<_>>();
+            if let Some(suggestion) = suggestion_snapshot.suggestion.as_ref() {
+                expected_text.replace(
+                    suggestion.position.0..suggestion.position.0,
+                    &suggestion.text.to_string(),
+                );
+                let suggestion_start = suggestion.position.to_point(&fold_snapshot).0;
+                let suggestion_end = suggestion_start + suggestion.text.max_point();
+                expected_buffer_rows.splice(
+                    (suggestion_start.row + 1) as usize..(suggestion_start.row + 1) as usize,
+                    (0..suggestion_end.row - suggestion_start.row).map(|_| None),
+                );
+            }
+            assert_eq!(suggestion_snapshot.text(), expected_text.to_string());
+            for row_start in 0..expected_buffer_rows.len() {
+                assert_eq!(
+                    suggestion_snapshot
+                        .buffer_rows(row_start as u32)
+                        .collect::<Vec<_>>(),
+                    &expected_buffer_rows[row_start..],
+                    "incorrect buffer rows starting at {}",
+                    row_start
+                );
+            }
+
+            for _ in 0..5 {
+                let mut end = rng.gen_range(0..=suggestion_snapshot.len().0);
+                end = expected_text.clip_offset(end, Bias::Right);
+                let mut start = rng.gen_range(0..=end);
+                start = expected_text.clip_offset(start, Bias::Right);
+
+                let actual_text = suggestion_snapshot
+                    .chunks(SuggestionOffset(start)..SuggestionOffset(end), false, None)
+                    .map(|chunk| chunk.text)
+                    .collect::<String>();
+                assert_eq!(
+                    actual_text,
+                    expected_text.slice(start..end).to_string(),
+                    "incorrect text in range {:?}",
+                    start..end
+                );
+
+                let start_point = SuggestionPoint(expected_text.offset_to_point(start));
+                let end_point = SuggestionPoint(expected_text.offset_to_point(end));
+                assert_eq!(
+                    suggestion_snapshot.text_summary_for_range(start_point..end_point),
+                    expected_text.slice(start..end).summary()
+                );
+            }
+
+            for edit in suggestion_edits.into_inner() {
+                prev_suggestion_text.replace_range(
+                    edit.new.start.0..edit.new.start.0 + edit.old_len().0,
+                    &suggestion_snapshot.text()[edit.new.start.0..edit.new.end.0],
+                );
+            }
+            assert_eq!(prev_suggestion_text, suggestion_snapshot.text());
+
+            assert_eq!(expected_text.max_point(), suggestion_snapshot.max_point().0);
+            assert_eq!(expected_text.len(), suggestion_snapshot.len().0);
+
+            let mut suggestion_point = SuggestionPoint::default();
+            let mut suggestion_offset = SuggestionOffset::default();
+            for ch in expected_text.chars() {
+                assert_eq!(
+                    suggestion_snapshot.to_offset(suggestion_point),
+                    suggestion_offset,
+                    "invalid to_offset({:?})",
+                    suggestion_point
+                );
+                assert_eq!(
+                    suggestion_snapshot.to_point(suggestion_offset),
+                    suggestion_point,
+                    "invalid to_point({:?})",
+                    suggestion_offset
+                );
+                assert_eq!(
+                    suggestion_snapshot
+                        .to_suggestion_point(suggestion_snapshot.to_fold_point(suggestion_point)),
+                    suggestion_snapshot.clip_point(suggestion_point, Bias::Left),
+                );
+
+                let mut bytes = [0; 4];
+                for byte in ch.encode_utf8(&mut bytes).as_bytes() {
+                    suggestion_offset.0 += 1;
+                    if *byte == b'\n' {
+                        suggestion_point.0 += Point::new(1, 0);
+                    } else {
+                        suggestion_point.0 += Point::new(0, 1);
+                    }
+
+                    let clipped_left_point =
+                        suggestion_snapshot.clip_point(suggestion_point, Bias::Left);
+                    let clipped_right_point =
+                        suggestion_snapshot.clip_point(suggestion_point, Bias::Right);
+                    assert!(
+                        clipped_left_point <= clipped_right_point,
+                        "clipped left point {:?} is greater than clipped right point {:?}",
+                        clipped_left_point,
+                        clipped_right_point
+                    );
+                    assert_eq!(
+                        clipped_left_point.0,
+                        expected_text.clip_point(clipped_left_point.0, Bias::Left)
+                    );
+                    assert_eq!(
+                        clipped_right_point.0,
+                        expected_text.clip_point(clipped_right_point.0, Bias::Right)
+                    );
+                    assert!(clipped_left_point <= suggestion_snapshot.max_point());
+                    assert!(clipped_right_point <= suggestion_snapshot.max_point());
+
+                    if let Some(suggestion) = suggestion_snapshot.suggestion.as_ref() {
+                        let suggestion_start = suggestion.position.to_point(&fold_snapshot).0;
+                        let suggestion_end = suggestion_start + suggestion.text.max_point();
+                        let invalid_range = (
+                            Bound::Excluded(suggestion_start),
+                            Bound::Included(suggestion_end),
+                        );
+                        assert!(
+                            !invalid_range.contains(&clipped_left_point.0),
+                            "clipped left point {:?} is inside invalid suggestion range {:?}",
+                            clipped_left_point,
+                            invalid_range
+                        );
+                        assert!(
+                            !invalid_range.contains(&clipped_right_point.0),
+                            "clipped right point {:?} is inside invalid suggestion range {:?}",
+                            clipped_right_point,
+                            invalid_range
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    impl SuggestionMap {
+        pub fn randomly_mutate(
+            &self,
+            rng: &mut impl Rng,
+        ) -> (SuggestionSnapshot, Vec<SuggestionEdit>) {
+            let fold_snapshot = self.0.lock().fold_snapshot.clone();
+            let new_suggestion = if rng.gen_bool(0.3) {
+                None
+            } else {
+                let index = rng.gen_range(0..=fold_snapshot.buffer_snapshot().len());
+                let len = rng.gen_range(0..30);
+                Some(Suggestion {
+                    position: index,
+                    text: util::RandomCharIter::new(rng)
+                        .take(len)
+                        .filter(|ch| *ch != '\r')
+                        .collect::<String>()
+                        .as_str()
+                        .into(),
+                    highlight_style: Default::default(),
+                })
+            };
+
+            log::info!("replacing suggestion with {:?}", new_suggestion);
+            self.replace(new_suggestion, fold_snapshot, Default::default())
+        }
+    }
+}

crates/editor/src/display_map/tab_map.rs

@@ -1,5 +1,5 @@
 use super::{
-    fold_map::{self, FoldEdit, FoldPoint, FoldSnapshot},
+    suggestion_map::{self, SuggestionChunks, SuggestionEdit, SuggestionPoint, SuggestionSnapshot},
     TextHighlights,
 };
 use crate::MultiBufferSnapshot;
@@ -11,9 +11,9 @@ use sum_tree::Bias;
 pub struct TabMap(Mutex<TabSnapshot>);
 
 impl TabMap {
-    pub fn new(input: FoldSnapshot, tab_size: NonZeroU32) -> (Self, TabSnapshot) {
+    pub fn new(input: SuggestionSnapshot, tab_size: NonZeroU32) -> (Self, TabSnapshot) {
         let snapshot = TabSnapshot {
-            fold_snapshot: input,
+            suggestion_snapshot: input,
             tab_size,
             version: 0,
         };
@@ -22,37 +22,37 @@ impl TabMap {
 
     pub fn sync(
         &self,
-        fold_snapshot: FoldSnapshot,
-        mut fold_edits: Vec<FoldEdit>,
+        suggestion_snapshot: SuggestionSnapshot,
+        mut suggestion_edits: Vec<SuggestionEdit>,
         tab_size: NonZeroU32,
     ) -> (TabSnapshot, Vec<TabEdit>) {
         let mut old_snapshot = self.0.lock();
         let mut new_snapshot = TabSnapshot {
-            fold_snapshot,
+            suggestion_snapshot,
             tab_size,
             version: old_snapshot.version,
         };
 
-        if old_snapshot.fold_snapshot.version != new_snapshot.fold_snapshot.version {
+        if old_snapshot.suggestion_snapshot.version != new_snapshot.suggestion_snapshot.version {
             new_snapshot.version += 1;
         }
 
-        let old_max_offset = old_snapshot.fold_snapshot.len();
-        let mut tab_edits = Vec::with_capacity(fold_edits.len());
+        let old_max_offset = old_snapshot.suggestion_snapshot.len();
+        let mut tab_edits = Vec::with_capacity(suggestion_edits.len());
 
         if old_snapshot.tab_size == new_snapshot.tab_size {
-            for fold_edit in &mut fold_edits {
+            for suggestion_edit in &mut suggestion_edits {
                 let mut delta = 0;
-                for chunk in old_snapshot.fold_snapshot.chunks(
-                    fold_edit.old.end..old_max_offset,
+                for chunk in old_snapshot.suggestion_snapshot.chunks(
+                    suggestion_edit.old.end..old_max_offset,
                     false,
                     None,
                 ) {
                     let patterns: &[_] = &['\t', '\n'];
                     if let Some(ix) = chunk.text.find(patterns) {
                         if &chunk.text[ix..ix + 1] == "\t" {
-                            fold_edit.old.end.0 += delta + ix + 1;
-                            fold_edit.new.end.0 += delta + ix + 1;
+                            suggestion_edit.old.end.0 += delta + ix + 1;
+                            suggestion_edit.new.end.0 += delta + ix + 1;
                         }
 
                         break;
@@ -63,24 +63,32 @@ impl TabMap {
             }
 
             let mut ix = 1;
-            while ix < fold_edits.len() {
-                let (prev_edits, next_edits) = fold_edits.split_at_mut(ix);
+            while ix < suggestion_edits.len() {
+                let (prev_edits, next_edits) = suggestion_edits.split_at_mut(ix);
                 let prev_edit = prev_edits.last_mut().unwrap();
                 let edit = &next_edits[0];
                 if prev_edit.old.end >= edit.old.start {
                     prev_edit.old.end = edit.old.end;
                     prev_edit.new.end = edit.new.end;
-                    fold_edits.remove(ix);
+                    suggestion_edits.remove(ix);
                 } else {
                     ix += 1;
                 }
             }
 
-            for fold_edit in fold_edits {
-                let old_start = fold_edit.old.start.to_point(&old_snapshot.fold_snapshot);
-                let old_end = fold_edit.old.end.to_point(&old_snapshot.fold_snapshot);
-                let new_start = fold_edit.new.start.to_point(&new_snapshot.fold_snapshot);
-                let new_end = fold_edit.new.end.to_point(&new_snapshot.fold_snapshot);
+            for suggestion_edit in suggestion_edits {
+                let old_start = old_snapshot
+                    .suggestion_snapshot
+                    .to_point(suggestion_edit.old.start);
+                let old_end = old_snapshot
+                    .suggestion_snapshot
+                    .to_point(suggestion_edit.old.end);
+                let new_start = new_snapshot
+                    .suggestion_snapshot
+                    .to_point(suggestion_edit.new.start);
+                let new_end = new_snapshot
+                    .suggestion_snapshot
+                    .to_point(suggestion_edit.new.end);
                 tab_edits.push(TabEdit {
                     old: old_snapshot.to_tab_point(old_start)..old_snapshot.to_tab_point(old_end),
                     new: new_snapshot.to_tab_point(new_start)..new_snapshot.to_tab_point(new_end),
@@ -101,14 +109,14 @@ impl TabMap {
 
 #[derive(Clone)]
 pub struct TabSnapshot {
-    pub fold_snapshot: FoldSnapshot,
+    pub suggestion_snapshot: SuggestionSnapshot,
     pub tab_size: NonZeroU32,
     pub version: usize,
 }
 
 impl TabSnapshot {
     pub fn buffer_snapshot(&self) -> &MultiBufferSnapshot {
-        self.fold_snapshot.buffer_snapshot()
+        self.suggestion_snapshot.buffer_snapshot()
     }
 
     pub fn line_len(&self, row: u32) -> u32 {
@@ -132,10 +140,10 @@ impl TabSnapshot {
     }
 
     pub fn text_summary_for_range(&self, range: Range<TabPoint>) -> TextSummary {
-        let input_start = self.to_fold_point(range.start, Bias::Left).0;
-        let input_end = self.to_fold_point(range.end, Bias::Right).0;
+        let input_start = self.to_suggestion_point(range.start, Bias::Left).0;
+        let input_end = self.to_suggestion_point(range.end, Bias::Right).0;
         let input_summary = self
-            .fold_snapshot
+            .suggestion_snapshot
             .text_summary_for_range(input_start..input_end);
 
         let mut first_line_chars = 0;
@@ -182,12 +190,11 @@ impl TabSnapshot {
         text_highlights: Option<&'a TextHighlights>,
     ) -> TabChunks<'a> {
         let (input_start, expanded_char_column, to_next_stop) =
-            self.to_fold_point(range.start, Bias::Left);
-        let input_start = input_start.to_offset(&self.fold_snapshot);
+            self.to_suggestion_point(range.start, Bias::Left);
+        let input_start = self.suggestion_snapshot.to_offset(input_start);
         let input_end = self
-            .to_fold_point(range.end, Bias::Right)
-            .0
-            .to_offset(&self.fold_snapshot);
+            .suggestion_snapshot
+            .to_offset(self.to_suggestion_point(range.end, Bias::Right).0);
         let to_next_stop = if range.start.0 + Point::new(0, to_next_stop as u32) > range.end.0 {
             (range.end.column() - range.start.column()) as usize
         } else {
@@ -195,7 +202,7 @@ impl TabSnapshot {
         };
 
         TabChunks {
-            fold_chunks: self.fold_snapshot.chunks(
+            suggestion_chunks: self.suggestion_snapshot.chunks(
                 input_start..input_end,
                 language_aware,
                 text_highlights,
@@ -212,8 +219,8 @@ impl TabSnapshot {
         }
     }
 
-    pub fn buffer_rows(&self, row: u32) -> fold_map::FoldBufferRows {
-        self.fold_snapshot.buffer_rows(row)
+    pub fn buffer_rows(&self, row: u32) -> suggestion_map::SuggestionBufferRows {
+        self.suggestion_snapshot.buffer_rows(row)
     }
 
     #[cfg(test)]
@@ -224,45 +231,58 @@ impl TabSnapshot {
     }
 
     pub fn max_point(&self) -> TabPoint {
-        self.to_tab_point(self.fold_snapshot.max_point())
+        self.to_tab_point(self.suggestion_snapshot.max_point())
     }
 
     pub fn clip_point(&self, point: TabPoint, bias: Bias) -> TabPoint {
         self.to_tab_point(
-            self.fold_snapshot
-                .clip_point(self.to_fold_point(point, bias).0, bias),
+            self.suggestion_snapshot
+                .clip_point(self.to_suggestion_point(point, bias).0, bias),
         )
     }
 
-    pub fn to_tab_point(&self, input: FoldPoint) -> TabPoint {
-        let chars = self.fold_snapshot.chars_at(FoldPoint::new(input.row(), 0));
+    pub fn to_tab_point(&self, input: SuggestionPoint) -> TabPoint {
+        let chars = self
+            .suggestion_snapshot
+            .chars_at(SuggestionPoint::new(input.row(), 0));
         let expanded = Self::expand_tabs(chars, input.column() as usize, self.tab_size);
         TabPoint::new(input.row(), expanded as u32)
     }
 
-    pub fn to_fold_point(&self, output: TabPoint, bias: Bias) -> (FoldPoint, usize, usize) {
-        let chars = self.fold_snapshot.chars_at(FoldPoint::new(output.row(), 0));
+    pub fn to_suggestion_point(
+        &self,
+        output: TabPoint,
+        bias: Bias,
+    ) -> (SuggestionPoint, usize, usize) {
+        let chars = self
+            .suggestion_snapshot
+            .chars_at(SuggestionPoint::new(output.row(), 0));
         let expanded = output.column() as usize;
         let (collapsed, expanded_char_column, to_next_stop) =
             Self::collapse_tabs(chars, expanded, bias, self.tab_size);
         (
-            FoldPoint::new(output.row(), collapsed as u32),
+            SuggestionPoint::new(output.row(), collapsed as u32),
             expanded_char_column,
             to_next_stop,
         )
     }
 
     pub fn make_tab_point(&self, point: Point, bias: Bias) -> TabPoint {
-        self.to_tab_point(self.fold_snapshot.to_fold_point(point, bias))
+        let fold_point = self
+            .suggestion_snapshot
+            .fold_snapshot
+            .to_fold_point(point, bias);
+        let suggestion_point = self.suggestion_snapshot.to_suggestion_point(fold_point);
+        self.to_tab_point(suggestion_point)
     }
 
     pub fn to_point(&self, point: TabPoint, bias: Bias) -> Point {
-        self.to_fold_point(point, bias)
-            .0
-            .to_buffer_point(&self.fold_snapshot)
+        let suggestion_point = self.to_suggestion_point(point, bias).0;
+        let fold_point = self.suggestion_snapshot.to_fold_point(suggestion_point);
+        fold_point.to_buffer_point(&self.suggestion_snapshot.fold_snapshot)
     }
 
-    fn expand_tabs(
+    pub fn expand_tabs(
         chars: impl Iterator<Item = char>,
         column: usize,
         tab_size: NonZeroU32,
@@ -412,7 +432,7 @@ impl<'a> std::ops::AddAssign<&'a Self> for TextSummary {
 const SPACES: &str = "                ";
 
 pub struct TabChunks<'a> {
-    fold_chunks: fold_map::FoldChunks<'a>,
+    suggestion_chunks: SuggestionChunks<'a>,
     chunk: Chunk<'a>,
     column: usize,
     output_position: Point,
@@ -426,7 +446,7 @@ impl<'a> Iterator for TabChunks<'a> {
 
     fn next(&mut self) -> Option<Self::Item> {
         if self.chunk.text.is_empty() {
-            if let Some(chunk) = self.fold_chunks.next() {
+            if let Some(chunk) = self.suggestion_chunks.next() {
                 self.chunk = chunk;
                 if self.skip_leading_tab {
                     self.chunk.text = &self.chunk.text[1..];
@@ -482,7 +502,10 @@ impl<'a> Iterator for TabChunks<'a> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{display_map::fold_map::FoldMap, MultiBuffer};
+    use crate::{
+        display_map::{fold_map::FoldMap, suggestion_map::SuggestionMap},
+        MultiBuffer,
+    };
     use rand::{prelude::StdRng, Rng};
 
     #[test]
@@ -518,10 +541,13 @@ mod tests {
 
         let (mut fold_map, _) = FoldMap::new(buffer_snapshot.clone());
         fold_map.randomly_mutate(&mut rng);
-        let (folds_snapshot, _) = fold_map.read(buffer_snapshot, vec![]);
-        log::info!("FoldMap text: {:?}", folds_snapshot.text());
+        let (fold_snapshot, _) = fold_map.read(buffer_snapshot, vec![]);
+        log::info!("FoldMap text: {:?}", fold_snapshot.text());
+        let (suggestion_map, _) = SuggestionMap::new(fold_snapshot);
+        let (suggestion_snapshot, _) = suggestion_map.randomly_mutate(&mut rng);
+        log::info!("SuggestionMap text: {:?}", suggestion_snapshot.text());
 
-        let (_, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), tab_size);
+        let (_, tabs_snapshot) = TabMap::new(suggestion_snapshot.clone(), tab_size);
         let text = text::Rope::from(tabs_snapshot.text().as_str());
         log::info!(
             "TabMap text (tab size: {}): {:?}",
@@ -557,7 +583,7 @@ mod tests {
             );
 
             let mut actual_summary = tabs_snapshot.text_summary_for_range(start..end);
-            if tab_size.get() > 1 && folds_snapshot.text().contains('\t') {
+            if tab_size.get() > 1 && suggestion_snapshot.text().contains('\t') {
                 actual_summary.longest_row = expected_summary.longest_row;
                 actual_summary.longest_row_chars = expected_summary.longest_row_chars;
             }

crates/editor/src/display_map/wrap_map.rs

@@ -1,5 +1,5 @@
 use super::{
-    fold_map,
+    suggestion_map::SuggestionBufferRows,
     tab_map::{self, TabEdit, TabPoint, TabSnapshot},
     TextHighlights,
 };
@@ -64,7 +64,7 @@ pub struct WrapChunks<'a> {
 
 #[derive(Clone)]
 pub struct WrapBufferRows<'a> {
-    input_buffer_rows: fold_map::FoldBufferRows<'a>,
+    input_buffer_rows: SuggestionBufferRows<'a>,
     input_buffer_row: Option<u32>,
     output_row: u32,
     soft_wrapped: bool,
@@ -755,16 +755,24 @@ impl WrapSnapshot {
             let text = language::Rope::from(self.text().as_str());
             let input_buffer_rows = self.buffer_snapshot().buffer_rows(0).collect::<Vec<_>>();
             let mut expected_buffer_rows = Vec::new();
-            let mut prev_tab_row = 0;
+            let mut prev_fold_row = 0;
             for display_row in 0..=self.max_point().row() {
                 let tab_point = self.to_tab_point(WrapPoint::new(display_row, 0));
-                if tab_point.row() == prev_tab_row && display_row != 0 {
+                let suggestion_point = self
+                    .tab_snapshot
+                    .to_suggestion_point(tab_point, Bias::Left)
+                    .0;
+                let fold_point = self
+                    .tab_snapshot
+                    .suggestion_snapshot
+                    .to_fold_point(suggestion_point);
+                if fold_point.row() == prev_fold_row && display_row != 0 {
                     expected_buffer_rows.push(None);
                 } else {
-                    let fold_point = self.tab_snapshot.to_fold_point(tab_point, Bias::Left).0;
-                    let buffer_point = fold_point.to_buffer_point(&self.tab_snapshot.fold_snapshot);
+                    let buffer_point = fold_point
+                        .to_buffer_point(&self.tab_snapshot.suggestion_snapshot.fold_snapshot);
                     expected_buffer_rows.push(input_buffer_rows[buffer_point.row as usize]);
-                    prev_tab_row = tab_point.row();
+                    prev_fold_row = fold_point.row();
                 }
 
                 assert_eq!(self.line_len(display_row), text.line_len(display_row));
@@ -1026,7 +1034,7 @@ fn consolidate_wrap_edits(edits: &mut Vec<WrapEdit>) {
 mod tests {
     use super::*;
     use crate::{
-        display_map::{fold_map::FoldMap, tab_map::TabMap},
+        display_map::{fold_map::FoldMap, suggestion_map::SuggestionMap, tab_map::TabMap},
         MultiBuffer,
     };
     use gpui::test::observe;
@@ -1053,7 +1061,9 @@ mod tests {
             Some(rng.gen_range(0.0..=1000.0))
         };
         let tab_size = NonZeroU32::new(rng.gen_range(1..=4)).unwrap();
-        let family_id = font_cache.load_family(&["Helvetica"]).unwrap();
+        let family_id = font_cache
+            .load_family(&["Helvetica"], &Default::default())
+            .unwrap();
         let font_id = font_cache
             .select_font(family_id, &Default::default())
             .unwrap();
@@ -1074,14 +1084,13 @@ mod tests {
             }
         });
         let mut buffer_snapshot = buffer.read_with(cx, |buffer, cx| buffer.snapshot(cx));
-        let (mut fold_map, folds_snapshot) = FoldMap::new(buffer_snapshot.clone());
-        let (tab_map, tabs_snapshot) = TabMap::new(folds_snapshot.clone(), tab_size);
-        log::info!("Unwrapped text (no folds): {:?}", buffer_snapshot.text());
-        log::info!(
-            "Unwrapped text (unexpanded tabs): {:?}",
-            folds_snapshot.text()
-        );
-        log::info!("Unwrapped text (expanded tabs): {:?}", tabs_snapshot.text());
+        log::info!("Buffer text: {:?}", buffer_snapshot.text());
+        let (mut fold_map, fold_snapshot) = FoldMap::new(buffer_snapshot.clone());
+        log::info!("FoldMap text: {:?}", fold_snapshot.text());
+        let (suggestion_map, suggestion_snapshot) = SuggestionMap::new(fold_snapshot.clone());
+        log::info!("SuggestionMap text: {:?}", suggestion_snapshot.text());
+        let (tab_map, tabs_snapshot) = TabMap::new(suggestion_snapshot.clone(), tab_size);
+        log::info!("TabMap text: {:?}", tabs_snapshot.text());
 
         let mut line_wrapper = LineWrapper::new(font_id, font_size, font_system);
         let unwrapped_text = tabs_snapshot.text();
@@ -1124,9 +1133,11 @@ mod tests {
                     wrap_map.update(cx, |map, cx| map.set_wrap_width(wrap_width, cx));
                 }
                 20..=39 => {
-                    for (folds_snapshot, fold_edits) in fold_map.randomly_mutate(&mut rng) {
+                    for (fold_snapshot, fold_edits) in fold_map.randomly_mutate(&mut rng) {
+                        let (suggestion_snapshot, suggestion_edits) =
+                            suggestion_map.sync(fold_snapshot, fold_edits);
                         let (tabs_snapshot, tab_edits) =
-                            tab_map.sync(folds_snapshot, fold_edits, tab_size);
+                            tab_map.sync(suggestion_snapshot, suggestion_edits, tab_size);
                         let (mut snapshot, wrap_edits) =
                             wrap_map.update(cx, |map, cx| map.sync(tabs_snapshot, tab_edits, cx));
                         snapshot.check_invariants();
@@ -1134,6 +1145,17 @@ mod tests {
                         edits.push((snapshot, wrap_edits));
                     }
                 }
+                40..=59 => {
+                    let (suggestion_snapshot, suggestion_edits) =
+                        suggestion_map.randomly_mutate(&mut rng);
+                    let (tabs_snapshot, tab_edits) =
+                        tab_map.sync(suggestion_snapshot, suggestion_edits, tab_size);
+                    let (mut snapshot, wrap_edits) =
+                        wrap_map.update(cx, |map, cx| map.sync(tabs_snapshot, tab_edits, cx));
+                    snapshot.check_invariants();
+                    snapshot.verify_chunks(&mut rng);
+                    edits.push((snapshot, wrap_edits));
+                }
                 _ => {
                     buffer.update(cx, |buffer, cx| {
                         let subscription = buffer.subscribe();
@@ -1145,14 +1167,15 @@ mod tests {
                 }
             }
 
-            log::info!("Unwrapped text (no folds): {:?}", buffer_snapshot.text());
-            let (folds_snapshot, fold_edits) = fold_map.read(buffer_snapshot.clone(), buffer_edits);
-            log::info!(
-                "Unwrapped text (unexpanded tabs): {:?}",
-                folds_snapshot.text()
-            );
-            let (tabs_snapshot, tab_edits) = tab_map.sync(folds_snapshot, fold_edits, tab_size);
-            log::info!("Unwrapped text (expanded tabs): {:?}", tabs_snapshot.text());
+            log::info!("Buffer text: {:?}", buffer_snapshot.text());
+            let (fold_snapshot, fold_edits) = fold_map.read(buffer_snapshot.clone(), buffer_edits);
+            log::info!("FoldMap text: {:?}", fold_snapshot.text());
+            let (suggestion_snapshot, suggestion_edits) =
+                suggestion_map.sync(fold_snapshot, fold_edits);
+            log::info!("SuggestionMap text: {:?}", suggestion_snapshot.text());
+            let (tabs_snapshot, tab_edits) =
+                tab_map.sync(suggestion_snapshot, suggestion_edits, tab_size);
+            log::info!("TabMap text: {:?}", tabs_snapshot.text());
 
             let unwrapped_text = tabs_snapshot.text();
             let expected_text = wrap_text(&unwrapped_text, wrap_width, &mut line_wrapper);
@@ -1199,7 +1222,7 @@ mod tests {
                 if tab_size.get() == 1
                     || !wrapped_snapshot
                         .tab_snapshot
-                        .fold_snapshot
+                        .suggestion_snapshot
                         .text()
                         .contains('\t')
                 {

crates/editor/src/element.rs

@@ -4,17 +4,17 @@ use super::{
     ToPoint, MAX_LINE_LEN,
 };
 use crate::{
-    display_map::{BlockStyle, DisplaySnapshot, TransformBlock},
+    display_map::{BlockStyle, DisplaySnapshot, FoldStatus, TransformBlock},
     git::{diff_hunk_to_display, DisplayDiffHunk},
     hover_popover::{
-        HoverAt, HOVER_POPOVER_GAP, MIN_POPOVER_CHARACTER_WIDTH, MIN_POPOVER_LINE_HEIGHT,
+        HideHover, HoverAt, HOVER_POPOVER_GAP, MIN_POPOVER_CHARACTER_WIDTH, MIN_POPOVER_LINE_HEIGHT,
     },
     link_go_to_definition::{
         GoToFetchedDefinition, GoToFetchedTypeDefinition, UpdateGoToDefinitionLink,
     },
     mouse_context_menu::DeployMouseContextMenu,
     scroll::actions::Scroll,
-    EditorStyle,
+    EditorStyle, GutterHover, UnfoldAt,
 };
 use clock::ReplicaId;
 use collections::{BTreeMap, HashMap};
@@ -48,6 +48,9 @@ use std::{
     ops::{DerefMut, Range},
     sync::Arc,
 };
+use workspace::item::Item;
+
+enum FoldMarkers {}
 
 struct SelectionLayout {
     head: DisplayPoint,
@@ -114,6 +117,7 @@ impl EditorElement {
     fn attach_mouse_handlers(
         view: &WeakViewHandle<Editor>,
         position_map: &Arc<PositionMap>,
+        has_popovers: bool,
         visible_bounds: RectF,
         text_bounds: RectF,
         gutter_bounds: RectF,
@@ -190,6 +194,11 @@ impl EditorElement {
                         }
                     }
                 })
+                .on_move_out(move |_, cx| {
+                    if has_popovers {
+                        cx.dispatch_action(HideHover);
+                    }
+                })
                 .on_scroll({
                     let position_map = position_map.clone();
                     move |e, cx| {
@@ -206,6 +215,17 @@ impl EditorElement {
                     }
                 }),
         );
+
+        enum GutterHandlers {}
+        cx.scene.push_mouse_region(
+            MouseRegion::new::<GutterHandlers>(view.id(), view.id() + 1, gutter_bounds).on_hover(
+                |hover, cx| {
+                    cx.dispatch_action(GutterHover {
+                        hovered: hover.started,
+                    })
+                },
+            ),
+        )
     }
 
     fn mouse_down(
@@ -394,16 +414,7 @@ impl EditorElement {
     ) -> bool {
         // This will be handled more correctly once https://github.com/zed-industries/zed/issues/1218 is completed
         // Don't trigger hover popover if mouse is hovering over context menu
-        let point = if text_bounds.contains_point(position) {
-            let (point, target_point) = position_map.point_for_position(text_bounds, position);
-            if point == target_point {
-                Some(point)
-            } else {
-                None
-            }
-        } else {
-            None
-        };
+        let point = position_to_display_point(position, text_bounds, position_map);
 
         cx.dispatch_action(UpdateGoToDefinitionLink {
             point,
@@ -412,6 +423,7 @@ impl EditorElement {
         });
 
         cx.dispatch_action(HoverAt { point });
+
         true
     }
 
@@ -562,8 +574,25 @@ impl EditorElement {
             }
         }
 
+        for (ix, fold_indicator) in layout.fold_indicators.iter_mut().enumerate() {
+            if let Some(indicator) = fold_indicator.as_mut() {
+                let position = vec2f(
+                    bounds.width() - layout.gutter_padding,
+                    ix as f32 * line_height - (scroll_top % line_height),
+                );
+                let centering_offset = vec2f(
+                    (layout.gutter_padding + layout.gutter_margin - indicator.size().x()) / 2.,
+                    (line_height - indicator.size().y()) / 2.,
+                );
+
+                let indicator_origin = bounds.origin() + position + centering_offset;
+
+                indicator.paint(indicator_origin, visible_bounds, cx);
+            }
+        }
+
         if let Some((row, indicator)) = layout.code_actions_indicator.as_mut() {
-            let mut x = bounds.width() - layout.gutter_padding;
+            let mut x = 0.;
             let mut y = *row as f32 * line_height - scroll_top;
             x += ((layout.gutter_padding + layout.gutter_margin) - indicator.size().x()) / 2.;
             y += (line_height - indicator.size().y()) / 2.;
@@ -670,6 +699,7 @@ impl EditorElement {
         let max_glyph_width = layout.position_map.em_width;
         let scroll_left = scroll_position.x() * max_glyph_width;
         let content_origin = bounds.origin() + vec2f(layout.gutter_margin, 0.);
+        let line_end_overshoot = 0.15 * layout.position_map.line_height;
 
         cx.scene.push_layer(Some(bounds));
 
@@ -682,12 +712,59 @@ impl EditorElement {
             },
         });
 
+        let fold_corner_radius =
+            self.style.folds.ellipses.corner_radius_factor * layout.position_map.line_height;
+        for (id, range, color) in layout.fold_ranges.iter() {
+            self.paint_highlighted_range(
+                range.clone(),
+                *color,
+                fold_corner_radius,
+                fold_corner_radius * 2.,
+                layout,
+                content_origin,
+                scroll_top,
+                scroll_left,
+                bounds,
+                cx,
+            );
+
+            for bound in range_to_bounds(
+                &range,
+                content_origin,
+                scroll_left,
+                scroll_top,
+                &layout.visible_display_row_range,
+                line_end_overshoot,
+                &layout.position_map,
+            ) {
+                cx.scene.push_cursor_region(CursorRegion {
+                    bounds: bound,
+                    style: CursorStyle::PointingHand,
+                });
+
+                let display_row = range.start.row();
+
+                let buffer_row = DisplayPoint::new(display_row, 0)
+                    .to_point(&layout.position_map.snapshot.display_snapshot)
+                    .row;
+
+                cx.scene.push_mouse_region(
+                    MouseRegion::new::<FoldMarkers>(self.view.id(), *id as usize, bound)
+                        .on_click(MouseButton::Left, move |_, cx| {
+                            cx.dispatch_action(UnfoldAt { buffer_row })
+                        })
+                        .with_notify_on_hover(true)
+                        .with_notify_on_click(true),
+                )
+            }
+        }
+
         for (range, color) in &layout.highlighted_ranges {
             self.paint_highlighted_range(
                 range.clone(),
                 *color,
                 0.,
-                0.15 * layout.position_map.line_height,
+                line_end_overshoot,
                 layout,
                 content_origin,
                 scroll_top,
@@ -698,9 +775,10 @@ impl EditorElement {
         }
 
         let mut cursors = SmallVec::<[Cursor; 32]>::new();
+        let corner_radius = 0.15 * layout.position_map.line_height;
+
         for (replica_id, selections) in &layout.selections {
             let selection_style = style.replica_selection_style(*replica_id);
-            let corner_radius = 0.15 * layout.position_map.line_height;
 
             for selection in selections {
                 self.paint_highlighted_range(
@@ -1139,12 +1217,17 @@ impl EditorElement {
         &self,
         rows: Range<u32>,
         active_rows: &BTreeMap<u32, bool>,
+        is_singleton: bool,
         snapshot: &EditorSnapshot,
         cx: &LayoutContext,
-    ) -> Vec<Option<text_layout::Line>> {
+    ) -> (
+        Vec<Option<text_layout::Line>>,
+        Vec<Option<(FoldStatus, BufferRow, bool)>>,
+    ) {
         let style = &self.style;
         let include_line_numbers = snapshot.mode == EditorMode::Full;
         let mut line_number_layouts = Vec::with_capacity(rows.len());
+        let mut fold_statuses = Vec::with_capacity(rows.len());
         let mut line_number = String::new();
         for (ix, row) in snapshot
             .buffer_rows(rows.start)
@@ -1152,10 +1235,10 @@ impl EditorElement {
             .enumerate()
         {
             let display_row = rows.start + ix as u32;
-            let color = if active_rows.contains_key(&display_row) {
-                style.line_number_active
+            let (active, color) = if active_rows.contains_key(&display_row) {
+                (true, style.line_number_active)
             } else {
-                style.line_number
+                (false, style.line_number)
             };
             if let Some(buffer_row) = row {
                 if include_line_numbers {
@@ -1173,13 +1256,23 @@ impl EditorElement {
                             },
                         )],
                     )));
+                    fold_statuses.push(
+                        is_singleton
+                            .then(|| {
+                                snapshot
+                                    .fold_for_line(buffer_row)
+                                    .map(|fold_status| (fold_status, buffer_row, active))
+                            })
+                            .flatten(),
+                    )
                 }
             } else {
+                fold_statuses.push(None);
                 line_number_layouts.push(None);
             }
         }
 
-        line_number_layouts
+        (line_number_layouts, fold_statuses)
     }
 
     fn layout_lines(
@@ -1432,7 +1525,7 @@ impl EditorElement {
                     } else {
                         let text_style = self.style.text.clone();
                         Flex::row()
-                            .with_child(Label::new("…".to_string(), text_style).boxed())
+                            .with_child(Label::new("⋯", text_style).boxed())
                             .with_children(jump_icon)
                             .contained()
                             .with_padding_left(gutter_padding)
@@ -1528,15 +1621,14 @@ impl Element for EditorElement {
         let snapshot = self.update_view(cx.app, |view, cx| {
             view.set_visible_line_count(size.y() / line_height);
 
+            let editor_width = text_width - gutter_margin - overscroll.x() - em_width;
             let wrap_width = match view.soft_wrap_mode(cx) {
-                SoftWrap::None => Some((MAX_LINE_LEN / 2) as f32 * em_advance),
-                SoftWrap::EditorWidth => {
-                    Some(text_width - gutter_margin - overscroll.x() - em_width)
-                }
-                SoftWrap::Column(column) => Some(column as f32 * em_advance),
+                SoftWrap::None => (MAX_LINE_LEN / 2) as f32 * em_advance,
+                SoftWrap::EditorWidth => editor_width,
+                SoftWrap::Column(column) => editor_width.min(column as f32 * em_advance),
             };
 
-            if view.set_wrap_width(wrap_width, cx) {
+            if view.set_wrap_width(Some(wrap_width), cx) {
                 view.snapshot(cx)
             } else {
                 snapshot
@@ -1601,9 +1693,13 @@ impl Element for EditorElement {
         let mut active_rows = BTreeMap::new();
         let mut highlighted_rows = None;
         let mut highlighted_ranges = Vec::new();
+        let mut fold_ranges = Vec::new();
         let mut show_scrollbars = false;
         let mut include_root = false;
+        let mut is_singleton = false;
         self.update_view(cx.app, |view, cx| {
+            is_singleton = view.is_singleton(cx);
+
             let display_map = view.display_map.update(cx, |map, cx| map.snapshot(cx));
 
             highlighted_rows = view.highlighted_rows();
@@ -1611,6 +1707,19 @@ impl Element for EditorElement {
             highlighted_ranges =
                 view.background_highlights_in_range(start_anchor..end_anchor, &display_map, theme);
 
+            fold_ranges.extend(
+                snapshot
+                    .folds_in_range(start_anchor..end_anchor)
+                    .map(|anchor| {
+                        let start = anchor.start.to_point(&snapshot.buffer_snapshot);
+                        (
+                            start.row,
+                            start.to_display_point(&snapshot.display_snapshot)
+                                ..anchor.end.to_display_point(&snapshot),
+                        )
+                    }),
+            );
+
             let mut remote_selections = HashMap::default();
             for (replica_id, line_mode, cursor_shape, selection) in display_map
                 .buffer_snapshot
@@ -1679,8 +1788,28 @@ impl Element for EditorElement {
                 .unwrap_or_default()
         });
 
-        let line_number_layouts =
-            self.layout_line_numbers(start_row..end_row, &active_rows, &snapshot, cx);
+        let fold_ranges: Vec<(BufferRow, Range<DisplayPoint>, Color)> = fold_ranges
+            .into_iter()
+            .map(|(id, fold)| {
+                let color = self
+                    .style
+                    .folds
+                    .ellipses
+                    .background
+                    .style_for(&mut cx.mouse_state::<FoldMarkers>(id as usize), false)
+                    .color;
+
+                (id, fold, color)
+            })
+            .collect();
+
+        let (line_number_layouts, fold_statuses) = self.layout_line_numbers(
+            start_row..end_row,
+            &active_rows,
+            is_singleton,
+            &snapshot,
+            cx,
+        );
 
         let display_hunks = self.layout_git_gutters(start_row..end_row, &snapshot);
 
@@ -1750,7 +1879,7 @@ impl Element for EditorElement {
         let mut code_actions_indicator = None;
         let mut hover = None;
         let mut mode = EditorMode::Full;
-        cx.render(&self.view.upgrade(cx).unwrap(), |view, cx| {
+        let mut fold_indicators = cx.render(&self.view.upgrade(cx).unwrap(), |view, cx| {
             let newest_selection_head = view
                 .selections
                 .newest::<usize>(cx)
@@ -1764,14 +1893,25 @@ impl Element for EditorElement {
                         view.render_context_menu(newest_selection_head, style.clone(), cx);
                 }
 
+                let active = matches!(view.context_menu, Some(crate::ContextMenu::CodeActions(_)));
+
                 code_actions_indicator = view
-                    .render_code_actions_indicator(&style, cx)
+                    .render_code_actions_indicator(&style, active, cx)
                     .map(|indicator| (newest_selection_head.row(), indicator));
             }
 
             let visible_rows = start_row..start_row + line_layouts.len() as u32;
             hover = view.hover_state.render(&snapshot, &style, visible_rows, cx);
             mode = view.mode;
+
+            view.render_fold_indicators(
+                fold_statuses,
+                &style,
+                view.gutter_hovered,
+                line_height,
+                gutter_margin,
+                cx,
+            )
         });
 
         if let Some((_, context_menu)) = context_menu.as_mut() {
@@ -1797,6 +1937,18 @@ impl Element for EditorElement {
             );
         }
 
+        for fold_indicator in fold_indicators.iter_mut() {
+            if let Some(indicator) = fold_indicator.as_mut() {
+                indicator.layout(
+                    SizeConstraint::strict_along(
+                        Axis::Vertical,
+                        line_height * style.code_actions.vertical_scale,
+                    ),
+                    cx,
+                );
+            }
+        }
+
         if let Some((_, hover_popovers)) = hover.as_mut() {
             for hover_popover in hover_popovers.iter_mut() {
                 hover_popover.layout(
@@ -1840,12 +1992,14 @@ impl Element for EditorElement {
                 active_rows,
                 highlighted_rows,
                 highlighted_ranges,
+                fold_ranges,
                 line_number_layouts,
                 display_hunks,
                 blocks,
                 selections,
                 context_menu,
                 code_actions_indicator,
+                fold_indicators,
                 hover_popovers: hover,
             },
         )
@@ -1870,6 +2024,7 @@ impl Element for EditorElement {
         Self::attach_mouse_handlers(
             &self.view,
             &layout.position_map,
+            layout.hover_popovers.is_some(),
             visible_bounds,
             text_bounds,
             gutter_bounds,
@@ -1952,6 +2107,8 @@ impl Element for EditorElement {
     }
 }
 
+type BufferRow = u32;
+
 pub struct LayoutState {
     position_map: Arc<PositionMap>,
     gutter_size: Vector2F,
@@ -1966,6 +2123,7 @@ pub struct LayoutState {
     display_hunks: Vec<DisplayDiffHunk>,
     blocks: Vec<BlockLayout>,
     highlighted_ranges: Vec<(Range<DisplayPoint>, Color)>,
+    fold_ranges: Vec<(BufferRow, Range<DisplayPoint>, Color)>,
     selections: Vec<(ReplicaId, Vec<SelectionLayout>)>,
     scrollbar_row_range: Range<f32>,
     show_scrollbars: bool,
@@ -1973,6 +2131,7 @@ pub struct LayoutState {
     context_menu: Option<(DisplayPoint, ElementBox)>,
     code_actions_indicator: Option<(u32, ElementBox)>,
     hover_popovers: Option<(DisplayPoint, Vec<ElementBox>)>,
+    fold_indicators: Vec<Option<ElementBox>>,
 }
 
 pub struct PositionMap {
@@ -2271,6 +2430,75 @@ impl HighlightedRange {
     }
 }
 
+pub fn position_to_display_point(
+    position: Vector2F,
+    text_bounds: RectF,
+    position_map: &PositionMap,
+) -> Option<DisplayPoint> {
+    if text_bounds.contains_point(position) {
+        let (point, target_point) = position_map.point_for_position(text_bounds, position);
+        if point == target_point {
+            Some(point)
+        } else {
+            None
+        }
+    } else {
+        None
+    }
+}
+
+pub fn range_to_bounds(
+    range: &Range<DisplayPoint>,
+    content_origin: Vector2F,
+    scroll_left: f32,
+    scroll_top: f32,
+    visible_row_range: &Range<u32>,
+    line_end_overshoot: f32,
+    position_map: &PositionMap,
+) -> impl Iterator<Item = RectF> {
+    let mut bounds: SmallVec<[RectF; 1]> = SmallVec::new();
+
+    if range.start == range.end {
+        return bounds.into_iter();
+    }
+
+    let start_row = visible_row_range.start;
+    let end_row = visible_row_range.end;
+
+    let row_range = if range.end.column() == 0 {
+        cmp::max(range.start.row(), start_row)..cmp::min(range.end.row(), end_row)
+    } else {
+        cmp::max(range.start.row(), start_row)..cmp::min(range.end.row() + 1, end_row)
+    };
+
+    let first_y =
+        content_origin.y() + row_range.start as f32 * position_map.line_height - scroll_top;
+
+    for (idx, row) in row_range.enumerate() {
+        let line_layout = &position_map.line_layouts[(row - start_row) as usize];
+
+        let start_x = if row == range.start.row() {
+            content_origin.x() + line_layout.x_for_index(range.start.column() as usize)
+                - scroll_left
+        } else {
+            content_origin.x() - scroll_left
+        };
+
+        let end_x = if row == range.end.row() {
+            content_origin.x() + line_layout.x_for_index(range.end.column() as usize) - scroll_left
+        } else {
+            content_origin.x() + line_layout.width() + line_end_overshoot - scroll_left
+        };
+
+        bounds.push(RectF::from_points(
+            vec2f(start_x, first_y + position_map.line_height * idx as f32),
+            vec2f(end_x, first_y + position_map.line_height * (idx + 1) as f32),
+        ))
+    }
+
+    bounds.into_iter()
+}
+
 pub fn scale_vertical_mouse_autoscroll_delta(delta: f32) -> f32 {
     delta.powf(1.5) / 100.0
 }
@@ -2304,7 +2532,9 @@ mod tests {
             let snapshot = editor.snapshot(cx);
             let mut presenter = cx.build_presenter(window_id, 30., Default::default());
             let layout_cx = presenter.build_layout_context(Vector2F::zero(), false, cx);
-            element.layout_line_numbers(0..6, &Default::default(), &snapshot, &layout_cx)
+            element
+                .layout_line_numbers(0..6, &Default::default(), false, &snapshot, &layout_cx)
+                .0
         });
         assert_eq!(layouts.len(), 6);
     }

crates/editor/src/highlight_matching_bracket.rs

@@ -17,7 +17,7 @@ pub fn refresh_matching_bracket_highlights(editor: &mut Editor, cx: &mut ViewCon
     let snapshot = editor.snapshot(cx);
     if let Some((opening_range, closing_range)) = snapshot
         .buffer_snapshot
-        .enclosing_bracket_ranges(head..head)
+        .innermost_enclosing_bracket_ranges(head..head)
     {
         editor.highlight_background::<MatchingBracketHighlight>(
             vec![
@@ -32,11 +32,10 @@ pub fn refresh_matching_bracket_highlights(editor: &mut Editor, cx: &mut ViewCon
 
 #[cfg(test)]
 mod tests {
-    use crate::test::editor_lsp_test_context::EditorLspTestContext;
-
     use super::*;
+    use crate::test::editor_lsp_test_context::EditorLspTestContext;
     use indoc::indoc;
-    use language::{BracketPair, Language, LanguageConfig};
+    use language::{BracketPair, BracketPairConfig, Language, LanguageConfig};
 
     #[gpui::test]
     async fn test_matching_bracket_highlights(cx: &mut gpui::TestAppContext) {
@@ -45,20 +44,23 @@ mod tests {
                 LanguageConfig {
                     name: "Rust".into(),
                     path_suffixes: vec!["rs".to_string()],
-                    brackets: vec![
-                        BracketPair {
-                            start: "{".to_string(),
-                            end: "}".to_string(),
-                            close: false,
-                            newline: true,
-                        },
-                        BracketPair {
-                            start: "(".to_string(),
-                            end: ")".to_string(),
-                            close: false,
-                            newline: true,
-                        },
-                    ],
+                    brackets: BracketPairConfig {
+                        pairs: vec![
+                            BracketPair {
+                                start: "{".to_string(),
+                                end: "}".to_string(),
+                                close: false,
+                                newline: true,
+                            },
+                            BracketPair {
+                                start: "(".to_string(),
+                                end: ")".to_string(),
+                                close: false,
+                                newline: true,
+                            },
+                        ],
+                        ..Default::default()
+                    },
                     ..Default::default()
                 },
                 Some(tree_sitter_rust::language()),