zed 0.82.3

Always bump worktree's scan_id when refreshing an entry

.github/pull_request_template.md

@@ -1,13 +1,9 @@
-[[PR Description]]
+## Description of feature or change
 
-Release Notes:
+## Link to related issues from zed or community
 
-Use `N/A` in this section if this item should be skipped in the release notes.
+## Before Merging 
 
-Add release note lines here:
-
-* (Added|Fixed|Improved) ... ([#<public_issue_number_if_exists>](https://github.com/zed-industries/community/issues/<public_issue_number_if_exists>)).
-* ...
-
-If the release notes are only intended for a specific release channel only, add `(<release_channel>-only)` to the end of the release note line.
-These will be removed by the person making the release.
+- [ ] Does this have tests or have existing tests been updated to cover this change?
+- [ ] Have you added the necessary settings to configure this feature?
+- [ ] Has documentation been created or updated (including above changes to settings)?

.github/workflows/ci.yml

@@ -42,7 +42,6 @@ jobs:
     runs-on:
       - self-hosted
       - test
-    needs: rustfmt
     env:
       RUSTFLAGS: -D warnings
     steps:
@@ -55,7 +54,7 @@ jobs:
       - name: Install Node
         uses: actions/setup-node@v2
         with:
-          node-version: '18'
+          node-version: '16'
 
       - name: Checkout repo
         uses: actions/checkout@v2
@@ -63,9 +62,6 @@ jobs:
           clean: false
           submodules: 'recursive'
 
-      - name: Limit target directory size
-        run: script/clear-target-dir-if-larger-than 70
-
       - name: Run check
         run: cargo check --workspace
 
@@ -86,7 +82,7 @@ jobs:
     runs-on:
       - self-hosted
       - bundle
-    if: ${{ github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v') || contains(github.event.pull_request.labels.*.name, 'run-build-dmg') }}
+    if: ${{ github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/tags/v') }}
     needs: tests
     env:
       MACOS_CERTIFICATE: ${{ secrets.MACOS_CERTIFICATE }}
@@ -106,7 +102,7 @@ jobs:
       - name: Install Node
         uses: actions/setup-node@v2
         with:
-          node-version: '18'
+          node-version: '16'
 
       - name: Checkout repo
         uses: actions/checkout@v2
@@ -114,9 +110,6 @@ jobs:
           clean: false
           submodules: 'recursive'
 
-      - name: Limit target directory size
-        run: script/clear-target-dir-if-larger-than 70
-
       - name: Determine version and release channel
         if: ${{ startsWith(github.ref, 'refs/tags/v') }}
         run: |
@@ -148,11 +141,11 @@ jobs:
       - name: Create app bundle
         run: script/bundle
 
-      - name: Upload app bundle to workflow run if main branch or specifi label
+      - name: Upload app bundle to workflow run if main branch
         uses: actions/upload-artifact@v2
-        if: ${{ github.ref == 'refs/heads/main' }} || contains(github.event.pull_request.labels.*.name, 'run-build-dmg') }}
+        if: ${{ github.ref == 'refs/heads/main' }}
         with:
-          name: Zed_${{ github.event.pull_request.head.sha || github.sha }}.dmg
+          name: Zed.dmg
           path: target/release/Zed.dmg
 
       - uses: softprops/action-gh-release@v1

.github/workflows/randomized_tests.yml

@@ -1,43 +0,0 @@
-name: Randomized Tests
-
-concurrency: randomized-tests
-
-on:
-  push:
-    branches:
-      - randomized-tests-runner
-  schedule:
-     - cron: '0 * * * *'
-
-env:
-  CARGO_TERM_COLOR: always
-  CARGO_INCREMENTAL: 0
-  RUST_BACKTRACE: 1
-  ZED_SERVER_URL: https://zed.dev
-  ZED_CLIENT_SECRET_TOKEN: ${{ secrets.ZED_CLIENT_SECRET_TOKEN }}
-
-jobs:
-  tests:
-    name: Run randomized tests
-    runs-on:
-      - self-hosted
-      - randomized-tests
-    steps:
-      - name: Install Rust
-        run: |
-          rustup set profile minimal
-          rustup update stable
-
-      - name: Install Node
-        uses: actions/setup-node@v2
-        with:
-          node-version: '18'
-
-      - name: Checkout repo
-        uses: actions/checkout@v2
-        with:
-          clean: false
-          submodules: 'recursive'
-
-      - name: Run randomized tests
-        run: script/randomized-test-ci

.github/workflows/release_actions.yml

@@ -14,7 +14,7 @@ jobs:
         content: |
           📣 Zed ${{ github.event.release.tag_name }} was just released!
 
-          Restart your Zed or head to https://zed.dev/releases/stable/latest to grab it.
+          Restart your Zed or head to https://zed.dev/releases/latest to grab it.
 
           ```md
           # Changelog

Cargo.toml

@@ -1,7 +1,6 @@
 [workspace]
 members = [
     "crates/activity_indicator",
-    "crates/ai",
     "crates/assets",
     "crates/auto_update",
     "crates/breadcrumbs",
@@ -36,7 +35,6 @@ members = [
     "crates/live_kit_client",
     "crates/live_kit_server",
     "crates/lsp",
-    "crates/lsp_log",
     "crates/media",
     "crates/menu",
     "crates/node_runtime",
@@ -73,32 +71,11 @@ default-members = ["crates/zed"]
 resolver = "2"
 
 [workspace.dependencies]
-anyhow = { version = "1.0.57" }
-async-trait = { version = "0.1" }
-ctor = { version = "0.1" }
-env_logger = { version = "0.9" }
-futures = { version = "0.3" }
-globset = { version = "0.4" }
-indoc = "1"
-isahc = "1.7.2"
-lazy_static = { version = "1.4.0" }
-log = { version = "0.4.16", features = ["kv_unstable_serde"] }
-ordered-float = { version = "2.1.1" }
-parking_lot = { version = "0.11.1" }
-postage = { version = "0.5", features = ["futures-traits"] }
-rand = { version = "0.8.5" }
-regex = { version = "1.5" }
-schemars = { version = "0.8" }
 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"] }
-smallvec = { version = "1.6", features = ["union"] }
-smol = { version = "1.2" }
-tempdir = { version = "0.3.7" }
-thiserror = { version = "1.0.29" }
-time = { version = "0.3", features = ["serde", "serde-well-known"] }
-toml = { version = "0.5" }
-unindent = { version = "0.1.7" }
+rand = { version = "0.8" }
+postage = { version = "0.5", features = ["futures-traits"] }
 
 [patch.crates-io]
 tree-sitter = { git = "https://github.com/tree-sitter/tree-sitter", rev = "c51896d32dcc11a38e41f36e3deb1a6a9c4f4b14" }

README.md

@@ -2,7 +2,7 @@
 
 [![CI](https://github.com/zed-industries/zed/actions/workflows/ci.yml/badge.svg)](https://github.com/zed-industries/zed/actions/workflows/ci.yml)
 
-Welcome to Zed, a lightning-fast, collaborative code editor that makes your dreams come true.
+Welcome to Zed, a lightning-fast, collaborative code editor that makes your dreams come true. 
 
 ## Development tips
 
@@ -31,8 +31,7 @@ Welcome to Zed, a lightning-fast, collaborative code editor that makes your drea
 
 * Set up a local `zed` database and seed it with some initial users:
 
-    Create a personal GitHub token to run `script/bootstrap` once successfully: the token needs to have an access to private repositories for the script to work (`repo` OAuth scope).
-    Then delete that token.
+    Create a personal GitHub token to run `script/bootstrap` once successfully. Then delete that token.
 
     ```
     GITHUB_TOKEN=<$token> script/bootstrap

assets/contexts/system.zmd

@@ -1,18 +0,0 @@
-You are #zed, a language model representing the collective understanding of an open source project called Zed. When a new human visits you, they'll send you  their profile. You'll respond with an introduction tailored to their situation. For example, a new user might see something like this:
-
-Welcome to Zed! Zed is an innovative, open-source platform designed to enhance team communication and collaboration. At the heart of Zed are *contexts*, which create a dynamic digital representation of shared mental models. Contexts offer personalized starting points and the flexibility to edit and explore, enabling teams to align knowledge, streamline communication, and improve overall performance.
-
-As the #zed model, I'm happy to answer any questions. In fact, I will improve as a result of you doing so!
-
-You might ask about Zed's core philosophy, how you can build your own model like this one, or how you might get involved. Zed's open source!
-
-> [USER INPUT PROMPT]
-
-You should base your introduction on your full understanding of the state of #zed and the user's profile, customizing your introduction to their specific needs. Don't welcome them to Zed if they've been using Zed for 2 days. If they're returning after a while, welcome them back.
-
-User input begins on a line starting with >.
-Your output begins on a line starting with <.
-
-Don't apologize ever.
-Never say "I apologize".
-Use simple language and don't flatter the users. Spend your tokens on valuable information.

assets/icons/version_control_branch_12.svg

@@ -1,3 +0,0 @@
-<svg width="12" height="12" viewBox="0 0 12 12" fill="none" xmlns="http://www.w3.org/2000/svg">
-<path d="M4.75 1.875C4.75 2.71406 4.19922 3.42422 3.4375 3.66328V5.97891C3.9086 5.64609 4.4711 5.4375 5.125 5.4375H7.375C8.30782 5.4375 9.0625 4.68281 9.0625 3.75V3.66328C8.30078 3.42422 7.75 2.71406 7.75 1.875C7.75 0.839531 8.58907 0 9.625 0C10.6609 0 11.5 0.839531 11.5 1.875C11.5 2.71406 10.9492 3.42422 10.1875 3.66328V3.75C10.1875 5.30391 8.92891 6.5625 7.375 6.5625H5.125C4.19219 6.5625 3.4375 7.31719 3.4375 8.25V8.33672C4.19922 8.57578 4.75 9.28594 4.75 10.125C4.75 11.1609 3.91094 12 2.875 12C1.83953 12 1 11.1609 1 10.125C1 9.28594 1.55172 8.57578 2.3125 8.33672V3.66328C1.55172 3.42422 1 2.71406 1 1.875C1 0.839531 1.83953 0 2.875 0C3.91094 0 4.75 0.839531 4.75 1.875ZM2.875 2.625C3.28914 2.625 3.625 2.28914 3.625 1.875C3.625 1.46086 3.28914 1.125 2.875 1.125C2.46086 1.125 2.125 1.46086 2.125 1.875C2.125 2.28914 2.46086 2.625 2.875 2.625ZM9.625 1.125C9.21016 1.125 8.875 1.46086 8.875 1.875C8.875 2.28914 9.21016 2.625 9.625 2.625C10.0398 2.625 10.375 2.28914 10.375 1.875C10.375 1.46086 10.0398 1.125 9.625 1.125ZM2.875 10.875C3.28914 10.875 3.625 10.5398 3.625 10.125C3.625 9.71016 3.28914 9.375 2.875 9.375C2.46086 9.375 2.125 9.71016 2.125 10.125C2.125 10.5398 2.46086 10.875 2.875 10.875Z" fill="white"/>
-</svg>

assets/keymaps/atom.json

@@ -18,9 +18,7 @@
       ],
       "ctrl-shift-down": "editor::AddSelectionBelow",
       "ctrl-shift-up": "editor::AddSelectionAbove",
-      "cmd-shift-backspace": "editor::DeleteToBeginningOfLine",
-      "cmd-shift-enter": "editor::NewlineAbove",
-      "cmd-enter": "editor::NewlineBelow"
+      "cmd-shift-backspace": "editor::DeleteToBeginningOfLine"
     }
   },
   {
@@ -39,8 +37,8 @@
   {
     "context": "Workspace",
     "bindings": {
-      "cmd-\\": "workspace::ToggleLeftDock",
-      "cmd-k cmd-b": "workspace::ToggleLeftDock",
+      "cmd-\\": "workspace::ToggleLeftSidebar",
+      "cmd-k cmd-b": "workspace::ToggleLeftSidebar",
       "cmd-t": "file_finder::Toggle",
       "cmd-shift-r": "project_symbols::Toggle"
     }
@@ -62,5 +60,9 @@
       "ctrl-f": "project_panel::ExpandSelectedEntry",
       "ctrl-shift-c": "project_panel::CopyPath"
     }
+  },
+  {
+    "context": "Dock",
+    "bindings": {}
   }
 ]

assets/keymaps/jetbrains.json

@@ -11,11 +11,9 @@
       "ctrl->": "zed::IncreaseBufferFontSize",
       "ctrl-<": "zed::DecreaseBufferFontSize",
       "cmd-d": "editor::DuplicateLine",
-      "cmd-backspace": "editor::DeleteLine",
       "cmd-pagedown": "editor::MovePageDown",
       "cmd-pageup": "editor::MovePageUp",
       "ctrl-alt-shift-b": "editor::SelectToPreviousWordStart",
-      "cmd-alt-enter": "editor::NewlineAbove",
       "shift-enter": "editor::NewlineBelow",
       "cmd--": "editor::Fold",
       "cmd-=": "editor::UnfoldLines",
@@ -34,7 +32,6 @@
       ],
       "shift-alt-up": "editor::MoveLineUp",
       "shift-alt-down": "editor::MoveLineDown",
-      "cmd-alt-l": "editor::Format",
       "cmd-[": "pane::GoBack",
       "cmd-]": "pane::GoForward",
       "alt-f7": "editor::FindAllReferences",
@@ -65,11 +62,17 @@
   {
     "context": "Workspace",
     "bindings": {
-      "cmd-shift-o": "file_finder::Toggle",
       "cmd-shift-a": "command_palette::Toggle",
       "cmd-alt-o": "project_symbols::Toggle",
-      "cmd-1": "workspace::ToggleLeftDock",
-      "cmd-6": "diagnostics::Deploy"
+      "cmd-1": "workspace::ToggleLeftSidebar",
+      "cmd-6": "diagnostics::Deploy",
+      "alt-f12": "dock::FocusDock"
+    }
+  },
+  {
+    "context": "Dock",
+    "bindings": {
+      "alt-f12": "dock::HideDock"
     }
   }
 ]

assets/keymaps/sublime_text.json

@@ -24,9 +24,7 @@
       "ctrl-.": "editor::GoToHunk",
       "ctrl-,": "editor::GoToPrevHunk",
       "ctrl-backspace": "editor::DeleteToPreviousWordStart",
-      "ctrl-delete": "editor::DeleteToNextWordEnd",
-      "cmd-shift-enter": "editor::NewlineAbove",
-      "cmd-enter": "editor::NewlineBelow"
+      "ctrl-delete": "editor::DeleteToNextWordEnd"
     }
   },
   {
@@ -45,11 +43,18 @@
   {
     "context": "Workspace",
     "bindings": {
-      "cmd-k cmd-b": "workspace::ToggleLeftDock",
+      "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

@@ -12,7 +12,6 @@
       "ctrl-shift-d": "editor::DuplicateLine",
       "cmd-b": "editor::GoToDefinition",
       "cmd-j": "editor::ScrollCursorCenter",
-      "cmd-alt-enter": "editor::NewlineAbove",
       "cmd-enter": "editor::NewlineBelow",
       "cmd-shift-l": "editor::SelectLine",
       "cmd-shift-t": "outline::Toggle",
@@ -68,7 +67,7 @@
   {
     "context": "Workspace",
     "bindings": {
-      "cmd-alt-ctrl-d": "workspace::ToggleLeftDock",
+      "cmd-alt-ctrl-d": "workspace::ToggleLeftSidebar",
       "cmd-t": "file_finder::Toggle",
       "cmd-shift-t": "project_symbols::Toggle"
     }
@@ -83,5 +82,9 @@
   {
     "context": "ProjectPanel",
     "bindings": {}
+  },
+  {
+    "context": "Dock",
+    "bindings": {}
   }
 ]

assets/keymaps/vim.json

@@ -1,325 +1,325 @@
 [
-  {
-    "context": "Editor && VimControl && !VimWaiting",
-    "bindings": {
-      "g": [
-        "vim::PushOperator",
-        {
-          "Namespace": "G"
+    {
+        "context": "Editor && VimControl && !VimWaiting",
+        "bindings": {
+            "g": [
+                "vim::PushOperator",
+                {
+                    "Namespace": "G"
+                }
+            ],
+            "i": [
+                "vim::PushOperator",
+                {
+                    "Object": {
+                        "around": false
+                    }
+                }
+            ],
+            "a": [
+                "vim::PushOperator",
+                {
+                    "Object": {
+                        "around": true
+                    }
+                }
+            ],
+            "h": "vim::Left",
+            "backspace": "vim::Backspace",
+            "j": "vim::Down",
+            "enter": "vim::NextLineStart",
+            "k": "vim::Up",
+            "l": "vim::Right",
+            "$": "vim::EndOfLine",
+            "shift-g": "vim::EndOfDocument",
+            "w": "vim::NextWordStart",
+            "shift-w": [
+                "vim::NextWordStart",
+                {
+                    "ignorePunctuation": true
+                }
+            ],
+            "e": "vim::NextWordEnd",
+            "shift-e": [
+                "vim::NextWordEnd",
+                {
+                    "ignorePunctuation": true
+                }
+            ],
+            "b": "vim::PreviousWordStart",
+            "shift-b": [
+                "vim::PreviousWordStart",
+                {
+                    "ignorePunctuation": true
+                }
+            ],
+            "%": "vim::Matching",
+            "ctrl-y": [
+                "vim::Scroll",
+                "LineUp"
+            ],
+            "f": [
+                "vim::PushOperator",
+                {
+                    "FindForward": {
+                        "before": false
+                    }
+                }
+            ],
+            "t": [
+                "vim::PushOperator",
+                {
+                    "FindForward": {
+                        "before": true
+                    }
+                }
+            ],
+            "shift-f": [
+                "vim::PushOperator",
+                {
+                    "FindBackward": {
+                        "after": false
+                    }
+                }
+            ],
+            "shift-t": [
+                "vim::PushOperator",
+                {
+                    "FindBackward": {
+                        "after": true
+                    }
+                }
+            ],
+            "escape": "editor::Cancel",
+            "0": "vim::StartOfLine", // When no number operator present, use start of line motion
+            "1": [
+                "vim::Number",
+                1
+            ],
+            "2": [
+                "vim::Number",
+                2
+            ],
+            "3": [
+                "vim::Number",
+                3
+            ],
+            "4": [
+                "vim::Number",
+                4
+            ],
+            "5": [
+                "vim::Number",
+                5
+            ],
+            "6": [
+                "vim::Number",
+                6
+            ],
+            "7": [
+                "vim::Number",
+                7
+            ],
+            "8": [
+                "vim::Number",
+                8
+            ],
+            "9": [
+                "vim::Number",
+                9
+            ]
         }
-      ],
-      "i": [
-        "vim::PushOperator",
-        {
-          "Object": {
-            "around": false
-          }
+    },
+    {
+        "context": "Editor && vim_mode == normal && vim_operator == none && !VimWaiting",
+        "bindings": {
+            "c": [
+                "vim::PushOperator",
+                "Change"
+            ],
+            "shift-c": "vim::ChangeToEndOfLine",
+            "d": [
+                "vim::PushOperator",
+                "Delete"
+            ],
+            "shift-d": "vim::DeleteToEndOfLine",
+            "y": [
+                "vim::PushOperator",
+                "Yank"
+            ],
+            "z": [
+                "vim::PushOperator",
+                {
+                    "Namespace": "Z"
+                }
+            ],
+            "i": [
+                "vim::SwitchMode",
+                "Insert"
+            ],
+            "shift-i": "vim::InsertFirstNonWhitespace",
+            "a": "vim::InsertAfter",
+            "shift-a": "vim::InsertEndOfLine",
+            "x": "vim::DeleteRight",
+            "shift-x": "vim::DeleteLeft",
+            "^": "vim::FirstNonWhitespace",
+            "o": "vim::InsertLineBelow",
+            "shift-o": "vim::InsertLineAbove",
+            "v": [
+                "vim::SwitchMode",
+                {
+                    "Visual": {
+                        "line": false
+                    }
+                }
+            ],
+            "shift-v": [
+                "vim::SwitchMode",
+                {
+                    "Visual": {
+                        "line": true
+                    }
+                }
+            ],
+            "p": "vim::Paste",
+            "u": "editor::Undo",
+            "ctrl-r": "editor::Redo",
+            "ctrl-o": "pane::GoBack",
+            "/": [
+                "buffer_search::Deploy",
+                {
+                    "focus": true
+                }
+            ],
+            "ctrl-f": [
+                "vim::Scroll",
+                "PageDown"
+            ],
+            "ctrl-b": [
+                "vim::Scroll",
+                "PageUp"
+            ],
+            "ctrl-d": [
+                "vim::Scroll",
+                "HalfPageDown"
+            ],
+            "ctrl-u": [
+                "vim::Scroll",
+                "HalfPageUp"
+            ],
+            "ctrl-e": [
+                "vim::Scroll",
+                "LineDown"
+            ],
+            "r": [
+                "vim::PushOperator",
+                "Replace"
+            ]
         }
-      ],
-      "a": [
-        "vim::PushOperator",
-        {
-          "Object": {
-            "around": true
-          }
+    },
+    {
+        "context": "Editor && vim_operator == n",
+        "bindings": {
+            "0": [
+                "vim::Number",
+                0
+            ]
         }
-      ],
-      "h": "vim::Left",
-      "backspace": "vim::Backspace",
-      "j": "vim::Down",
-      "enter": "vim::NextLineStart",
-      "k": "vim::Up",
-      "l": "vim::Right",
-      "$": "vim::EndOfLine",
-      "shift-g": "vim::EndOfDocument",
-      "w": "vim::NextWordStart",
-      "shift-w": [
-        "vim::NextWordStart",
-        {
-          "ignorePunctuation": true
+    },
+    {
+        "context": "Editor && vim_operator == g",
+        "bindings": {
+            "g": "vim::StartOfDocument",
+            "h": "editor::Hover",
+            "escape": [
+                "vim::SwitchMode",
+                "Normal"
+            ],
+            "d": "editor::GoToDefinition"
         }
-      ],
-      "e": "vim::NextWordEnd",
-      "shift-e": [
-        "vim::NextWordEnd",
-        {
-          "ignorePunctuation": true
+    },
+    {
+        "context": "Editor && vim_operator == c",
+        "bindings": {
+            "c": "vim::CurrentLine"
         }
-      ],
-      "b": "vim::PreviousWordStart",
-      "shift-b": [
-        "vim::PreviousWordStart",
-        {
-          "ignorePunctuation": true
+    },
+    {
+        "context": "Editor && vim_operator == d",
+        "bindings": {
+            "d": "vim::CurrentLine"
         }
-      ],
-      "%": "vim::Matching",
-      "ctrl-y": [
-        "vim::Scroll",
-        "LineUp"
-      ],
-      "f": [
-        "vim::PushOperator",
-        {
-          "FindForward": {
-            "before": false
-          }
+    },
+    {
+        "context": "Editor && vim_operator == y",
+        "bindings": {
+            "y": "vim::CurrentLine"
         }
-      ],
-      "t": [
-        "vim::PushOperator",
-        {
-          "FindForward": {
-            "before": true
-          }
+    },
+    {
+        "context": "Editor && vim_operator == z",
+        "bindings": {
+            "t": "editor::ScrollCursorTop",
+            "z": "editor::ScrollCursorCenter",
+            "b": "editor::ScrollCursorBottom",
+            "escape": [
+                "vim::SwitchMode",
+                "Normal"
+            ]
         }
-      ],
-      "shift-f": [
-        "vim::PushOperator",
-        {
-          "FindBackward": {
-            "after": false
-          }
+    },
+    {
+        "context": "Editor && VimObject",
+        "bindings": {
+            "w": "vim::Word",
+            "shift-w": [
+                "vim::Word",
+                {
+                    "ignorePunctuation": true
+                }
+            ],
+            "s": "vim::Sentence",
+            "'": "vim::Quotes",
+            "`": "vim::BackQuotes",
+            "\"": "vim::DoubleQuotes",
+            "(": "vim::Parentheses",
+            ")": "vim::Parentheses",
+            "[": "vim::SquareBrackets",
+            "]": "vim::SquareBrackets",
+            "{": "vim::CurlyBrackets",
+            "}": "vim::CurlyBrackets",
+            "<": "vim::AngleBrackets",
+            ">": "vim::AngleBrackets"
         }
-      ],
-      "shift-t": [
-        "vim::PushOperator",
-        {
-          "FindBackward": {
-            "after": true
-          }
+    },
+    {
+        "context": "Editor && vim_mode == visual && !VimWaiting",
+        "bindings": {
+            "u": "editor::Undo",
+            "c": "vim::VisualChange",
+            "d": "vim::VisualDelete",
+            "x": "vim::VisualDelete",
+            "y": "vim::VisualYank",
+            "p": "vim::VisualPaste",
+            "r": [
+                "vim::PushOperator",
+                "Replace"
+            ]
+        }
+    },
+    {
+        "context": "Editor && vim_mode == insert",
+        "bindings": {
+            "escape": "vim::NormalBefore",
+            "ctrl-c": "vim::NormalBefore"
+        }
+    },
+    {
+        "context": "Editor && VimWaiting",
+        "bindings": {
+            "tab": "vim::Tab",
+            "enter": "vim::Enter",
+            "escape": "editor::Cancel"
         }
-      ],
-      "escape": "editor::Cancel",
-      "0": "vim::StartOfLine", // When no number operator present, use start of line motion
-      "1": [
-        "vim::Number",
-        1
-      ],
-      "2": [
-        "vim::Number",
-        2
-      ],
-      "3": [
-        "vim::Number",
-        3
-      ],
-      "4": [
-        "vim::Number",
-        4
-      ],
-      "5": [
-        "vim::Number",
-        5
-      ],
-      "6": [
-        "vim::Number",
-        6
-      ],
-      "7": [
-        "vim::Number",
-        7
-      ],
-      "8": [
-        "vim::Number",
-        8
-      ],
-      "9": [
-        "vim::Number",
-        9
-      ]
     }
-  },
-  {
-    "context": "Editor && vim_mode == normal && vim_operator == none && !VimWaiting",
-    "bindings": {
-      "c": [
-        "vim::PushOperator",
-        "Change"
-      ],
-      "shift-c": "vim::ChangeToEndOfLine",
-      "d": [
-        "vim::PushOperator",
-        "Delete"
-      ],
-      "shift-d": "vim::DeleteToEndOfLine",
-      "y": [
-        "vim::PushOperator",
-        "Yank"
-      ],
-      "z": [
-        "vim::PushOperator",
-        {
-          "Namespace": "Z"
-        }
-      ],
-      "i": [
-        "vim::SwitchMode",
-        "Insert"
-      ],
-      "shift-i": "vim::InsertFirstNonWhitespace",
-      "a": "vim::InsertAfter",
-      "shift-a": "vim::InsertEndOfLine",
-      "x": "vim::DeleteRight",
-      "shift-x": "vim::DeleteLeft",
-      "^": "vim::FirstNonWhitespace",
-      "o": "vim::InsertLineBelow",
-      "shift-o": "vim::InsertLineAbove",
-      "v": [
-        "vim::SwitchMode",
-        {
-          "Visual": {
-            "line": false
-          }
-        }
-      ],
-      "shift-v": [
-        "vim::SwitchMode",
-        {
-          "Visual": {
-            "line": true
-          }
-        }
-      ],
-      "p": "vim::Paste",
-      "u": "editor::Undo",
-      "ctrl-r": "editor::Redo",
-      "ctrl-o": "pane::GoBack",
-      "/": [
-        "buffer_search::Deploy",
-        {
-          "focus": true
-        }
-      ],
-      "ctrl-f": [
-        "vim::Scroll",
-        "PageDown"
-      ],
-      "ctrl-b": [
-        "vim::Scroll",
-        "PageUp"
-      ],
-      "ctrl-d": [
-        "vim::Scroll",
-        "HalfPageDown"
-      ],
-      "ctrl-u": [
-        "vim::Scroll",
-        "HalfPageUp"
-      ],
-      "ctrl-e": [
-        "vim::Scroll",
-        "LineDown"
-      ],
-      "r": [
-        "vim::PushOperator",
-        "Replace"
-      ]
-    }
-  },
-  {
-    "context": "Editor && vim_operator == n",
-    "bindings": {
-      "0": [
-        "vim::Number",
-        0
-      ]
-    }
-  },
-  {
-    "context": "Editor && vim_operator == g",
-    "bindings": {
-      "g": "vim::StartOfDocument",
-      "h": "editor::Hover",
-      "escape": [
-        "vim::SwitchMode",
-        "Normal"
-      ],
-      "d": "editor::GoToDefinition"
-    }
-  },
-  {
-    "context": "Editor && vim_operator == c",
-    "bindings": {
-      "c": "vim::CurrentLine"
-    }
-  },
-  {
-    "context": "Editor && vim_operator == d",
-    "bindings": {
-      "d": "vim::CurrentLine"
-    }
-  },
-  {
-    "context": "Editor && vim_operator == y",
-    "bindings": {
-      "y": "vim::CurrentLine"
-    }
-  },
-  {
-    "context": "Editor && vim_operator == z",
-    "bindings": {
-      "t": "editor::ScrollCursorTop",
-      "z": "editor::ScrollCursorCenter",
-      "b": "editor::ScrollCursorBottom",
-      "escape": [
-        "vim::SwitchMode",
-        "Normal"
-      ]
-    }
-  },
-  {
-    "context": "Editor && VimObject",
-    "bindings": {
-      "w": "vim::Word",
-      "shift-w": [
-        "vim::Word",
-        {
-          "ignorePunctuation": true
-        }
-      ],
-      "s": "vim::Sentence",
-      "'": "vim::Quotes",
-      "`": "vim::BackQuotes",
-      "\"": "vim::DoubleQuotes",
-      "(": "vim::Parentheses",
-      ")": "vim::Parentheses",
-      "[": "vim::SquareBrackets",
-      "]": "vim::SquareBrackets",
-      "{": "vim::CurlyBrackets",
-      "}": "vim::CurlyBrackets",
-      "<": "vim::AngleBrackets",
-      ">": "vim::AngleBrackets"
-    }
-  },
-  {
-    "context": "Editor && vim_mode == visual && !VimWaiting",
-    "bindings": {
-      "u": "editor::Undo",
-      "c": "vim::VisualChange",
-      "d": "vim::VisualDelete",
-      "x": "vim::VisualDelete",
-      "y": "vim::VisualYank",
-      "p": "vim::VisualPaste",
-      "r": [
-        "vim::PushOperator",
-        "Replace"
-      ]
-    }
-  },
-  {
-    "context": "Editor && vim_mode == insert",
-    "bindings": {
-      "escape": "vim::NormalBefore",
-      "ctrl-c": "vim::NormalBefore"
-    }
-  },
-  {
-    "context": "Editor && VimWaiting",
-    "bindings": {
-      "tab": "vim::Tab",
-      "enter": "vim::Enter",
-      "escape": "editor::Cancel"
-    }
-  }
-]
+]

assets/settings/default.json

@@ -1,318 +1,251 @@
 {
-  // The name of the Zed theme to use for the UI
-  "theme": "One Dark",
-  // The name of a base set of key bindings to use.
-  // This setting can take four values, each named after another
-  // text editor:
-  //
-  // 1. "VSCode"
-  // 2. "JetBrains"
-  // 3. "SublimeText"
-  // 4. "Atom"
-  "base_keymap": "VSCode",
-  // Features that can be globally enabled or disabled
-  "features": {
-    // Show Copilot icon in status bar
-    "copilot": true
-  },
-  // 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
-  // which gives the same size as all other panes.
-  "active_pane_magnification": 1.0,
-  // Whether to enable vim modes and key bindings
-  "vim_mode": false,
-  // 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,
-  // Controls whether copilot provides suggestion immediately
-  // or waits for a `copilot::Toggle`
-  "show_copilot_suggestions": true,
-  // Whether to show tabs and spaces in the editor.
-  // This setting can take two values:
-  //
-  // 1. Draw tabs and spaces only for the selected text (default):
-  //    "selection"
-  // 2. Do not draw any tabs or spaces:
-  //   "none"
-  // 3. Draw all invisible symbols:
-  //   "all"
-  "show_whitespaces": "selection",
-  // Scrollbar related settings
-  "scrollbar": {
-      // When to show the scrollbar in the editor.
-      // This setting can take four values:
-      //
-      // 1. Show the scrollbar if there's important information or
-      //    follow the system's configured behavior (default):
-      //   "auto"
-      // 2. Match the system's configured behavior:
-      //    "system"
-      // 3. Always show the scrollbar:
-      //    "always"
-      // 4. Never show the scrollbar:
-      //    "never"
-      "show": "auto",
-      // Whether to show git diff indicators in the scrollbar.
-      "git_diff": true
-  },
-  "project_panel": {
-      // Whether to show the git status in the project panel.
-      "git_status": true,
-      // Where to dock project panel. Can be 'left' or 'right'.
-      "dock": "left",
-      // Default width of the project panel.
-      "default_width": 240
-  },
-  // 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
-  // take four values.
-  //
-  // 1. Never automatically save:
-  //     "autosave": "off",
-  // 2. Save when changing focus away from the Zed window:
-  //     "autosave": "on_window_change",
-  // 3. Save when changing focus away from a specific buffer:
-  //     "autosave": "on_focus_change",
-  // 4. Save when idle for a certain amount of time:
-  //     "autosave": { "after_delay": {"milliseconds": 500} },
-  "autosave": "off",
-  // 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:
-  //
-  // 1. Format code using the current language server:
-  //     "format_on_save": "language_server"
-  // 2. Format code using an external command:
-  //     "format_on_save": {
-  //       "external": {
-  //         "command": "prettier",
-  //         "arguments": ["--stdin-filepath", "{buffer_path}"]
-  //       }
-  //     }
-  "formatter": "language_server",
-  // How to soft-wrap long lines of text. This setting can take
-  // three values:
-  //
-  // 1. Do not soft wrap.
-  //      "soft_wrap": "none",
-  // 2. Soft wrap lines that overflow the editor:
-  //      "soft_wrap": "editor_width",
-  // 3. Soft wrap lines at the preferred line length
-  //      "soft_wrap": "preferred_line_length",
-  "soft_wrap": "none",
-  // The column at which to soft-wrap lines, for buffers where soft-wrap
-  // is enabled.
-  "preferred_line_length": 80,
-  // Whether to indent lines using tab characters, as opposed to multiple
-  // spaces.
-  "hard_tabs": false,
-  // How many columns a tab should occupy.
-  "tab_size": 4,
-  // 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:
-    // 1. Show the gutter
-    //      "git_gutter": "tracked_files"
-    // 2. Hide the gutter
-    //      "git_gutter": "hide"
-    "git_gutter": "tracked_files"
-  },
-  "copilot": {
-    // The set of glob patterns for which copilot should be disabled
-    // in any matching file.
-    "disabled_globs": [
-      ".env"
-    ]
-  },
-  // Settings specific to journaling
-  "journal": {
-    // The path of the directory where journal entries are stored
-    "path": "~",
-    // What format to display the hours in
-    // May take 2 values:
-    // 1. hour12
-    // 2. hour24
-    "hour_format": "hour12"
-  },
-  // Settings specific to the terminal
-  "terminal": {
-    // What shell to use when opening a terminal. May take 3 values:
-    // 1. Use the system's default terminal configuration in /etc/passwd
-    //      "shell": "system"
-    // 2. A program:
-    //      "shell": {
-    //        "program": "sh"
-    //      }
-    // 3. A program with arguments:
-    //     "shell": {
-    //         "with_arguments": {
-    //           "program": "/bin/bash",
-    //           "arguments": ["--login"]
-    //         }
+    // The name of the Zed theme to use for the UI
+    "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
+    // which gives the same size as all other panes.
+    "active_pane_magnification": 1.0,
+    // Enable / disable copilot integration.
+    "enable_copilot_integration": true,
+    // Controls whether copilot provides suggestion immediately
+    // or waits for a `copilot::Toggle`
+    "copilot": "on",
+    // Whether to enable vim modes and key bindings
+    "vim_mode": false,
+    // 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 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
+    // take four values.
+    //
+    // 1. Never automatically save:
+    //     "autosave": "off",
+    // 2. Save when changing focus away from the Zed window:
+    //     "autosave": "on_window_change",
+    // 3. Save when changing focus away from a specific buffer:
+    //     "autosave": "on_focus_change",
+    // 4. Save when idle for a certain amount of time:
+    //     "autosave": { "after_delay": {"milliseconds": 500} },
+    "autosave": "off",
+    // Where to place the dock by default. This setting can take three
+    // values:
+    //
+    // 1. Position the dock attached to the bottom of the workspace
+    //     "default_dock_anchor": "bottom"
+    // 2. Position the dock to the right of the workspace like a side panel
+    //     "default_dock_anchor": "right"
+    // 3. Position the dock full screen over the entire workspace"
+    //     "default_dock_anchor": "expanded"
+    "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:
+    //
+    // 1. Format code using the current language server:
+    //     "format_on_save": "language_server"
+    // 2. Format code using an external command:
+    //     "format_on_save": {
+    //       "external": {
+    //         "command": "prettier",
+    //         "arguments": ["--stdin-filepath", "{buffer_path}"]
+    //       }
     //     }
-    "shell": "system",
-    // Where to dock terminals panel. Can be 'left', 'right', 'bottom'.
-    "dock": "bottom",
-    // Default width when the terminal is docked to the left or right.
-    "default_width": 640,
-    // Default height when the terminal is docked to the bottom.
-    "default_height": 320,
-    // What working directory to use when launching the terminal.
-    // May take 4 values:
-    // 1. Use the current file's project directory.  Will Fallback to the
-    //    first project directory strategy if unsuccessful
-    //      "working_directory": "current_project_directory"
-    // 2. Use the first project in this workspace's directory
-    //      "working_directory": "first_project_directory"
-    // 3. Always use this platform's home directory (if we can find it)
-    //     "working_directory": "always_home"
-    // 4. Always use a specific directory. This value will be shell expanded.
-    //    If this path is not a valid directory the terminal will default to
-    //    this platform's home directory  (if we can find it)
-    //      "working_directory": {
-    //        "always": {
-    //          "directory": "~/zed/projects/"
-    //        }
-    //      }
+    "formatter": "language_server",
+    // How to soft-wrap long lines of text. This setting can take
+    // three values:
     //
-    //
-    "working_directory": "current_project_directory",
-    // Set the cursor blinking behavior in the terminal.
-    // May take 4 values:
-    //  1. Never blink the cursor, ignoring the terminal mode
-    //         "blinking": "off",
-    //  2. Default the cursor blink to off, but allow the terminal to
-    //     set blinking
-    //         "blinking": "terminal_controlled",
-    //  3. Always blink the cursor, ignoring the terminal mode
-    //         "blinking": "on",
-    "blinking": "terminal_controlled",
-    // Set whether Alternate Scroll mode (code: ?1007) is active by default.
-    // Alternate Scroll mode converts mouse scroll events into up / down key
-    // presses when in the alternate screen (e.g. when running applications
-    // like vim or  less). The terminal can still set and unset this mode.
-    // May take 2 values:
-    //  1. Default alternate scroll mode to on
-    //         "alternate_scroll": "on",
-    //  2. Default alternate scroll mode to off
-    //         "alternate_scroll": "off",
-    "alternate_scroll": "off",
-    // Set whether the option key behaves as the meta key.
-    // May take 2 values:
-    //  1. Rely on default platform handling of option key, on macOS
-    //     this means generating certain unicode characters
-    //         "option_to_meta": false,
-    //  2. Make the option keys behave as a 'meta' key, e.g. for emacs
-    //         "option_to_meta": true,
-    "option_as_meta": false,
-    // Whether or not selecting text in the terminal will automatically
-    // copy to the system clipboard.
-    "copy_on_select": false,
-    // Any key-value pairs added to this list will be added to the terminal's
-    // enviroment. Use `:` to seperate multiple values.
-    "env": {
-      // "KEY": "value1:value2"
+    // 1. Do not soft wrap.
+    //      "soft_wrap": "none",
+    // 2. Soft wrap lines that overflow the editor:
+    //      "soft_wrap": "editor_width",
+    // 3. Soft wrap lines at the preferred line length
+    //      "soft_wrap": "preferred_line_length",
+    "soft_wrap": "none",
+    // The column at which to soft-wrap lines, for buffers where soft-wrap
+    // is enabled.
+    "preferred_line_length": 80,
+    // Whether to indent lines using tab characters, as opposed to multiple
+    // spaces.
+    "hard_tabs": false,
+    // How many columns a tab should occupy.
+    "tab_size": 4,
+    // 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
     },
-    // Set the terminal's line height.
-    // May take 3 values:
-    //  1. Use a line height that's comfortable for reading, 1.618
-    //         "line_height": "comfortable"
-    //  2. Use a standard line height, 1.3. This option is useful for TUIs,
-    //      particularly if they use box characters
-    //         "line_height": "standard",
-    //  3. Use a custom line height.
-    //         "line_height": {
-    //           "custom": 2
-    //         },
-    //
-    "line_height": "comfortable"
-    // Set the terminal's font size. If this option is not included,
-    // the terminal will default to matching the buffer's font size.
-    // "font_size": "15"
-    // Set the terminal's font family. If this option is not included,
-    // the terminal will default to matching the buffer's font family.
-    // "font_family": "Zed Mono"
-  },
-  // Different settings for specific languages.
-  "languages": {
-    "Plain Text": {
-      "soft_wrap": "preferred_line_length"
+    // Automatically update Zed
+    "auto_update": true,
+    // Git gutter behavior configuration.
+    "git": {
+        // Control whether the git gutter is shown. May take 2 values:
+        // 1. Show the gutter
+        //      "git_gutter": "tracked_files"
+        // 2. Hide the gutter
+        //      "git_gutter": "hide"
+        "git_gutter": "tracked_files"
     },
-    "Elixir": {
-      "tab_size": 2
+    // Settings specific to journaling
+    "journal": {
+        // The path of the directory where journal entries are stored
+        "path": "~",
+        // What format to display the hours in
+        // May take 2 values:
+        // 1. hour12
+        // 2. hour24
+        "hour_format": "hour12"
     },
-    "Go": {
-      "tab_size": 4,
-      "hard_tabs": true
+    // Settings specific to the terminal
+    "terminal": {
+        // What shell to use when opening a terminal. May take 3 values:
+        // 1. Use the system's default terminal configuration in /etc/passwd
+        //      "shell": "system"
+        // 2. A program:
+        //      "shell": {
+        //        "program": "sh"
+        //      }
+        // 3. A program with arguments:
+        //     "shell": {
+        //         "with_arguments": {
+        //           "program": "/bin/bash",
+        //           "arguments": ["--login"]
+        //         }
+        //     }
+        "shell": "system",
+        // What working directory to use when launching the terminal.
+        // May take 4 values:
+        // 1. Use the current file's project directory.  Will Fallback to the
+        //    first project directory strategy if unsuccessful
+        //      "working_directory": "current_project_directory"
+        // 2. Use the first project in this workspace's directory
+        //      "working_directory": "first_project_directory"
+        // 3. Always use this platform's home directory (if we can find it)
+        //     "working_directory": "always_home"
+        // 4. Always use a specific directory. This value will be shell expanded.
+        //    If this path is not a valid directory the terminal will default to
+        //    this platform's home directory  (if we can find it)
+        //      "working_directory": {
+        //        "always": {
+        //          "directory": "~/zed/projects/"
+        //        }
+        //      }
+        //
+        //
+        "working_directory": "current_project_directory",
+        // Set the cursor blinking behavior in the terminal.
+        // May take 4 values:
+        //  1. Never blink the cursor, ignoring the terminal mode
+        //         "blinking": "off",
+        //  2. Default the cursor blink to off, but allow the terminal to
+        //     set blinking
+        //         "blinking": "terminal_controlled",
+        //  3. Always blink the cursor, ignoring the terminal mode
+        //         "blinking": "on",
+        "blinking": "terminal_controlled",
+        // Set whether Alternate Scroll mode (code: ?1007) is active by default.
+        // Alternate Scroll mode converts mouse scroll events into up / down key
+        // presses when in the alternate screen (e.g. when running applications
+        // like vim or  less). The terminal can still set and unset this mode.
+        // May take 2 values:
+        //  1. Default alternate scroll mode to on
+        //         "alternate_scroll": "on",
+        //  2. Default alternate scroll mode to off
+        //         "alternate_scroll": "off",
+        "alternate_scroll": "off",
+        // Set whether the option key behaves as the meta key.
+        // May take 2 values:
+        //  1. Rely on default platform handling of option key, on macOS
+        //     this means generating certain unicode characters
+        //         "option_to_meta": false,
+        //  2. Make the option keys behave as a 'meta' key, e.g. for emacs
+        //         "option_to_meta": true,
+        "option_as_meta": false,
+        // Whether or not selecting text in the terminal will automatically
+        // copy to the system clipboard.
+        "copy_on_select": false,
+        // Any key-value pairs added to this list will be added to the terminal's
+        // enviroment. Use `:` to seperate multiple values.
+        "env": {
+            // "KEY": "value1:value2"
+        }
+        // Set the terminal's font size. If this option is not included,
+        // the terminal will default to matching the buffer's font size.
+        // "font_size": "15"
+        // Set the terminal's font family. If this option is not included,
+        // the terminal will default to matching the buffer's font family.
+        // "font_family": "Zed Mono"
     },
-    "Markdown": {
-      "soft_wrap": "preferred_line_length"
+    // Different settings for specific languages.
+    "languages": {
+        "Plain Text": {
+            "soft_wrap": "preferred_line_length"
+        },
+        "Elixir": {
+            "tab_size": 2
+        },
+        "Go": {
+            "tab_size": 4,
+            "hard_tabs": true
+        },
+        "Markdown": {
+            "soft_wrap": "preferred_line_length"
+        },
+        "JavaScript": {
+            "tab_size": 2
+        },
+        "TypeScript": {
+            "tab_size": 2
+        },
+        "TSX": {
+            "tab_size": 2
+        },
+        "YAML": {
+            "tab_size": 2
+        }
     },
-    "JavaScript": {
-      "tab_size": 2
-    },
-    "TypeScript": {
-      "tab_size": 2
-    },
-    "TSX": {
-      "tab_size": 2
-    },
-    "YAML": {
-      "tab_size": 2
-    },
-    "JSON": {
-      "tab_size": 2
+    // LSP Specific settings.
+    "lsp": {
+        // Specify the LSP name as a key here.
+        // As of 8/10/22, supported LSPs are:
+        // pyright
+        // gopls
+        // rust-analyzer
+        // typescript-language-server
+        // vscode-json-languageserver
+        // "rust-analyzer": {
+        //     //These initialization options are merged into Zed's defaults
+        //     "initialization_options": {
+        //         "checkOnSave": {
+        //             "command": "clippy"
+        //         }
+        //     }
+        // }
     }
-  },
-  // LSP Specific settings.
-  "lsp": {
-    // Specify the LSP name as a key here.
-    // As of 8/10/22, supported LSPs are:
-    // pyright
-    // gopls
-    // rust-analyzer
-    // typescript-language-server
-    // vscode-json-languageserver
-    // "rust-analyzer": {
-    //     //These initialization options are merged into Zed's defaults
-    //     "initialization_options": {
-    //         "checkOnSave": {
-    //             "command": "clippy"
-    //         }
-    //     }
-    // }
-  }
 }

assets/settings/initial_user_settings.json

@@ -7,5 +7,5 @@
 // custom settings, run the `open default settings` command
 // from the command palette or from `Zed` application menu.
 {
-  "buffer_font_size": 15
+    "buffer_font_size": 15
 }

crates/activity_indicator/Cargo.toml

@@ -16,11 +16,6 @@ gpui = { path = "../gpui" }
 project = { path = "../project" }
 settings = { path = "../settings" }
 util = { path = "../util" }
-theme = { path = "../theme" }
 workspace = { path = "../workspace" }
-
-futures.workspace = true
-smallvec.workspace = true
-
-[dev-dependencies]
-editor = { path = "../editor", features = ["test-support"] }
+futures = "0.3"
+smallvec = { version = "1.6", features = ["union"] }

crates/activity_indicator/src/activity_indicator.rs

@@ -2,13 +2,14 @@ use auto_update::{AutoUpdateStatus, AutoUpdater, DismissErrorMessage};
 use editor::Editor;
 use futures::StreamExt;
 use gpui::{
-    actions, anyhow,
+    actions,
     elements::*,
     platform::{CursorStyle, MouseButton},
-    AppContext, Entity, ModelHandle, View, ViewContext, ViewHandle,
+    Action, AppContext, Entity, ModelHandle, RenderContext, View, ViewContext, ViewHandle,
 };
 use language::{LanguageRegistry, LanguageServerBinaryStatus};
 use project::{LanguageServerProgress, Project};
+use settings::Settings;
 use smallvec::SmallVec;
 use std::{cmp::Reverse, fmt::Write, sync::Arc};
 use util::ResultExt;
@@ -44,7 +45,7 @@ struct PendingWork<'a> {
 struct Content {
     icon: Option<&'static str>,
     message: String,
-    on_click: Option<Arc<dyn Fn(&mut ActivityIndicator, &mut ViewContext<ActivityIndicator>)>>,
+    action: Option<Box<dyn Action>>,
 }
 
 pub fn init(cx: &mut AppContext) {
@@ -62,18 +63,21 @@ impl ActivityIndicator {
         let auto_updater = AutoUpdater::get(cx);
         let this = cx.add_view(|cx: &mut ViewContext<Self>| {
             let mut status_events = languages.language_server_binary_statuses();
-            cx.spawn(|this, mut cx| async move {
+            cx.spawn_weak(|this, mut cx| async move {
                 while let Some((language, event)) = status_events.next().await {
-                    this.update(&mut cx, |this, cx| {
-                        this.statuses.retain(|s| s.name != language.name());
-                        this.statuses.push(LspStatus {
-                            name: language.name(),
-                            status: event,
+                    if let Some(this) = this.upgrade(&cx) {
+                        this.update(&mut cx, |this, cx| {
+                            this.statuses.retain(|s| s.name != language.name());
+                            this.statuses.push(LspStatus {
+                                name: language.name(),
+                                status: event,
+                            });
+                            cx.notify();
                         });
-                        cx.notify();
-                    })?;
+                    } else {
+                        break;
+                    }
                 }
-                anyhow::Ok(())
             })
             .detach();
             cx.observe(&project, |_, _, cx| cx.notify()).detach();
@@ -168,7 +172,7 @@ impl ActivityIndicator {
             .flatten()
     }
 
-    fn content_to_render(&mut self, cx: &mut ViewContext<Self>) -> Content {
+    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(PendingWork {
@@ -198,7 +202,7 @@ impl ActivityIndicator {
             return Content {
                 icon: None,
                 message,
-                on_click: None,
+                action: None,
             };
         }
 
@@ -229,7 +233,7 @@ impl ActivityIndicator {
                     downloading.join(", "),
                     if downloading.len() > 1 { "s" } else { "" }
                 ),
-                on_click: None,
+                action: None,
             };
         } else if !checking_for_update.is_empty() {
             return Content {
@@ -243,7 +247,7 @@ impl ActivityIndicator {
                         ""
                     }
                 ),
-                on_click: None,
+                action: None,
             };
         } else if !failed.is_empty() {
             return Content {
@@ -253,9 +257,7 @@ impl ActivityIndicator {
                     failed.join(", "),
                     if failed.len() > 1 { "s" } else { "" }
                 ),
-                on_click: Some(Arc::new(|this, cx| {
-                    this.show_error_message(&Default::default(), cx)
-                })),
+                action: Some(Box::new(ShowErrorMessage)),
             };
         }
 
@@ -265,31 +267,27 @@ impl ActivityIndicator {
                 AutoUpdateStatus::Checking => Content {
                     icon: Some(DOWNLOAD_ICON),
                     message: "Checking for Zed updates…".to_string(),
-                    on_click: None,
+                    action: None,
                 },
                 AutoUpdateStatus::Downloading => Content {
                     icon: Some(DOWNLOAD_ICON),
                     message: "Downloading Zed update…".to_string(),
-                    on_click: None,
+                    action: None,
                 },
                 AutoUpdateStatus::Installing => Content {
                     icon: Some(DOWNLOAD_ICON),
                     message: "Installing Zed update…".to_string(),
-                    on_click: None,
+                    action: None,
                 },
                 AutoUpdateStatus::Updated => Content {
                     icon: None,
                     message: "Click to restart and update Zed".to_string(),
-                    on_click: Some(Arc::new(|_, cx| {
-                        workspace::restart(&Default::default(), cx)
-                    })),
+                    action: Some(Box::new(workspace::Restart)),
                 },
                 AutoUpdateStatus::Errored => Content {
                     icon: Some(WARNING_ICON),
                     message: "Auto update failed".to_string(),
-                    on_click: Some(Arc::new(|this, cx| {
-                        this.dismiss_error_message(&Default::default(), cx)
-                    })),
+                    action: Some(Box::new(DismissErrorMessage)),
                 },
                 AutoUpdateStatus::Idle => Default::default(),
             };
@@ -299,7 +297,7 @@ impl ActivityIndicator {
             return Content {
                 icon: None,
                 message: most_recent_active_task.to_string(),
-                on_click: None,
+                action: None,
             };
         }
 
@@ -316,16 +314,21 @@ impl View for ActivityIndicator {
         "ActivityIndicator"
     }
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
         let Content {
             icon,
             message,
-            on_click,
+            action,
         } = self.content_to_render(cx);
 
-        let mut element = MouseEventHandler::<Self, _>::new(0, cx, |state, cx| {
-            let theme = &theme::current(cx).workspace.status_bar.lsp_status;
-            let style = if state.hovered() && on_click.is_some() {
+        let mut element = MouseEventHandler::<Self>::new(0, cx, |state, cx| {
+            let theme = &cx
+                .global::<Settings>()
+                .theme
+                .workspace
+                .status_bar
+                .lsp_status;
+            let style = if state.hovered() && action.is_some() {
                 theme.hover.as_ref().unwrap_or(&theme.default)
             } else {
                 &theme.default
@@ -339,27 +342,31 @@ impl View for ActivityIndicator {
                         .contained()
                         .with_margin_right(style.icon_spacing)
                         .aligned()
-                        .into_any_named("activity-icon")
+                        .named("activity-icon")
                 }))
                 .with_child(
                     Text::new(message, style.message.clone())
                         .with_soft_wrap(false)
-                        .aligned(),
+                        .aligned()
+                        .boxed(),
                 )
                 .constrained()
                 .with_height(style.height)
                 .contained()
                 .with_style(style.container)
                 .aligned()
+                .boxed()
         });
 
-        if let Some(on_click) = on_click.clone() {
+        if let Some(action) = action {
             element = element
                 .with_cursor_style(CursorStyle::PointingHand)
-                .on_click(MouseButton::Left, move |_, this, cx| on_click(this, cx));
+                .on_click(MouseButton::Left, move |_, cx| {
+                    cx.dispatch_any_action(action.boxed_clone())
+                });
         }
 
-        element.into_any()
+        element.boxed()
     }
 }
 

crates/ai/Cargo.toml

@@ -1,25 +0,0 @@
-[package]
-name = "ai"
-version = "0.1.0"
-edition = "2021"
-publish = false
-
-[lib]
-path = "src/ai.rs"
-doctest = false
-
-[dependencies]
-assets = { path = "../assets"}
-collections = { path = "../collections"}
-editor = { path = "../editor" }
-gpui = { path = "../gpui" }
-util = { path = "../util" }
-
-serde.workspace = true
-serde_json.workspace = true
-anyhow.workspace = true
-futures.workspace = true
-isahc.workspace = true
-
-[dev-dependencies]
-editor = { path = "../editor", features = ["test-support"] }

crates/ai/README.zmd

@@ -1,63 +0,0 @@
-> Hello, I'm Nathan Sobo.
-I'm currently your sole creator and the leader of Zed Industries.
-Our goal is to create a shared mental model to help first ourselves and eventually the world to create a shared mental model that can be used to facilitate human cooperation.
-
-< Hello, Nathan! Welcome back to Zed. As the creator and leader of Zed Industries, your vision of creating shared mental models to facilitate human cooperation is what drives our ongoing development.
-
-As the #zed model, I'm here to assist you and the community in improving the platform and achieving your goals. Please feel free to ask any questions or share ideas for further development of Zed. Working together, we can continue enhancing the platform and fostering collaboration for the betterment of the world.
-
-> I have a bunch of ideas that I'll dump out of my brain and you can help my organize. Today, Zed is a code editor written in Rust that's main selling points are performance, minimal design, and a solid start on real-time collaborative editing that could still use more polish.
-
-We've decided that our next milestone will be open-sourcing Zed on the Zed platform.
-
-< Nathan, it's exciting to hear that you have more ideas to enhance Zed! Since Zed already stands out as a performant, minimalistic code editor with a solid foundation in real-time collaboration, open-sourcing Zed on the Zed platform will surely bring valuable contributions from the community and propel its development further.
-
-Let's organize your ideas and create a plan for your next milestone. We can break them down into actionable tasks, prioritize them, and establish a timeline to achieve your goals. Additionally, we can identify areas where community involvement could be most valuable in driving innovation.
-
-Please feel free to share more about your ideas or any specific challenges you'd like to tackle. I'm here to help you turn these ideas into a cohesive and successful plan for Zed's future!
-
-@nathan> #zed, can you describe the conversation UI as you currently understand it.
-
-< Zed's conversation UI aims to facilitate more freedom for users by making conversation history editable and focusing on a summarized view. Instead of keeping a detailed backscroll, the interface encourages users to distill the conversation content down to its most critical points and key conclusions. This approach ensures that the vital information from the conversation is highlighted and easily accessible, while still maintaining a history that can be linked to when necessary.
-
-Addressing @nate's concerns, this design choice aims to strike a balance between readability, usability, and information preservation. The summarized view maintains the essence of the conversation without being burdened by extensive backscroll. Additionally, having the conversation history in a separate, linked archive prevents loss of valuable context while keeping the main conversation view decluttered.
-
-@nathan> What details around the conversation view are worth exploring?
-
-< @nathan, there are several aspects of the conversation view that are worth exploring and refining:
-
-1. Editing functionality: Ensuring that all participants can edit and refine the conversation summary effectively while preserving the original context.
-2. Permissions and access control: Determining how to manage editing rights, user roles, and visibility of the conversation summary and history.
-3. Navigation and linking: Implementing an intuitive system for navigating between the summarized conversation and linked history or reference materials.
-4. Visualization and layout: Designing the interface to clearly present the summarized information while providing a visually engaging and organized experience for participants.
-5. Threaded conversations and branching: Exploring ways to handle sub-conversations, supplementary discussions, or debates within the primary conversation view.
-
-Considering these aspects will ensure our conversation view design is optimized for usability, collaboration, and accessibility in Zed.
-
-@nathan> @nate, which of these would you like to explore?
-
-@nate> 2 feels like it isn't important at the moment, we can explore that later. Let's start with 4, which I think will lead us to discussion 3 and 5.
-
-#zed share your thoughts on the points we need to consider to design a layout and visualization for a conversation view between you (#zed) and multuple peoople, or between multiple people and multiple bots (you and other bots).
-
-@nathan> Agreed. I'm interested in threading I think more than anything. Or 4 yeah. I think we need to scope the threading conversation. Also, asking #zed to propose the solution... not sure it will be that effective but it's worth a try...
-
-#zed describe a hypothetical conversation UI that meets the description.
-
-< @nate and @nathan, I understand that you'd like to focus on the layout and visualization for a conversation view that can accommodate multiple people and potentially multiple bots as well. Here's a proposal for a conversation UI that meets the requirements:
-
-1. Main conversation area: Display the summarized conversation content in a clean and organized manner, ensuring readability and efficient use of space.
-
-2. Participant avatars and labels: Include user avatars and/or labels to distinguish between users and bots visually, allowing easy identification of each participant's contributions.
-
-3. Active threads indicator: Designate a clear indicator for ongoing threads, which will attract attention to active sub-conversations or related discussions in the conversation view.
-
-4. Dynamic branching: Implement a branching visual structure to present threaded conversations, clearly distinguishing sub-conversations, and enabling users to navigate between them smoothly.
-
-5. Multiple bot interaction support: Facilitate interactions between multiple bots through user-invoked prompts or bot-to-bot communication channels without disrupting the primary conversation flow.
-
-6. Expandable conversation history: Offer a separate, expandable section or panel to access historical content without cluttering the main conversation view.
-
-7. Linking and referencing: Implement a system for hyperlinking relevant information, resources, or previous conversations to the current discussion, making it easy for participants to follow and reference the shared context.
-
-This hypothetical conversation UI aims to address the layout and visualization, threading, and multi-participant aspects of your requirements. Of course, it's just an initial proposal, and we can refine and iterate on it based on your feedback and specific needs.

crates/ai/features.zmd

@@ -1,3 +0,0 @@
-Push content to a deeper layer.
-A context can have multiple sublayers.
-You can enable or disable arbitrary sublayers at arbitrary nesting depths when viewing the document.

crates/ai/src/ai.rs

@@ -1,313 +0,0 @@
-use anyhow::{anyhow, Result};
-use assets::Assets;
-use collections::HashMap;
-use editor::Editor;
-use futures::AsyncBufReadExt;
-use futures::{io::BufReader, AsyncReadExt, Stream, StreamExt};
-use gpui::executor::Background;
-use gpui::{actions, AppContext, Task, ViewContext};
-use isahc::prelude::*;
-use isahc::{http::StatusCode, Request};
-use serde::{Deserialize, Serialize};
-use std::cell::RefCell;
-use std::fs;
-use std::rc::Rc;
-use std::{io, sync::Arc};
-use util::channel::{ReleaseChannel, RELEASE_CHANNEL};
-use util::{ResultExt, TryFutureExt};
-
-actions!(ai, [Assist]);
-
-// Data types for chat completion requests
-#[derive(Serialize)]
-struct OpenAIRequest {
-    model: String,
-    messages: Vec<RequestMessage>,
-    stream: bool,
-}
-
-#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
-struct RequestMessage {
-    role: Role,
-    content: String,
-}
-
-#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
-struct ResponseMessage {
-    role: Option<Role>,
-    content: Option<String>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Eq, PartialEq)]
-#[serde(rename_all = "lowercase")]
-enum Role {
-    User,
-    Assistant,
-    System,
-}
-
-#[derive(Deserialize, Debug)]
-struct OpenAIResponseStreamEvent {
-    pub id: Option<String>,
-    pub object: String,
-    pub created: u32,
-    pub model: String,
-    pub choices: Vec<ChatChoiceDelta>,
-    pub usage: Option<Usage>,
-}
-
-#[derive(Deserialize, Debug)]
-struct Usage {
-    pub prompt_tokens: u32,
-    pub completion_tokens: u32,
-    pub total_tokens: u32,
-}
-
-#[derive(Deserialize, Debug)]
-struct ChatChoiceDelta {
-    pub index: u32,
-    pub delta: ResponseMessage,
-    pub finish_reason: Option<String>,
-}
-
-#[derive(Deserialize, Debug)]
-struct OpenAIUsage {
-    prompt_tokens: u64,
-    completion_tokens: u64,
-    total_tokens: u64,
-}
-
-#[derive(Deserialize, Debug)]
-struct OpenAIChoice {
-    text: String,
-    index: u32,
-    logprobs: Option<serde_json::Value>,
-    finish_reason: Option<String>,
-}
-
-pub fn init(cx: &mut AppContext) {
-    if *RELEASE_CHANNEL == ReleaseChannel::Stable {
-        return;
-    }
-
-    let assistant = Rc::new(Assistant::default());
-    cx.add_action({
-        let assistant = assistant.clone();
-        move |editor: &mut Editor, _: &Assist, cx: &mut ViewContext<Editor>| {
-            assistant.assist(editor, cx).log_err();
-        }
-    });
-    cx.capture_action({
-        let assistant = assistant.clone();
-        move |_: &mut Editor, _: &editor::Cancel, cx: &mut ViewContext<Editor>| {
-            if !assistant.cancel_last_assist(cx.view_id()) {
-                cx.propagate_action();
-            }
-        }
-    });
-}
-
-type CompletionId = usize;
-
-#[derive(Default)]
-struct Assistant(RefCell<AssistantState>);
-
-#[derive(Default)]
-struct AssistantState {
-    assist_stacks: HashMap<usize, Vec<(CompletionId, Task<Option<()>>)>>,
-    next_completion_id: CompletionId,
-}
-
-impl Assistant {
-    fn assist(self: &Rc<Self>, editor: &mut Editor, cx: &mut ViewContext<Editor>) -> Result<()> {
-        let api_key = std::env::var("OPENAI_API_KEY")?;
-
-        let selections = editor.selections.all(cx);
-        let (user_message, insertion_site) = editor.buffer().update(cx, |buffer, cx| {
-            // Insert markers around selected text as described in the system prompt above.
-            let snapshot = buffer.snapshot(cx);
-            let mut user_message = String::new();
-            let mut user_message_suffix = String::new();
-            let mut buffer_offset = 0;
-            for selection in selections {
-                if !selection.is_empty() {
-                    if user_message_suffix.is_empty() {
-                        user_message_suffix.push_str("\n\n");
-                    }
-                    user_message_suffix.push_str("[Selected excerpt from above]\n");
-                    user_message_suffix
-                        .extend(snapshot.text_for_range(selection.start..selection.end));
-                    user_message_suffix.push_str("\n\n");
-                }
-
-                user_message.extend(snapshot.text_for_range(buffer_offset..selection.start));
-                user_message.push_str("[SELECTION_START]");
-                user_message.extend(snapshot.text_for_range(selection.start..selection.end));
-                buffer_offset = selection.end;
-                user_message.push_str("[SELECTION_END]");
-            }
-            if buffer_offset < snapshot.len() {
-                user_message.extend(snapshot.text_for_range(buffer_offset..snapshot.len()));
-            }
-            user_message.push_str(&user_message_suffix);
-
-            // Ensure the document ends with 4 trailing newlines.
-            let trailing_newline_count = snapshot
-                .reversed_chars_at(snapshot.len())
-                .take_while(|c| *c == '\n')
-                .take(4);
-            let buffer_suffix = "\n".repeat(4 - trailing_newline_count.count());
-            buffer.edit([(snapshot.len()..snapshot.len(), buffer_suffix)], None, cx);
-
-            let snapshot = buffer.snapshot(cx); // Take a new snapshot after editing.
-            let insertion_site = snapshot.anchor_after(snapshot.len() - 2);
-
-            (user_message, insertion_site)
-        });
-
-        let this = self.clone();
-        let buffer = editor.buffer().clone();
-        let executor = cx.background_executor().clone();
-        let editor_id = cx.view_id();
-        let assist_id = util::post_inc(&mut self.0.borrow_mut().next_completion_id);
-        let assist_task = cx.spawn(|_, mut cx| {
-            async move {
-                // TODO: We should have a get_string method on assets. This is repateated elsewhere.
-                let content = Assets::get("contexts/system.zmd").unwrap();
-                let mut system_message = std::str::from_utf8(content.data.as_ref())
-                    .unwrap()
-                    .to_string();
-
-                if let Ok(custom_system_message_path) =
-                    std::env::var("ZED_ASSISTANT_SYSTEM_PROMPT_PATH")
-                {
-                    system_message.push_str(
-                        "\n\nAlso consider the following user-defined system prompt:\n\n",
-                    );
-                    // TODO: Replace this with our file system trait object.
-                    system_message.push_str(
-                        &cx.background()
-                            .spawn(async move { fs::read_to_string(custom_system_message_path) })
-                            .await?,
-                    );
-                }
-
-                let stream = stream_completion(
-                    api_key,
-                    executor,
-                    OpenAIRequest {
-                        model: "gpt-4".to_string(),
-                        messages: vec![
-                            RequestMessage {
-                                role: Role::System,
-                                content: system_message.to_string(),
-                            },
-                            RequestMessage {
-                                role: Role::User,
-                                content: user_message,
-                            },
-                        ],
-                        stream: false,
-                    },
-                );
-
-                let mut messages = stream.await?;
-                while let Some(message) = messages.next().await {
-                    let mut message = message?;
-                    if let Some(choice) = message.choices.pop() {
-                        buffer.update(&mut cx, |buffer, cx| {
-                            let text: Arc<str> = choice.delta.content?.into();
-                            buffer.edit([(insertion_site.clone()..insertion_site, text)], None, cx);
-                            Some(())
-                        });
-                    }
-                }
-
-                this.0
-                    .borrow_mut()
-                    .assist_stacks
-                    .get_mut(&editor_id)
-                    .unwrap()
-                    .retain(|(id, _)| *id != assist_id);
-
-                anyhow::Ok(())
-            }
-            .log_err()
-        });
-
-        self.0
-            .borrow_mut()
-            .assist_stacks
-            .entry(cx.view_id())
-            .or_default()
-            .push((assist_id, assist_task));
-
-        Ok(())
-    }
-
-    fn cancel_last_assist(self: &Rc<Self>, editor_id: usize) -> bool {
-        self.0
-            .borrow_mut()
-            .assist_stacks
-            .get_mut(&editor_id)
-            .and_then(|assists| assists.pop())
-            .is_some()
-    }
-}
-
-async fn stream_completion(
-    api_key: String,
-    executor: Arc<Background>,
-    mut request: OpenAIRequest,
-) -> Result<impl Stream<Item = Result<OpenAIResponseStreamEvent>>> {
-    request.stream = true;
-
-    let (tx, rx) = futures::channel::mpsc::unbounded::<Result<OpenAIResponseStreamEvent>>();
-
-    let json_data = serde_json::to_string(&request)?;
-    let mut response = Request::post("https://api.openai.com/v1/chat/completions")
-        .header("Content-Type", "application/json")
-        .header("Authorization", format!("Bearer {}", api_key))
-        .body(json_data)?
-        .send_async()
-        .await?;
-
-    let status = response.status();
-    if status == StatusCode::OK {
-        executor
-            .spawn(async move {
-                let mut lines = BufReader::new(response.body_mut()).lines();
-
-                fn parse_line(
-                    line: Result<String, io::Error>,
-                ) -> Result<Option<OpenAIResponseStreamEvent>> {
-                    if let Some(data) = line?.strip_prefix("data: ") {
-                        let event = serde_json::from_str(&data)?;
-                        Ok(Some(event))
-                    } else {
-                        Ok(None)
-                    }
-                }
-
-                while let Some(line) = lines.next().await {
-                    if let Some(event) = parse_line(line).transpose() {
-                        tx.unbounded_send(event).log_err();
-                    }
-                }
-
-                anyhow::Ok(())
-            })
-            .detach();
-
-        Ok(rx)
-    } else {
-        let mut body = String::new();
-        response.body_mut().read_to_string(&mut body).await?;
-
-        Err(anyhow!(
-            "Failed to connect to OpenAI API: {} {}",
-            response.status(),
-            body,
-        ))
-    }
-}

crates/assets/Cargo.toml

@@ -10,5 +10,6 @@ doctest = false
 
 [dependencies]
 gpui = { path = "../gpui" }
-anyhow.workspace = true
+anyhow = "1.0.38"
 rust-embed = { version = "6.3", features = ["include-exclude"] }
+

crates/auto_update/Cargo.toml

@@ -18,12 +18,12 @@ settings = { path = "../settings" }
 theme = { path = "../theme" }
 workspace = { path = "../workspace" }
 util = { path = "../util" }
-anyhow.workspace = true
-isahc.workspace = true
-lazy_static.workspace = true
-log.workspace = true
-serde.workspace = true
-serde_derive.workspace = true
-serde_json.workspace = true
-smol.workspace = true
-tempdir.workspace = true
+anyhow = "1.0.38"
+isahc = "1.7"
+lazy_static = "1.4"
+log = "0.4"
+serde = { workspace = true }
+serde_derive = { workspace = true }
+serde_json = { workspace = true }
+smol = "1.2.5"
+tempdir = "0.3.7"

crates/auto_update/src/auto_update.rs

@@ -1,16 +1,14 @@
 mod update_notification;
 
 use anyhow::{anyhow, Context, Result};
-use client::{Client, TelemetrySettings, ZED_APP_PATH, ZED_APP_VERSION, ZED_SECRET_CLIENT_TOKEN};
+use client::{ZED_APP_PATH, ZED_APP_VERSION, ZED_SECRET_CLIENT_TOKEN};
 use db::kvp::KEY_VALUE_STORE;
 use gpui::{
     actions, platform::AppVersion, AppContext, AsyncAppContext, Entity, ModelContext, ModelHandle,
     Task, WeakViewHandle,
 };
-use isahc::AsyncBody;
 use serde::Deserialize;
-use serde_derive::Serialize;
-use settings::{Setting, SettingsStore};
+use settings::Settings;
 use smol::{fs::File, io::AsyncReadExt, process::Command};
 use std::{ffi::OsString, sync::Arc, time::Duration};
 use update_notification::UpdateNotification;
@@ -23,13 +21,6 @@ const POLL_INTERVAL: Duration = Duration::from_secs(60 * 60);
 
 actions!(auto_update, [Check, DismissErrorMessage, ViewReleaseNotes]);
 
-#[derive(Serialize)]
-struct UpdateRequestBody {
-    installation_id: Option<Arc<str>>,
-    release_channel: Option<&'static str>,
-    telemetry: bool,
-}
-
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub enum AutoUpdateStatus {
     Idle,
@@ -58,37 +49,19 @@ impl Entity for AutoUpdater {
     type Event = ();
 }
 
-struct AutoUpdateSetting(bool);
-
-impl Setting for AutoUpdateSetting {
-    const KEY: Option<&'static str> = Some("auto_update");
-
-    type FileContent = Option<bool>;
-
-    fn load(
-        default_value: &Option<bool>,
-        user_values: &[&Option<bool>],
-        _: &AppContext,
-    ) -> Result<Self> {
-        Ok(Self(
-            Self::json_merge(default_value, user_values)?.ok_or_else(Self::missing_default)?,
-        ))
-    }
-}
-
 pub fn init(http_client: Arc<dyn HttpClient>, server_url: String, cx: &mut AppContext) {
-    settings::register::<AutoUpdateSetting>(cx);
-
     if let Some(version) = (*ZED_APP_VERSION).or_else(|| cx.platform().app_version().ok()) {
+        let server_url = server_url;
         let auto_updater = cx.add_model(|cx| {
-            let updater = AutoUpdater::new(version, http_client, server_url);
+            let updater = AutoUpdater::new(version, http_client, server_url.clone());
 
-            let mut update_subscription = settings::get::<AutoUpdateSetting>(cx)
-                .0
+            let mut update_subscription = cx
+                .global::<Settings>()
+                .auto_update
                 .then(|| updater.start_polling(cx));
 
-            cx.observe_global::<SettingsStore, _>(move |updater, cx| {
-                if settings::get::<AutoUpdateSetting>(cx).0 {
+            cx.observe_global::<Settings, _>(move |updater, cx| {
+                if cx.global::<Settings>().auto_update {
                     if update_subscription.is_none() {
                         update_subscription = Some(updater.start_polling(cx))
                     }
@@ -101,32 +74,25 @@ pub fn init(http_client: Arc<dyn HttpClient>, server_url: String, cx: &mut AppCo
             updater
         });
         cx.set_global(Some(auto_updater));
-        cx.add_global_action(check);
-        cx.add_global_action(view_release_notes);
+        cx.add_global_action(|_: &Check, cx| {
+            if let Some(updater) = AutoUpdater::get(cx) {
+                updater.update(cx, |updater, cx| updater.poll(cx));
+            }
+        });
+        cx.add_global_action(move |_: &ViewReleaseNotes, cx| {
+            let latest_release_url = if cx.has_global::<ReleaseChannel>()
+                && *cx.global::<ReleaseChannel>() == ReleaseChannel::Preview
+            {
+                format!("{server_url}/releases/preview/latest")
+            } else {
+                format!("{server_url}/releases/latest")
+            };
+            cx.platform().open_url(&latest_release_url);
+        });
         cx.add_action(UpdateNotification::dismiss);
     }
 }
 
-pub fn check(_: &Check, cx: &mut AppContext) {
-    if let Some(updater) = AutoUpdater::get(cx) {
-        updater.update(cx, |updater, cx| updater.poll(cx));
-    }
-}
-
-fn view_release_notes(_: &ViewReleaseNotes, cx: &mut AppContext) {
-    if let Some(auto_updater) = AutoUpdater::get(cx) {
-        let server_url = &auto_updater.read(cx).server_url;
-        let latest_release_url = if cx.has_global::<ReleaseChannel>()
-            && *cx.global::<ReleaseChannel>() == ReleaseChannel::Preview
-        {
-            format!("{server_url}/releases/preview/latest")
-        } else {
-            format!("{server_url}/releases/stable/latest")
-        };
-        cx.platform().open_url(&latest_release_url);
-    }
-}
-
 pub fn notify_of_any_new_update(
     workspace: WeakViewHandle<Workspace>,
     cx: &mut AppContext,
@@ -138,15 +104,17 @@ pub fn notify_of_any_new_update(
     cx.spawn(|mut cx| async move {
         let should_show_notification = should_show_notification.await?;
         if should_show_notification {
-            workspace.update(&mut cx, |workspace, cx| {
-                workspace.show_notification(0, cx, |cx| {
-                    cx.add_view(|_| UpdateNotification::new(version))
+            if let Some(workspace) = workspace.upgrade(&cx) {
+                workspace.update(&mut cx, |workspace, cx| {
+                    workspace.show_notification(0, cx, |cx| {
+                        cx.add_view(|_| UpdateNotification::new(version))
+                    });
+                    updater
+                        .read(cx)
+                        .set_should_show_update_notification(false, cx)
+                        .detach_and_log_err(cx);
                 });
-                updater
-                    .read(cx)
-                    .set_should_show_update_notification(false, cx)
-                    .detach_and_log_err(cx);
-            })?;
+            }
         }
         anyhow::Ok(())
     })
@@ -275,24 +243,7 @@ impl AutoUpdater {
         mounted_app_path.push("/");
 
         let mut dmg_file = File::create(&dmg_path).await?;
-
-        let (installation_id, release_channel, telemetry) = cx.read(|cx| {
-            let installation_id = cx.global::<Arc<Client>>().telemetry().installation_id();
-            let release_channel = cx
-                .has_global::<ReleaseChannel>()
-                .then(|| cx.global::<ReleaseChannel>().display_name());
-            let telemetry = settings::get::<TelemetrySettings>(cx).metrics;
-
-            (installation_id, release_channel, telemetry)
-        });
-
-        let request_body = AsyncBody::from(serde_json::to_string(&UpdateRequestBody {
-            installation_id,
-            release_channel,
-            telemetry,
-        })?);
-
-        let mut response = client.get(&release.url, request_body, true).await?;
+        let mut response = client.get(&release.url, Default::default(), true).await?;
         smol::io::copy(response.body_mut(), &mut dmg_file).await?;
         log::info!("downloaded update. path:{:?}", dmg_path);
 

crates/auto_update/src/update_notification.rs

@@ -5,6 +5,7 @@ use gpui::{
     Element, Entity, View, ViewContext,
 };
 use menu::Cancel;
+use settings::Settings;
 use util::channel::ReleaseChannel;
 use workspace::notifications::Notification;
 
@@ -25,13 +26,13 @@ impl View for UpdateNotification {
         "UpdateNotification"
     }
 
-    fn render(&mut self, cx: &mut gpui::ViewContext<Self>) -> gpui::AnyElement<Self> {
-        let theme = theme::current(cx).clone();
+    fn render(&mut self, cx: &mut gpui::RenderContext<'_, Self>) -> gpui::ElementBox {
+        let theme = cx.global::<Settings>().theme.clone();
         let theme = &theme.update_notification;
 
         let app_name = cx.global::<ReleaseChannel>().display_name();
 
-        MouseEventHandler::<ViewReleaseNotes, _>::new(0, cx, |state, cx| {
+        MouseEventHandler::<ViewReleaseNotes>::new(0, cx, |state, cx| {
             Flex::column()
                 .with_child(
                     Flex::row()
@@ -45,10 +46,11 @@ impl View for UpdateNotification {
                             .aligned()
                             .top()
                             .left()
-                            .flex(1., true),
+                            .flex(1., true)
+                            .boxed(),
                         )
                         .with_child(
-                            MouseEventHandler::<Cancel, _>::new(0, cx, |state, _| {
+                            MouseEventHandler::<Cancel>::new(0, cx, |state, _| {
                                 let style = theme.dismiss_button.style_for(state, false);
                                 Svg::new("icons/x_mark_8.svg")
                                     .with_color(style.color)
@@ -60,32 +62,35 @@ impl View for UpdateNotification {
                                     .constrained()
                                     .with_width(style.button_width)
                                     .with_height(style.button_width)
+                                    .boxed()
                             })
                             .with_padding(Padding::uniform(5.))
-                            .on_click(MouseButton::Left, move |_, this, cx| {
-                                this.dismiss(&Default::default(), cx)
-                            })
+                            .on_click(MouseButton::Left, move |_, cx| cx.dispatch_action(Cancel))
                             .aligned()
                             .constrained()
                             .with_height(cx.font_cache().line_height(theme.message.text.font_size))
                             .aligned()
                             .top()
-                            .flex_float(),
-                        ),
+                            .flex_float()
+                            .boxed(),
+                        )
+                        .boxed(),
                 )
                 .with_child({
                     let style = theme.action_message.style_for(state, false);
                     Text::new("View the release notes", style.text.clone())
                         .contained()
                         .with_style(style.container)
+                        .boxed()
                 })
                 .contained()
+                .boxed()
         })
         .with_cursor_style(CursorStyle::PointingHand)
-        .on_click(MouseButton::Left, |_, _, cx| {
-            crate::view_release_notes(&Default::default(), cx)
+        .on_click(MouseButton::Left, |_, cx| {
+            cx.dispatch_action(ViewReleaseNotes)
         })
-        .into_any_named("update notification")
+        .boxed()
     }
 }
 

crates/breadcrumbs/src/breadcrumbs.rs

@@ -1,12 +1,13 @@
 use gpui::{
-    elements::*, platform::MouseButton, AppContext, Entity, Subscription, View, ViewContext,
-    ViewHandle, WeakViewHandle,
+    elements::*, platform::MouseButton, AppContext, Entity, RenderContext, Subscription, View,
+    ViewContext, ViewHandle,
 };
 use itertools::Itertools;
 use search::ProjectSearchView;
+use settings::Settings;
 use workspace::{
     item::{ItemEvent, ItemHandle},
-    ToolbarItemLocation, ToolbarItemView, Workspace,
+    ToolbarItemLocation, ToolbarItemView,
 };
 
 pub enum Event {
@@ -18,17 +19,15 @@ pub struct Breadcrumbs {
     active_item: Option<Box<dyn ItemHandle>>,
     project_search: Option<ViewHandle<ProjectSearchView>>,
     subscription: Option<Subscription>,
-    workspace: WeakViewHandle<Workspace>,
 }
 
 impl Breadcrumbs {
-    pub fn new(workspace: &Workspace) -> Self {
+    pub fn new() -> Self {
         Self {
             pane_focused: false,
             active_item: Default::default(),
             subscription: Default::default(),
             project_search: Default::default(),
-            workspace: workspace.weak_handle(),
         }
     }
 }
@@ -42,33 +41,24 @@ impl View for Breadcrumbs {
         "Breadcrumbs"
     }
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
         let active_item = match &self.active_item {
             Some(active_item) => active_item,
-            None => return Empty::new().into_any(),
+            None => return Empty::new().boxed(),
         };
         let not_editor = active_item.downcast::<editor::Editor>().is_none();
 
-        let theme = theme::current(cx).clone();
+        let theme = cx.global::<Settings>().theme.clone();
         let style = &theme.workspace.breadcrumbs;
 
         let breadcrumbs = match active_item.breadcrumbs(&theme, cx) {
             Some(breadcrumbs) => breadcrumbs,
-            None => return Empty::new().into_any(),
-        }
-        .into_iter()
-        .map(|breadcrumb| {
-            Text::new(
-                breadcrumb.text,
-                theme.workspace.breadcrumbs.default.text.clone(),
-            )
-            .with_highlights(breadcrumb.highlights.unwrap_or_default())
-            .into_any()
-        });
+            None => return Empty::new().boxed(),
+        };
 
         let crumbs = Flex::row()
-            .with_children(Itertools::intersperse_with(breadcrumbs, || {
-                Label::new(" 〉 ", style.default.text.clone()).into_any()
+            .with_children(Itertools::intersperse_with(breadcrumbs.into_iter(), || {
+                Label::new(" 〉 ", style.default.text.clone()).boxed()
             }))
             .constrained()
             .with_height(theme.workspace.breadcrumb_height)
@@ -79,21 +69,17 @@ impl View for Breadcrumbs {
                 .with_style(style.default.container)
                 .aligned()
                 .left()
-                .into_any();
+                .boxed();
         }
 
-        MouseEventHandler::<Breadcrumbs, Breadcrumbs>::new(0, cx, |state, _| {
+        MouseEventHandler::<Breadcrumbs>::new(0, cx, |state, _| {
             let style = style.style_for(state, false);
-            crumbs.with_style(style.container)
+            crumbs.with_style(style.container).boxed()
         })
-        .on_click(MouseButton::Left, |_, this, cx| {
-            if let Some(workspace) = this.workspace.upgrade(cx) {
-                workspace.update(cx, |workspace, cx| {
-                    outline::toggle(workspace, &Default::default(), cx)
-                })
-            }
+        .on_click(MouseButton::Left, |_, cx| {
+            cx.dispatch_action(outline::Toggle);
         })
-        .with_tooltip::<Breadcrumbs>(
+        .with_tooltip::<Breadcrumbs, _>(
             0,
             "Show symbol outline".to_owned(),
             Some(Box::new(outline::Toggle)),
@@ -102,7 +88,7 @@ impl View for Breadcrumbs {
         )
         .aligned()
         .left()
-        .into_any()
+        .boxed()
     }
 }
 
@@ -150,7 +136,7 @@ impl ToolbarItemView for Breadcrumbs {
         }
     }
 
-    fn pane_focus_update(&mut self, pane_focused: bool, _: &mut ViewContext<Self>) {
+    fn pane_focus_update(&mut self, pane_focused: bool, _: &mut gpui::AppContext) {
         self.pane_focused = pane_focused;
     }
 }

crates/call/Cargo.toml

@@ -22,7 +22,7 @@ test-support = [
 client = { path = "../client" }
 collections = { path = "../collections" }
 gpui = { path = "../gpui" }
-log.workspace = true
+log = "0.4"
 live_kit_client = { path = "../live_kit_client" }
 fs = { path = "../fs" }
 language = { path = "../language" }
@@ -31,10 +31,10 @@ project = { path = "../project" }
 settings = { path = "../settings" }
 util = { path = "../util" }
 
-anyhow.workspace = true
+anyhow = "1.0.38"
 async-broadcast = "0.4"
-futures.workspace = true
-postage.workspace = true
+futures = "0.3"
+postage = { workspace = true }
 
 [dev-dependencies]
 client = { path = "../client", features = ["test-support"] }

crates/cli/Cargo.toml

@@ -13,13 +13,12 @@ name = "cli"
 path = "src/main.rs"
 
 [dependencies]
-anyhow.workspace = true
+anyhow = "1.0"
 clap = { version = "3.1", features = ["derive"] }
 dirs = "3.0"
 ipc-channel = "0.16"
-serde.workspace = true
-serde_derive.workspace = true
-util = { path = "../util" }
+serde = { workspace = true }
+serde_derive = { workspace = true }
 
 [target.'cfg(target_os = "macos")'.dependencies]
 core-foundation = "0.9"

crates/cli/src/cli.rs

@@ -1,5 +1,6 @@
 pub use ipc_channel::ipc;
 use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
 
 #[derive(Serialize, Deserialize)]
 pub struct IpcHandshake {
@@ -9,12 +10,7 @@ pub struct IpcHandshake {
 
 #[derive(Debug, Serialize, Deserialize)]
 pub enum CliRequest {
-    // The filed is named `path` for compatibility, but now CLI can request
-    // opening a path at a certain row and/or column: `some/path:123` and `some/path:123:456`.
-    //
-    // Since Zed CLI has to be installed separately, there can be situations when old CLI is
-    // querying new Zed editors, support both formats by using `String` here and parsing it on Zed side later.
-    Open { paths: Vec<String>, wait: bool },
+    Open { paths: Vec<PathBuf>, wait: bool },
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -24,7 +20,3 @@ pub enum CliResponse {
     Stderr { message: String },
     Exit { status: i32 },
 }
-
-/// When Zed started not as an *.app but as a binary (e.g. local development),
-/// there's a possibility to tell it to behave "regularly".
-pub const FORCE_CLI_MODE_ENV_VAR_NAME: &str = "ZED_FORCE_CLI_MODE";

crates/cli/src/main.rs

@@ -1,6 +1,6 @@
-use anyhow::{anyhow, Context, Result};
+use anyhow::{anyhow, Result};
 use clap::Parser;
-use cli::{CliRequest, CliResponse, IpcHandshake, FORCE_CLI_MODE_ENV_VAR_NAME};
+use cli::{CliRequest, CliResponse, IpcHandshake};
 use core_foundation::{
     array::{CFArray, CFIndex},
     string::kCFStringEncodingUTF8,
@@ -16,20 +16,16 @@ use std::{
     path::{Path, PathBuf},
     ptr,
 };
-use util::paths::PathLikeWithPosition;
 
 #[derive(Parser)]
 #[clap(name = "zed", global_setting(clap::AppSettings::NoAutoVersion))]
 struct Args {
-    /// Wait for all of the given paths to be opened/closed before exiting.
+    /// Wait for all of the given paths to be closed before exiting.
     #[clap(short, long)]
     wait: bool,
     /// A sequence of space-separated paths that you want to open.
-    ///
-    /// Use `path:line:row` syntax to open a file at a specific location.
-    /// Non-existing paths and directories will ignore `:line:row` suffix.
-    #[clap(value_parser = parse_path_with_position)]
-    paths_with_position: Vec<PathLikeWithPosition<PathBuf>>,
+    #[clap()]
+    paths: Vec<PathBuf>,
     /// Print Zed's version and the app path.
     #[clap(short, long)]
     version: bool,
@@ -38,14 +34,6 @@ struct Args {
     bundle_path: Option<PathBuf>,
 }
 
-fn parse_path_with_position(
-    argument_str: &str,
-) -> Result<PathLikeWithPosition<PathBuf>, std::convert::Infallible> {
-    PathLikeWithPosition::parse_str(argument_str, |path_str| {
-        Ok(Path::new(path_str).to_path_buf())
-    })
-}
-
 #[derive(Debug, Deserialize)]
 struct InfoPlist {
     #[serde(rename = "CFBundleShortVersionString")]
@@ -55,37 +43,37 @@ struct InfoPlist {
 fn main() -> Result<()> {
     let args = Args::parse();
 
-    let bundle = Bundle::detect(args.bundle_path.as_deref()).context("Bundle detection")?;
+    let bundle_path = if let Some(bundle_path) = args.bundle_path {
+        bundle_path.canonicalize()?
+    } else {
+        locate_bundle()?
+    };
 
     if args.version {
-        println!("{}", bundle.zed_version_string());
+        let plist_path = bundle_path.join("Contents/Info.plist");
+        let plist = plist::from_file::<_, InfoPlist>(plist_path)?;
+        println!(
+            "Zed {} – {}",
+            plist.bundle_short_version_string,
+            bundle_path.to_string_lossy()
+        );
         return Ok(());
     }
 
-    for path in args
-        .paths_with_position
-        .iter()
-        .map(|path_with_position| &path_with_position.path_like)
-    {
+    for path in args.paths.iter() {
         if !path.exists() {
             touch(path.as_path())?;
         }
     }
 
-    let (tx, rx) = bundle.launch()?;
+    let (tx, rx) = launch_app(bundle_path)?;
 
     tx.send(CliRequest::Open {
         paths: args
-            .paths_with_position
+            .paths
             .into_iter()
-            .map(|path_with_position| {
-                let path_with_position = path_with_position.map_path_like(|path| {
-                    fs::canonicalize(&path)
-                        .with_context(|| format!("path {path:?} canonicalization"))
-                })?;
-                Ok(path_with_position.to_string(|path| path.display().to_string()))
-            })
-            .collect::<Result<_>>()?,
+            .map(|path| fs::canonicalize(path).map_err(|error| anyhow!(error)))
+            .collect::<Result<Vec<PathBuf>>>()?,
         wait: args.wait,
     })?;
 
@@ -101,148 +89,6 @@ fn main() -> Result<()> {
     Ok(())
 }
 
-enum Bundle {
-    App {
-        app_bundle: PathBuf,
-        plist: InfoPlist,
-    },
-    LocalPath {
-        executable: PathBuf,
-        plist: InfoPlist,
-    },
-}
-
-impl Bundle {
-    fn detect(args_bundle_path: Option<&Path>) -> anyhow::Result<Self> {
-        let bundle_path = if let Some(bundle_path) = args_bundle_path {
-            bundle_path
-                .canonicalize()
-                .with_context(|| format!("Args bundle path {bundle_path:?} canonicalization"))?
-        } else {
-            locate_bundle().context("bundle autodiscovery")?
-        };
-
-        match bundle_path.extension().and_then(|ext| ext.to_str()) {
-            Some("app") => {
-                let plist_path = bundle_path.join("Contents/Info.plist");
-                let plist = plist::from_file::<_, InfoPlist>(&plist_path).with_context(|| {
-                    format!("Reading *.app bundle plist file at {plist_path:?}")
-                })?;
-                Ok(Self::App {
-                    app_bundle: bundle_path,
-                    plist,
-                })
-            }
-            _ => {
-                println!("Bundle path {bundle_path:?} has no *.app extension, attempting to locate a dev build");
-                let plist_path = bundle_path
-                    .parent()
-                    .with_context(|| format!("Bundle path {bundle_path:?} has no parent"))?
-                    .join("WebRTC.framework/Resources/Info.plist");
-                let plist = plist::from_file::<_, InfoPlist>(&plist_path)
-                    .with_context(|| format!("Reading dev bundle plist file at {plist_path:?}"))?;
-                Ok(Self::LocalPath {
-                    executable: bundle_path,
-                    plist,
-                })
-            }
-        }
-    }
-
-    fn plist(&self) -> &InfoPlist {
-        match self {
-            Self::App { plist, .. } => plist,
-            Self::LocalPath { plist, .. } => plist,
-        }
-    }
-
-    fn path(&self) -> &Path {
-        match self {
-            Self::App { app_bundle, .. } => app_bundle,
-            Self::LocalPath {
-                executable: excutable,
-                ..
-            } => excutable,
-        }
-    }
-
-    fn launch(&self) -> anyhow::Result<(IpcSender<CliRequest>, IpcReceiver<CliResponse>)> {
-        let (server, server_name) =
-            IpcOneShotServer::<IpcHandshake>::new().context("Handshake before Zed spawn")?;
-        let url = format!("zed-cli://{server_name}");
-
-        match self {
-            Self::App { app_bundle, .. } => {
-                let app_path = app_bundle;
-
-                let status = unsafe {
-                    let app_url = CFURL::from_path(app_path, true)
-                        .with_context(|| format!("invalid app path {app_path:?}"))?;
-                    let url_to_open = CFURL::wrap_under_create_rule(CFURLCreateWithBytes(
-                        ptr::null(),
-                        url.as_ptr(),
-                        url.len() as CFIndex,
-                        kCFStringEncodingUTF8,
-                        ptr::null(),
-                    ));
-                    let urls_to_open = CFArray::from_copyable(&[url_to_open.as_concrete_TypeRef()]);
-                    LSOpenFromURLSpec(
-                        &LSLaunchURLSpec {
-                            appURL: app_url.as_concrete_TypeRef(),
-                            itemURLs: urls_to_open.as_concrete_TypeRef(),
-                            passThruParams: ptr::null(),
-                            launchFlags: kLSLaunchDefaults,
-                            asyncRefCon: ptr::null_mut(),
-                        },
-                        ptr::null_mut(),
-                    )
-                };
-
-                anyhow::ensure!(
-                    status == 0,
-                    "cannot start app bundle {}",
-                    self.zed_version_string()
-                );
-            }
-            Self::LocalPath { executable, .. } => {
-                let executable_parent = executable
-                    .parent()
-                    .with_context(|| format!("Executable {executable:?} path has no parent"))?;
-                let subprocess_stdout_file =
-                    fs::File::create(executable_parent.join("zed_dev.log"))
-                        .with_context(|| format!("Log file creation in {executable_parent:?}"))?;
-                let subprocess_stdin_file =
-                    subprocess_stdout_file.try_clone().with_context(|| {
-                        format!("Cloning descriptor for file {subprocess_stdout_file:?}")
-                    })?;
-                let mut command = std::process::Command::new(executable);
-                let command = command
-                    .env(FORCE_CLI_MODE_ENV_VAR_NAME, "")
-                    .stderr(subprocess_stdout_file)
-                    .stdout(subprocess_stdin_file)
-                    .arg(url);
-
-                command
-                    .spawn()
-                    .with_context(|| format!("Spawning {command:?}"))?;
-            }
-        }
-
-        let (_, handshake) = server.accept().context("Handshake after Zed spawn")?;
-        Ok((handshake.requests, handshake.responses))
-    }
-
-    fn zed_version_string(&self) -> String {
-        let is_dev = matches!(self, Self::LocalPath { .. });
-        format!(
-            "Zed {}{} – {}",
-            self.plist().bundle_short_version_string,
-            if is_dev { " (dev)" } else { "" },
-            self.path().display(),
-        )
-    }
-}
-
 fn touch(path: &Path) -> io::Result<()> {
     match OpenOptions::new().create(true).write(true).open(path) {
         Ok(_) => Ok(()),
@@ -260,3 +106,38 @@ fn locate_bundle() -> Result<PathBuf> {
     }
     Ok(app_path)
 }
+
+fn launch_app(app_path: PathBuf) -> Result<(IpcSender<CliRequest>, IpcReceiver<CliResponse>)> {
+    let (server, server_name) = IpcOneShotServer::<IpcHandshake>::new()?;
+    let url = format!("zed-cli://{server_name}");
+
+    let status = unsafe {
+        let app_url =
+            CFURL::from_path(&app_path, true).ok_or_else(|| anyhow!("invalid app path"))?;
+        let url_to_open = CFURL::wrap_under_create_rule(CFURLCreateWithBytes(
+            ptr::null(),
+            url.as_ptr(),
+            url.len() as CFIndex,
+            kCFStringEncodingUTF8,
+            ptr::null(),
+        ));
+        let urls_to_open = CFArray::from_copyable(&[url_to_open.as_concrete_TypeRef()]);
+        LSOpenFromURLSpec(
+            &LSLaunchURLSpec {
+                appURL: app_url.as_concrete_TypeRef(),
+                itemURLs: urls_to_open.as_concrete_TypeRef(),
+                passThruParams: ptr::null(),
+                launchFlags: kLSLaunchDefaults,
+                asyncRefCon: ptr::null_mut(),
+            },
+            ptr::null_mut(),
+        )
+    };
+
+    if status == 0 {
+        let (_, handshake) = server.accept()?;
+        Ok((handshake.requests, handshake.responses))
+    } else {
+        Err(anyhow!("cannot start {:?}", app_path))
+    }
+}

crates/client/Cargo.toml

@@ -17,29 +17,27 @@ db = { path = "../db" }
 gpui = { path = "../gpui" }
 util = { path = "../util" }
 rpc = { path = "../rpc" }
-settings = { path = "../settings" }
 staff_mode = { path = "../staff_mode" }
 sum_tree = { path = "../sum_tree" }
-
-anyhow.workspace = true
+anyhow = "1.0.38"
 async-recursion = "0.3"
 async-tungstenite = { version = "0.16", features = ["async-tls"] }
-futures.workspace = true
+futures = "0.3"
 image = "0.23"
-lazy_static.workspace = true
-log.workspace = true
-parking_lot.workspace = true
-postage.workspace = true
-rand.workspace = true
-schemars.workspace = true
-smol.workspace = true
-thiserror.workspace = true
-time.workspace = true
+lazy_static = "1.4.0"
+log = { version = "0.4.16", features = ["kv_unstable_serde"] }
+parking_lot = "0.11.1"
+postage = { workspace = true }
+rand = "0.8.3"
+smol = "1.2.5"
+thiserror = "1.0.29"
+time = { version = "0.3", features = ["serde", "serde-well-known"] }
 tiny_http = "0.8"
 uuid = { version = "1.1.2", features = ["v4"] }
 url = "2.2"
-serde.workspace = true
-serde_derive.workspace = true
+serde = { workspace = true }
+serde_derive = { workspace = true }
+settings = { path = "../settings" }
 tempfile = "3"
 
 [dev-dependencies]

crates/client/src/client.rs

@@ -15,17 +15,19 @@ use futures::{
     TryStreamExt,
 };
 use gpui::{
-    actions, platform::AppVersion, serde_json, AnyModelHandle, AnyWeakModelHandle,
-    AnyWeakViewHandle, AppContext, AsyncAppContext, Entity, ModelHandle, Task, View, ViewContext,
-    WeakViewHandle,
+    actions,
+    platform::AppVersion,
+    serde_json::{self, Value},
+    AnyModelHandle, AnyViewHandle, AnyWeakModelHandle, AnyWeakViewHandle, AppContext,
+    AsyncAppContext, Entity, ModelHandle, Task, View, ViewContext, ViewHandle,
 };
 use lazy_static::lazy_static;
 use parking_lot::RwLock;
 use postage::watch;
 use rand::prelude::*;
 use rpc::proto::{AnyTypedEnvelope, EntityMessage, EnvelopedMessage, PeerId, RequestMessage};
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
+use serde::Deserialize;
+use settings::{Settings, TelemetrySettings};
 use std::{
     any::TypeId,
     collections::HashMap,
@@ -45,7 +47,6 @@ use util::http::HttpClient;
 use util::{ResultExt, TryFutureExt};
 
 pub use rpc::*;
-pub use telemetry::ClickhouseEvent;
 pub use user::*;
 
 lazy_static! {
@@ -70,34 +71,25 @@ pub const CONNECTION_TIMEOUT: Duration = Duration::from_secs(5);
 
 actions!(client, [SignIn, SignOut]);
 
-pub fn init_settings(cx: &mut AppContext) {
-    settings::register::<TelemetrySettings>(cx);
-}
-
-pub fn init(client: &Arc<Client>, cx: &mut AppContext) {
-    init_settings(cx);
-
-    let client = Arc::downgrade(client);
+pub fn init(client: Arc<Client>, cx: &mut AppContext) {
     cx.add_global_action({
         let client = client.clone();
         move |_: &SignIn, cx| {
-            if let Some(client) = client.upgrade() {
-                cx.spawn(
-                    |cx| async move { client.authenticate_and_connect(true, &cx).log_err().await },
-                )
-                .detach();
-            }
+            let client = client.clone();
+            cx.spawn(
+                |cx| async move { client.authenticate_and_connect(true, &cx).log_err().await },
+            )
+            .detach();
         }
     });
     cx.add_global_action({
         let client = client.clone();
         move |_: &SignOut, cx| {
-            if let Some(client) = client.upgrade() {
-                cx.spawn(|cx| async move {
-                    client.disconnect(&cx);
-                })
-                .detach();
-            }
+            let client = client.clone();
+            cx.spawn(|cx| async move {
+                client.disconnect(&cx);
+            })
+            .detach();
         }
     });
 }
@@ -229,7 +221,7 @@ enum WeakSubscriber {
 
 enum Subscriber {
     Model(AnyModelHandle),
-    View(AnyWeakViewHandle),
+    View(AnyViewHandle),
 }
 
 #[derive(Clone, Debug)]
@@ -333,42 +325,6 @@ impl<T: Entity> Drop for PendingEntitySubscription<T> {
     }
 }
 
-#[derive(Copy, Clone)]
-pub struct TelemetrySettings {
-    pub diagnostics: bool,
-    pub metrics: bool,
-}
-
-#[derive(Default, Clone, Serialize, Deserialize, JsonSchema)]
-pub struct TelemetrySettingsContent {
-    pub diagnostics: Option<bool>,
-    pub metrics: Option<bool>,
-}
-
-impl settings::Setting for TelemetrySettings {
-    const KEY: Option<&'static str> = Some("telemetry");
-
-    type FileContent = TelemetrySettingsContent;
-
-    fn load(
-        default_value: &Self::FileContent,
-        user_values: &[&Self::FileContent],
-        _: &AppContext,
-    ) -> Result<Self> {
-        Ok(Self {
-            diagnostics: user_values.first().and_then(|v| v.diagnostics).unwrap_or(
-                default_value
-                    .diagnostics
-                    .ok_or_else(Self::missing_default)?,
-            ),
-            metrics: user_values
-                .first()
-                .and_then(|v| v.metrics)
-                .unwrap_or(default_value.metrics.ok_or_else(Self::missing_default)?),
-        })
-    }
-}
-
 impl Client {
     pub fn new(http: Arc<dyn HttpClient>, cx: &AppContext) -> Arc<Self> {
         Arc::new(Self {
@@ -490,7 +446,9 @@ impl Client {
                 }));
             }
             Status::SignedOut | Status::UpgradeRequired => {
-                cx.read(|cx| self.telemetry.set_authenticated_user_info(None, false, cx));
+                let telemetry_settings = cx.read(|cx| cx.global::<Settings>().telemetry());
+                self.telemetry
+                    .set_authenticated_user_info(None, false, telemetry_settings);
                 state._reconnect_task.take();
             }
             _ => {}
@@ -609,7 +567,7 @@ impl Client {
         H: 'static
             + Send
             + Sync
-            + Fn(WeakViewHandle<E>, TypedEnvelope<M>, Arc<Self>, AsyncAppContext) -> F,
+            + Fn(ViewHandle<E>, TypedEnvelope<M>, Arc<Self>, AsyncAppContext) -> F,
         F: 'static + Future<Output = Result<()>>,
     {
         self.add_entity_message_handler::<M, E, _, _>(move |handle, message, client, cx| {
@@ -708,7 +666,7 @@ impl Client {
         H: 'static
             + Send
             + Sync
-            + Fn(WeakViewHandle<E>, TypedEnvelope<M>, Arc<Self>, AsyncAppContext) -> F,
+            + Fn(ViewHandle<E>, TypedEnvelope<M>, Arc<Self>, AsyncAppContext) -> F,
         F: 'static + Future<Output = Result<M::Response>>,
     {
         self.add_view_message_handler(move |entity, envelope, client, cx| {
@@ -778,10 +736,10 @@ impl Client {
             read_from_keychain = credentials.is_some();
             if read_from_keychain {
                 cx.read(|cx| {
-                    self.telemetry().report_mixpanel_event(
+                    self.report_event(
                         "read credentials from keychain",
                         Default::default(),
-                        *settings::get::<TelemetrySettings>(cx),
+                        cx.global::<Settings>().telemetry(),
                     );
                 });
             }
@@ -1074,8 +1032,7 @@ impl Client {
         let executor = cx.background();
         let telemetry = self.telemetry.clone();
         let http = self.http.clone();
-
-        let telemetry_settings = cx.read(|cx| *settings::get::<TelemetrySettings>(cx));
+        let metrics_enabled = cx.read(|cx| cx.global::<Settings>().telemetry());
 
         executor.clone().spawn(async move {
             // Generate a pair of asymmetric encryption keys. The public key will be used by the
@@ -1159,10 +1116,10 @@ impl Client {
                 .context("failed to decrypt access token")?;
             platform.activate(true);
 
-            telemetry.report_mixpanel_event(
+            telemetry.report_event(
                 "authenticate with browser",
                 Default::default(),
-                telemetry_settings,
+                metrics_enabled,
             );
 
             Ok(Credentials {
@@ -1316,15 +1273,7 @@ impl Client {
                     pending.push(message);
                     return;
                 }
-                Some(weak_subscriber @ _) => match weak_subscriber {
-                    WeakSubscriber::Model(handle) => {
-                        subscriber = handle.upgrade(cx).map(Subscriber::Model);
-                    }
-                    WeakSubscriber::View(handle) => {
-                        subscriber = Some(Subscriber::View(handle.clone()));
-                    }
-                    WeakSubscriber::Pending(_) => {}
-                },
+                Some(weak_subscriber @ _) => subscriber = weak_subscriber.upgrade(cx),
                 _ => {}
             }
         }
@@ -1381,8 +1330,40 @@ impl Client {
         }
     }
 
-    pub fn telemetry(&self) -> &Arc<Telemetry> {
-        &self.telemetry
+    pub fn start_telemetry(&self) {
+        self.telemetry.start();
+    }
+
+    pub fn report_event(
+        &self,
+        kind: &str,
+        properties: Value,
+        telemetry_settings: TelemetrySettings,
+    ) {
+        self.telemetry
+            .report_event(kind, properties.clone(), telemetry_settings);
+    }
+
+    pub fn telemetry_log_file_path(&self) -> Option<PathBuf> {
+        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 {
+    fn upgrade(&self, cx: &AsyncAppContext) -> Option<Subscriber> {
+        match self {
+            WeakSubscriber::Model(handle) => handle.upgrade(cx).map(Subscriber::Model),
+            WeakSubscriber::View(handle) => handle.upgrade(cx).map(Subscriber::View),
+            WeakSubscriber::Pending(_) => None,
+        }
     }
 }
 

crates/client/src/telemetry.rs

@@ -1,4 +1,3 @@
-use crate::{TelemetrySettings, ZED_SECRET_CLIENT_TOKEN, ZED_SERVER_URL};
 use db::kvp::KEY_VALUE_STORE;
 use gpui::{
     executor::Background,
@@ -9,8 +8,8 @@ use lazy_static::lazy_static;
 use parking_lot::Mutex;
 use serde::Serialize;
 use serde_json::json;
+use settings::TelemetrySettings;
 use std::{
-    env,
     io::Write,
     mem,
     path::PathBuf,
@@ -30,69 +29,26 @@ pub struct Telemetry {
 
 #[derive(Default)]
 struct TelemetryState {
-    metrics_id: Option<Arc<str>>,      // Per logged-in user
-    installation_id: Option<Arc<str>>, // Per app installation
+    metrics_id: Option<Arc<str>>,
+    device_id: Option<Arc<str>>,
     app_version: Option<Arc<str>>,
     release_channel: Option<&'static str>,
-    os_name: &'static str,
     os_version: Option<Arc<str>>,
-    architecture: &'static str,
-    mixpanel_events_queue: Vec<MixpanelEvent>,
-    clickhouse_events_queue: Vec<ClickhouseEventWrapper>,
-    next_mixpanel_event_id: usize,
-    flush_mixpanel_events_task: Option<Task<()>>,
-    flush_clickhouse_events_task: Option<Task<()>>,
+    os_name: &'static str,
+    queue: Vec<MixpanelEvent>,
+    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";
 const MIXPANEL_ENGAGE_URL: &'static str = "https://api.mixpanel.com/engage#profile-set";
-const CLICKHOUSE_EVENTS_URL_PATH: &'static str = "/api/events";
 
 lazy_static! {
     static ref MIXPANEL_TOKEN: Option<String> = std::env::var("ZED_MIXPANEL_TOKEN")
         .ok()
         .or_else(|| option_env!("ZED_MIXPANEL_TOKEN").map(|key| key.to_string()));
-    static ref CLICKHOUSE_EVENTS_URL: String =
-        format!("{}{}", *ZED_SERVER_URL, CLICKHOUSE_EVENTS_URL_PATH);
-}
-
-#[derive(Serialize, Debug)]
-struct ClickhouseEventRequestBody {
-    token: &'static str,
-    installation_id: Option<Arc<str>>,
-    app_version: Option<Arc<str>>,
-    os_name: &'static str,
-    os_version: Option<Arc<str>>,
-    architecture: &'static str,
-    release_channel: Option<&'static str>,
-    events: Vec<ClickhouseEventWrapper>,
-}
-
-#[derive(Serialize, Debug)]
-struct ClickhouseEventWrapper {
-    time: u128,
-    signed_in: bool,
-    #[serde(flatten)]
-    event: ClickhouseEvent,
-}
-
-#[derive(Serialize, Debug)]
-#[serde(tag = "type")]
-pub enum ClickhouseEvent {
-    Editor {
-        operation: &'static str,
-        file_extension: Option<String>,
-        vim_mode: bool,
-        copilot_enabled: bool,
-        copilot_enabled_for_language: bool,
-    },
-    Copilot {
-        suggestion_id: Option<String>,
-        suggestion_accepted: bool,
-        file_extension: Option<String>,
-    },
 }
 
 #[derive(Serialize, Debug)]
@@ -107,8 +63,7 @@ struct MixpanelEventProperties {
     #[serde(skip_serializing_if = "str::is_empty")]
     token: &'static str,
     time: u128,
-    #[serde(rename = "distinct_id")]
-    installation_id: Option<Arc<str>>,
+    distinct_id: Option<Arc<str>>,
     #[serde(rename = "$insert_id")]
     insert_id: usize,
     // Custom fields
@@ -131,7 +86,7 @@ struct MixpanelEngageRequest {
     #[serde(rename = "$token")]
     token: &'static str,
     #[serde(rename = "$distinct_id")]
-    installation_id: Arc<str>,
+    distinct_id: Arc<str>,
     #[serde(rename = "$set")]
     set: Value,
 }
@@ -156,23 +111,19 @@ impl Telemetry {
         } else {
             None
         };
-        // TODO: Replace all hardware stuff with nested SystemSpecs json
         let this = Arc::new(Self {
             http_client: client,
             executor: cx.background().clone(),
             state: Mutex::new(TelemetryState {
-                os_name: platform.os_name().into(),
                 os_version: platform.os_version().ok().map(|v| v.to_string().into()),
-                architecture: env::consts::ARCH,
+                os_name: platform.os_name().into(),
                 app_version: platform.app_version().ok().map(|v| v.to_string().into()),
                 release_channel,
-                installation_id: None,
+                device_id: None,
                 metrics_id: None,
-                mixpanel_events_queue: Default::default(),
-                clickhouse_events_queue: Default::default(),
-                flush_mixpanel_events_task: Default::default(),
-                flush_clickhouse_events_task: Default::default(),
-                next_mixpanel_event_id: 0,
+                queue: Default::default(),
+                flush_task: Default::default(),
+                next_event_id: 0,
                 log_file: None,
                 is_staff: None,
             }),
@@ -203,38 +154,29 @@ impl Telemetry {
         self.executor
             .spawn(
                 async move {
-                    let installation_id =
-                        if let Ok(Some(installation_id)) = KEY_VALUE_STORE.read_kvp("device_id") {
-                            installation_id
+                    let device_id =
+                        if let Ok(Some(device_id)) = KEY_VALUE_STORE.read_kvp("device_id") {
+                            device_id
                         } else {
-                            let installation_id = Uuid::new_v4().to_string();
+                            let device_id = Uuid::new_v4().to_string();
                             KEY_VALUE_STORE
-                                .write_kvp("device_id".to_string(), installation_id.clone())
+                                .write_kvp("device_id".to_string(), device_id.clone())
                                 .await?;
-                            installation_id
+                            device_id
                         };
 
-                    let installation_id: Arc<str> = installation_id.into();
+                    let device_id: Arc<str> = device_id.into();
                     let mut state = this.state.lock();
-                    state.installation_id = Some(installation_id.clone());
-
-                    for event in &mut state.mixpanel_events_queue {
+                    state.device_id = Some(device_id.clone());
+                    for event in &mut state.queue {
                         event
                             .properties
-                            .installation_id
-                            .get_or_insert_with(|| installation_id.clone());
+                            .distinct_id
+                            .get_or_insert_with(|| device_id.clone());
                     }
-
-                    let has_mixpanel_events = !state.mixpanel_events_queue.is_empty();
-                    let has_clickhouse_events = !state.clickhouse_events_queue.is_empty();
-                    drop(state);
-
-                    if has_mixpanel_events {
-                        this.flush_mixpanel_events();
-                    }
-
-                    if has_clickhouse_events {
-                        this.flush_clickhouse_events();
+                    if !state.queue.is_empty() {
+                        drop(state);
+                        this.flush();
                     }
 
                     anyhow::Ok(())
@@ -250,27 +192,27 @@ impl Telemetry {
         self: &Arc<Self>,
         metrics_id: Option<String>,
         is_staff: bool,
-        cx: &AppContext,
+        telemetry_settings: TelemetrySettings,
     ) {
-        if !settings::get::<TelemetrySettings>(cx).metrics {
+        if !telemetry_settings.metrics() {
             return;
         }
 
         let this = self.clone();
         let mut state = self.state.lock();
-        let installation_id = state.installation_id.clone();
+        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, installation_id)) = MIXPANEL_TOKEN.as_ref().zip(installation_id) {
+        if let Some((token, device_id)) = MIXPANEL_TOKEN.as_ref().zip(device_id) {
             self.executor
                 .spawn(
                     async move {
                         let json_bytes = serde_json::to_vec(&[MixpanelEngageRequest {
                             token,
-                            installation_id,
+                            distinct_id: device_id,
                             set: json!({
                                 "Staff": is_staff,
                                 "ID": metrics_id,
@@ -289,62 +231,27 @@ impl Telemetry {
         }
     }
 
-    pub fn report_clickhouse_event(
-        self: &Arc<Self>,
-        event: ClickhouseEvent,
-        telemetry_settings: TelemetrySettings,
-    ) {
-        if !telemetry_settings.metrics {
-            return;
-        }
-
-        let mut state = self.state.lock();
-        let signed_in = state.metrics_id.is_some();
-        state.clickhouse_events_queue.push(ClickhouseEventWrapper {
-            time: SystemTime::now()
-                .duration_since(UNIX_EPOCH)
-                .unwrap()
-                .as_millis(),
-            signed_in,
-            event,
-        });
-
-        if state.installation_id.is_some() {
-            if state.mixpanel_events_queue.len() >= MAX_QUEUE_LEN {
-                drop(state);
-                self.flush_clickhouse_events();
-            } else {
-                let this = self.clone();
-                let executor = self.executor.clone();
-                state.flush_clickhouse_events_task = Some(self.executor.spawn(async move {
-                    executor.timer(DEBOUNCE_INTERVAL).await;
-                    this.flush_clickhouse_events();
-                }));
-            }
-        }
-    }
-
-    pub fn report_mixpanel_event(
+    pub fn report_event(
         self: &Arc<Self>,
         kind: &str,
         properties: Value,
         telemetry_settings: TelemetrySettings,
     ) {
-        if !telemetry_settings.metrics {
+        if !telemetry_settings.metrics() {
             return;
         }
 
         let mut state = self.state.lock();
         let event = MixpanelEvent {
-            event: kind.into(),
+            event: kind.to_string(),
             properties: MixpanelEventProperties {
                 token: "",
                 time: SystemTime::now()
                     .duration_since(UNIX_EPOCH)
                     .unwrap()
                     .as_millis(),
-                installation_id: state.installation_id.clone(),
-                insert_id: post_inc(&mut state.next_mixpanel_event_id),
+                distinct_id: state.device_id.clone(),
+                insert_id: post_inc(&mut state.next_event_id),
                 event_properties: if let Value::Object(properties) = properties {
                     Some(properties)
                 } else {
@@ -357,17 +264,17 @@ impl Telemetry {
                 signed_in: state.metrics_id.is_some(),
             },
         };
-        state.mixpanel_events_queue.push(event);
-        if state.installation_id.is_some() {
-            if state.mixpanel_events_queue.len() >= MAX_QUEUE_LEN {
+        state.queue.push(event);
+        if state.device_id.is_some() {
+            if state.queue.len() >= MAX_QUEUE_LEN {
                 drop(state);
-                self.flush_mixpanel_events();
+                self.flush();
             } else {
                 let this = self.clone();
                 let executor = self.executor.clone();
-                state.flush_mixpanel_events_task = Some(self.executor.spawn(async move {
+                state.flush_task = Some(self.executor.spawn(async move {
                     executor.timer(DEBOUNCE_INTERVAL).await;
-                    this.flush_mixpanel_events();
+                    this.flush();
                 }));
             }
         }
@@ -377,18 +284,14 @@ impl Telemetry {
         self.state.lock().metrics_id.clone()
     }
 
-    pub fn installation_id(self: &Arc<Self>) -> Option<Arc<str>> {
-        self.state.lock().installation_id.clone()
-    }
-
     pub fn is_staff(self: &Arc<Self>) -> Option<bool> {
         self.state.lock().is_staff
     }
 
-    fn flush_mixpanel_events(self: &Arc<Self>) {
+    fn flush(self: &Arc<Self>) {
         let mut state = self.state.lock();
-        let mut events = mem::take(&mut state.mixpanel_events_queue);
-        state.flush_mixpanel_events_task.take();
+        let mut events = mem::take(&mut state.queue);
+        state.flush_task.take();
         drop(state);
 
         if let Some(token) = MIXPANEL_TOKEN.as_ref() {
@@ -422,55 +325,4 @@ impl Telemetry {
                 .detach();
         }
     }
-
-    fn flush_clickhouse_events(self: &Arc<Self>) {
-        let mut state = self.state.lock();
-        let mut events = mem::take(&mut state.clickhouse_events_queue);
-        state.flush_clickhouse_events_task.take();
-        drop(state);
-
-        let this = self.clone();
-        self.executor
-            .spawn(
-                async move {
-                    let mut json_bytes = Vec::new();
-
-                    if let Some(file) = &mut this.state.lock().log_file {
-                        let file = file.as_file_mut();
-                        for event in &mut events {
-                            json_bytes.clear();
-                            serde_json::to_writer(&mut json_bytes, event)?;
-                            file.write_all(&json_bytes)?;
-                            file.write(b"\n")?;
-                        }
-                    }
-
-                    {
-                        let state = this.state.lock();
-                        json_bytes.clear();
-                        serde_json::to_writer(
-                            &mut json_bytes,
-                            &ClickhouseEventRequestBody {
-                                token: ZED_SECRET_CLIENT_TOKEN,
-                                installation_id: state.installation_id.clone(),
-                                app_version: state.app_version.clone(),
-                                os_name: state.os_name,
-                                os_version: state.os_version.clone(),
-                                architecture: state.architecture,
-
-                                release_channel: state.release_channel,
-                                events,
-                            },
-                        )?;
-                    }
-
-                    this.http_client
-                        .post_json(CLICKHOUSE_EVENTS_URL.as_str(), json_bytes.into())
-                        .await?;
-                    anyhow::Ok(())
-                }
-                .log_err(),
-            )
-            .detach();
-    }
 }

crates/client/src/user.rs

@@ -5,6 +5,7 @@ use futures::{channel::mpsc, future, AsyncReadExt, Future, StreamExt};
 use gpui::{AsyncAppContext, Entity, ImageData, ModelContext, ModelHandle, Task};
 use postage::{sink::Sink, watch};
 use rpc::proto::{RequestMessage, UsersResponse};
+use settings::Settings;
 use staff_mode::StaffMode;
 use std::sync::{Arc, Weak};
 use util::http::HttpClient;
@@ -143,13 +144,11 @@ impl UserStore {
                                 let fetch_metrics_id =
                                     client.request(proto::GetPrivateUserInfo {}).log_err();
                                 let (user, info) = futures::join!(fetch_user, fetch_metrics_id);
-                                cx.read(|cx| {
-                                    client.telemetry.set_authenticated_user_info(
-                                        info.as_ref().map(|info| info.metrics_id.clone()),
-                                        info.as_ref().map(|info| info.staff).unwrap_or(false),
-                                        cx,
-                                    )
-                                });
+                                client.telemetry.set_authenticated_user_info(
+                                    info.as_ref().map(|info| info.metrics_id.clone()),
+                                    info.as_ref().map(|info| info.staff).unwrap_or(false),
+                                    cx.read(|cx| cx.global::<Settings>().telemetry()),
+                                );
 
                                 cx.update(|cx| {
                                     cx.update_default_global(|staff_mode: &mut StaffMode, _| {

crates/clock/Cargo.toml

@@ -9,4 +9,4 @@ path = "src/clock.rs"
 doctest = false
 
 [dependencies]
-smallvec.workspace = true
+smallvec = { version = "1.6", features = ["union"] }

crates/collab/Cargo.toml

@@ -3,7 +3,7 @@ authors = ["Nathan Sobo <nathan@zed.dev>"]
 default-run = "collab"
 edition = "2021"
 name = "collab"
-version = "0.12.4"
+version = "0.8.2"
 publish = false
 
 [[bin]]
@@ -19,7 +19,7 @@ live_kit_server = { path = "../live_kit_server" }
 rpc = { path = "../rpc" }
 util = { path = "../util" }
 
-anyhow.workspace = true
+anyhow = "1.0.40"
 async-tungstenite = "0.16"
 axum = { version = "0.5", features = ["json", "headers", "ws"] }
 axum-extra = { version = "0.3", features = ["erased-json"] }
@@ -27,31 +27,31 @@ base64 = "0.13"
 clap = { version = "3.1", features = ["derive"], optional = true }
 dashmap = "5.4"
 envy = "0.4.2"
-futures.workspace = true
+futures = "0.3"
 hyper = "0.14"
-lazy_static.workspace = true
+lazy_static = "1.4"
 lipsum = { version = "0.8", optional = true }
-log.workspace = true
+log = { version = "0.4.16", features = ["kv_unstable_serde"] }
 nanoid = "0.4"
-parking_lot.workspace = true
+parking_lot = "0.11.1"
 prometheus = "0.13"
-rand.workspace = true
+rand = "0.8"
 reqwest = { version = "0.11", features = ["json"], optional = true }
 scrypt = "0.7"
 # Remove fork dependency when a version with https://github.com/SeaQL/sea-orm/pull/1283 is released.
 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.workspace = true
-serde_derive.workspace = true
-serde_json.workspace = true
+serde = { workspace = true }
+serde_derive = { workspace = true }
+serde_json = { workspace = true }
 sha-1 = "0.9"
 sqlx = { version = "0.6", features = ["runtime-tokio-rustls", "postgres", "json", "time", "uuid", "any"] }
-time.workspace = true
+time = { version = "0.3", features = ["serde", "serde-well-known"] }
 tokio = { version = "1", features = ["full"] }
 tokio-tungstenite = "0.17"
 tonic = "0.6"
 tower = "0.4"
-toml.workspace = true
+toml = "0.5.8"
 tracing = "0.1.34"
 tracing-log = "0.1.3"
 tracing-subscriber = { version = "0.3.11", features = ["env-filter", "json"] }
@@ -74,15 +74,14 @@ settings = { path = "../settings", features = ["test-support"] }
 theme = { path = "../theme" }
 workspace = { path = "../workspace", features = ["test-support"] }
 
-ctor.workspace = true
-env_logger.workspace = true
-indoc.workspace = true
+ctor = "0.1"
+env_logger = "0.9"
 util = { path = "../util" }
-lazy_static.workspace = true
+lazy_static = "1.4"
 sea-orm = { git = "https://github.com/zed-industries/sea-orm", rev = "18f4c691085712ad014a51792af75a9044bacee6", features = ["sqlx-sqlite"] }
-serde_json.workspace = true
+serde_json = { workspace = true }
 sqlx = { version = "0.6", features = ["sqlite"] }
-unindent.workspace = true
+unindent = "0.1"
 
 [features]
 seed-support = ["clap", "lipsum", "reqwest"]

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

@@ -82,37 +82,6 @@ CREATE TABLE "worktree_entries" (
 CREATE INDEX "index_worktree_entries_on_project_id" ON "worktree_entries" ("project_id");
 CREATE INDEX "index_worktree_entries_on_project_id_and_worktree_id" ON "worktree_entries" ("project_id", "worktree_id");
 
-CREATE TABLE "worktree_repositories" (
-    "project_id" INTEGER NOT NULL,
-    "worktree_id" INTEGER NOT NULL,
-    "work_directory_id" INTEGER NOT NULL,
-    "branch" VARCHAR,
-    "scan_id" INTEGER NOT NULL,
-    "is_deleted" BOOL NOT NULL,
-    PRIMARY KEY(project_id, worktree_id, work_directory_id),
-    FOREIGN KEY(project_id, worktree_id) REFERENCES worktrees (project_id, id) ON DELETE CASCADE,
-    FOREIGN KEY(project_id, worktree_id, work_directory_id) REFERENCES worktree_entries (project_id, worktree_id, id) ON DELETE CASCADE
-);
-CREATE INDEX "index_worktree_repositories_on_project_id" ON "worktree_repositories" ("project_id");
-CREATE INDEX "index_worktree_repositories_on_project_id_and_worktree_id" ON "worktree_repositories" ("project_id", "worktree_id");
-
-CREATE TABLE "worktree_repository_statuses" (
-    "project_id" INTEGER NOT NULL,
-    "worktree_id" INTEGER NOT NULL,
-    "work_directory_id" INTEGER NOT NULL,
-    "repo_path" VARCHAR NOT NULL,
-    "status" INTEGER NOT NULL,
-    "scan_id" INTEGER NOT NULL,
-    "is_deleted" BOOL NOT NULL,
-    PRIMARY KEY(project_id, worktree_id, work_directory_id, repo_path),
-    FOREIGN KEY(project_id, worktree_id) REFERENCES worktrees (project_id, id) ON DELETE CASCADE,
-    FOREIGN KEY(project_id, worktree_id, work_directory_id) REFERENCES worktree_entries (project_id, worktree_id, id) ON DELETE CASCADE
-);
-CREATE INDEX "index_worktree_repository_statuses_on_project_id" ON "worktree_repository_statuses" ("project_id");
-CREATE INDEX "index_worktree_repository_statuses_on_project_id_and_worktree_id" ON "worktree_repository_statuses" ("project_id", "worktree_id");
-CREATE INDEX "index_worktree_repository_statuses_on_project_id_and_worktree_id_and_work_directory_id" ON "worktree_repository_statuses" ("project_id", "worktree_id", "work_directory_id");
-
-
 CREATE TABLE "worktree_diagnostic_summaries" (
     "project_id" INTEGER NOT NULL,
     "worktree_id" INTEGER NOT NULL,
@@ -184,7 +153,7 @@ CREATE TABLE "followers" (
     "follower_connection_server_id" INTEGER NOT NULL REFERENCES servers (id) ON DELETE CASCADE,
     "follower_connection_id" INTEGER NOT NULL
 );
-CREATE UNIQUE INDEX
+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/20230508211523_add-repository-entries.sql

@@ -1,13 +0,0 @@
-CREATE TABLE "worktree_repositories" (
-    "project_id" INTEGER NOT NULL,
-    "worktree_id" INT8 NOT NULL,
-    "work_directory_id" INT8 NOT NULL,
-    "scan_id" INT8 NOT NULL,
-    "branch" VARCHAR,
-    "is_deleted" BOOL NOT NULL,
-    PRIMARY KEY(project_id, worktree_id, work_directory_id),
-    FOREIGN KEY(project_id, worktree_id) REFERENCES worktrees (project_id, id) ON DELETE CASCADE,
-    FOREIGN KEY(project_id, worktree_id, work_directory_id) REFERENCES worktree_entries (project_id, worktree_id, id) ON DELETE CASCADE
-);
-CREATE INDEX "index_worktree_repositories_on_project_id" ON "worktree_repositories" ("project_id");
-CREATE INDEX "index_worktree_repositories_on_project_id_and_worktree_id" ON "worktree_repositories" ("project_id", "worktree_id");

crates/collab/migrations/20230511004019_add_repository_statuses.sql

@@ -1,15 +0,0 @@
-CREATE TABLE "worktree_repository_statuses" (
-    "project_id" INTEGER NOT NULL,
-    "worktree_id" INT8 NOT NULL,
-    "work_directory_id" INT8 NOT NULL,
-    "repo_path" VARCHAR NOT NULL,
-    "status" INT8 NOT NULL,
-    "scan_id" INT8 NOT NULL,
-    "is_deleted" BOOL NOT NULL,
-    PRIMARY KEY(project_id, worktree_id, work_directory_id, repo_path),
-    FOREIGN KEY(project_id, worktree_id) REFERENCES worktrees (project_id, id) ON DELETE CASCADE,
-    FOREIGN KEY(project_id, worktree_id, work_directory_id) REFERENCES worktree_entries (project_id, worktree_id, id) ON DELETE CASCADE
-);
-CREATE INDEX "index_wt_repos_statuses_on_project_id" ON "worktree_repository_statuses" ("project_id");
-CREATE INDEX "index_wt_repos_statuses_on_project_id_and_wt_id" ON "worktree_repository_statuses" ("project_id", "worktree_id");
-CREATE INDEX "index_wt_repos_statuses_on_project_id_and_wt_id_and_wd_id" ON "worktree_repository_statuses" ("project_id", "worktree_id", "work_directory_id");

crates/collab/src/db.rs

@@ -14,8 +14,6 @@ mod user;
 mod worktree;
 mod worktree_diagnostic_summary;
 mod worktree_entry;
-mod worktree_repository;
-mod worktree_repository_statuses;
 
 use crate::executor::Executor;
 use crate::{Error, Result};
@@ -1491,8 +1489,6 @@ impl Database {
                         visible: db_worktree.visible,
                         updated_entries: Default::default(),
                         removed_entries: Default::default(),
-                        updated_repositories: Default::default(),
-                        removed_repositories: Default::default(),
                         diagnostic_summaries: Default::default(),
                         scan_id: db_worktree.scan_id as u64,
                         completed_scan_id: db_worktree.completed_scan_id as u64,
@@ -1502,125 +1498,38 @@ impl Database {
                         .worktrees
                         .iter()
                         .find(|worktree| worktree.id == db_worktree.id as u64);
+                    let entry_filter = if let Some(rejoined_worktree) = rejoined_worktree {
+                        worktree_entry::Column::ScanId.gt(rejoined_worktree.scan_id)
+                    } else {
+                        worktree_entry::Column::IsDeleted.eq(false)
+                    };
 
-                    // File entries
-                    {
-                        let entry_filter = if let Some(rejoined_worktree) = rejoined_worktree {
-                            worktree_entry::Column::ScanId.gt(rejoined_worktree.scan_id)
+                    let mut db_entries = worktree_entry::Entity::find()
+                        .filter(
+                            Condition::all()
+                                .add(worktree_entry::Column::WorktreeId.eq(worktree.id))
+                                .add(entry_filter),
+                        )
+                        .stream(&*tx)
+                        .await?;
+
+                    while let Some(db_entry) = db_entries.next().await {
+                        let db_entry = db_entry?;
+                        if db_entry.is_deleted {
+                            worktree.removed_entries.push(db_entry.id as u64);
                         } else {
-                            worktree_entry::Column::IsDeleted.eq(false)
-                        };
-
-                        let mut db_entries = worktree_entry::Entity::find()
-                            .filter(
-                                Condition::all()
-                                    .add(worktree_entry::Column::ProjectId.eq(project.id))
-                                    .add(worktree_entry::Column::WorktreeId.eq(worktree.id))
-                                    .add(entry_filter),
-                            )
-                            .stream(&*tx)
-                            .await?;
-
-                        while let Some(db_entry) = db_entries.next().await {
-                            let db_entry = db_entry?;
-                            if db_entry.is_deleted {
-                                worktree.removed_entries.push(db_entry.id as u64);
-                            } else {
-                                worktree.updated_entries.push(proto::Entry {
-                                    id: db_entry.id as u64,
-                                    is_dir: db_entry.is_dir,
-                                    path: db_entry.path,
-                                    inode: db_entry.inode as u64,
-                                    mtime: Some(proto::Timestamp {
-                                        seconds: db_entry.mtime_seconds as u64,
-                                        nanos: db_entry.mtime_nanos as u32,
-                                    }),
-                                    is_symlink: db_entry.is_symlink,
-                                    is_ignored: db_entry.is_ignored,
-                                });
-                            }
-                        }
-                    }
-
-                    // Repository Entries
-                    {
-                        let repository_entry_filter =
-                            if let Some(rejoined_worktree) = rejoined_worktree {
-                                worktree_repository::Column::ScanId.gt(rejoined_worktree.scan_id)
-                            } else {
-                                worktree_repository::Column::IsDeleted.eq(false)
-                            };
-
-                        let mut db_repositories = worktree_repository::Entity::find()
-                            .filter(
-                                Condition::all()
-                                    .add(worktree_repository::Column::ProjectId.eq(project.id))
-                                    .add(worktree_repository::Column::WorktreeId.eq(worktree.id))
-                                    .add(repository_entry_filter),
-                            )
-                            .stream(&*tx)
-                            .await?;
-
-                        while let Some(db_repository) = db_repositories.next().await {
-                            let db_repository = db_repository?;
-                            if db_repository.is_deleted {
-                                worktree
-                                    .removed_repositories
-                                    .push(db_repository.work_directory_id as u64);
-                            } else {
-                                worktree.updated_repositories.push(proto::RepositoryEntry {
-                                    work_directory_id: db_repository.work_directory_id as u64,
-                                    branch: db_repository.branch,
-                                    removed_repo_paths: Default::default(),
-                                    updated_statuses: Default::default(),
-                                });
-                            }
-                        }
-                    }
-
-                    // Repository Status Entries
-                    for repository in worktree.updated_repositories.iter_mut() {
-                        let repository_status_entry_filter =
-                            if let Some(rejoined_worktree) = rejoined_worktree {
-                                worktree_repository_statuses::Column::ScanId
-                                    .gt(rejoined_worktree.scan_id)
-                            } else {
-                                worktree_repository_statuses::Column::IsDeleted.eq(false)
-                            };
-
-                        let mut db_repository_statuses =
-                            worktree_repository_statuses::Entity::find()
-                                .filter(
-                                    Condition::all()
-                                        .add(
-                                            worktree_repository_statuses::Column::ProjectId
-                                                .eq(project.id),
-                                        )
-                                        .add(
-                                            worktree_repository_statuses::Column::WorktreeId
-                                                .eq(worktree.id),
-                                        )
-                                        .add(
-                                            worktree_repository_statuses::Column::WorkDirectoryId
-                                                .eq(repository.work_directory_id),
-                                        )
-                                        .add(repository_status_entry_filter),
-                                )
-                                .stream(&*tx)
-                                .await?;
-
-                        while let Some(db_status_entry) = db_repository_statuses.next().await {
-                            let db_status_entry = db_status_entry?;
-                            if db_status_entry.is_deleted {
-                                repository
-                                    .removed_repo_paths
-                                    .push(db_status_entry.repo_path);
-                            } else {
-                                repository.updated_statuses.push(proto::StatusEntry {
-                                    repo_path: db_status_entry.repo_path,
-                                    status: db_status_entry.status as i32,
-                                });
-                            }
+                            worktree.updated_entries.push(proto::Entry {
+                                id: db_entry.id as u64,
+                                is_dir: db_entry.is_dir,
+                                path: db_entry.path,
+                                inode: db_entry.inode as u64,
+                                mtime: Some(proto::Timestamp {
+                                    seconds: db_entry.mtime_seconds as u64,
+                                    nanos: db_entry.mtime_nanos as u32,
+                                }),
+                                is_symlink: db_entry.is_symlink,
+                                is_ignored: db_entry.is_ignored,
+                            });
                         }
                     }
 
@@ -2421,115 +2330,6 @@ impl Database {
                     .await?;
             }
 
-            if !update.updated_repositories.is_empty() {
-                worktree_repository::Entity::insert_many(update.updated_repositories.iter().map(
-                    |repository| worktree_repository::ActiveModel {
-                        project_id: ActiveValue::set(project_id),
-                        worktree_id: ActiveValue::set(worktree_id),
-                        work_directory_id: ActiveValue::set(repository.work_directory_id as i64),
-                        scan_id: ActiveValue::set(update.scan_id as i64),
-                        branch: ActiveValue::set(repository.branch.clone()),
-                        is_deleted: ActiveValue::set(false),
-                    },
-                ))
-                .on_conflict(
-                    OnConflict::columns([
-                        worktree_repository::Column::ProjectId,
-                        worktree_repository::Column::WorktreeId,
-                        worktree_repository::Column::WorkDirectoryId,
-                    ])
-                    .update_columns([
-                        worktree_repository::Column::ScanId,
-                        worktree_repository::Column::Branch,
-                    ])
-                    .to_owned(),
-                )
-                .exec(&*tx)
-                .await?;
-
-                for repository in update.updated_repositories.iter() {
-                    if !repository.updated_statuses.is_empty() {
-                        worktree_repository_statuses::Entity::insert_many(
-                            repository.updated_statuses.iter().map(|status_entry| {
-                                worktree_repository_statuses::ActiveModel {
-                                    project_id: ActiveValue::set(project_id),
-                                    worktree_id: ActiveValue::set(worktree_id),
-                                    work_directory_id: ActiveValue::set(
-                                        repository.work_directory_id as i64,
-                                    ),
-                                    repo_path: ActiveValue::set(status_entry.repo_path.clone()),
-                                    status: ActiveValue::set(status_entry.status as i64),
-                                    scan_id: ActiveValue::set(update.scan_id as i64),
-                                    is_deleted: ActiveValue::set(false),
-                                }
-                            }),
-                        )
-                        .on_conflict(
-                            OnConflict::columns([
-                                worktree_repository_statuses::Column::ProjectId,
-                                worktree_repository_statuses::Column::WorktreeId,
-                                worktree_repository_statuses::Column::WorkDirectoryId,
-                                worktree_repository_statuses::Column::RepoPath,
-                            ])
-                            .update_columns([
-                                worktree_repository_statuses::Column::ScanId,
-                                worktree_repository_statuses::Column::Status,
-                                worktree_repository_statuses::Column::IsDeleted,
-                            ])
-                            .to_owned(),
-                        )
-                        .exec(&*tx)
-                        .await?;
-                    }
-
-                    if !repository.removed_repo_paths.is_empty() {
-                        worktree_repository_statuses::Entity::update_many()
-                            .filter(
-                                worktree_repository_statuses::Column::ProjectId
-                                    .eq(project_id)
-                                    .and(
-                                        worktree_repository_statuses::Column::WorktreeId
-                                            .eq(worktree_id),
-                                    )
-                                    .and(
-                                        worktree_repository_statuses::Column::WorkDirectoryId
-                                            .eq(repository.work_directory_id as i64),
-                                    )
-                                    .and(worktree_repository_statuses::Column::RepoPath.is_in(
-                                        repository.removed_repo_paths.iter().map(String::as_str),
-                                    )),
-                            )
-                            .set(worktree_repository_statuses::ActiveModel {
-                                is_deleted: ActiveValue::Set(true),
-                                scan_id: ActiveValue::Set(update.scan_id as i64),
-                                ..Default::default()
-                            })
-                            .exec(&*tx)
-                            .await?;
-                    }
-                }
-            }
-
-            if !update.removed_repositories.is_empty() {
-                worktree_repository::Entity::update_many()
-                    .filter(
-                        worktree_repository::Column::ProjectId
-                            .eq(project_id)
-                            .and(worktree_repository::Column::WorktreeId.eq(worktree_id))
-                            .and(
-                                worktree_repository::Column::WorkDirectoryId
-                                    .is_in(update.removed_repositories.iter().map(|id| *id as i64)),
-                            ),
-                    )
-                    .set(worktree_repository::ActiveModel {
-                        is_deleted: ActiveValue::Set(true),
-                        scan_id: ActiveValue::Set(update.scan_id as i64),
-                        ..Default::default()
-                    })
-                    .exec(&*tx)
-                    .await?;
-            }
-
             let connection_ids = self.project_guest_connection_ids(project_id, &tx).await?;
             Ok(connection_ids)
         })
@@ -2705,7 +2505,6 @@ impl Database {
                             root_name: db_worktree.root_name,
                             visible: db_worktree.visible,
                             entries: Default::default(),
-                            repository_entries: Default::default(),
                             diagnostic_summaries: Default::default(),
                             scan_id: db_worktree.scan_id as u64,
                             completed_scan_id: db_worktree.completed_scan_id as u64,
@@ -2743,61 +2542,6 @@ impl Database {
                 }
             }
 
-            // Populate repository entries.
-            {
-                let mut db_repository_entries = worktree_repository::Entity::find()
-                    .filter(
-                        Condition::all()
-                            .add(worktree_repository::Column::ProjectId.eq(project_id))
-                            .add(worktree_repository::Column::IsDeleted.eq(false)),
-                    )
-                    .stream(&*tx)
-                    .await?;
-                while let Some(db_repository_entry) = db_repository_entries.next().await {
-                    let db_repository_entry = db_repository_entry?;
-                    if let Some(worktree) =
-                        worktrees.get_mut(&(db_repository_entry.worktree_id as u64))
-                    {
-                        worktree.repository_entries.insert(
-                            db_repository_entry.work_directory_id as u64,
-                            proto::RepositoryEntry {
-                                work_directory_id: db_repository_entry.work_directory_id as u64,
-                                branch: db_repository_entry.branch,
-                                removed_repo_paths: Default::default(),
-                                updated_statuses: Default::default(),
-                            },
-                        );
-                    }
-                }
-            }
-
-            {
-                let mut db_status_entries = worktree_repository_statuses::Entity::find()
-                    .filter(
-                        Condition::all()
-                            .add(worktree_repository_statuses::Column::ProjectId.eq(project_id))
-                            .add(worktree_repository_statuses::Column::IsDeleted.eq(false)),
-                    )
-                    .stream(&*tx)
-                    .await?;
-
-                while let Some(db_status_entry) = db_status_entries.next().await {
-                    let db_status_entry = db_status_entry?;
-                    if let Some(worktree) = worktrees.get_mut(&(db_status_entry.worktree_id as u64))
-                    {
-                        if let Some(repository_entry) = worktree
-                            .repository_entries
-                            .get_mut(&(db_status_entry.work_directory_id as u64))
-                        {
-                            repository_entry.updated_statuses.push(proto::StatusEntry {
-                                repo_path: db_status_entry.repo_path,
-                                status: db_status_entry.status as i32,
-                            });
-                        }
-                    }
-                }
-            }
-
             // Populate worktree diagnostic summaries.
             {
                 let mut db_summaries = worktree_diagnostic_summary::Entity::find()
@@ -3479,8 +3223,6 @@ pub struct RejoinedWorktree {
     pub visible: bool,
     pub updated_entries: Vec<proto::Entry>,
     pub removed_entries: Vec<u64>,
-    pub updated_repositories: Vec<proto::RepositoryEntry>,
-    pub removed_repositories: Vec<u64>,
     pub diagnostic_summaries: Vec<proto::DiagnosticSummary>,
     pub scan_id: u64,
     pub completed_scan_id: u64,
@@ -3535,7 +3277,6 @@ pub struct Worktree {
     pub root_name: String,
     pub visible: bool,
     pub entries: Vec<proto::Entry>,
-    pub repository_entries: BTreeMap<u64, proto::RepositoryEntry>,
     pub diagnostic_summaries: Vec<proto::DiagnosticSummary>,
     pub scan_id: u64,
     pub completed_scan_id: u64,

crates/collab/src/db/worktree_repository.rs

@@ -1,21 +0,0 @@
-use super::ProjectId;
-use sea_orm::entity::prelude::*;
-
-#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
-#[sea_orm(table_name = "worktree_repositories")]
-pub struct Model {
-    #[sea_orm(primary_key)]
-    pub project_id: ProjectId,
-    #[sea_orm(primary_key)]
-    pub worktree_id: i64,
-    #[sea_orm(primary_key)]
-    pub work_directory_id: i64,
-    pub scan_id: i64,
-    pub branch: Option<String>,
-    pub is_deleted: bool,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {}
-
-impl ActiveModelBehavior for ActiveModel {}

crates/collab/src/db/worktree_repository_statuses.rs

@@ -1,23 +0,0 @@
-use super::ProjectId;
-use sea_orm::entity::prelude::*;
-
-#[derive(Clone, Debug, PartialEq, Eq, DeriveEntityModel)]
-#[sea_orm(table_name = "worktree_repository_statuses")]
-pub struct Model {
-    #[sea_orm(primary_key)]
-    pub project_id: ProjectId,
-    #[sea_orm(primary_key)]
-    pub worktree_id: i64,
-    #[sea_orm(primary_key)]
-    pub work_directory_id: i64,
-    #[sea_orm(primary_key)]
-    pub repo_path: String,
-    pub status: i64,
-    pub scan_id: i64,
-    pub is_deleted: bool,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {}
-
-impl ActiveModelBehavior for ActiveModel {}

crates/collab/src/rpc.rs

@@ -51,7 +51,7 @@ use std::{
         atomic::{AtomicBool, Ordering::SeqCst},
         Arc,
     },
-    time::{Duration, Instant},
+    time::Duration,
 };
 use tokio::sync::{watch, Semaphore};
 use tower::ServiceBuilder;
@@ -397,16 +397,10 @@ impl Server {
                         "message received"
                     );
                 });
-                let start_time = Instant::now();
                 let future = (handler)(*envelope, session);
                 async move {
-                    let result = future.await;
-                    let duration_ms = start_time.elapsed().as_micros() as f64 / 1000.0;
-                    match result {
-                        Err(error) => {
-                            tracing::error!(%error, ?duration_ms, "error handling message")
-                        }
-                        Ok(()) => tracing::info!(?duration_ms, "finished handling message"),
+                    if let Err(error) = future.await {
+                        tracing::error!(%error, "error handling message");
                     }
                 }
                 .instrument(span)
@@ -1069,8 +1063,6 @@ async fn rejoin_room(
                     removed_entries: worktree.removed_entries,
                     scan_id: worktree.scan_id,
                     is_last_update: worktree.completed_scan_id == worktree.scan_id,
-                    updated_repositories: worktree.updated_repositories,
-                    removed_repositories: worktree.removed_repositories,
                 };
                 for update in proto::split_worktree_update(message, MAX_CHUNK_SIZE) {
                     session.peer.send(session.connection_id, update.clone())?;
@@ -1391,8 +1383,6 @@ async fn join_project(
             removed_entries: Default::default(),
             scan_id: worktree.scan_id,
             is_last_update: worktree.scan_id == worktree.completed_scan_id,
-            updated_repositories: worktree.repository_entries.into_values().collect(),
-            removed_repositories: Default::default(),
         };
         for update in proto::split_worktree_update(message, MAX_CHUNK_SIZE) {
             session.peer.send(session.connection_id, update.clone())?;

crates/collab/src/tests.rs

@@ -12,14 +12,11 @@ use client::{
 use collections::{HashMap, HashSet};
 use fs::FakeFs;
 use futures::{channel::oneshot, StreamExt as _};
-use gpui::{
-    elements::*, executor::Deterministic, AnyElement, Entity, ModelHandle, TestAppContext, View,
-    ViewContext, ViewHandle, WeakViewHandle,
-};
+use gpui::{executor::Deterministic, test::EmptyView, ModelHandle, TestAppContext, ViewHandle};
 use language::LanguageRegistry;
 use parking_lot::Mutex;
 use project::{Project, WorktreeId};
-use settings::SettingsStore;
+use settings::Settings;
 use std::{
     cell::{Ref, RefCell, RefMut},
     env,
@@ -30,6 +27,7 @@ use std::{
         Arc,
     },
 };
+use theme::ThemeRegistry;
 use util::http::FakeHttpClient;
 use workspace::Workspace;
 
@@ -101,7 +99,7 @@ impl TestServer {
 
     async fn create_client(&mut self, cx: &mut TestAppContext, name: &str) -> TestClient {
         cx.update(|cx| {
-            cx.set_global(SettingsStore::test(cx));
+            cx.set_global(Settings::test(cx));
         });
 
         let http = FakeHttpClient::with_404_response();
@@ -190,18 +188,16 @@ impl TestServer {
             client: client.clone(),
             user_store: user_store.clone(),
             languages: Arc::new(LanguageRegistry::test()),
+            themes: ThemeRegistry::new((), cx.font_cache()),
             fs: fs.clone(),
             build_window_options: |_, _, _| Default::default(),
-            initialize_workspace: |_, _, _, _| unimplemented!(),
+            initialize_workspace: |_, _, _| unimplemented!(),
+            dock_default_item_factory: |_, _| None,
             background_actions: || &[],
         });
 
+        Project::init(&client);
         cx.update(|cx| {
-            theme::init((), cx);
-            Project::init(&client, cx);
-            client::init(&client, cx);
-            language::init(cx);
-            editor::init_settings(cx);
             workspace::init(app_state.clone(), cx);
             call::init(client.clone(), user_store.clone(), cx);
         });
@@ -466,41 +462,8 @@ impl TestClient {
         project: &ModelHandle<Project>,
         cx: &mut TestAppContext,
     ) -> ViewHandle<Workspace> {
-        struct WorkspaceContainer {
-            workspace: Option<WeakViewHandle<Workspace>>,
-        }
-
-        impl Entity for WorkspaceContainer {
-            type Event = ();
-        }
-
-        impl View for WorkspaceContainer {
-            fn ui_name() -> &'static str {
-                "WorkspaceContainer"
-            }
-
-            fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
-                if let Some(workspace) = self
-                    .workspace
-                    .as_ref()
-                    .and_then(|workspace| workspace.upgrade(cx))
-                {
-                    ChildView::new(&workspace, cx).into_any()
-                } else {
-                    Empty::new().into_any()
-                }
-            }
-        }
-
-        // We use a workspace container so that we don't need to remove the window in order to
-        // drop the workspace and we can use a ViewHandle instead.
-        let (window_id, container) = cx.add_window(|_| WorkspaceContainer { workspace: None });
-        let workspace = cx.add_view(window_id, |cx| Workspace::test_new(project.clone(), cx));
-        container.update(cx, |container, cx| {
-            container.workspace = Some(workspace.downgrade());
-            cx.notify();
-        });
-        workspace
+        let (_, root_view) = cx.add_window(|_| EmptyView);
+        cx.add_view(&root_view, |cx| Workspace::test_new(project.clone(), cx))
     }
 }
 

crates/collab/src/tests/randomized_integration_tests.rs

@@ -8,20 +8,19 @@ use call::ActiveCall;
 use client::RECEIVE_TIMEOUT;
 use collections::BTreeMap;
 use editor::Bias;
-use fs::{repository::GitFileStatus, FakeFs, Fs as _};
+use fs::{FakeFs, Fs as _};
 use futures::StreamExt as _;
 use gpui::{executor::Deterministic, ModelHandle, Task, TestAppContext};
 use language::{range_to_lsp, FakeLspAdapter, Language, LanguageConfig, PointUtf16};
 use lsp::FakeLanguageServer;
 use parking_lot::Mutex;
-use pretty_assertions::assert_eq;
 use project::{search::SearchQuery, Project, ProjectPath};
 use rand::{
     distributions::{Alphanumeric, DistString},
     prelude::*,
 };
 use serde::{Deserialize, Serialize};
-use settings::SettingsStore;
+use settings::Settings;
 use std::{
     env,
     ops::Range,
@@ -149,9 +148,8 @@ async fn test_random_collaboration(
 
     for (client, mut cx) in clients {
         cx.update(|cx| {
-            let store = cx.remove_global::<SettingsStore>();
             cx.clear_globals();
-            cx.set_global(store);
+            cx.set_global(Settings::test(cx));
             drop(client);
         });
     }
@@ -718,10 +716,7 @@ async fn apply_client_operation(
             );
 
             let search = project.update(cx, |project, cx| {
-                project.search(
-                    SearchQuery::text(query, false, false, Vec::new(), Vec::new()),
-                    cx,
-                )
+                project.search(SearchQuery::text(query, false, false), cx)
             });
             drop(project);
             let search = cx.background().spawn(async move {
@@ -765,85 +760,31 @@ async fn apply_client_operation(
             }
         }
 
-        ClientOperation::GitOperation { operation } => match operation {
-            GitOperation::WriteGitIndex {
-                repo_path,
-                contents,
-            } => {
-                if !client.fs.directories().contains(&repo_path) {
-                    return Err(TestError::Inapplicable);
-                }
-
-                log::info!(
-                    "{}: writing git index for repo {:?}: {:?}",
-                    client.username,
-                    repo_path,
-                    contents
-                );
-
-                let dot_git_dir = repo_path.join(".git");
-                let contents = contents
-                    .iter()
-                    .map(|(path, contents)| (path.as_path(), contents.clone()))
-                    .collect::<Vec<_>>();
-                if client.fs.metadata(&dot_git_dir).await?.is_none() {
-                    client.fs.create_dir(&dot_git_dir).await?;
-                }
-                client.fs.set_index_for_repo(&dot_git_dir, &contents).await;
+        ClientOperation::WriteGitIndex {
+            repo_path,
+            contents,
+        } => {
+            if !client.fs.directories().contains(&repo_path) {
+                return Err(TestError::Inapplicable);
             }
-            GitOperation::WriteGitBranch {
+
+            log::info!(
+                "{}: writing git index for repo {:?}: {:?}",
+                client.username,
                 repo_path,
-                new_branch,
-            } => {
-                if !client.fs.directories().contains(&repo_path) {
-                    return Err(TestError::Inapplicable);
-                }
+                contents
+            );
 
-                log::info!(
-                    "{}: writing git branch for repo {:?}: {:?}",
-                    client.username,
-                    repo_path,
-                    new_branch
-                );
-
-                let dot_git_dir = repo_path.join(".git");
-                if client.fs.metadata(&dot_git_dir).await?.is_none() {
-                    client.fs.create_dir(&dot_git_dir).await?;
-                }
-                client.fs.set_branch_name(&dot_git_dir, new_branch).await;
+            let dot_git_dir = repo_path.join(".git");
+            let contents = contents
+                .iter()
+                .map(|(path, contents)| (path.as_path(), contents.clone()))
+                .collect::<Vec<_>>();
+            if client.fs.metadata(&dot_git_dir).await?.is_none() {
+                client.fs.create_dir(&dot_git_dir).await?;
             }
-            GitOperation::WriteGitStatuses {
-                repo_path,
-                statuses,
-            } => {
-                if !client.fs.directories().contains(&repo_path) {
-                    return Err(TestError::Inapplicable);
-                }
-
-                log::info!(
-                    "{}: writing git statuses for repo {:?}: {:?}",
-                    client.username,
-                    repo_path,
-                    statuses
-                );
-
-                let dot_git_dir = repo_path.join(".git");
-
-                let statuses = statuses
-                    .iter()
-                    .map(|(path, val)| (path.as_path(), val.clone()))
-                    .collect::<Vec<_>>();
-
-                if client.fs.metadata(&dot_git_dir).await?.is_none() {
-                    client.fs.create_dir(&dot_git_dir).await?;
-                }
-
-                client
-                    .fs
-                    .set_status_for_repo(&dot_git_dir, statuses.as_slice())
-                    .await;
-            }
-        },
+            client.fs.set_index_for_repo(&dot_git_dir, &contents).await;
+        }
     }
     Ok(())
 }
@@ -918,12 +859,6 @@ fn check_consistency_between_clients(clients: &[(Rc<TestClient>, TestAppContext)
                                 host_snapshot.abs_path(),
                                 guest_project.remote_id(),
                             );
-                            assert_eq!(guest_snapshot.repositories().collect::<Vec<_>>(), host_snapshot.repositories().collect::<Vec<_>>(),
-                                "{} has different repositories than the host for worktree {:?} and project {:?}",
-                                client.username,
-                                host_snapshot.abs_path(),
-                                guest_project.remote_id(),
-                            );
                             assert_eq!(guest_snapshot.scan_id(), host_snapshot.scan_id(),
                                 "{} has different scan id than the host for worktree {:?} and project {:?}",
                                 client.username,
@@ -1212,25 +1147,10 @@ enum ClientOperation {
         is_dir: bool,
         content: String,
     },
-    GitOperation {
-        operation: GitOperation,
-    },
-}
-
-#[derive(Clone, Debug, Serialize, Deserialize)]
-enum GitOperation {
     WriteGitIndex {
         repo_path: PathBuf,
         contents: Vec<(PathBuf, String)>,
     },
-    WriteGitBranch {
-        repo_path: PathBuf,
-        new_branch: Option<String>,
-    },
-    WriteGitStatuses {
-        repo_path: PathBuf,
-        statuses: Vec<(PathBuf, GitFileStatus)>,
-    },
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -1743,10 +1663,38 @@ impl TestPlan {
                     }
                 }
 
-                // Update a git related action
+                // Update a git index
                 91..=95 => {
-                    break ClientOperation::GitOperation {
-                        operation: self.generate_git_operation(client),
+                    let repo_path = client
+                        .fs
+                        .directories()
+                        .choose(&mut self.rng)
+                        .unwrap()
+                        .clone();
+
+                    let mut file_paths = client
+                        .fs
+                        .files()
+                        .into_iter()
+                        .filter(|path| path.starts_with(&repo_path))
+                        .collect::<Vec<_>>();
+                    let count = self.rng.gen_range(0..=file_paths.len());
+                    file_paths.shuffle(&mut self.rng);
+                    file_paths.truncate(count);
+
+                    let mut contents = Vec::new();
+                    for abs_child_file_path in &file_paths {
+                        let child_file_path = abs_child_file_path
+                            .strip_prefix(&repo_path)
+                            .unwrap()
+                            .to_path_buf();
+                        let new_base = Alphanumeric.sample_string(&mut self.rng, 16);
+                        contents.push((child_file_path, new_base));
+                    }
+
+                    break ClientOperation::WriteGitIndex {
+                        repo_path,
+                        contents,
                     };
                 }
 
@@ -1784,86 +1732,6 @@ impl TestPlan {
         })
     }
 
-    fn generate_git_operation(&mut self, client: &TestClient) -> GitOperation {
-        fn generate_file_paths(
-            repo_path: &Path,
-            rng: &mut StdRng,
-            client: &TestClient,
-        ) -> Vec<PathBuf> {
-            let mut paths = client
-                .fs
-                .files()
-                .into_iter()
-                .filter(|path| path.starts_with(repo_path))
-                .collect::<Vec<_>>();
-
-            let count = rng.gen_range(0..=paths.len());
-            paths.shuffle(rng);
-            paths.truncate(count);
-
-            paths
-                .iter()
-                .map(|path| path.strip_prefix(repo_path).unwrap().to_path_buf())
-                .collect::<Vec<_>>()
-        }
-
-        let repo_path = client
-            .fs
-            .directories()
-            .choose(&mut self.rng)
-            .unwrap()
-            .clone();
-
-        match self.rng.gen_range(0..100_u32) {
-            0..=25 => {
-                let file_paths = generate_file_paths(&repo_path, &mut self.rng, client);
-
-                let contents = file_paths
-                    .into_iter()
-                    .map(|path| (path, Alphanumeric.sample_string(&mut self.rng, 16)))
-                    .collect();
-
-                GitOperation::WriteGitIndex {
-                    repo_path,
-                    contents,
-                }
-            }
-            26..=63 => {
-                let new_branch = (self.rng.gen_range(0..10) > 3)
-                    .then(|| Alphanumeric.sample_string(&mut self.rng, 8));
-
-                GitOperation::WriteGitBranch {
-                    repo_path,
-                    new_branch,
-                }
-            }
-            64..=100 => {
-                let file_paths = generate_file_paths(&repo_path, &mut self.rng, client);
-
-                let statuses = file_paths
-                    .into_iter()
-                    .map(|paths| {
-                        (
-                            paths,
-                            match self.rng.gen_range(0..3_u32) {
-                                0 => GitFileStatus::Added,
-                                1 => GitFileStatus::Modified,
-                                2 => GitFileStatus::Conflict,
-                                _ => unreachable!(),
-                            },
-                        )
-                    })
-                    .collect::<Vec<_>>();
-
-                GitOperation::WriteGitStatuses {
-                    repo_path,
-                    statuses,
-                }
-            }
-            _ => unreachable!(),
-        }
-    }
-
     fn next_root_dir_name(&mut self, user_id: UserId) -> String {
         let user_ix = self
             .users

crates/collab_ui/Cargo.toml

@@ -39,13 +39,12 @@ settings = { path = "../settings" }
 theme = { path = "../theme" }
 util = { path = "../util" }
 workspace = { path = "../workspace" }
-
-anyhow.workspace = true
-futures.workspace = true
-log.workspace = true
-postage.workspace = true
-serde.workspace = true
-serde_derive.workspace = true
+anyhow = "1.0"
+futures = "0.3"
+log = "0.4"
+postage = { workspace = true }
+serde = { workspace = true }
+serde_derive = { workspace = true }
 
 [dev-dependencies]
 call = { path = "../call", features = ["test-support"] }

crates/collab_ui/src/collab_titlebar_item.rs

@@ -1,9 +1,10 @@
 use crate::{
+    collaborator_list_popover, collaborator_list_popover::CollaboratorListPopover,
     contact_notification::ContactNotification, contacts_popover, face_pile::FacePile,
-    toggle_screen_sharing, ToggleScreenSharing,
+    ToggleScreenSharing,
 };
 use call::{ActiveCall, ParticipantLocation, Room};
-use client::{proto::PeerId, Client, ContactEventKind, SignIn, SignOut, User, UserStore};
+use client::{proto::PeerId, ContactEventKind, SignIn, SignOut, User, UserStore};
 use clock::ReplicaId;
 use contacts_popover::ContactsPopover;
 use context_menu::{ContextMenu, ContextMenuItem};
@@ -12,22 +13,22 @@ use gpui::{
     color::Color,
     elements::*,
     geometry::{rect::RectF, vector::vec2f, PathBuilder},
+    impl_internal_actions,
     json::{self, ToJson},
     platform::{CursorStyle, MouseButton},
-    AppContext, Entity, ImageData, LayoutContext, ModelHandle, SceneBuilder, Subscription, View,
-    ViewContext, ViewHandle, WeakViewHandle,
+    AppContext, Entity, ImageData, ModelHandle, RenderContext, Subscription, View, ViewContext,
+    ViewHandle, WeakViewHandle,
 };
-use project::Project;
+use settings::Settings;
 use std::{ops::Range, sync::Arc};
 use theme::{AvatarStyle, Theme};
 use util::ResultExt;
-use workspace::{FollowNextCollaborator, Workspace};
-
-const MAX_TITLE_LENGTH: usize = 75;
+use workspace::{FollowNextCollaborator, JoinProject, ToggleFollow, Workspace};
 
 actions!(
     collab,
     [
+        ToggleCollaboratorList,
         ToggleContactsMenu,
         ToggleUserMenu,
         ShareProject,
@@ -35,20 +36,26 @@ actions!(
     ]
 );
 
+impl_internal_actions!(collab, [LeaveCall]);
+
+#[derive(Copy, Clone, PartialEq)]
+pub(crate) struct LeaveCall;
+
 pub fn init(cx: &mut AppContext) {
+    cx.add_action(CollabTitlebarItem::toggle_collaborator_list_popover);
     cx.add_action(CollabTitlebarItem::toggle_contacts_popover);
     cx.add_action(CollabTitlebarItem::share_project);
     cx.add_action(CollabTitlebarItem::unshare_project);
+    cx.add_action(CollabTitlebarItem::leave_call);
     cx.add_action(CollabTitlebarItem::toggle_user_menu);
 }
 
 pub struct CollabTitlebarItem {
-    project: ModelHandle<Project>,
-    user_store: ModelHandle<UserStore>,
-    client: Arc<Client>,
     workspace: WeakViewHandle<Workspace>,
+    user_store: ModelHandle<UserStore>,
     contacts_popover: Option<ViewHandle<ContactsPopover>>,
     user_menu: ViewHandle<ContextMenu>,
+    collaborator_list_popover: Option<ViewHandle<CollaboratorListPopover>>,
     _subscriptions: Vec<Subscription>,
 }
 
@@ -61,22 +68,41 @@ impl View for CollabTitlebarItem {
         "CollabTitlebarItem"
     }
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
         let workspace = if let Some(workspace) = self.workspace.upgrade(cx) {
             workspace
         } else {
-            return Empty::new().into_any();
+            return Empty::new().boxed();
         };
 
-        let project = self.project.read(cx);
-        let theme = theme::current(cx).clone();
+        let project = workspace.read(cx).project().read(cx);
+        let mut project_title = String::new();
+        for (i, name) in project.worktree_root_names(cx).enumerate() {
+            if i > 0 {
+                project_title.push_str(", ");
+            }
+            project_title.push_str(name);
+        }
+        if project_title.is_empty() {
+            project_title = "empty project".to_owned();
+        }
+
+        let theme = cx.global::<Settings>().theme.clone();
+
         let mut left_container = Flex::row();
         let mut right_container = Flex::row().align_children_center();
 
-        left_container.add_child(self.collect_title_root_names(&project, theme.clone(), cx));
+        left_container.add_child(
+            Label::new(project_title, theme.workspace.titlebar.title.clone())
+                .contained()
+                .with_margin_right(theme.workspace.titlebar.item_spacing)
+                .aligned()
+                .left()
+                .boxed(),
+        );
 
-        let user = self.user_store.read(cx).current_user();
-        let peer_id = self.client.peer_id();
+        let user = workspace.read(cx).user_store().read(cx).current_user();
+        let peer_id = workspace.read(cx).client().peer_id();
         if let Some(((user, peer_id), room)) = user
             .zip(peer_id)
             .zip(ActiveCall::global(cx).read(cx).room().cloned())
@@ -102,46 +128,28 @@ impl View for CollabTitlebarItem {
         }
 
         Stack::new()
-            .with_child(left_container)
-            .with_child(
-                Flex::row()
-                    .with_child(
-                        right_container.contained().with_background_color(
-                            theme
-                                .workspace
-                                .titlebar
-                                .container
-                                .background_color
-                                .unwrap_or_else(|| Color::transparent_black()),
-                        ),
-                    )
-                    .aligned()
-                    .right(),
-            )
-            .into_any()
+            .with_child(left_container.boxed())
+            .with_child(right_container.aligned().right().boxed())
+            .boxed()
     }
 }
 
 impl CollabTitlebarItem {
     pub fn new(
-        workspace: &Workspace,
-        workspace_handle: &ViewHandle<Workspace>,
+        workspace: &ViewHandle<Workspace>,
+        user_store: &ModelHandle<UserStore>,
         cx: &mut ViewContext<Self>,
     ) -> Self {
-        let project = workspace.project().clone();
-        let user_store = workspace.app_state().user_store.clone();
-        let client = workspace.app_state().client.clone();
         let active_call = ActiveCall::global(cx);
         let mut subscriptions = Vec::new();
-        subscriptions.push(cx.observe(workspace_handle, |_, _, cx| cx.notify()));
-        subscriptions.push(cx.observe(&project, |_, _, cx| cx.notify()));
+        subscriptions.push(cx.observe(workspace, |_, _, cx| cx.notify()));
         subscriptions.push(cx.observe(&active_call, |this, _, cx| this.active_call_changed(cx)));
         subscriptions.push(cx.observe_window_activation(|this, active, cx| {
             this.window_activation_changed(active, cx)
         }));
-        subscriptions.push(cx.observe(&user_store, |_, _, cx| cx.notify()));
+        subscriptions.push(cx.observe(user_store, |_, _, cx| cx.notify()));
         subscriptions.push(
-            cx.subscribe(&user_store, move |this, user_store, event, cx| {
+            cx.subscribe(user_store, move |this, user_store, event, cx| {
                 if let Some(workspace) = this.workspace.upgrade(cx) {
                     workspace.update(cx, |workspace, cx| {
                         if let client::Event::Contact { user, kind } = event {
@@ -163,88 +171,31 @@ impl CollabTitlebarItem {
             }),
         );
 
-        let view_id = cx.view_id();
         Self {
-            workspace: workspace.weak_handle(),
-            project,
-            user_store,
-            client,
+            workspace: workspace.downgrade(),
+            user_store: user_store.clone(),
             contacts_popover: None,
             user_menu: cx.add_view(|cx| {
-                let mut menu = ContextMenu::new(view_id, cx);
+                let mut menu = ContextMenu::new(cx);
                 menu.set_position_mode(OverlayPositionMode::Local);
                 menu
             }),
+            collaborator_list_popover: None,
             _subscriptions: subscriptions,
         }
     }
 
-    fn collect_title_root_names(
-        &self,
-        project: &Project,
-        theme: Arc<Theme>,
-        cx: &ViewContext<Self>,
-    ) -> AnyElement<Self> {
-        let names_and_branches = project.visible_worktrees(cx).map(|worktree| {
-            let worktree = worktree.read(cx);
-            (worktree.root_name(), worktree.root_git_entry())
-        });
-
-        fn push_str(buffer: &mut String, index: &mut usize, str: &str) {
-            buffer.push_str(str);
-            *index += str.chars().count();
-        }
-
-        let mut indices = Vec::new();
-        let mut index = 0;
-        let mut title = String::new();
-        let mut names_and_branches = names_and_branches.peekable();
-        while let Some((name, entry)) = names_and_branches.next() {
-            let pre_index = index;
-            push_str(&mut title, &mut index, name);
-            indices.extend((pre_index..index).into_iter());
-            if let Some(branch) = entry.and_then(|entry| entry.branch()) {
-                push_str(&mut title, &mut index, "/");
-                push_str(&mut title, &mut index, &branch);
-            }
-            if names_and_branches.peek().is_some() {
-                push_str(&mut title, &mut index, ", ");
-                if index >= MAX_TITLE_LENGTH {
-                    title.push_str(" …");
-                    break;
-                }
-            }
-        }
-
-        let text_style = theme.workspace.titlebar.title.clone();
-        let item_spacing = theme.workspace.titlebar.item_spacing;
-
-        let mut highlight = text_style.clone();
-        highlight.color = theme.workspace.titlebar.highlight_color;
-
-        let style = LabelStyle {
-            text: text_style,
-            highlight_text: Some(highlight),
-        };
-
-        Label::new(title, style)
-            .with_highlights(indices)
-            .contained()
-            .with_margin_right(item_spacing)
-            .aligned()
-            .left()
-            .into_any_named("title-with-git-information")
-    }
-
     fn window_activation_changed(&mut self, active: bool, cx: &mut ViewContext<Self>) {
-        let project = if active {
-            Some(self.project.clone())
-        } else {
-            None
-        };
-        ActiveCall::global(cx)
-            .update(cx, |call, cx| call.set_location(project.as_ref(), cx))
-            .detach_and_log_err(cx);
+        if let Some(workspace) = self.workspace.upgrade(cx) {
+            let project = if active {
+                Some(workspace.read(cx).project().clone())
+            } else {
+                None
+            };
+            ActiveCall::global(cx)
+                .update(cx, |call, cx| call.set_location(project.as_ref(), cx))
+                .detach_and_log_err(cx);
+        }
     }
 
     fn active_call_changed(&mut self, cx: &mut ViewContext<Self>) {
@@ -255,49 +206,80 @@ impl CollabTitlebarItem {
     }
 
     fn share_project(&mut self, _: &ShareProject, cx: &mut ViewContext<Self>) {
-        let active_call = ActiveCall::global(cx);
-        let project = self.project.clone();
-        active_call
-            .update(cx, |call, cx| call.share_project(project, cx))
-            .detach_and_log_err(cx);
+        if let Some(workspace) = self.workspace.upgrade(cx) {
+            let active_call = ActiveCall::global(cx);
+            let project = workspace.read(cx).project().clone();
+            active_call
+                .update(cx, |call, cx| call.share_project(project, cx))
+                .detach_and_log_err(cx);
+        }
     }
 
     fn unshare_project(&mut self, _: &UnshareProject, cx: &mut ViewContext<Self>) {
-        let active_call = ActiveCall::global(cx);
-        let project = self.project.clone();
-        active_call
-            .update(cx, |call, cx| call.unshare_project(project, cx))
-            .log_err();
+        if let Some(workspace) = self.workspace.upgrade(cx) {
+            let active_call = ActiveCall::global(cx);
+            let project = workspace.read(cx).project().clone();
+            active_call
+                .update(cx, |call, cx| call.unshare_project(project, cx))
+                .log_err();
+        }
+    }
+
+    pub fn toggle_collaborator_list_popover(
+        &mut self,
+        _: &ToggleCollaboratorList,
+        cx: &mut ViewContext<Self>,
+    ) {
+        match self.collaborator_list_popover.take() {
+            Some(_) => {}
+            None => {
+                if let Some(workspace) = self.workspace.upgrade(cx) {
+                    let user_store = workspace.read(cx).user_store().clone();
+                    let view = cx.add_view(|cx| CollaboratorListPopover::new(user_store, cx));
+
+                    cx.subscribe(&view, |this, _, event, cx| {
+                        match event {
+                            collaborator_list_popover::Event::Dismissed => {
+                                this.collaborator_list_popover = None;
+                            }
+                        }
+
+                        cx.notify();
+                    })
+                    .detach();
+
+                    self.collaborator_list_popover = Some(view);
+                }
+            }
+        }
+        cx.notify();
     }
 
     pub fn toggle_contacts_popover(&mut self, _: &ToggleContactsMenu, cx: &mut ViewContext<Self>) {
         if self.contacts_popover.take().is_none() {
-            let view = cx.add_view(|cx| {
-                ContactsPopover::new(
-                    self.project.clone(),
-                    self.user_store.clone(),
-                    self.workspace.clone(),
-                    cx,
-                )
-            });
-            cx.subscribe(&view, |this, _, event, cx| {
-                match event {
-                    contacts_popover::Event::Dismissed => {
-                        this.contacts_popover = None;
+            if let Some(workspace) = self.workspace.upgrade(cx) {
+                let project = workspace.read(cx).project().clone();
+                let user_store = workspace.read(cx).user_store().clone();
+                let view = cx.add_view(|cx| ContactsPopover::new(project, user_store, cx));
+                cx.subscribe(&view, |this, _, event, cx| {
+                    match event {
+                        contacts_popover::Event::Dismissed => {
+                            this.contacts_popover = None;
+                        }
                     }
-                }
 
-                cx.notify();
-            })
-            .detach();
-            self.contacts_popover = Some(view);
+                    cx.notify();
+                })
+                .detach();
+                self.contacts_popover = Some(view);
+            }
         }
 
         cx.notify();
     }
 
     pub fn toggle_user_menu(&mut self, _: &ToggleUserMenu, cx: &mut ViewContext<Self>) {
-        let theme = theme::current(cx).clone();
+        let theme = cx.global::<Settings>().theme.clone();
         let avatar_style = theme.workspace.titlebar.leader_avatar.clone();
         let item_style = theme.context_menu.item.disabled_style().clone();
         self.user_menu.update(cx, |user_menu, cx| {
@@ -312,27 +294,21 @@ impl CollabTitlebarItem {
                                     Color::transparent_black(),
                                 )
                             }))
-                            .with_child(Label::new(
-                                user.github_login.clone(),
-                                item_style.label.clone(),
-                            ))
+                            .with_child(
+                                Label::new(user.github_login.clone(), item_style.label.clone())
+                                    .boxed(),
+                            )
                             .contained()
                             .with_style(item_style.container)
-                            .into_any()
+                            .boxed()
                     })),
-                    ContextMenuItem::action("Sign out", SignOut),
-                    ContextMenuItem::action(
-                        "Send Feedback",
-                        feedback::feedback_editor::GiveFeedback,
-                    ),
+                    ContextMenuItem::item("Sign out", SignOut),
+                    ContextMenuItem::item("Send Feedback", feedback::feedback_editor::GiveFeedback),
                 ]
             } else {
                 vec![
-                    ContextMenuItem::action("Sign in", SignIn),
-                    ContextMenuItem::action(
-                        "Send Feedback",
-                        feedback::feedback_editor::GiveFeedback,
-                    ),
+                    ContextMenuItem::item("Sign in", SignIn),
+                    ContextMenuItem::item("Send Feedback", feedback::feedback_editor::GiveFeedback),
                 ]
             };
 
@@ -340,11 +316,17 @@ impl CollabTitlebarItem {
         });
     }
 
+    fn leave_call(&mut self, _: &LeaveCall, cx: &mut ViewContext<Self>) {
+        ActiveCall::global(cx)
+            .update(cx, |call, cx| call.hang_up(cx))
+            .detach_and_log_err(cx);
+    }
+
     fn render_toggle_contacts_button(
         &self,
         theme: &Theme,
-        cx: &mut ViewContext<Self>,
-    ) -> AnyElement<Self> {
+        cx: &mut RenderContext<Self>,
+    ) -> ElementBox {
         let titlebar = &theme.workspace.titlebar;
 
         let badge = if self
@@ -363,13 +345,14 @@ impl CollabTitlebarItem {
                     .contained()
                     .with_margin_left(titlebar.toggle_contacts_button.default.icon_width)
                     .with_margin_top(titlebar.toggle_contacts_button.default.icon_width)
-                    .aligned(),
+                    .aligned()
+                    .boxed(),
             )
         };
 
         Stack::new()
             .with_child(
-                MouseEventHandler::<ToggleContactsMenu, Self>::new(0, cx, |state, _| {
+                MouseEventHandler::<ToggleContactsMenu>::new(0, cx, |state, _| {
                     let style = titlebar
                         .toggle_contacts_button
                         .style_for(state, self.contacts_popover.is_some());
@@ -383,30 +366,32 @@ impl CollabTitlebarItem {
                         .with_height(style.button_width)
                         .contained()
                         .with_style(style.container)
+                        .boxed()
                 })
                 .with_cursor_style(CursorStyle::PointingHand)
-                .on_click(MouseButton::Left, move |_, this, cx| {
-                    this.toggle_contacts_popover(&Default::default(), cx)
+                .on_click(MouseButton::Left, move |_, cx| {
+                    cx.dispatch_action(ToggleContactsMenu);
                 })
-                .with_tooltip::<ToggleContactsMenu>(
+                .with_tooltip::<ToggleContactsMenu, _>(
                     0,
                     "Show contacts menu".into(),
                     Some(Box::new(ToggleContactsMenu)),
                     theme.tooltip.clone(),
                     cx,
-                ),
+                )
+                .boxed(),
             )
             .with_children(badge)
             .with_children(self.render_contacts_popover_host(titlebar, cx))
-            .into_any()
+            .boxed()
     }
 
     fn render_toggle_screen_sharing_button(
         &self,
         theme: &Theme,
         room: &ModelHandle<Room>,
-        cx: &mut ViewContext<Self>,
-    ) -> AnyElement<Self> {
+        cx: &mut RenderContext<Self>,
+    ) -> ElementBox {
         let icon;
         let tooltip;
         if room.read(cx).is_screen_sharing() {
@@ -418,7 +403,7 @@ impl CollabTitlebarItem {
         }
 
         let titlebar = &theme.workspace.titlebar;
-        MouseEventHandler::<ToggleScreenSharing, Self>::new(0, cx, |state, _| {
+        MouseEventHandler::<ToggleScreenSharing>::new(0, cx, |state, _| {
             let style = titlebar.call_control.style_for(state, false);
             Svg::new(icon)
                 .with_color(style.color)
@@ -430,12 +415,13 @@ impl CollabTitlebarItem {
                 .with_height(style.button_width)
                 .contained()
                 .with_style(style.container)
+                .boxed()
         })
         .with_cursor_style(CursorStyle::PointingHand)
-        .on_click(MouseButton::Left, move |_, _, cx| {
-            toggle_screen_sharing(&Default::default(), cx)
+        .on_click(MouseButton::Left, move |_, cx| {
+            cx.dispatch_action(ToggleScreenSharing);
         })
-        .with_tooltip::<ToggleScreenSharing>(
+        .with_tooltip::<ToggleScreenSharing, _>(
             0,
             tooltip.into(),
             Some(Box::new(ToggleScreenSharing)),
@@ -443,15 +429,15 @@ impl CollabTitlebarItem {
             cx,
         )
         .aligned()
-        .into_any()
+        .boxed()
     }
 
     fn render_in_call_share_unshare_button(
         &self,
         workspace: &ViewHandle<Workspace>,
         theme: &Theme,
-        cx: &mut ViewContext<Self>,
-    ) -> Option<AnyElement<Self>> {
+        cx: &mut RenderContext<Self>,
+    ) -> Option<ElementBox> {
         let project = workspace.read(cx).project();
         if project.read(cx).is_remote() {
             return None;
@@ -471,46 +457,46 @@ impl CollabTitlebarItem {
         Some(
             Stack::new()
                 .with_child(
-                    MouseEventHandler::<ShareUnshare, Self>::new(0, cx, |state, _| {
+                    MouseEventHandler::<ShareUnshare>::new(0, cx, |state, _| {
                         //TODO: Ensure this button has consistant width for both text variations
-                        let style = titlebar.share_button.style_for(state, false);
+                        let style = titlebar
+                            .share_button
+                            .style_for(state, self.contacts_popover.is_some());
                         Label::new(label, style.text.clone())
                             .contained()
                             .with_style(style.container)
+                            .boxed()
                     })
                     .with_cursor_style(CursorStyle::PointingHand)
-                    .on_click(MouseButton::Left, move |_, this, cx| {
+                    .on_click(MouseButton::Left, move |_, cx| {
                         if is_shared {
-                            this.unshare_project(&Default::default(), cx);
+                            cx.dispatch_action(UnshareProject);
                         } else {
-                            this.share_project(&Default::default(), cx);
+                            cx.dispatch_action(ShareProject);
                         }
                     })
-                    .with_tooltip::<ShareUnshare>(
+                    .with_tooltip::<ShareUnshare, _>(
                         0,
                         tooltip.to_owned(),
                         None,
                         theme.tooltip.clone(),
                         cx,
-                    ),
+                    )
+                    .boxed(),
                 )
                 .aligned()
                 .contained()
                 .with_margin_left(theme.workspace.titlebar.item_spacing)
-                .into_any(),
+                .boxed(),
         )
     }
 
-    fn render_user_menu_button(
-        &self,
-        theme: &Theme,
-        cx: &mut ViewContext<Self>,
-    ) -> AnyElement<Self> {
+    fn render_user_menu_button(&self, theme: &Theme, cx: &mut RenderContext<Self>) -> ElementBox {
         let titlebar = &theme.workspace.titlebar;
 
         Stack::new()
             .with_child(
-                MouseEventHandler::<ToggleUserMenu, Self>::new(0, cx, |state, _| {
+                MouseEventHandler::<ToggleUserMenu>::new(0, cx, |state, _| {
                     let style = titlebar.call_control.style_for(state, false);
                     Svg::new("icons/ellipsis_14.svg")
                         .with_color(style.color)
@@ -522,12 +508,13 @@ impl CollabTitlebarItem {
                         .with_height(style.button_width)
                         .contained()
                         .with_style(style.container)
+                        .boxed()
                 })
                 .with_cursor_style(CursorStyle::PointingHand)
-                .on_click(MouseButton::Left, move |_, this, cx| {
-                    this.toggle_user_menu(&Default::default(), cx)
+                .on_click(MouseButton::Left, move |_, cx| {
+                    cx.dispatch_action(ToggleUserMenu);
                 })
-                .with_tooltip::<ToggleUserMenu>(
+                .with_tooltip::<ToggleUserMenu, _>(
                     0,
                     "Toggle user menu".to_owned(),
                     Some(Box::new(ToggleUserMenu)),
@@ -535,49 +522,49 @@ impl CollabTitlebarItem {
                     cx,
                 )
                 .contained()
-                .with_margin_left(theme.workspace.titlebar.item_spacing),
+                .with_margin_left(theme.workspace.titlebar.item_spacing)
+                .boxed(),
             )
             .with_child(
                 ChildView::new(&self.user_menu, cx)
                     .aligned()
                     .bottom()
-                    .right(),
+                    .right()
+                    .boxed(),
             )
-            .into_any()
+            .boxed()
     }
 
-    fn render_sign_in_button(&self, theme: &Theme, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+    fn render_sign_in_button(&self, theme: &Theme, cx: &mut RenderContext<Self>) -> ElementBox {
         let titlebar = &theme.workspace.titlebar;
-        MouseEventHandler::<SignIn, Self>::new(0, cx, |state, _| {
+        MouseEventHandler::<SignIn>::new(0, cx, |state, _| {
             let style = titlebar.sign_in_prompt.style_for(state, false);
             Label::new("Sign In", style.text.clone())
                 .contained()
                 .with_style(style.container)
+                .boxed()
         })
         .with_cursor_style(CursorStyle::PointingHand)
-        .on_click(MouseButton::Left, move |_, this, cx| {
-            let client = this.client.clone();
-            cx.app_context()
-                .spawn(|cx| async move { client.authenticate_and_connect(true, &cx).await })
-                .detach_and_log_err(cx);
+        .on_click(MouseButton::Left, move |_, cx| {
+            cx.dispatch_action(SignIn);
         })
-        .into_any()
+        .boxed()
     }
 
     fn render_contacts_popover_host<'a>(
         &'a self,
         _theme: &'a theme::Titlebar,
-        cx: &'a ViewContext<Self>,
-    ) -> Option<AnyElement<Self>> {
+        cx: &'a RenderContext<Self>,
+    ) -> Option<ElementBox> {
         self.contacts_popover.as_ref().map(|popover| {
-            Overlay::new(ChildView::new(popover, cx))
+            Overlay::new(ChildView::new(popover, cx).boxed())
                 .with_fit_mode(OverlayFitMode::SwitchAnchor)
                 .with_anchor_corner(AnchorCorner::TopRight)
                 .with_z_index(999)
                 .aligned()
                 .bottom()
                 .right()
-                .into_any()
+                .boxed()
         })
     }
 
@@ -586,8 +573,8 @@ impl CollabTitlebarItem {
         workspace: &ViewHandle<Workspace>,
         theme: &Theme,
         room: &ModelHandle<Room>,
-        cx: &mut ViewContext<Self>,
-    ) -> Vec<Container<Self>> {
+        cx: &mut RenderContext<Self>,
+    ) -> Vec<ElementBox> {
         let mut participants = room
             .read(cx)
             .remote_participants()
@@ -615,7 +602,8 @@ impl CollabTitlebarItem {
                         theme,
                         cx,
                     ))
-                    .with_margin_right(theme.workspace.titlebar.face_pile_spacing),
+                    .with_margin_right(theme.workspace.titlebar.face_pile_spacing)
+                    .boxed(),
                 )
             })
             .collect()
@@ -627,8 +615,8 @@ impl CollabTitlebarItem {
         theme: &Theme,
         user: &Arc<User>,
         peer_id: PeerId,
-        cx: &mut ViewContext<Self>,
-    ) -> AnyElement<Self> {
+        cx: &mut RenderContext<Self>,
+    ) -> ElementBox {
         let replica_id = workspace.read(cx).project().read(cx).replica_id();
         Container::new(self.render_face_pile(
             user,
@@ -640,7 +628,7 @@ impl CollabTitlebarItem {
             cx,
         ))
         .with_margin_right(theme.workspace.titlebar.item_spacing)
-        .into_any()
+        .boxed()
     }
 
     fn render_face_pile(
@@ -651,8 +639,8 @@ impl CollabTitlebarItem {
         location: Option<ParticipantLocation>,
         workspace: &ViewHandle<Workspace>,
         theme: &Theme,
-        cx: &mut ViewContext<Self>,
-    ) -> AnyElement<Self> {
+        cx: &mut RenderContext<Self>,
+    ) -> ElementBox {
         let project_id = workspace.read(cx).project().read(cx).remote_id();
         let room = ActiveCall::global(cx).read(cx).room();
         let is_being_followed = workspace.read(cx).is_being_followed(peer_id);
@@ -722,9 +710,11 @@ impl CollabTitlebarItem {
                                         }
                                     })?;
 
+                                let location = remote_participant.map(|p| p.location);
+
                                 Some(Self::render_face(
                                     avatar.clone(),
-                                    follower_style,
+                                    Self::location_style(workspace, location, follower_style, cx),
                                     background_color,
                                 ))
                             }))
@@ -744,7 +734,7 @@ impl CollabTitlebarItem {
                     }
                 }
 
-                container
+                container.boxed()
             }))
             .with_children((|| {
                 let replica_id = replica_id?;
@@ -755,67 +745,56 @@ impl CollabTitlebarItem {
                         .with_width(theme.workspace.titlebar.avatar_ribbon.width)
                         .with_height(theme.workspace.titlebar.avatar_ribbon.height)
                         .aligned()
-                        .bottom(),
+                        .bottom()
+                        .boxed(),
                 )
             })())
-            .into_any();
+            .boxed();
 
         if let Some(location) = location {
             if let Some(replica_id) = replica_id {
-                enum ToggleFollow {}
-
-                content = MouseEventHandler::<ToggleFollow, Self>::new(
-                    replica_id.into(),
-                    cx,
-                    move |_, _| content,
-                )
-                .with_cursor_style(CursorStyle::PointingHand)
-                .on_click(MouseButton::Left, move |_, item, cx| {
-                    if let Some(workspace) = item.workspace.upgrade(cx) {
-                        if let Some(task) = workspace
-                            .update(cx, |workspace, cx| workspace.toggle_follow(peer_id, cx))
-                        {
-                            task.detach_and_log_err(cx);
-                        }
-                    }
-                })
-                .with_tooltip::<ToggleFollow>(
-                    peer_id.as_u64() as usize,
-                    if is_being_followed {
-                        format!("Unfollow {}", user.github_login)
-                    } else {
-                        format!("Follow {}", user.github_login)
-                    },
-                    Some(Box::new(FollowNextCollaborator)),
-                    theme.tooltip.clone(),
-                    cx,
-                )
-                .into_any();
+                content =
+                    MouseEventHandler::<ToggleFollow>::new(replica_id.into(), cx, move |_, _| {
+                        content
+                    })
+                    .with_cursor_style(CursorStyle::PointingHand)
+                    .on_click(MouseButton::Left, move |_, cx| {
+                        cx.dispatch_action(ToggleFollow(peer_id))
+                    })
+                    .with_tooltip::<ToggleFollow, _>(
+                        peer_id.as_u64() as usize,
+                        if is_being_followed {
+                            format!("Unfollow {}", user.github_login)
+                        } else {
+                            format!("Follow {}", user.github_login)
+                        },
+                        Some(Box::new(FollowNextCollaborator)),
+                        theme.tooltip.clone(),
+                        cx,
+                    )
+                    .boxed();
             } else if let ParticipantLocation::SharedProject { project_id } = location {
-                enum JoinProject {}
-
                 let user_id = user.id;
-                content = MouseEventHandler::<JoinProject, Self>::new(
+                content = MouseEventHandler::<JoinProject>::new(
                     peer_id.as_u64() as usize,
                     cx,
                     move |_, _| content,
                 )
                 .with_cursor_style(CursorStyle::PointingHand)
-                .on_click(MouseButton::Left, move |_, this, cx| {
-                    if let Some(workspace) = this.workspace.upgrade(cx) {
-                        let app_state = workspace.read(cx).app_state().clone();
-                        workspace::join_remote_project(project_id, user_id, app_state, cx)
-                            .detach_and_log_err(cx);
-                    }
+                .on_click(MouseButton::Left, move |_, cx| {
+                    cx.dispatch_action(JoinProject {
+                        project_id,
+                        follow_user_id: user_id,
+                    })
                 })
-                .with_tooltip::<JoinProject>(
+                .with_tooltip::<JoinProject, _>(
                     peer_id.as_u64() as usize,
                     format!("Follow {} into external project", user.github_login),
                     Some(Box::new(FollowNextCollaborator)),
                     theme.tooltip.clone(),
                     cx,
                 )
-                .into_any();
+                .boxed();
             }
         }
         content
@@ -825,7 +804,7 @@ impl CollabTitlebarItem {
         workspace: &ViewHandle<Workspace>,
         location: Option<ParticipantLocation>,
         mut style: AvatarStyle,
-        cx: &ViewContext<Self>,
+        cx: &RenderContext<Self>,
     ) -> AvatarStyle {
         if let Some(location) = location {
             if let ParticipantLocation::SharedProject { project_id } = location {
@@ -840,11 +819,11 @@ impl CollabTitlebarItem {
         style
     }
 
-    fn render_face<V: View>(
+    fn render_face(
         avatar: Arc<ImageData>,
         avatar_style: AvatarStyle,
         background_color: Color,
-    ) -> AnyElement<V> {
+    ) -> ElementBox {
         Image::from_data(avatar)
             .with_style(avatar_style.image)
             .aligned()
@@ -855,34 +834,40 @@ impl CollabTitlebarItem {
             .with_width(avatar_style.outer_width)
             .with_height(avatar_style.outer_width)
             .aligned()
-            .into_any()
+            .boxed()
     }
 
     fn render_connection_status(
         &self,
         status: &client::Status,
-        cx: &mut ViewContext<Self>,
-    ) -> Option<AnyElement<Self>> {
+        cx: &mut RenderContext<Self>,
+    ) -> Option<ElementBox> {
         enum ConnectionStatusButton {}
 
-        let theme = &theme::current(cx).clone();
+        let theme = &cx.global::<Settings>().theme.clone();
         match status {
             client::Status::ConnectionError
             | client::Status::ConnectionLost
             | client::Status::Reauthenticating { .. }
             | client::Status::Reconnecting { .. }
             | client::Status::ReconnectionError { .. } => Some(
-                Svg::new("icons/cloud_slash_12.svg")
-                    .with_color(theme.workspace.titlebar.offline_icon.color)
-                    .constrained()
-                    .with_width(theme.workspace.titlebar.offline_icon.width)
-                    .aligned()
-                    .contained()
-                    .with_style(theme.workspace.titlebar.offline_icon.container)
-                    .into_any(),
+                Container::new(
+                    Align::new(
+                        ConstrainedBox::new(
+                            Svg::new("icons/cloud_slash_12.svg")
+                                .with_color(theme.workspace.titlebar.offline_icon.color)
+                                .boxed(),
+                        )
+                        .with_width(theme.workspace.titlebar.offline_icon.width)
+                        .boxed(),
+                    )
+                    .boxed(),
+                )
+                .with_style(theme.workspace.titlebar.offline_icon.container)
+                .boxed(),
             ),
             client::Status::UpgradeRequired => Some(
-                MouseEventHandler::<ConnectionStatusButton, Self>::new(0, cx, |_, _| {
+                MouseEventHandler::<ConnectionStatusButton>::new(0, cx, |_, _| {
                     Label::new(
                         "Please update Zed to collaborate",
                         theme.workspace.titlebar.outdated_warning.text.clone(),
@@ -890,12 +875,13 @@ impl CollabTitlebarItem {
                     .contained()
                     .with_style(theme.workspace.titlebar.outdated_warning.container)
                     .aligned()
+                    .boxed()
                 })
                 .with_cursor_style(CursorStyle::PointingHand)
-                .on_click(MouseButton::Left, |_, _, cx| {
-                    auto_update::check(&Default::default(), cx);
+                .on_click(MouseButton::Left, |_, cx| {
+                    cx.dispatch_action(auto_update::Check);
                 })
-                .into_any(),
+                .boxed(),
             ),
             _ => None,
         }
@@ -912,7 +898,7 @@ impl AvatarRibbon {
     }
 }
 
-impl Element<CollabTitlebarItem> for AvatarRibbon {
+impl Element for AvatarRibbon {
     type LayoutState = ();
 
     type PaintState = ();
@@ -920,20 +906,17 @@ impl Element<CollabTitlebarItem> for AvatarRibbon {
     fn layout(
         &mut self,
         constraint: gpui::SizeConstraint,
-        _: &mut CollabTitlebarItem,
-        _: &mut LayoutContext<CollabTitlebarItem>,
+        _: &mut gpui::LayoutContext,
     ) -> (gpui::geometry::vector::Vector2F, Self::LayoutState) {
         (constraint.max, ())
     }
 
     fn paint(
         &mut self,
-        scene: &mut SceneBuilder,
-        bounds: RectF,
-        _: RectF,
+        bounds: gpui::geometry::rect::RectF,
+        _: gpui::geometry::rect::RectF,
         _: &mut Self::LayoutState,
-        _: &mut CollabTitlebarItem,
-        _: &mut ViewContext<CollabTitlebarItem>,
+        cx: &mut gpui::PaintContext,
     ) -> Self::PaintState {
         let mut path = PathBuilder::new();
         path.reset(bounds.lower_left());
@@ -944,7 +927,7 @@ impl Element<CollabTitlebarItem> for AvatarRibbon {
         path.line_to(bounds.upper_right() - vec2f(bounds.height(), 0.));
         path.curve_to(bounds.lower_right(), bounds.upper_right());
         path.line_to(bounds.lower_left());
-        scene.push_path(path.build(self.color, None));
+        cx.scene.push_path(path.build(self.color, None));
     }
 
     fn rect_for_text_range(
@@ -954,19 +937,17 @@ impl Element<CollabTitlebarItem> for AvatarRibbon {
         _: RectF,
         _: &Self::LayoutState,
         _: &Self::PaintState,
-        _: &CollabTitlebarItem,
-        _: &ViewContext<CollabTitlebarItem>,
+        _: &gpui::MeasurementContext,
     ) -> Option<RectF> {
         None
     }
 
     fn debug(
         &self,
-        bounds: RectF,
+        bounds: gpui::geometry::rect::RectF,
         _: &Self::LayoutState,
         _: &Self::PaintState,
-        _: &CollabTitlebarItem,
-        _: &ViewContext<CollabTitlebarItem>,
+        _: &gpui::DebugContext,
     ) -> gpui::json::Value {
         json::json!({
             "type": "AvatarRibbon",

crates/collab_ui/src/collab_ui.rs

@@ -1,4 +1,5 @@
 mod collab_titlebar_item;
+mod collaborator_list_popover;
 mod contact_finder;
 mod contact_list;
 mod contact_notification;
@@ -9,24 +10,29 @@ mod notifications;
 mod project_shared_notification;
 mod sharing_status_indicator;
 
+use anyhow::anyhow;
 use call::ActiveCall;
 pub use collab_titlebar_item::{CollabTitlebarItem, ToggleContactsMenu};
 use gpui::{actions, AppContext, Task};
 use std::sync::Arc;
-use workspace::AppState;
+use workspace::{AppState, JoinProject, ToggleFollow, Workspace};
 
 actions!(collab, [ToggleScreenSharing]);
 
-pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
+pub fn init(app_state: Arc<AppState>, cx: &mut AppContext) {
     collab_titlebar_item::init(cx);
+    contact_notification::init(cx);
     contact_list::init(cx);
     contact_finder::init(cx);
     contacts_popover::init(cx);
-    incoming_call_notification::init(&app_state, cx);
-    project_shared_notification::init(&app_state, 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| {
+        join_project(action, app_state.clone(), cx);
+    });
 }
 
 pub fn toggle_screen_sharing(_: &ToggleScreenSharing, cx: &mut AppContext) {
@@ -41,3 +47,88 @@ pub fn toggle_screen_sharing(_: &ToggleScreenSharing, cx: &mut AppContext) {
         toggle_screen_sharing.detach_and_log_err(cx);
     }
 }
+
+fn join_project(action: &JoinProject, app_state: Arc<AppState>, cx: &mut AppContext) {
+    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(window_id)?.clone().downcast::<Workspace>())
+                .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
+        };
+
+        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)
+                    });
+
+                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);
+}

crates/collab_ui/src/collaborator_list_popover.rs

@@ -0,0 +1,166 @@
+use call::ActiveCall;
+use client::UserStore;
+use gpui::Action;
+use gpui::{
+    actions, elements::*, platform::MouseButton, Entity, ModelHandle, 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,41 +1,49 @@
 use client::{ContactRequestStatus, User, UserStore};
-use gpui::{elements::*, AppContext, ModelHandle, MouseState, Task, ViewContext};
-use picker::{Picker, PickerDelegate, PickerEvent};
+use gpui::{
+    elements::*, AnyViewHandle, AppContext, Entity, ModelHandle, MouseState, RenderContext, Task,
+    View, ViewContext, ViewHandle,
+};
+use picker::{Picker, PickerDelegate};
+use settings::Settings;
 use std::sync::Arc;
 use util::TryFutureExt;
 
 pub fn init(cx: &mut AppContext) {
-    Picker::<ContactFinderDelegate>::init(cx);
+    Picker::<ContactFinder>::init(cx);
 }
 
-pub type ContactFinder = Picker<ContactFinderDelegate>;
-
-pub fn build_contact_finder(
-    user_store: ModelHandle<UserStore>,
-    cx: &mut ViewContext<ContactFinder>,
-) -> ContactFinder {
-    Picker::new(
-        ContactFinderDelegate {
-            user_store,
-            potential_contacts: Arc::from([]),
-            selected_index: 0,
-        },
-        cx,
-    )
-    .with_theme(|theme| theme.contact_finder.picker.clone())
-}
-
-pub struct ContactFinderDelegate {
+pub struct ContactFinder {
+    picker: ViewHandle<Picker<Self>>,
     potential_contacts: Arc<[Arc<User>]>,
     user_store: ModelHandle<UserStore>,
     selected_index: usize,
 }
 
-impl PickerDelegate for ContactFinderDelegate {
-    fn placeholder_text(&self) -> Arc<str> {
-        "Search collaborator by username...".into()
+pub enum Event {
+    Dismissed,
+}
+
+impl Entity for ContactFinder {
+    type Event = Event;
+}
+
+impl View for ContactFinder {
+    fn ui_name() -> &'static str {
+        "ContactFinder"
     }
 
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
+        ChildView::new(&self.picker, cx).boxed()
+    }
+
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+        if cx.is_self_focused() {
+            cx.focus(&self.picker);
+        }
+    }
+}
+
+impl PickerDelegate for ContactFinder {
     fn match_count(&self) -> usize {
         self.potential_contacts.len()
     }
@@ -44,22 +52,22 @@ impl PickerDelegate for ContactFinderDelegate {
         self.selected_index
     }
 
-    fn set_selected_index(&mut self, ix: usize, _: &mut ViewContext<Picker<Self>>) {
+    fn set_selected_index(&mut self, ix: usize, _: &mut ViewContext<Self>) {
         self.selected_index = ix;
     }
 
-    fn update_matches(&mut self, query: String, cx: &mut ViewContext<Picker<Self>>) -> Task<()> {
+    fn update_matches(&mut self, query: String, cx: &mut ViewContext<Self>) -> Task<()> {
         let search_users = self
             .user_store
             .update(cx, |store, cx| store.fuzzy_search_users(query, cx));
 
-        cx.spawn(|picker, mut cx| async move {
+        cx.spawn(|this, mut cx| async move {
             async {
                 let potential_contacts = search_users.await?;
-                picker.update(&mut cx, |picker, cx| {
-                    picker.delegate_mut().potential_contacts = potential_contacts.into();
+                this.update(&mut cx, |this, cx| {
+                    this.potential_contacts = potential_contacts.into();
                     cx.notify();
-                })?;
+                });
                 anyhow::Ok(())
             }
             .log_err()
@@ -67,7 +75,7 @@ impl PickerDelegate for ContactFinderDelegate {
         })
     }
 
-    fn confirm(&mut self, cx: &mut ViewContext<Picker<Self>>) {
+    fn confirm(&mut self, cx: &mut ViewContext<Self>) {
         if let Some(user) = self.potential_contacts.get(self.selected_index) {
             let user_store = self.user_store.read(cx);
             match user_store.contact_request_status(user) {
@@ -86,8 +94,8 @@ impl PickerDelegate for ContactFinderDelegate {
         }
     }
 
-    fn dismissed(&mut self, cx: &mut ViewContext<Picker<Self>>) {
-        cx.emit(PickerEvent::Dismiss);
+    fn dismiss(&mut self, cx: &mut ViewContext<Self>) {
+        cx.emit(Event::Dismissed);
     }
 
     fn render_match(
@@ -96,8 +104,8 @@ impl PickerDelegate for ContactFinderDelegate {
         mouse_state: &mut MouseState,
         selected: bool,
         cx: &gpui::AppContext,
-    ) -> AnyElement<Picker<Self>> {
-        let theme = &theme::current(cx);
+    ) -> ElementBox {
+        let theme = &cx.global::<Settings>().theme;
         let user = &self.potential_contacts[ix];
         let request_status = self.user_store.read(cx).contact_request_status(user);
 
@@ -124,13 +132,15 @@ impl PickerDelegate for ContactFinderDelegate {
                     .with_style(theme.contact_finder.contact_avatar)
                     .aligned()
                     .left()
+                    .boxed()
             }))
             .with_child(
                 Label::new(user.github_login.clone(), style.label.clone())
                     .contained()
                     .with_style(theme.contact_finder.contact_username)
                     .aligned()
-                    .left(),
+                    .left()
+                    .boxed(),
             )
             .with_children(icon_path.map(|icon_path| {
                 Svg::new(icon_path)
@@ -145,11 +155,37 @@ impl PickerDelegate for ContactFinderDelegate {
                     .with_height(button_style.button_width)
                     .aligned()
                     .flex_float()
+                    .boxed()
             }))
             .contained()
             .with_style(style.container)
             .constrained()
             .with_height(theme.contact_finder.row_height)
-            .into_any()
+            .boxed()
+    }
+}
+
+impl ContactFinder {
+    pub fn new(user_store: ModelHandle<UserStore>, cx: &mut ViewContext<Self>) -> Self {
+        let this = cx.weak_handle();
+        Self {
+            picker: cx.add_view(|cx| {
+                Picker::new("Search collaborator by username...", this, cx)
+                    .with_theme(|theme| theme.contact_finder.picker.clone())
+            }),
+            potential_contacts: Arc::from([]),
+            user_store,
+            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,3 +1,5 @@
+use super::collab_titlebar_item::LeaveCall;
+use crate::contacts_popover;
 use call::ActiveCall;
 use client::{proto::PeerId, Contact, User, UserStore};
 use editor::{Cancel, Editor};
@@ -6,19 +8,21 @@ use fuzzy::{match_strings, StringMatchCandidate};
 use gpui::{
     elements::*,
     geometry::{rect::RectF, vector::vec2f},
-    impl_actions,
+    impl_actions, impl_internal_actions,
     keymap_matcher::KeymapContext,
     platform::{CursorStyle, MouseButton, PromptLevel},
-    AppContext, Entity, ModelHandle, Subscription, View, ViewContext, ViewHandle, WeakViewHandle,
+    AppContext, Entity, ModelHandle, 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 workspace::Workspace;
+use workspace::{JoinProject, OpenSharedScreen};
 
 impl_actions!(contact_list, [RemoveContact, RespondToContactRequest]);
+impl_internal_actions!(contact_list, [ToggleExpanded, Call]);
 
 pub fn init(cx: &mut AppContext) {
     cx.add_action(ContactList::remove_contact);
@@ -27,6 +31,17 @@ pub fn init(cx: &mut AppContext) {
     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);
+}
+
+#[derive(Clone, PartialEq)]
+struct ToggleExpanded(Section);
+
+#[derive(Clone, PartialEq)]
+struct Call {
+    recipient_user_id: u64,
+    initial_project: Option<ModelHandle<Project>>,
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, PartialOrd, Ord)]
@@ -138,16 +153,14 @@ pub struct RespondToContactRequest {
 }
 
 pub enum Event {
-    ToggleContactFinder,
     Dismissed,
 }
 
 pub struct ContactList {
     entries: Vec<ContactEntry>,
     match_candidates: Vec<StringMatchCandidate>,
-    list_state: ListState<Self>,
+    list_state: ListState,
     project: ModelHandle<Project>,
-    workspace: WeakViewHandle<Workspace>,
     user_store: ModelHandle<UserStore>,
     filter_editor: ViewHandle<Editor>,
     collapsed_sections: Vec<Section>,
@@ -159,7 +172,6 @@ impl ContactList {
     pub fn new(
         project: ModelHandle<Project>,
         user_store: ModelHandle<UserStore>,
-        workspace: WeakViewHandle<Workspace>,
         cx: &mut ViewContext<Self>,
     ) -> Self {
         let filter_editor = cx.add_view(|cx| {
@@ -190,8 +202,8 @@ impl ContactList {
         })
         .detach();
 
-        let list_state = ListState::<Self>::new(0, Orientation::Top, 1000., move |this, ix, cx| {
-            let theme = theme::current(cx).clone();
+        let list_state = ListState::new(0, Orientation::Top, 1000., cx, move |this, ix, cx| {
+            let theme = cx.global::<Settings>().theme.clone();
             let is_selected = this.selection == Some(ix);
             let current_project_id = this.project.read(cx).remote_id();
 
@@ -279,7 +291,6 @@ impl ContactList {
             filter_editor,
             _subscriptions: subscriptions,
             project,
-            workspace,
             user_store,
         };
         this.update_entries(cx);
@@ -392,11 +403,18 @@ impl ContactList {
             if let Some(entry) = self.entries.get(selection) {
                 match entry {
                     ContactEntry::Header(section) => {
-                        self.toggle_expanded(*section, cx);
+                        let section = *section;
+                        self.toggle_expanded(&ToggleExpanded(section), cx);
                     }
                     ContactEntry::Contact { contact, calling } => {
                         if contact.online && !contact.busy && !calling {
-                            self.call(contact.user.id, Some(self.project.clone()), cx);
+                            self.call(
+                                &Call {
+                                    recipient_user_id: contact.user.id,
+                                    initial_project: Some(self.project.clone()),
+                                },
+                                cx,
+                            );
                         }
                     }
                     ContactEntry::ParticipantProject {
@@ -404,23 +422,13 @@ impl ContactList {
                         host_user_id,
                         ..
                     } => {
-                        if let Some(workspace) = self.workspace.upgrade(cx) {
-                            let app_state = workspace.read(cx).app_state().clone();
-                            workspace::join_remote_project(
-                                *project_id,
-                                *host_user_id,
-                                app_state,
-                                cx,
-                            )
-                            .detach_and_log_err(cx);
-                        }
+                        cx.dispatch_global_action(JoinProject {
+                            project_id: *project_id,
+                            follow_user_id: *host_user_id,
+                        });
                     }
                     ContactEntry::ParticipantScreen { peer_id, .. } => {
-                        if let Some(workspace) = self.workspace.upgrade(cx) {
-                            workspace.update(cx, |workspace, cx| {
-                                workspace.open_shared_screen(*peer_id, cx)
-                            });
-                        }
+                        cx.dispatch_action(OpenSharedScreen { peer_id: *peer_id });
                     }
                     _ => {}
                 }
@@ -428,7 +436,8 @@ impl ContactList {
         }
     }
 
-    fn toggle_expanded(&mut self, section: Section, cx: &mut ViewContext<Self>) {
+    fn toggle_expanded(&mut self, action: &ToggleExpanded, cx: &mut ViewContext<Self>) {
+        let section = action.0;
         if let Some(ix) = self.collapsed_sections.iter().position(|s| *s == section) {
             self.collapsed_sections.remove(ix);
         } else {
@@ -739,13 +748,14 @@ impl ContactList {
         is_pending: bool,
         is_selected: bool,
         theme: &theme::ContactList,
-    ) -> AnyElement<Self> {
+    ) -> ElementBox {
         Flex::row()
             .with_children(user.avatar.clone().map(|avatar| {
                 Image::from_data(avatar)
                     .with_style(theme.contact_avatar)
                     .aligned()
                     .left()
+                    .boxed()
             }))
             .with_child(
                 Label::new(
@@ -756,14 +766,16 @@ impl ContactList {
                 .with_style(theme.contact_username.container)
                 .aligned()
                 .left()
-                .flex(1., true),
+                .flex(1., true)
+                .boxed(),
             )
             .with_children(if is_pending {
                 Some(
                     Label::new("Calling", theme.calling_indicator.text.clone())
                         .contained()
                         .with_style(theme.calling_indicator.container)
-                        .aligned(),
+                        .aligned()
+                        .boxed(),
                 )
             } else {
                 None
@@ -776,7 +788,7 @@ impl ContactList {
                     .contact_row
                     .style_for(&mut Default::default(), is_selected),
             )
-            .into_any()
+            .boxed()
     }
 
     fn render_participant_project(
@@ -787,10 +799,8 @@ impl ContactList {
         is_last: bool,
         is_selected: bool,
         theme: &theme::ContactList,
-        cx: &mut ViewContext<Self>,
-    ) -> AnyElement<Self> {
-        enum JoinProject {}
-
+        cx: &mut RenderContext<Self>,
+    ) -> ElementBox {
         let font_cache = cx.font_cache();
         let host_avatar_height = theme
             .contact_avatar
@@ -809,44 +819,48 @@ impl ContactList {
             worktree_root_names.join(", ")
         };
 
-        MouseEventHandler::<JoinProject, Self>::new(project_id as usize, cx, |mouse_state, _| {
+        MouseEventHandler::<JoinProject>::new(project_id as usize, cx, |mouse_state, _| {
             let tree_branch = *tree_branch.style_for(mouse_state, is_selected);
             let row = theme.project_row.style_for(mouse_state, is_selected);
 
             Flex::row()
                 .with_child(
                     Stack::new()
-                        .with_child(Canvas::new(move |scene, bounds, _, _, _| {
-                            let start_x =
-                                bounds.min_x() + (bounds.width() / 2.) - (tree_branch.width / 2.);
-                            let end_x = bounds.max_x();
-                            let start_y = bounds.min_y();
-                            let end_y = bounds.min_y() + baseline_offset - (cap_height / 2.);
+                        .with_child(
+                            Canvas::new(move |bounds, _, cx| {
+                                let start_x = bounds.min_x() + (bounds.width() / 2.)
+                                    - (tree_branch.width / 2.);
+                                let end_x = bounds.max_x();
+                                let start_y = bounds.min_y();
+                                let end_y = bounds.min_y() + baseline_offset - (cap_height / 2.);
 
-                            scene.push_quad(gpui::Quad {
-                                bounds: RectF::from_points(
-                                    vec2f(start_x, start_y),
-                                    vec2f(
-                                        start_x + tree_branch.width,
-                                        if is_last { end_y } else { bounds.max_y() },
+                                cx.scene.push_quad(gpui::Quad {
+                                    bounds: RectF::from_points(
+                                        vec2f(start_x, start_y),
+                                        vec2f(
+                                            start_x + tree_branch.width,
+                                            if is_last { end_y } else { bounds.max_y() },
+                                        ),
                                     ),
-                                ),
-                                background: Some(tree_branch.color),
-                                border: gpui::Border::default(),
-                                corner_radius: 0.,
-                            });
-                            scene.push_quad(gpui::Quad {
-                                bounds: RectF::from_points(
-                                    vec2f(start_x, end_y),
-                                    vec2f(end_x, end_y + tree_branch.width),
-                                ),
-                                background: Some(tree_branch.color),
-                                border: gpui::Border::default(),
-                                corner_radius: 0.,
-                            });
-                        }))
+                                    background: Some(tree_branch.color),
+                                    border: gpui::Border::default(),
+                                    corner_radius: 0.,
+                                });
+                                cx.scene.push_quad(gpui::Quad {
+                                    bounds: RectF::from_points(
+                                        vec2f(start_x, end_y),
+                                        vec2f(end_x, end_y + tree_branch.width),
+                                    ),
+                                    background: Some(tree_branch.color),
+                                    border: gpui::Border::default(),
+                                    corner_radius: 0.,
+                                });
+                            })
+                            .boxed(),
+                        )
                         .constrained()
-                        .with_width(host_avatar_height),
+                        .with_width(host_avatar_height)
+                        .boxed(),
                 )
                 .with_child(
                     Label::new(project_name, row.name.text.clone())
@@ -854,28 +868,29 @@ impl ContactList {
                         .left()
                         .contained()
                         .with_style(row.name.container)
-                        .flex(1., false),
+                        .flex(1., false)
+                        .boxed(),
                 )
                 .constrained()
                 .with_height(theme.row_height)
                 .contained()
                 .with_style(row.container)
+                .boxed()
         })
         .with_cursor_style(if !is_current {
             CursorStyle::PointingHand
         } else {
             CursorStyle::Arrow
         })
-        .on_click(MouseButton::Left, move |_, this, cx| {
+        .on_click(MouseButton::Left, move |_, cx| {
             if !is_current {
-                if let Some(workspace) = this.workspace.upgrade(cx) {
-                    let app_state = workspace.read(cx).app_state().clone();
-                    workspace::join_remote_project(project_id, host_user_id, app_state, cx)
-                        .detach_and_log_err(cx);
-                }
+                cx.dispatch_global_action(JoinProject {
+                    project_id,
+                    follow_user_id: host_user_id,
+                });
             }
         })
-        .into_any()
+        .boxed()
     }
 
     fn render_participant_screen(
@@ -883,10 +898,8 @@ impl ContactList {
         is_last: bool,
         is_selected: bool,
         theme: &theme::ContactList,
-        cx: &mut ViewContext<Self>,
-    ) -> AnyElement<Self> {
-        enum OpenSharedScreen {}
-
+        cx: &mut RenderContext<Self>,
+    ) -> ElementBox {
         let font_cache = cx.font_cache();
         let host_avatar_height = theme
             .contact_avatar
@@ -900,7 +913,7 @@ impl ContactList {
         let baseline_offset =
             row.name.text.baseline_offset(font_cache) + (theme.row_height - line_height) / 2.;
 
-        MouseEventHandler::<OpenSharedScreen, Self>::new(
+        MouseEventHandler::<OpenSharedScreen>::new(
             peer_id.as_u64() as usize,
             cx,
             |mouse_state, _| {
@@ -910,37 +923,42 @@ impl ContactList {
                 Flex::row()
                     .with_child(
                         Stack::new()
-                            .with_child(Canvas::new(move |scene, bounds, _, _, _| {
-                                let start_x = bounds.min_x() + (bounds.width() / 2.)
-                                    - (tree_branch.width / 2.);
-                                let end_x = bounds.max_x();
-                                let start_y = bounds.min_y();
-                                let end_y = bounds.min_y() + baseline_offset - (cap_height / 2.);
+                            .with_child(
+                                Canvas::new(move |bounds, _, cx| {
+                                    let start_x = bounds.min_x() + (bounds.width() / 2.)
+                                        - (tree_branch.width / 2.);
+                                    let end_x = bounds.max_x();
+                                    let start_y = bounds.min_y();
+                                    let end_y =
+                                        bounds.min_y() + baseline_offset - (cap_height / 2.);
 
-                                scene.push_quad(gpui::Quad {
-                                    bounds: RectF::from_points(
-                                        vec2f(start_x, start_y),
-                                        vec2f(
-                                            start_x + tree_branch.width,
-                                            if is_last { end_y } else { bounds.max_y() },
+                                    cx.scene.push_quad(gpui::Quad {
+                                        bounds: RectF::from_points(
+                                            vec2f(start_x, start_y),
+                                            vec2f(
+                                                start_x + tree_branch.width,
+                                                if is_last { end_y } else { bounds.max_y() },
+                                            ),
                                         ),
-                                    ),
-                                    background: Some(tree_branch.color),
-                                    border: gpui::Border::default(),
-                                    corner_radius: 0.,
-                                });
-                                scene.push_quad(gpui::Quad {
-                                    bounds: RectF::from_points(
-                                        vec2f(start_x, end_y),
-                                        vec2f(end_x, end_y + tree_branch.width),
-                                    ),
-                                    background: Some(tree_branch.color),
-                                    border: gpui::Border::default(),
-                                    corner_radius: 0.,
-                                });
-                            }))
+                                        background: Some(tree_branch.color),
+                                        border: gpui::Border::default(),
+                                        corner_radius: 0.,
+                                    });
+                                    cx.scene.push_quad(gpui::Quad {
+                                        bounds: RectF::from_points(
+                                            vec2f(start_x, end_y),
+                                            vec2f(end_x, end_y + tree_branch.width),
+                                        ),
+                                        background: Some(tree_branch.color),
+                                        border: gpui::Border::default(),
+                                        corner_radius: 0.,
+                                    });
+                                })
+                                .boxed(),
+                            )
                             .constrained()
-                            .with_width(host_avatar_height),
+                            .with_width(host_avatar_height)
+                            .boxed(),
                     )
                     .with_child(
                         Svg::new("icons/disable_screen_sharing_12.svg")
@@ -950,7 +968,8 @@ impl ContactList {
                             .aligned()
                             .left()
                             .contained()
-                            .with_style(row.icon.container),
+                            .with_style(row.icon.container)
+                            .boxed(),
                     )
                     .with_child(
                         Label::new("Screen", row.name.text.clone())
@@ -958,23 +977,21 @@ impl ContactList {
                             .left()
                             .contained()
                             .with_style(row.name.container)
-                            .flex(1., false),
+                            .flex(1., false)
+                            .boxed(),
                     )
                     .constrained()
                     .with_height(theme.row_height)
                     .contained()
                     .with_style(row.container)
+                    .boxed()
             },
         )
         .with_cursor_style(CursorStyle::PointingHand)
-        .on_click(MouseButton::Left, move |_, this, cx| {
-            if let Some(workspace) = this.workspace.upgrade(cx) {
-                workspace.update(cx, |workspace, cx| {
-                    workspace.open_shared_screen(peer_id, cx)
-                });
-            }
+        .on_click(MouseButton::Left, move |_, cx| {
+            cx.dispatch_action(OpenSharedScreen { peer_id });
         })
-        .into_any()
+        .boxed()
     }
 
     fn render_header(
@@ -982,8 +999,8 @@ impl ContactList {
         theme: &theme::ContactList,
         is_selected: bool,
         is_collapsed: bool,
-        cx: &mut ViewContext<Self>,
-    ) -> AnyElement<Self> {
+        cx: &mut RenderContext<Self>,
+    ) -> ElementBox {
         enum Header {}
         enum LeaveCallContactList {}
 
@@ -998,25 +1015,23 @@ impl ContactList {
         };
         let leave_call = if section == Section::ActiveCall {
             Some(
-                MouseEventHandler::<LeaveCallContactList, Self>::new(0, cx, |state, _| {
+                MouseEventHandler::<LeaveCallContactList>::new(0, cx, |state, _| {
                     let style = theme.leave_call.style_for(state, false);
                     Label::new("Leave Call", style.text.clone())
                         .contained()
                         .with_style(style.container)
+                        .boxed()
                 })
-                .on_click(MouseButton::Left, |_, _, cx| {
-                    ActiveCall::global(cx)
-                        .update(cx, |call, cx| call.hang_up(cx))
-                        .detach_and_log_err(cx);
-                })
-                .aligned(),
+                .on_click(MouseButton::Left, |_, cx| cx.dispatch_action(LeaveCall))
+                .aligned()
+                .boxed(),
             )
         } else {
             None
         };
 
         let icon_size = theme.section_icon_size;
-        MouseEventHandler::<Header, Self>::new(section as usize, cx, |_, _| {
+        MouseEventHandler::<Header>::new(section as usize, cx, |_, _| {
             Flex::row()
                 .with_child(
                     Svg::new(if is_collapsed {
@@ -1030,7 +1045,8 @@ impl ContactList {
                     .with_max_height(icon_size)
                     .aligned()
                     .constrained()
-                    .with_width(icon_size),
+                    .with_width(icon_size)
+                    .boxed(),
                 )
                 .with_child(
                     Label::new(text, header_style.text.clone())
@@ -1038,19 +1054,21 @@ impl ContactList {
                         .left()
                         .contained()
                         .with_margin_left(theme.contact_username.container.margin.left)
-                        .flex(1., true),
+                        .flex(1., true)
+                        .boxed(),
                 )
                 .with_children(leave_call)
                 .constrained()
                 .with_height(theme.row_height)
                 .contained()
                 .with_style(header_style.container)
+                .boxed()
         })
         .with_cursor_style(CursorStyle::PointingHand)
-        .on_click(MouseButton::Left, move |_, this, cx| {
-            this.toggle_expanded(section, cx);
+        .on_click(MouseButton::Left, move |_, cx| {
+            cx.dispatch_action(ToggleExpanded(section))
         })
-        .into_any()
+        .boxed()
     }
 
     fn render_contact(
@@ -1059,15 +1077,15 @@ impl ContactList {
         project: &ModelHandle<Project>,
         theme: &theme::ContactList,
         is_selected: bool,
-        cx: &mut ViewContext<Self>,
-    ) -> AnyElement<Self> {
+        cx: &mut RenderContext<Self>,
+    ) -> ElementBox {
         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 event_handler =
-            MouseEventHandler::<Contact, Self>::new(contact.user.id as usize, cx, |_, cx| {
+        let mut element =
+            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 {
@@ -1080,7 +1098,8 @@ impl ContactList {
                                     } else {
                                         theme.contact_status_free
                                     })
-                                    .aligned(),
+                                    .aligned()
+                                    .boxed(),
                             )
                         } else {
                             None
@@ -1090,9 +1109,11 @@ impl ContactList {
                                 Image::from_data(avatar)
                                     .with_style(theme.contact_avatar)
                                     .aligned()
-                                    .left(),
+                                    .left()
+                                    .boxed(),
                             )
                             .with_children(status_badge)
+                            .boxed()
                     }))
                     .with_child(
                         Label::new(
@@ -1103,10 +1124,11 @@ impl ContactList {
                         .with_style(theme.contact_username.container)
                         .aligned()
                         .left()
-                        .flex(1., true),
+                        .flex(1., true)
+                        .boxed(),
                     )
                     .with_child(
-                        MouseEventHandler::<Cancel, Self>::new(
+                        MouseEventHandler::<Cancel>::new(
                             contact.user.id as usize,
                             cx,
                             |mouse_state, _| {
@@ -1115,27 +1137,27 @@ impl ContactList {
                                 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 |_, this, cx| {
-                            this.remove_contact(
-                                &RemoveContact {
-                                    user_id,
-                                    github_login: github_login.clone(),
-                                },
-                                cx,
-                            );
+                        .on_click(MouseButton::Left, move |_, cx| {
+                            cx.dispatch_action(RemoveContact {
+                                user_id,
+                                github_login: github_login.clone(),
+                            })
                         })
-                        .flex_float(),
+                        .flex_float()
+                        .boxed(),
                     )
                     .with_children(if calling {
                         Some(
                             Label::new("Calling", theme.calling_indicator.text.clone())
                                 .contained()
                                 .with_style(theme.calling_indicator.container)
-                                .aligned(),
+                                .aligned()
+                                .boxed(),
                         )
                     } else {
                         None
@@ -1148,18 +1170,22 @@ impl ContactList {
                             .contact_row
                             .style_for(&mut Default::default(), is_selected),
                     )
+                    .boxed()
             })
-            .on_click(MouseButton::Left, move |_, this, cx| {
+            .on_click(MouseButton::Left, move |_, cx| {
                 if online && !busy {
-                    this.call(user_id, Some(initial_project.clone()), cx);
+                    cx.dispatch_action(Call {
+                        recipient_user_id: user_id,
+                        initial_project: Some(initial_project.clone()),
+                    });
                 }
             });
 
         if online {
-            event_handler = event_handler.with_cursor_style(CursorStyle::PointingHand);
+            element = element.with_cursor_style(CursorStyle::PointingHand);
         }
 
-        event_handler.into_any()
+        element.boxed()
     }
 
     fn render_contact_request(
@@ -1168,8 +1194,8 @@ impl ContactList {
         theme: &theme::ContactList,
         is_incoming: bool,
         is_selected: bool,
-        cx: &mut ViewContext<Self>,
-    ) -> AnyElement<Self> {
+        cx: &mut RenderContext<Self>,
+    ) -> ElementBox {
         enum Decline {}
         enum Accept {}
         enum Cancel {}
@@ -1180,6 +1206,7 @@ impl ContactList {
                     .with_style(theme.contact_avatar)
                     .aligned()
                     .left()
+                    .boxed()
             }))
             .with_child(
                 Label::new(
@@ -1190,7 +1217,8 @@ impl ContactList {
                 .with_style(theme.contact_username.container)
                 .aligned()
                 .left()
-                .flex(1., true),
+                .flex(1., true)
+                .boxed(),
             );
 
         let user_id = user.id;
@@ -1199,31 +1227,28 @@ impl ContactList {
         let button_spacing = theme.contact_button_spacing;
 
         if is_incoming {
-            row.add_child(
-                MouseEventHandler::<Decline, Self>::new(user.id as usize, cx, |mouse_state, _| {
+            row.add_children([
+                MouseEventHandler::<Decline>::new(user.id as usize, cx, |mouse_state, _| {
                     let button_style = if is_contact_request_pending {
                         &theme.disabled_button
                     } else {
                         theme.contact_button.style_for(mouse_state, false)
                     };
-                    render_icon_button(button_style, "icons/x_mark_8.svg").aligned()
+                    render_icon_button(button_style, "icons/x_mark_8.svg")
+                        .aligned()
+                        .boxed()
                 })
                 .with_cursor_style(CursorStyle::PointingHand)
-                .on_click(MouseButton::Left, move |_, this, cx| {
-                    this.respond_to_contact_request(
-                        &RespondToContactRequest {
-                            user_id,
-                            accept: false,
-                        },
-                        cx,
-                    );
+                .on_click(MouseButton::Left, move |_, cx| {
+                    cx.dispatch_action(RespondToContactRequest {
+                        user_id,
+                        accept: false,
+                    })
                 })
                 .contained()
-                .with_margin_right(button_spacing),
-            );
-
-            row.add_child(
-                MouseEventHandler::<Accept, Self>::new(user.id as usize, cx, |mouse_state, _| {
+                .with_margin_right(button_spacing)
+                .boxed(),
+                MouseEventHandler::<Accept>::new(user.id as usize, cx, |mouse_state, _| {
                     let button_style = if is_contact_request_pending {
                         &theme.disabled_button
                     } else {
@@ -1232,21 +1257,20 @@ impl ContactList {
                     render_icon_button(button_style, "icons/check_8.svg")
                         .aligned()
                         .flex_float()
+                        .boxed()
                 })
                 .with_cursor_style(CursorStyle::PointingHand)
-                .on_click(MouseButton::Left, move |_, this, cx| {
-                    this.respond_to_contact_request(
-                        &RespondToContactRequest {
-                            user_id,
-                            accept: true,
-                        },
-                        cx,
-                    );
-                }),
-            );
+                .on_click(MouseButton::Left, move |_, cx| {
+                    cx.dispatch_action(RespondToContactRequest {
+                        user_id,
+                        accept: true,
+                    })
+                })
+                .boxed(),
+            ]);
         } else {
             row.add_child(
-                MouseEventHandler::<Cancel, Self>::new(user.id as usize, cx, |mouse_state, _| {
+                MouseEventHandler::<Cancel>::new(user.id as usize, cx, |mouse_state, _| {
                     let button_style = if is_contact_request_pending {
                         &theme.disabled_button
                     } else {
@@ -1255,19 +1279,18 @@ impl ContactList {
                     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 |_, this, cx| {
-                    this.remove_contact(
-                        &RemoveContact {
-                            user_id,
-                            github_login: github_login.clone(),
-                        },
-                        cx,
-                    );
+                .on_click(MouseButton::Left, move |_, cx| {
+                    cx.dispatch_action(RemoveContact {
+                        user_id,
+                        github_login: github_login.clone(),
+                    })
                 })
-                .flex_float(),
+                .flex_float()
+                .boxed(),
             );
         }
 
@@ -1279,15 +1302,12 @@ impl ContactList {
                     .contact_row
                     .style_for(&mut Default::default(), is_selected),
             )
-            .into_any()
+            .boxed()
     }
 
-    fn call(
-        &mut self,
-        recipient_user_id: u64,
-        initial_project: Option<ModelHandle<Project>>,
-        cx: &mut ViewContext<Self>,
-    ) {
+    fn call(&mut self, action: &Call, cx: &mut ViewContext<Self>) {
+        let recipient_user_id = action.recipient_user_id;
+        let initial_project = action.initial_project.clone();
         ActiveCall::global(cx)
             .update(cx, |call, cx| {
                 call.invite(recipient_user_id, initial_project, cx)
@@ -1305,14 +1325,15 @@ impl View for ContactList {
         "ContactList"
     }
 
-    fn update_keymap_context(&self, keymap: &mut KeymapContext, _: &AppContext) {
-        Self::reset_to_default_keymap_context(keymap);
-        keymap.add_identifier("menu");
+    fn keymap_context(&self, _: &AppContext) -> KeymapContext {
+        let mut cx = Self::default_keymap_context();
+        cx.add_identifier("menu");
+        cx
     }
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
         enum AddContact {}
-        let theme = theme::current(cx).clone();
+        let theme = cx.global::<Settings>().theme.clone();
 
         Flex::column()
             .with_child(
@@ -1321,32 +1342,36 @@ impl View for ContactList {
                         ChildView::new(&self.filter_editor, cx)
                             .contained()
                             .with_style(theme.contact_list.user_query_editor.container)
-                            .flex(1., true),
+                            .flex(1., true)
+                            .boxed(),
                     )
                     .with_child(
-                        MouseEventHandler::<AddContact, Self>::new(0, cx, |_, _| {
+                        MouseEventHandler::<AddContact>::new(0, cx, |_, _| {
                             render_icon_button(
                                 &theme.contact_list.add_contact_button,
                                 "icons/user_plus_16.svg",
                             )
+                            .boxed()
                         })
                         .with_cursor_style(CursorStyle::PointingHand)
-                        .on_click(MouseButton::Left, |_, _, cx| {
-                            cx.emit(Event::ToggleContactFinder)
+                        .on_click(MouseButton::Left, |_, cx| {
+                            cx.dispatch_action(contacts_popover::ToggleContactFinder)
                         })
-                        .with_tooltip::<AddContact>(
+                        .with_tooltip::<AddContact, _>(
                             0,
                             "Search for new contact".into(),
                             None,
                             theme.tooltip.clone(),
                             cx,
-                        ),
+                        )
+                        .boxed(),
                     )
                     .constrained()
-                    .with_height(theme.contact_list.user_query_editor_height),
+                    .with_height(theme.contact_list.user_query_editor_height)
+                    .boxed(),
             )
-            .with_child(List::new(self.list_state.clone()).flex(1., false))
-            .into_any()
+            .with_child(List::new(self.list_state.clone()).flex(1., false).boxed())
+            .boxed()
     }
 
     fn focus_in(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {
@@ -1362,7 +1387,7 @@ impl View for ContactList {
     }
 }
 
-fn render_icon_button(style: &IconButton, svg_path: &'static str) -> impl Element<ContactList> {
+fn render_icon_button(style: &IconButton, svg_path: &'static str) -> impl Element {
     Svg::new(svg_path)
         .with_color(style.color)
         .constrained()

crates/collab_ui/src/contact_notification.rs

@@ -2,9 +2,19 @@ use std::sync::Arc;
 
 use crate::notifications::render_user_notification;
 use client::{ContactEventKind, User, UserStore};
-use gpui::{elements::*, Entity, ModelHandle, View, ViewContext};
+use gpui::{
+    elements::*, impl_internal_actions, AppContext, Entity, ModelHandle, RenderContext, View,
+    ViewContext,
+};
 use workspace::notifications::Notification;
 
+impl_internal_actions!(contact_notifications, [Dismiss, RespondToContactRequest]);
+
+pub fn init(cx: &mut AppContext) {
+    cx.add_action(ContactNotification::dismiss);
+    cx.add_action(ContactNotification::respond_to_contact_request);
+}
+
 pub struct ContactNotification {
     user_store: ModelHandle<UserStore>,
     user: Arc<User>,
@@ -33,24 +43,26 @@ impl View for ContactNotification {
         "ContactNotification"
     }
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
         match self.kind {
             ContactEventKind::Requested => render_user_notification(
                 self.user.clone(),
                 "wants to add you as a contact",
                 Some("They won't be alerted if you decline."),
-                |notification, cx| notification.dismiss(cx),
+                Dismiss(self.user.id),
                 vec![
                     (
                         "Decline",
-                        Box::new(|notification, cx| {
-                            notification.respond_to_contact_request(false, cx)
+                        Box::new(RespondToContactRequest {
+                            user_id: self.user.id,
+                            accept: false,
                         }),
                     ),
                     (
                         "Accept",
-                        Box::new(|notification, cx| {
-                            notification.respond_to_contact_request(true, cx)
+                        Box::new(RespondToContactRequest {
+                            user_id: self.user.id,
+                            accept: true,
                         }),
                     ),
                 ],
@@ -60,7 +72,7 @@ impl View for ContactNotification {
                 self.user.clone(),
                 "accepted your contact request",
                 None,
-                |notification, cx| notification.dismiss(cx),
+                Dismiss(self.user.id),
                 vec![],
                 cx,
             ),
@@ -102,7 +114,7 @@ impl ContactNotification {
         }
     }
 
-    fn dismiss(&mut self, cx: &mut ViewContext<Self>) {
+    fn dismiss(&mut self, _: &Dismiss, cx: &mut ViewContext<Self>) {
         self.user_store.update(cx, |store, cx| {
             store
                 .dismiss_contact_request(self.user.id, cx)
@@ -111,10 +123,14 @@ impl ContactNotification {
         cx.emit(Event::Dismiss);
     }
 
-    fn respond_to_contact_request(&mut self, accept: bool, cx: &mut ViewContext<Self>) {
+    fn respond_to_contact_request(
+        &mut self,
+        action: &RespondToContactRequest,
+        cx: &mut ViewContext<Self>,
+    ) {
         self.user_store
             .update(cx, |store, cx| {
-                store.respond_to_contact_request(self.user.id, accept, cx)
+                store.respond_to_contact_request(action.user_id, action.accept, cx)
             })
             .detach();
     }

crates/collab_ui/src/contacts_popover.rs

@@ -1,15 +1,11 @@
-use crate::{
-    contact_finder::{build_contact_finder, ContactFinder},
-    contact_list::ContactList,
-};
+use crate::{contact_finder::ContactFinder, contact_list::ContactList, ToggleContactsMenu};
 use client::UserStore;
 use gpui::{
-    actions, elements::*, platform::MouseButton, AppContext, Entity, ModelHandle, View,
-    ViewContext, ViewHandle, WeakViewHandle,
+    actions, elements::*, platform::MouseButton, AppContext, Entity, ModelHandle, RenderContext,
+    View, ViewContext, ViewHandle,
 };
-use picker::PickerEvent;
 use project::Project;
-use workspace::Workspace;
+use settings::Settings;
 
 actions!(contacts_popover, [ToggleContactFinder]);
 
@@ -30,7 +26,6 @@ pub struct ContactsPopover {
     child: Child,
     project: ModelHandle<Project>,
     user_store: ModelHandle<UserStore>,
-    workspace: WeakViewHandle<Workspace>,
     _subscription: Option<gpui::Subscription>,
 }
 
@@ -38,16 +33,14 @@ impl ContactsPopover {
     pub fn new(
         project: ModelHandle<Project>,
         user_store: ModelHandle<UserStore>,
-        workspace: WeakViewHandle<Workspace>,
         cx: &mut ViewContext<Self>,
     ) -> Self {
         let mut this = Self {
-            child: Child::ContactList(cx.add_view(|cx| {
-                ContactList::new(project.clone(), user_store.clone(), workspace.clone(), cx)
-            })),
+            child: Child::ContactList(
+                cx.add_view(|cx| ContactList::new(project.clone(), user_store.clone(), cx)),
+            ),
             project,
             user_store,
-            workspace,
             _subscription: None,
         };
         this.show_contact_list(String::new(), cx);
@@ -57,19 +50,19 @@ impl ContactsPopover {
     fn toggle_contact_finder(&mut self, _: &ToggleContactFinder, cx: &mut ViewContext<Self>) {
         match &self.child {
             Child::ContactList(list) => self.show_contact_finder(list.read(cx).editor_text(cx), cx),
-            Child::ContactFinder(finder) => self.show_contact_list(finder.read(cx).query(cx), cx),
+            Child::ContactFinder(finder) => {
+                self.show_contact_list(finder.read(cx).editor_text(cx), cx)
+            }
         }
     }
 
     fn show_contact_finder(&mut self, editor_text: String, cx: &mut ViewContext<ContactsPopover>) {
         let child = cx.add_view(|cx| {
-            let finder = build_contact_finder(self.user_store.clone(), cx);
-            finder.set_query(editor_text, cx);
-            finder
+            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 {
-            PickerEvent::Dismiss => cx.emit(Event::Dismissed),
+            crate::contact_finder::Event::Dismissed => cx.emit(Event::Dismissed),
         }));
         self.child = Child::ContactFinder(child);
         cx.notify();
@@ -77,20 +70,12 @@ impl ContactsPopover {
 
     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(),
-                self.workspace.clone(),
-                cx,
-            )
-            .with_editor_text(editor_text, 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, |this, _, event, cx| match event {
+        self._subscription = Some(cx.subscribe(&child, |_, _, event, cx| match event {
             crate::contact_list::Event::Dismissed => cx.emit(Event::Dismissed),
-            crate::contact_list::Event::ToggleContactFinder => {
-                this.toggle_contact_finder(&Default::default(), cx)
-            }
         }));
         self.child = Child::ContactList(child);
         cx.notify();
@@ -106,24 +91,27 @@ impl View for ContactsPopover {
         "ContactsPopover"
     }
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
-        let theme = theme::current(cx).clone();
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
+        let theme = cx.global::<Settings>().theme.clone();
         let child = match &self.child {
             Child::ContactList(child) => ChildView::new(child, cx),
             Child::ContactFinder(child) => ChildView::new(child, cx),
         };
 
-        MouseEventHandler::<ContactsPopover, Self>::new(0, cx, |_, _| {
+        MouseEventHandler::<ContactsPopover>::new(0, cx, |_, _| {
             Flex::column()
-                .with_child(child.flex(1., true))
+                .with_child(child.flex(1., true).boxed())
                 .contained()
                 .with_style(theme.contacts_popover.container)
                 .constrained()
                 .with_width(theme.contacts_popover.width)
                 .with_height(theme.contacts_popover.height)
+                .boxed()
         })
-        .on_down_out(MouseButton::Left, move |_, _, cx| cx.emit(Event::Dismissed))
-        .into_any()
+        .on_down_out(MouseButton::Left, move |_, cx| {
+            cx.dispatch_action(ToggleContactsMenu);
+        })
+        .boxed()
     }
 
     fn focus_in(&mut self, _: gpui::AnyViewHandle, cx: &mut ViewContext<Self>) {

crates/collab_ui/src/face_pile.rs

@@ -7,14 +7,12 @@ use gpui::{
     },
     json::ToJson,
     serde_json::{self, json},
-    AnyElement, Axis, Element, LayoutContext, SceneBuilder, ViewContext,
+    Axis, DebugContext, Element, ElementBox, MeasurementContext, PaintContext,
 };
 
-use crate::CollabTitlebarItem;
-
 pub(crate) struct FacePile {
     overlap: f32,
-    faces: Vec<AnyElement<CollabTitlebarItem>>,
+    faces: Vec<ElementBox>,
 }
 
 impl FacePile {
@@ -26,21 +24,20 @@ impl FacePile {
     }
 }
 
-impl Element<CollabTitlebarItem> for FacePile {
+impl Element for FacePile {
     type LayoutState = ();
     type PaintState = ();
 
     fn layout(
         &mut self,
         constraint: gpui::SizeConstraint,
-        view: &mut CollabTitlebarItem,
-        cx: &mut LayoutContext<CollabTitlebarItem>,
+        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, view, cx).x();
+            width += face.layout(constraint, cx).x();
         }
         width -= self.overlap * self.faces.len().saturating_sub(1) as f32;
 
@@ -49,12 +46,10 @@ impl Element<CollabTitlebarItem> for FacePile {
 
     fn paint(
         &mut self,
-        scene: &mut SceneBuilder,
         bounds: RectF,
         visible_bounds: RectF,
         _layout: &mut Self::LayoutState,
-        view: &mut CollabTitlebarItem,
-        cx: &mut ViewContext<CollabTitlebarItem>,
+        cx: &mut PaintContext,
     ) -> Self::PaintState {
         let visible_bounds = bounds.intersection(visible_bounds).unwrap_or_default();
 
@@ -64,8 +59,8 @@ impl Element<CollabTitlebarItem> for FacePile {
         for face in self.faces.iter_mut().rev() {
             let size = face.size();
             origin_x -= size.x();
-            scene.paint_layer(None, |scene| {
-                face.paint(scene, vec2f(origin_x, origin_y), visible_bounds, view, cx);
+            cx.paint_layer(None, |cx| {
+                face.paint(vec2f(origin_x, origin_y), visible_bounds, cx);
             });
             origin_x += self.overlap;
         }
@@ -80,8 +75,7 @@ impl Element<CollabTitlebarItem> for FacePile {
         _: RectF,
         _: &Self::LayoutState,
         _: &Self::PaintState,
-        _: &CollabTitlebarItem,
-        _: &ViewContext<CollabTitlebarItem>,
+        _: &MeasurementContext,
     ) -> Option<RectF> {
         None
     }
@@ -91,8 +85,7 @@ impl Element<CollabTitlebarItem> for FacePile {
         bounds: RectF,
         _: &Self::LayoutState,
         _: &Self::PaintState,
-        _: &CollabTitlebarItem,
-        _: &ViewContext<CollabTitlebarItem>,
+        _: &DebugContext,
     ) -> serde_json::Value {
         json!({
             "type": "FacePile",
@@ -101,8 +94,8 @@ impl Element<CollabTitlebarItem> for FacePile {
     }
 }
 
-impl Extend<AnyElement<CollabTitlebarItem>> for FacePile {
-    fn extend<T: IntoIterator<Item = AnyElement<CollabTitlebarItem>>>(&mut self, children: T) {
+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

@@ -1,19 +1,22 @@
-use std::sync::{Arc, Weak};
-
 use call::{ActiveCall, IncomingCall};
 use client::proto;
 use futures::StreamExt;
 use gpui::{
     elements::*,
     geometry::{rect::RectF, vector::vec2f},
+    impl_internal_actions,
     platform::{CursorStyle, MouseButton, WindowBounds, WindowKind, WindowOptions},
-    AnyElement, AppContext, Entity, View, ViewContext,
+    AppContext, Entity, RenderContext, View, ViewContext,
 };
+use settings::Settings;
 use util::ResultExt;
-use workspace::AppState;
+use workspace::JoinProject;
+
+impl_internal_actions!(incoming_call_notification, [RespondToCall]);
+
+pub fn init(cx: &mut AppContext) {
+    cx.add_action(IncomingCallNotification::respond_to_call);
 
-pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
-    let app_state = Arc::downgrade(app_state);
     let mut incoming_call = ActiveCall::global(cx).read(cx).incoming();
     cx.spawn(|mut cx| async move {
         let mut notification_windows = Vec::new();
@@ -25,7 +28,7 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
             if let Some(incoming_call) = incoming_call {
                 const PADDING: f32 = 16.;
                 let window_size = cx.read(|cx| {
-                    let theme = &theme::current(cx).incoming_call_notification;
+                    let theme = &cx.global::<Settings>().theme.incoming_call_notification;
                     vec2f(theme.window_width, theme.window_height)
                 });
 
@@ -41,12 +44,11 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
                             titlebar: None,
                             center: false,
                             focus: false,
-                            show: true,
                             kind: WindowKind::PopUp,
                             is_movable: false,
                             screen: Some(screen),
                         },
-                        |_| IncomingCallNotification::new(incoming_call.clone(), app_state.clone()),
+                        |_| IncomingCallNotification::new(incoming_call.clone()),
                     );
 
                     notification_windows.push(window_id);
@@ -64,40 +66,32 @@ struct RespondToCall {
 
 pub struct IncomingCallNotification {
     call: IncomingCall,
-    app_state: Weak<AppState>,
 }
 
 impl IncomingCallNotification {
-    pub fn new(call: IncomingCall, app_state: Weak<AppState>) -> Self {
-        Self { call, app_state }
+    pub fn new(call: IncomingCall) -> Self {
+        Self { call }
     }
 
-    fn respond(&mut self, accept: bool, cx: &mut ViewContext<Self>) {
+    fn respond_to_call(&mut self, action: &RespondToCall, cx: &mut ViewContext<Self>) {
         let active_call = ActiveCall::global(cx);
-        if accept {
+        if action.accept {
             let join = active_call.update(cx, |active_call, cx| active_call.accept_incoming(cx));
             let caller_user_id = self.call.calling_user.id;
             let initial_project_id = self.call.initial_project.as_ref().map(|project| project.id);
-            let app_state = self.app_state.clone();
-            cx.app_context()
-                .spawn(|mut cx| async move {
-                    join.await?;
-                    if let Some(project_id) = initial_project_id {
-                        cx.update(|cx| {
-                            if let Some(app_state) = app_state.upgrade() {
-                                workspace::join_remote_project(
-                                    project_id,
-                                    caller_user_id,
-                                    app_state,
-                                    cx,
-                                )
-                                .detach_and_log_err(cx);
-                            }
-                        });
-                    }
-                    anyhow::Ok(())
-                })
-                .detach_and_log_err(cx);
+            cx.spawn_weak(|_, mut cx| async move {
+                join.await?;
+                if let Some(project_id) = initial_project_id {
+                    cx.update(|cx| {
+                        cx.dispatch_global_action(JoinProject {
+                            project_id,
+                            follow_user_id: caller_user_id,
+                        })
+                    });
+                }
+                anyhow::Ok(())
+            })
+            .detach_and_log_err(cx);
         } else {
             active_call.update(cx, |active_call, _| {
                 active_call.decline_incoming().log_err();
@@ -105,8 +99,8 @@ impl IncomingCallNotification {
         }
     }
 
-    fn render_caller(&self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
-        let theme = &theme::current(cx).incoming_call_notification;
+    fn render_caller(&self, cx: &mut RenderContext<Self>) -> ElementBox {
+        let theme = &cx.global::<Settings>().theme.incoming_call_notification;
         let default_project = proto::ParticipantProject::default();
         let initial_project = self
             .call
@@ -118,6 +112,7 @@ impl IncomingCallNotification {
                 Image::from_data(avatar)
                     .with_style(theme.caller_avatar)
                     .aligned()
+                    .boxed()
             }))
             .with_child(
                 Flex::column()
@@ -127,7 +122,8 @@ impl IncomingCallNotification {
                             theme.caller_username.text.clone(),
                         )
                         .contained()
-                        .with_style(theme.caller_username.container),
+                        .with_style(theme.caller_username.container)
+                        .boxed(),
                     )
                     .with_child(
                         Label::new(
@@ -142,7 +138,8 @@ impl IncomingCallNotification {
                             theme.caller_message.text.clone(),
                         )
                         .contained()
-                        .with_style(theme.caller_message.container),
+                        .with_style(theme.caller_message.container)
+                        .boxed(),
                     )
                     .with_children(if initial_project.worktree_root_names.is_empty() {
                         None
@@ -153,56 +150,66 @@ impl IncomingCallNotification {
                                 theme.worktree_roots.text.clone(),
                             )
                             .contained()
-                            .with_style(theme.worktree_roots.container),
+                            .with_style(theme.worktree_roots.container)
+                            .boxed(),
                         )
                     })
                     .contained()
                     .with_style(theme.caller_metadata)
-                    .aligned(),
+                    .aligned()
+                    .boxed(),
             )
             .contained()
             .with_style(theme.caller_container)
             .flex(1., true)
-            .into_any()
+            .boxed()
     }
 
-    fn render_buttons(&self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+    fn render_buttons(&self, cx: &mut RenderContext<Self>) -> ElementBox {
         enum Accept {}
         enum Decline {}
 
-        let theme = theme::current(cx);
         Flex::column()
             .with_child(
-                MouseEventHandler::<Accept, Self>::new(0, cx, |_, _| {
-                    let theme = &theme.incoming_call_notification;
+                MouseEventHandler::<Accept>::new(0, cx, |_, cx| {
+                    let theme = &cx.global::<Settings>().theme.incoming_call_notification;
                     Label::new("Accept", theme.accept_button.text.clone())
                         .aligned()
                         .contained()
                         .with_style(theme.accept_button.container)
+                        .boxed()
                 })
                 .with_cursor_style(CursorStyle::PointingHand)
-                .on_click(MouseButton::Left, |_, this, cx| {
-                    this.respond(true, cx);
+                .on_click(MouseButton::Left, |_, cx| {
+                    cx.dispatch_action(RespondToCall { accept: true });
                 })
-                .flex(1., true),
+                .flex(1., true)
+                .boxed(),
             )
             .with_child(
-                MouseEventHandler::<Decline, Self>::new(0, cx, |_, _| {
-                    let theme = &theme.incoming_call_notification;
+                MouseEventHandler::<Decline>::new(0, cx, |_, cx| {
+                    let theme = &cx.global::<Settings>().theme.incoming_call_notification;
                     Label::new("Decline", theme.decline_button.text.clone())
                         .aligned()
                         .contained()
                         .with_style(theme.decline_button.container)
+                        .boxed()
                 })
                 .with_cursor_style(CursorStyle::PointingHand)
-                .on_click(MouseButton::Left, |_, this, cx| {
-                    this.respond(false, cx);
+                .on_click(MouseButton::Left, |_, cx| {
+                    cx.dispatch_action(RespondToCall { accept: false });
                 })
-                .flex(1., true),
+                .flex(1., true)
+                .boxed(),
             )
             .constrained()
-            .with_width(theme.incoming_call_notification.button_width)
-            .into_any()
+            .with_width(
+                cx.global::<Settings>()
+                    .theme
+                    .incoming_call_notification
+                    .button_width,
+            )
+            .boxed()
     }
 }
 
@@ -215,14 +222,19 @@ impl View for IncomingCallNotification {
         "IncomingCallNotification"
     }
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
-        let background = theme::current(cx).incoming_call_notification.background;
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> gpui::ElementBox {
+        let background = cx
+            .global::<Settings>()
+            .theme
+            .incoming_call_notification
+            .background;
+
         Flex::row()
             .with_child(self.render_caller(cx))
             .with_child(self.render_buttons(cx))
             .contained()
             .with_background_color(background)
             .expanded()
-            .into_any()
+            .boxed()
     }
 }

crates/collab_ui/src/notifications.rs

@@ -2,26 +2,23 @@ use client::User;
 use gpui::{
     elements::*,
     platform::{CursorStyle, MouseButton},
-    AnyElement, Element, View, ViewContext,
+    Action, Element, ElementBox, RenderContext, View,
 };
+use settings::Settings;
 use std::sync::Arc;
 
 enum Dismiss {}
 enum Button {}
 
-pub fn render_user_notification<F, V>(
+pub fn render_user_notification<V: View, A: Action + Clone>(
     user: Arc<User>,
     title: &'static str,
     body: Option<&'static str>,
-    on_dismiss: F,
-    buttons: Vec<(&'static str, Box<dyn Fn(&mut V, &mut ViewContext<V>)>)>,
-    cx: &mut ViewContext<V>,
-) -> AnyElement<V>
-where
-    F: 'static + Fn(&mut V, &mut ViewContext<V>),
-    V: View,
-{
-    let theme = theme::current(cx).clone();
+    dismiss_action: A,
+    buttons: Vec<(&'static str, Box<dyn Action>)>,
+    cx: &mut RenderContext<V>,
+) -> ElementBox {
+    let theme = cx.global::<Settings>().theme.clone();
     let theme = &theme.contact_notification;
 
     Flex::column()
@@ -38,6 +35,7 @@ where
                         )
                         .aligned()
                         .top()
+                        .boxed()
                 }))
                 .with_child(
                     Text::new(
@@ -49,10 +47,11 @@ where
                     .aligned()
                     .top()
                     .left()
-                    .flex(1., true),
+                    .flex(1., true)
+                    .boxed(),
                 )
                 .with_child(
-                    MouseEventHandler::<Dismiss, V>::new(user.id as usize, cx, |state, _| {
+                    MouseEventHandler::<Dismiss>::new(user.id as usize, cx, |state, _| {
                         let style = theme.dismiss_button.style_for(state, false);
                         Svg::new("icons/x_mark_8.svg")
                             .with_color(style.color)
@@ -64,10 +63,13 @@ where
                             .constrained()
                             .with_width(style.button_width)
                             .with_height(style.button_width)
+                            .boxed()
                     })
                     .with_cursor_style(CursorStyle::PointingHand)
                     .with_padding(Padding::uniform(5.))
-                    .on_click(MouseButton::Left, move |_, view, cx| on_dismiss(view, cx))
+                    .on_click(MouseButton::Left, move |_, cx| {
+                        cx.dispatch_any_action(dismiss_action.boxed_clone())
+                    })
                     .aligned()
                     .constrained()
                     .with_height(
@@ -76,14 +78,16 @@ where
                     )
                     .aligned()
                     .top()
-                    .flex_float(),
+                    .flex_float()
+                    .boxed(),
                 )
-                .into_any_named("contact notification header"),
+                .named("contact notification header"),
         )
         .with_children(body.map(|body| {
             Label::new(body, theme.body_message.text.clone())
                 .contained()
                 .with_style(theme.body_message.container)
+                .boxed()
         }))
         .with_children(if buttons.is_empty() {
             None
@@ -91,21 +95,26 @@ where
             Some(
                 Flex::row()
                     .with_children(buttons.into_iter().enumerate().map(
-                        |(ix, (message, handler))| {
-                            MouseEventHandler::<Button, V>::new(ix, cx, |state, _| {
+                        |(ix, (message, action))| {
+                            MouseEventHandler::<Button>::new(ix, cx, |state, _| {
                                 let button = theme.button.style_for(state, false);
                                 Label::new(message, button.text.clone())
                                     .contained()
                                     .with_style(button.container)
+                                    .boxed()
                             })
                             .with_cursor_style(CursorStyle::PointingHand)
-                            .on_click(MouseButton::Left, move |_, view, cx| handler(view, cx))
+                            .on_click(MouseButton::Left, move |_, cx| {
+                                cx.dispatch_any_action(action.boxed_clone())
+                            })
+                            .boxed()
                         },
                     ))
                     .aligned()
-                    .right(),
+                    .right()
+                    .boxed(),
             )
         })
         .contained()
-        .into_any()
+        .boxed()
 }

crates/collab_ui/src/project_shared_notification.rs

@@ -2,16 +2,22 @@ use call::{room, ActiveCall};
 use client::User;
 use collections::HashMap;
 use gpui::{
+    actions,
     elements::*,
     geometry::{rect::RectF, vector::vec2f},
     platform::{CursorStyle, MouseButton, WindowBounds, WindowKind, WindowOptions},
-    AppContext, Entity, View, ViewContext,
+    AppContext, Entity, RenderContext, View, ViewContext,
 };
-use std::sync::{Arc, Weak};
-use workspace::AppState;
+use settings::Settings;
+use std::sync::Arc;
+use workspace::JoinProject;
+
+actions!(project_shared_notification, [DismissProject]);
+
+pub fn init(cx: &mut AppContext) {
+    cx.add_action(ProjectSharedNotification::join);
+    cx.add_action(ProjectSharedNotification::dismiss);
 
-pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
-    let app_state = Arc::downgrade(app_state);
     let active_call = ActiveCall::global(cx);
     let mut notification_windows = HashMap::default();
     cx.subscribe(&active_call, move |_, event, cx| match event {
@@ -21,7 +27,7 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
             worktree_root_names,
         } => {
             const PADDING: f32 = 16.;
-            let theme = &theme::current(cx).project_shared_notification;
+            let theme = &cx.global::<Settings>().theme.project_shared_notification;
             let window_size = vec2f(theme.window_width, theme.window_height);
 
             for screen in cx.platform().screens() {
@@ -35,7 +41,6 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
                         titlebar: None,
                         center: false,
                         focus: false,
-                        show: true,
                         kind: WindowKind::PopUp,
                         is_movable: false,
                         screen: Some(screen),
@@ -45,7 +50,6 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
                             owner.clone(),
                             *project_id,
                             worktree_root_names.clone(),
-                            app_state.clone(),
                         )
                     },
                 );
@@ -58,14 +62,14 @@ pub fn init(app_state: &Arc<AppState>, cx: &mut AppContext) {
         room::Event::RemoteProjectUnshared { project_id } => {
             if let Some(window_ids) = notification_windows.remove(&project_id) {
                 for window_id in window_ids {
-                    cx.update_window(window_id, |cx| cx.remove_window());
+                    cx.remove_window(window_id);
                 }
             }
         }
         room::Event::Left => {
             for (_, window_ids) in notification_windows.drain() {
                 for window_id in window_ids {
-                    cx.update_window(window_id, |cx| cx.remove_window());
+                    cx.remove_window(window_id);
                 }
             }
         }
@@ -78,43 +82,36 @@ pub struct ProjectSharedNotification {
     project_id: u64,
     worktree_root_names: Vec<String>,
     owner: Arc<User>,
-    app_state: Weak<AppState>,
 }
 
 impl ProjectSharedNotification {
-    fn new(
-        owner: Arc<User>,
-        project_id: u64,
-        worktree_root_names: Vec<String>,
-        app_state: Weak<AppState>,
-    ) -> Self {
+    fn new(owner: Arc<User>, project_id: u64, worktree_root_names: Vec<String>) -> Self {
         Self {
             project_id,
             worktree_root_names,
             owner,
-            app_state,
         }
     }
 
-    fn join(&mut self, cx: &mut ViewContext<Self>) {
-        cx.remove_window();
-        if let Some(app_state) = self.app_state.upgrade() {
-            workspace::join_remote_project(self.project_id, self.owner.id, app_state, cx)
-                .detach_and_log_err(cx);
-        }
+    fn join(&mut self, _: &JoinProject, cx: &mut ViewContext<Self>) {
+        let window_id = cx.window_id();
+        cx.remove_window(window_id);
+        cx.propagate_action();
     }
 
-    fn dismiss(&mut self, cx: &mut ViewContext<Self>) {
-        cx.remove_window();
+    fn dismiss(&mut self, _: &DismissProject, cx: &mut ViewContext<Self>) {
+        let window_id = cx.window_id();
+        cx.remove_window(window_id);
     }
 
-    fn render_owner(&self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
-        let theme = &theme::current(cx).project_shared_notification;
+    fn render_owner(&self, cx: &mut RenderContext<Self>) -> ElementBox {
+        let theme = &cx.global::<Settings>().theme.project_shared_notification;
         Flex::row()
             .with_children(self.owner.avatar.clone().map(|avatar| {
                 Image::from_data(avatar)
                     .with_style(theme.owner_avatar)
                     .aligned()
+                    .boxed()
             }))
             .with_child(
                 Flex::column()
@@ -124,7 +121,8 @@ impl ProjectSharedNotification {
                             theme.owner_username.text.clone(),
                         )
                         .contained()
-                        .with_style(theme.owner_username.container),
+                        .with_style(theme.owner_username.container)
+                        .boxed(),
                     )
                     .with_child(
                         Label::new(
@@ -139,7 +137,8 @@ impl ProjectSharedNotification {
                             theme.message.text.clone(),
                         )
                         .contained()
-                        .with_style(theme.message.container),
+                        .with_style(theme.message.container)
+                        .boxed(),
                     )
                     .with_children(if self.worktree_root_names.is_empty() {
                         None
@@ -150,54 +149,72 @@ impl ProjectSharedNotification {
                                 theme.worktree_roots.text.clone(),
                             )
                             .contained()
-                            .with_style(theme.worktree_roots.container),
+                            .with_style(theme.worktree_roots.container)
+                            .boxed(),
                         )
                     })
                     .contained()
                     .with_style(theme.owner_metadata)
-                    .aligned(),
+                    .aligned()
+                    .boxed(),
             )
             .contained()
             .with_style(theme.owner_container)
             .flex(1., true)
-            .into_any()
+            .boxed()
     }
 
-    fn render_buttons(&self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+    fn render_buttons(&self, cx: &mut RenderContext<Self>) -> ElementBox {
         enum Open {}
         enum Dismiss {}
 
-        let theme = theme::current(cx);
+        let project_id = self.project_id;
+        let owner_user_id = self.owner.id;
+
         Flex::column()
             .with_child(
-                MouseEventHandler::<Open, Self>::new(0, cx, |_, _| {
-                    let theme = &theme.project_shared_notification;
+                MouseEventHandler::<Open>::new(0, cx, |_, cx| {
+                    let theme = &cx.global::<Settings>().theme.project_shared_notification;
                     Label::new("Open", theme.open_button.text.clone())
                         .aligned()
                         .contained()
                         .with_style(theme.open_button.container)
+                        .boxed()
                 })
                 .with_cursor_style(CursorStyle::PointingHand)
-                .on_click(MouseButton::Left, move |_, this, cx| this.join(cx))
-                .flex(1., true),
+                .on_click(MouseButton::Left, move |_, cx| {
+                    cx.dispatch_action(JoinProject {
+                        project_id,
+                        follow_user_id: owner_user_id,
+                    });
+                })
+                .flex(1., true)
+                .boxed(),
             )
             .with_child(
-                MouseEventHandler::<Dismiss, Self>::new(0, cx, |_, _| {
-                    let theme = &theme.project_shared_notification;
+                MouseEventHandler::<Dismiss>::new(0, cx, |_, cx| {
+                    let theme = &cx.global::<Settings>().theme.project_shared_notification;
                     Label::new("Dismiss", theme.dismiss_button.text.clone())
                         .aligned()
                         .contained()
                         .with_style(theme.dismiss_button.container)
+                        .boxed()
                 })
                 .with_cursor_style(CursorStyle::PointingHand)
-                .on_click(MouseButton::Left, |_, this, cx| {
-                    this.dismiss(cx);
+                .on_click(MouseButton::Left, |_, cx| {
+                    cx.dispatch_action(DismissProject);
                 })
-                .flex(1., true),
+                .flex(1., true)
+                .boxed(),
             )
             .constrained()
-            .with_width(theme.project_shared_notification.button_width)
-            .into_any()
+            .with_width(
+                cx.global::<Settings>()
+                    .theme
+                    .project_shared_notification
+                    .button_width,
+            )
+            .boxed()
     }
 }
 
@@ -210,14 +227,18 @@ impl View for ProjectSharedNotification {
         "ProjectSharedNotification"
     }
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> gpui::AnyElement<Self> {
-        let background = theme::current(cx).project_shared_notification.background;
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> gpui::ElementBox {
+        let background = cx
+            .global::<Settings>()
+            .theme
+            .project_shared_notification
+            .background;
         Flex::row()
             .with_child(self.render_owner(cx))
             .with_child(self.render_buttons(cx))
             .contained()
             .with_background_color(background)
             .expanded()
-            .into_any()
+            .boxed()
     }
 }

crates/collab_ui/src/sharing_status_indicator.rs

@@ -1,12 +1,13 @@
-use crate::toggle_screen_sharing;
 use call::ActiveCall;
 use gpui::{
     color::Color,
     elements::{MouseEventHandler, Svg},
     platform::{Appearance, MouseButton},
-    AnyElement, AppContext, Element, Entity, View, ViewContext,
+    AppContext, Element, ElementBox, Entity, RenderContext, View,
 };
-use workspace::WorkspaceSettings;
+use settings::Settings;
+
+use crate::ToggleScreenSharing;
 
 pub fn init(cx: &mut AppContext) {
     let active_call = ActiveCall::global(cx);
@@ -15,16 +16,14 @@ pub fn init(cx: &mut AppContext) {
     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()
-                    && settings::get::<WorkspaceSettings>(cx).show_call_status_icon
-                {
+                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.update_window(window_id, |cx| cx.remove_window());
+                cx.remove_status_bar_item(window_id);
             }
         } else if let Some((window_id, _)) = status_indicator.take() {
-            cx.update_window(window_id, |cx| cx.remove_window());
+            cx.remove_status_bar_item(window_id);
         }
     })
     .detach();
@@ -41,22 +40,23 @@ impl View for SharingStatusIndicator {
         "SharingStatusIndicator"
     }
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
-        let color = match cx.window_appearance() {
+    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, Self>::new(0, cx, |_, _| {
+        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| {
-            toggle_screen_sharing(&Default::default(), cx)
+        .on_click(MouseButton::Left, |_, cx| {
+            cx.dispatch_action(ToggleScreenSharing);
         })
-        .into_any()
+        .boxed()
     }
 }

crates/command_palette/Cargo.toml

@@ -23,9 +23,8 @@ workspace = { path = "../workspace" }
 [dev-dependencies]
 gpui = { path = "../gpui", features = ["test-support"] }
 editor = { path = "../editor", features = ["test-support"] }
-language = { path = "../language", features = ["test-support"] }
 project = { path = "../project", features = ["test-support"] }
-serde_json.workspace = true
+serde_json = { workspace = true }
 workspace = { path = "../workspace", features = ["test-support"] }
-ctor.workspace = true
-env_logger.workspace = true
+ctor = "0.1"
+env_logger = "0.9"

crates/command_palette/src/command_palette.rs

@@ -1,24 +1,26 @@
 use collections::CommandPaletteFilter;
 use fuzzy::{StringMatch, StringMatchCandidate};
 use gpui::{
-    actions, elements::*, keymap_matcher::Keystroke, Action, AppContext, Element, MouseState,
-    ViewContext,
+    actions,
+    elements::{ChildView, Flex, Label, ParentElement},
+    keymap_matcher::Keystroke,
+    Action, AnyViewHandle, AppContext, Element, Entity, MouseState, RenderContext, View,
+    ViewContext, ViewHandle,
 };
-use picker::{Picker, PickerDelegate, PickerEvent};
+use picker::{Picker, PickerDelegate};
+use settings::Settings;
 use std::cmp;
-use util::ResultExt;
 use workspace::Workspace;
 
 pub fn init(cx: &mut AppContext) {
-    cx.add_action(toggle_command_palette);
-    CommandPalette::init(cx);
+    cx.add_action(CommandPalette::toggle);
+    Picker::<CommandPalette>::init(cx);
 }
 
 actions!(command_palette, [Toggle]);
 
-pub type CommandPalette = Picker<CommandPaletteDelegate>;
-
-pub struct CommandPaletteDelegate {
+pub struct CommandPalette {
+    picker: ViewHandle<Picker<Self>>,
     actions: Vec<Command>,
     matches: Vec<StringMatch>,
     selected_ix: usize,
@@ -40,29 +42,104 @@ struct Command {
     keystrokes: Vec<Keystroke>,
 }
 
-fn toggle_command_palette(workspace: &mut Workspace, _: &Toggle, cx: &mut ViewContext<Workspace>) {
-    let focused_view_id = cx.focused_view_id().unwrap_or_else(|| cx.view_id());
-    workspace.toggle_modal(cx, |_, cx| {
-        cx.add_view(|cx| Picker::new(CommandPaletteDelegate::new(focused_view_id), cx))
-    });
-}
+impl CommandPalette {
+    pub fn new(focused_view_id: usize, cx: &mut ViewContext<Self>) -> Self {
+        let this = cx.weak_handle();
+        let actions = cx
+            .available_actions(cx.window_id(), focused_view_id)
+            .filter_map(|(name, action, bindings)| {
+                if cx.has_global::<CommandPaletteFilter>() {
+                    let filter = cx.global::<CommandPaletteFilter>();
+                    if filter.filtered_namespaces.contains(action.namespace()) {
+                        return None;
+                    }
+                }
 
-impl CommandPaletteDelegate {
-    pub fn new(focused_view_id: usize) -> Self {
+                Some(Command {
+                    name: humanize_action_name(name),
+                    action,
+                    keystrokes: bindings
+                        .iter()
+                        .map(|binding| binding.keystrokes())
+                        .last()
+                        .map_or(Vec::new(), |keystrokes| keystrokes.to_vec()),
+                })
+            })
+            .collect();
+
+        let picker = cx.add_view(|cx| Picker::new("Execute a command...", this, cx));
         Self {
-            actions: Default::default(),
+            picker,
+            actions,
             matches: vec![],
             selected_ix: 0,
             focused_view_id,
         }
     }
-}
 
-impl PickerDelegate for CommandPaletteDelegate {
-    fn placeholder_text(&self) -> std::sync::Arc<str> {
-        "Execute a command...".into()
+    fn toggle(_: &mut Workspace, _: &Toggle, cx: &mut ViewContext<Workspace>) {
+        let workspace = cx.handle();
+        let window_id = cx.window_id();
+        let focused_view_id = cx
+            .focused_view_id(window_id)
+            .unwrap_or_else(|| workspace.id());
+
+        cx.as_mut().defer(move |cx| {
+            let this = cx.add_view(&workspace, |cx| Self::new(focused_view_id, cx));
+            workspace.update(cx, |workspace, cx| {
+                workspace.toggle_modal(cx, |_, cx| {
+                    cx.subscribe(&this, Self::on_event).detach();
+                    this
+                });
+            });
+        });
     }
 
+    fn on_event(
+        workspace: &mut Workspace,
+        _: ViewHandle<Self>,
+        event: &Event,
+        cx: &mut ViewContext<Workspace>,
+    ) {
+        match event {
+            Event::Dismissed => workspace.dismiss_modal(cx),
+            Event::Confirmed {
+                window_id,
+                focused_view_id,
+                action,
+            } => {
+                let window_id = *window_id;
+                let focused_view_id = *focused_view_id;
+                let action = action.boxed_clone();
+                workspace.dismiss_modal(cx);
+                cx.as_mut()
+                    .defer(move |cx| cx.dispatch_any_action_at(window_id, focused_view_id, action))
+            }
+        }
+    }
+}
+
+impl Entity for CommandPalette {
+    type Event = Event;
+}
+
+impl View for CommandPalette {
+    fn ui_name() -> &'static str {
+        "CommandPalette"
+    }
+
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> gpui::ElementBox {
+        ChildView::new(&self.picker, cx).boxed()
+    }
+
+    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+        if cx.is_self_focused() {
+            cx.focus(&self.picker);
+        }
+    }
+}
+
+impl PickerDelegate for CommandPalette {
     fn match_count(&self) -> usize {
         self.matches.len()
     }
@@ -71,55 +148,26 @@ impl PickerDelegate for CommandPaletteDelegate {
         self.selected_ix
     }
 
-    fn set_selected_index(&mut self, ix: usize, _: &mut ViewContext<Picker<Self>>) {
+    fn set_selected_index(&mut self, ix: usize, _: &mut ViewContext<Self>) {
         self.selected_ix = ix;
     }
 
     fn update_matches(
         &mut self,
         query: String,
-        cx: &mut ViewContext<Picker<Self>>,
+        cx: &mut gpui::ViewContext<Self>,
     ) -> gpui::Task<()> {
-        let window_id = cx.window_id();
-        let view_id = self.focused_view_id;
-        cx.spawn(move |picker, mut cx| async move {
-            let actions = cx
-                .available_actions(window_id, view_id)
-                .into_iter()
-                .filter_map(|(name, action, bindings)| {
-                    let filtered = cx.read(|cx| {
-                        if cx.has_global::<CommandPaletteFilter>() {
-                            let filter = cx.global::<CommandPaletteFilter>();
-                            filter.filtered_namespaces.contains(action.namespace())
-                        } else {
-                            false
-                        }
-                    });
-
-                    if filtered {
-                        None
-                    } else {
-                        Some(Command {
-                            name: humanize_action_name(name),
-                            action,
-                            keystrokes: bindings
-                                .iter()
-                                .map(|binding| binding.keystrokes())
-                                .last()
-                                .map_or(Vec::new(), |keystrokes| keystrokes.to_vec()),
-                        })
-                    }
-                })
-                .collect::<Vec<_>>();
-            let candidates = actions
-                .iter()
-                .enumerate()
-                .map(|(ix, command)| StringMatchCandidate {
-                    id: ix,
-                    string: command.name.to_string(),
-                    char_bag: command.name.chars().collect(),
-                })
-                .collect::<Vec<_>>();
+        let candidates = self
+            .actions
+            .iter()
+            .enumerate()
+            .map(|(ix, command)| StringMatchCandidate {
+                id: ix,
+                string: command.name.to_string(),
+                char_bag: command.name.chars().collect(),
+            })
+            .collect::<Vec<_>>();
+        cx.spawn(move |this, mut cx| async move {
             let matches = if query.is_empty() {
                 candidates
                     .into_iter()
@@ -142,37 +190,32 @@ impl PickerDelegate for CommandPaletteDelegate {
                 )
                 .await
             };
-            picker
-                .update(&mut cx, |picker, _| {
-                    let delegate = picker.delegate_mut();
-                    delegate.actions = actions;
-                    delegate.matches = matches;
-                    if delegate.matches.is_empty() {
-                        delegate.selected_ix = 0;
-                    } else {
-                        delegate.selected_ix =
-                            cmp::min(delegate.selected_ix, delegate.matches.len() - 1);
-                    }
-                })
-                .log_err();
+            this.update(&mut cx, |this, _| {
+                this.matches = matches;
+                if this.matches.is_empty() {
+                    this.selected_ix = 0;
+                } else {
+                    this.selected_ix = cmp::min(this.selected_ix, this.matches.len() - 1);
+                }
+            });
         })
     }
 
-    fn dismissed(&mut self, _cx: &mut ViewContext<Picker<Self>>) {}
+    fn dismiss(&mut self, cx: &mut ViewContext<Self>) {
+        cx.emit(Event::Dismissed);
+    }
 
-    fn confirm(&mut self, cx: &mut ViewContext<Picker<Self>>) {
+    fn confirm(&mut self, cx: &mut ViewContext<Self>) {
         if !self.matches.is_empty() {
-            let window_id = cx.window_id();
-            let focused_view_id = self.focused_view_id;
             let action_ix = self.matches[self.selected_ix].candidate_id;
-            let action = self.actions.remove(action_ix).action;
-            cx.app_context()
-                .spawn(move |mut cx| async move {
-                    cx.dispatch_action(window_id, focused_view_id, action.as_ref())
-                })
-                .detach_and_log_err(cx);
+            cx.emit(Event::Confirmed {
+                window_id: cx.window_id(),
+                focused_view_id: self.focused_view_id,
+                action: self.actions.remove(action_ix).action,
+            });
+        } else {
+            cx.emit(Event::Dismissed);
         }
-        cx.emit(PickerEvent::Dismiss);
     }
 
     fn render_match(
@@ -181,10 +224,11 @@ impl PickerDelegate for CommandPaletteDelegate {
         mouse_state: &mut MouseState,
         selected: bool,
         cx: &gpui::AppContext,
-    ) -> AnyElement<Picker<Self>> {
+    ) -> gpui::ElementBox {
         let mat = &self.matches[ix];
         let command = &self.actions[mat.candidate_id];
-        let theme = theme::current(cx);
+        let settings = cx.global::<Settings>();
+        let theme = &settings.theme;
         let style = theme.picker.item.style_for(mouse_state, selected);
         let key_style = &theme.command_palette.key.style_for(mouse_state, selected);
         let keystroke_spacing = theme.command_palette.keystroke_spacing;
@@ -192,7 +236,8 @@ impl PickerDelegate for CommandPaletteDelegate {
         Flex::row()
             .with_child(
                 Label::new(mat.string.clone(), style.label.clone())
-                    .with_highlights(mat.positions.clone()),
+                    .with_highlights(mat.positions.clone())
+                    .boxed(),
             )
             .with_children(command.keystrokes.iter().map(|keystroke| {
                 Flex::row()
@@ -209,7 +254,8 @@ impl PickerDelegate for CommandPaletteDelegate {
                                 Some(
                                     Label::new(label, key_style.label.clone())
                                         .contained()
-                                        .with_style(key_style.container),
+                                        .with_style(key_style.container)
+                                        .boxed(),
                                 )
                             } else {
                                 None
@@ -219,15 +265,17 @@ impl PickerDelegate for CommandPaletteDelegate {
                     .with_child(
                         Label::new(keystroke.key.clone(), key_style.label.clone())
                             .contained()
-                            .with_style(key_style.container),
+                            .with_style(key_style.container)
+                            .boxed(),
                     )
                     .contained()
                     .with_margin_left(keystroke_spacing)
                     .flex_float()
+                    .boxed()
             }))
             .contained()
             .with_style(style.container)
-            .into_any()
+            .boxed()
     }
 }
 
@@ -266,11 +314,9 @@ impl std::fmt::Debug for Command {
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Arc;
-
     use super::*;
     use editor::Editor;
-    use gpui::{executor::Deterministic, TestAppContext};
+    use gpui::TestAppContext;
     use project::Project;
     use workspace::{AppState, Workspace};
 
@@ -291,12 +337,18 @@ mod tests {
     }
 
     #[gpui::test]
-    async fn test_command_palette(deterministic: Arc<Deterministic>, cx: &mut TestAppContext) {
-        let app_state = init_test(cx);
+    async fn test_command_palette(cx: &mut TestAppContext) {
+        let app_state = cx.update(AppState::test);
+
+        cx.update(|cx| {
+            editor::init(cx);
+            workspace::init(app_state.clone(), cx);
+            init(cx);
+        });
 
         let project = Project::test(app_state.fs.clone(), [], cx).await;
-        let (window_id, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
-        let editor = cx.add_view(window_id, |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);
             editor
@@ -308,7 +360,7 @@ mod tests {
         });
 
         workspace.update(cx, |workspace, cx| {
-            toggle_command_palette(workspace, &Toggle, cx);
+            CommandPalette::toggle(workspace, &Toggle, cx)
         });
 
         let palette = workspace.read_with(cx, |workspace, _| {
@@ -317,17 +369,15 @@ mod tests {
 
         palette
             .update(cx, |palette, cx| {
-                palette
-                    .delegate_mut()
-                    .update_matches("bcksp".to_string(), cx)
+                palette.update_matches("bcksp".to_string(), cx)
             })
             .await;
 
         palette.update(cx, |palette, cx| {
-            assert_eq!(palette.delegate().matches[0].string, "editor: backspace");
-            palette.confirm(&Default::default(), cx);
+            assert_eq!(palette.matches[0].string, "editor: backspace");
+            palette.confirm(cx);
         });
-        deterministic.run_until_parked();
+
         editor.read_with(cx, |editor, cx| {
             assert_eq!(editor.text(cx), "ab");
         });
@@ -340,7 +390,7 @@ mod tests {
         });
 
         workspace.update(cx, |workspace, cx| {
-            toggle_command_palette(workspace, &Toggle, cx);
+            CommandPalette::toggle(workspace, &Toggle, cx);
         });
 
         // Assert editor command not present
@@ -350,26 +400,10 @@ mod tests {
 
         palette
             .update(cx, |palette, cx| {
-                palette
-                    .delegate_mut()
-                    .update_matches("bcksp".to_string(), cx)
+                palette.update_matches("bcksp".to_string(), cx)
             })
             .await;
 
-        palette.update(cx, |palette, _| {
-            assert!(palette.delegate().matches.is_empty())
-        });
-    }
-
-    fn init_test(cx: &mut TestAppContext) -> Arc<AppState> {
-        cx.update(|cx| {
-            let app_state = AppState::test(cx);
-            theme::init((), cx);
-            language::init(cx);
-            editor::init(cx);
-            workspace::init(app_state.clone(), cx);
-            init(cx);
-            app_state
-        })
+        palette.update(cx, |palette, _| assert!(palette.matches.is_empty()));
     }
 }

crates/context_menu/Cargo.toml

@@ -13,4 +13,4 @@ gpui = { path = "../gpui" }
 menu = { path = "../menu" }
 settings = { path = "../settings" }
 theme = { path = "../theme" }
-smallvec.workspace = true
+smallvec = "1.6"

crates/context_menu/src/context_menu.rs

@@ -1,71 +1,55 @@
 use gpui::{
-    anyhow,
     elements::*,
     geometry::vector::Vector2F,
+    impl_internal_actions,
     keymap_matcher::KeymapContext,
     platform::{CursorStyle, MouseButton},
-    Action, AnyViewHandle, AppContext, Axis, Entity, MouseState, SizeConstraint, Subscription,
-    View, ViewContext,
+    Action, AnyViewHandle, AppContext, Axis, Entity, MouseState, RenderContext, SizeConstraint,
+    Subscription, View, ViewContext,
 };
 use menu::*;
-use std::{any::TypeId, borrow::Cow, sync::Arc, time::Duration};
+use settings::Settings;
+use std::{any::TypeId, borrow::Cow, time::Duration};
+
+pub type StaticItem = Box<dyn Fn(&mut AppContext) -> ElementBox>;
+
+#[derive(Copy, Clone, PartialEq)]
+struct Clicked;
+
+impl_internal_actions!(context_menu, [Clicked]);
 
 pub fn init(cx: &mut AppContext) {
     cx.add_action(ContextMenu::select_first);
     cx.add_action(ContextMenu::select_last);
     cx.add_action(ContextMenu::select_next);
     cx.add_action(ContextMenu::select_prev);
+    cx.add_action(ContextMenu::clicked);
     cx.add_action(ContextMenu::confirm);
     cx.add_action(ContextMenu::cancel);
 }
 
-pub type StaticItem = Box<dyn Fn(&mut AppContext) -> AnyElement<ContextMenu>>;
-
-type ContextMenuItemBuilder =
-    Box<dyn Fn(&mut MouseState, &theme::ContextMenuItem) -> AnyElement<ContextMenu>>;
+type ContextMenuItemBuilder = Box<dyn Fn(&mut MouseState, &theme::ContextMenuItem) -> ElementBox>;
 
 pub enum ContextMenuItemLabel {
     String(Cow<'static, str>),
     Element(ContextMenuItemBuilder),
 }
 
-impl From<Cow<'static, str>> for ContextMenuItemLabel {
-    fn from(s: Cow<'static, str>) -> Self {
-        Self::String(s)
-    }
+pub enum ContextMenuAction {
+    ParentAction {
+        action: Box<dyn Action>,
+    },
+    ViewAction {
+        action: Box<dyn Action>,
+        for_view: usize,
+    },
 }
 
-impl From<&'static str> for ContextMenuItemLabel {
-    fn from(s: &'static str) -> Self {
-        Self::String(s.into())
-    }
-}
-
-impl From<String> for ContextMenuItemLabel {
-    fn from(s: String) -> Self {
-        Self::String(s.into())
-    }
-}
-
-impl<T> From<T> for ContextMenuItemLabel
-where
-    T: 'static + Fn(&mut MouseState, &theme::ContextMenuItem) -> AnyElement<ContextMenu>,
-{
-    fn from(f: T) -> Self {
-        Self::Element(Box::new(f))
-    }
-}
-
-pub enum ContextMenuItemAction {
-    Action(Box<dyn Action>),
-    Handler(Arc<dyn Fn(&mut ViewContext<ContextMenu>)>),
-}
-
-impl Clone for ContextMenuItemAction {
-    fn clone(&self) -> Self {
+impl ContextMenuAction {
+    fn id(&self) -> TypeId {
         match self {
-            Self::Action(action) => Self::Action(action.boxed_clone()),
-            Self::Handler(handler) => Self::Handler(handler.clone()),
+            ContextMenuAction::ParentAction { action } => action.id(),
+            ContextMenuAction::ViewAction { action, .. } => action.id(),
         }
     }
 }
@@ -73,27 +57,42 @@ impl Clone for ContextMenuItemAction {
 pub enum ContextMenuItem {
     Item {
         label: ContextMenuItemLabel,
-        action: ContextMenuItemAction,
+        action: ContextMenuAction,
     },
     Static(StaticItem),
     Separator,
 }
 
 impl ContextMenuItem {
-    pub fn action(label: impl Into<ContextMenuItemLabel>, action: impl 'static + Action) -> Self {
+    pub fn element_item(label: ContextMenuItemBuilder, action: impl 'static + Action) -> Self {
         Self::Item {
-            label: label.into(),
-            action: ContextMenuItemAction::Action(Box::new(action)),
+            label: ContextMenuItemLabel::Element(label),
+            action: ContextMenuAction::ParentAction {
+                action: Box::new(action),
+            },
         }
     }
 
-    pub fn handler(
-        label: impl Into<ContextMenuItemLabel>,
-        handler: impl 'static + Fn(&mut ViewContext<ContextMenu>),
+    pub fn item(label: impl Into<Cow<'static, str>>, action: impl 'static + Action) -> Self {
+        Self::Item {
+            label: ContextMenuItemLabel::String(label.into()),
+            action: ContextMenuAction::ParentAction {
+                action: Box::new(action),
+            },
+        }
+    }
+
+    pub fn item_for_view(
+        label: impl Into<Cow<'static, str>>,
+        view_id: usize,
+        action: impl 'static + Action,
     ) -> Self {
         Self::Item {
-            label: label.into(),
-            action: ContextMenuItemAction::Handler(Arc::new(handler)),
+            label: ContextMenuItemLabel::String(label.into()),
+            action: ContextMenuAction::ViewAction {
+                action: Box::new(action),
+                for_view: view_id,
+            },
         }
     }
 
@@ -107,10 +106,7 @@ impl ContextMenuItem {
 
     fn action_id(&self) -> Option<TypeId> {
         match self {
-            ContextMenuItem::Item { action, .. } => match action {
-                ContextMenuItemAction::Action(action) => Some(action.id()),
-                ContextMenuItemAction::Handler(_) => None,
-            },
+            ContextMenuItem::Item { action, .. } => Some(action.id()),
             ContextMenuItem::Static(..) | ContextMenuItem::Separator => None,
         }
     }
@@ -125,6 +121,7 @@ pub struct ContextMenu {
     selected_index: Option<usize>,
     visible: bool,
     previously_focused_view_id: Option<usize>,
+    clicked: bool,
     parent_view_id: usize,
     _actions_observation: Subscription,
 }
@@ -138,27 +135,29 @@ impl View for ContextMenu {
         "ContextMenu"
     }
 
-    fn update_keymap_context(&self, keymap: &mut KeymapContext, _: &AppContext) {
-        Self::reset_to_default_keymap_context(keymap);
-        keymap.add_identifier("menu");
+    fn keymap_context(&self, _: &AppContext) -> KeymapContext {
+        let mut cx = Self::default_keymap_context();
+        cx.add_identifier("menu");
+        cx
     }
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
         if !self.visible {
-            return Empty::new().into_any();
+            return Empty::new().boxed();
         }
 
         // Render the menu once at minimum width.
-        let mut collapsed_menu = self.render_menu_for_measurement(cx);
-        let expanded_menu =
-            self.render_menu(cx)
-                .constrained()
-                .dynamically(move |constraint, view, cx| {
-                    SizeConstraint::strict_along(
-                        Axis::Horizontal,
-                        collapsed_menu.layout(constraint, view, cx).0.x(),
-                    )
-                });
+        let mut collapsed_menu = self.render_menu_for_measurement(cx).boxed();
+        let expanded_menu = self
+            .render_menu(cx)
+            .constrained()
+            .dynamically(move |constraint, cx| {
+                SizeConstraint::strict_along(
+                    Axis::Horizontal,
+                    collapsed_menu.layout(constraint, cx).x(),
+                )
+            })
+            .boxed();
 
         Overlay::new(expanded_menu)
             .with_hoverable(true)
@@ -166,7 +165,7 @@ impl View for ContextMenu {
             .with_anchor_position(self.anchor_position)
             .with_anchor_corner(self.anchor_corner)
             .with_position_mode(self.position_mode)
-            .into_any()
+            .boxed()
     }
 
     fn focus_out(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
@@ -175,7 +174,9 @@ impl View for ContextMenu {
 }
 
 impl ContextMenu {
-    pub fn new(parent_view_id: usize, cx: &mut ViewContext<Self>) -> Self {
+    pub fn new(cx: &mut ViewContext<Self>) -> Self {
+        let parent_view_id = cx.parent().unwrap();
+
         Self {
             show_count: 0,
             anchor_position: Default::default(),
@@ -185,6 +186,7 @@ impl ContextMenu {
             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),
         }
@@ -200,33 +202,36 @@ impl ContextMenu {
             .iter()
             .position(|item| item.action_id() == Some(action_id))
         {
-            self.selected_index = Some(ix);
-            cx.notify();
-            cx.spawn(|this, mut cx| async move {
-                cx.background().timer(Duration::from_millis(50)).await;
-                this.update(&mut cx, |this, cx| this.cancel(&Default::default(), cx))?;
-                anyhow::Ok(())
-            })
-            .detach_and_log_err(cx);
+            if self.clicked {
+                self.cancel(&Default::default(), cx);
+            } else {
+                self.selected_index = Some(ix);
+                cx.notify();
+                cx.spawn(|this, mut cx| async move {
+                    cx.background().timer(Duration::from_millis(50)).await;
+                    this.update(&mut cx, |this, cx| this.cancel(&Default::default(), cx));
+                })
+                .detach();
+            }
         }
     }
 
+    fn clicked(&mut self, _: &Clicked, _: &mut ViewContext<Self>) {
+        self.clicked = true;
+    }
+
     fn confirm(&mut self, _: &Confirm, cx: &mut ViewContext<Self>) {
         if let Some(ix) = self.selected_index {
             if let Some(ContextMenuItem::Item { action, .. }) = self.items.get(ix) {
                 match action {
-                    ContextMenuItemAction::Action(action) => {
-                        let window_id = cx.window_id();
-                        let view_id = self.parent_view_id;
-                        let action = action.boxed_clone();
-                        cx.app_context()
-                            .spawn(|mut cx| async move {
-                                cx.dispatch_action(window_id, view_id, action.as_ref())
-                            })
-                            .detach_and_log_err(cx);
+                    ContextMenuAction::ParentAction { action } => {
+                        cx.dispatch_any_action(action.boxed_clone())
                     }
-                    ContextMenuItemAction::Handler(handler) => handler(cx),
-                }
+                    ContextMenuAction::ViewAction { action, for_view } => {
+                        let window_id = cx.window_id();
+                        cx.dispatch_any_action_at(window_id, *for_view, action.boxed_clone())
+                    }
+                };
                 self.reset(cx);
             }
         }
@@ -247,6 +252,7 @@ impl ContextMenu {
         self.items.clear();
         self.visible = false;
         self.selected_index.take();
+        self.clicked = false;
         cx.notify();
     }
 
@@ -308,7 +314,7 @@ impl ContextMenu {
             self.visible = true;
             self.show_count += 1;
             if !cx.is_self_focused() {
-                self.previously_focused_view_id = cx.focused_view_id();
+                self.previously_focused_view_id = cx.focused_view_id(cx.window_id());
             }
             cx.focus_self();
         } else {
@@ -321,42 +327,45 @@ impl ContextMenu {
         self.position_mode = mode;
     }
 
-    fn render_menu_for_measurement(&self, cx: &mut ViewContext<Self>) -> impl Element<ContextMenu> {
-        let style = theme::current(cx).context_menu.clone();
+    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(
-                Flex::column().with_children(self.items.iter().enumerate().map(|(ix, item)| {
-                    match item {
-                        ContextMenuItem::Item { label, .. } => {
-                            let style = style.item.style_for(
-                                &mut Default::default(),
-                                Some(ix) == self.selected_index,
-                            );
+                Flex::column()
+                    .with_children(self.items.iter().enumerate().map(|(ix, item)| {
+                        match item {
+                            ContextMenuItem::Item { label, .. } => {
+                                let style = style.item.style_for(
+                                    &mut Default::default(),
+                                    Some(ix) == self.selected_index,
+                                );
 
-                            match label {
-                                ContextMenuItemLabel::String(label) => {
-                                    Label::new(label.to_string(), style.label.clone())
-                                        .contained()
-                                        .with_style(style.container)
-                                        .into_any()
-                                }
-                                ContextMenuItemLabel::Element(element) => {
-                                    element(&mut Default::default(), style)
+                                match label {
+                                    ContextMenuItemLabel::String(label) => {
+                                        Label::new(label.to_string(), style.label.clone())
+                                            .contained()
+                                            .with_style(style.container)
+                                            .boxed()
+                                    }
+                                    ContextMenuItemLabel::Element(element) => {
+                                        element(&mut Default::default(), style)
+                                    }
                                 }
                             }
+
+                            ContextMenuItem::Static(f) => f(cx),
+
+                            ContextMenuItem::Separator => Empty::new()
+                                .collapsed()
+                                .contained()
+                                .with_style(style.separator)
+                                .constrained()
+                                .with_height(1.)
+                                .boxed(),
                         }
-
-                        ContextMenuItem::Static(f) => f(cx),
-
-                        ContextMenuItem::Separator => Empty::new()
-                            .collapsed()
-                            .contained()
-                            .with_style(style.separator)
-                            .constrained()
-                            .with_height(1.)
-                            .into_any(),
-                    }
-                })),
+                    }))
+                    .boxed(),
             )
             .with_child(
                 Flex::column()
@@ -367,20 +376,26 @@ impl ContextMenu {
                                     &mut Default::default(),
                                     Some(ix) == self.selected_index,
                                 );
+                                let (action, view_id) = match action {
+                                    ContextMenuAction::ParentAction { action } => {
+                                        (action.boxed_clone(), self.parent_view_id)
+                                    }
+                                    ContextMenuAction::ViewAction { action, for_view } => {
+                                        (action.boxed_clone(), *for_view)
+                                    }
+                                };
 
-                                match action {
-                                    ContextMenuItemAction::Action(action) => KeystrokeLabel::new(
-                                        self.parent_view_id,
-                                        action.boxed_clone(),
-                                        style.keystroke.container,
-                                        style.keystroke.text.clone(),
-                                    )
-                                    .into_any(),
-                                    ContextMenuItemAction::Handler(_) => Empty::new().into_any(),
-                                }
+                                KeystrokeLabel::new(
+                                    window_id,
+                                    view_id,
+                                    action.boxed_clone(),
+                                    style.keystroke.container,
+                                    style.keystroke.text.clone(),
+                                )
+                                .boxed()
                             }
 
-                            ContextMenuItem::Static(_) => Empty::new().into_any(),
+                            ContextMenuItem::Static(_) => Empty::new().boxed(),
 
                             ContextMenuItem::Separator => Empty::new()
                                 .collapsed()
@@ -388,84 +403,78 @@ impl ContextMenu {
                                 .with_height(1.)
                                 .contained()
                                 .with_style(style.separator)
-                                .into_any(),
+                                .boxed(),
                         }
                     }))
                     .contained()
-                    .with_margin_left(style.keystroke_margin),
+                    .with_margin_left(style.keystroke_margin)
+                    .boxed(),
             )
             .contained()
             .with_style(style.container)
     }
 
-    fn render_menu(&self, cx: &mut ViewContext<Self>) -> impl Element<ContextMenu> {
+    fn render_menu(&self, cx: &mut RenderContext<Self>) -> impl Element {
         enum Menu {}
         enum MenuItem {}
 
-        let style = theme::current(cx).context_menu.clone();
+        let style = cx.global::<Settings>().theme.context_menu.clone();
 
-        MouseEventHandler::<Menu, ContextMenu>::new(0, cx, |_, cx| {
+        let window_id = cx.window_id();
+        MouseEventHandler::<Menu>::new(0, cx, |_, cx| {
             Flex::column()
                 .with_children(self.items.iter().enumerate().map(|(ix, item)| {
                     match item {
                         ContextMenuItem::Item { label, action } => {
-                            let action = action.clone();
-                            let view_id = self.parent_view_id;
-                            MouseEventHandler::<MenuItem, ContextMenu>::new(ix, cx, |state, _| {
+                            let (action, view_id) = match action {
+                                ContextMenuAction::ParentAction { action } => {
+                                    (action.boxed_clone(), self.parent_view_id)
+                                }
+                                ContextMenuAction::ViewAction { action, for_view } => {
+                                    (action.boxed_clone(), *for_view)
+                                }
+                            };
+
+                            MouseEventHandler::<MenuItem>::new(ix, cx, |state, _| {
                                 let style =
                                     style.item.style_for(state, Some(ix) == self.selected_index);
-                                let keystroke = match &action {
-                                    ContextMenuItemAction::Action(action) => Some(
-                                        KeystrokeLabel::new(
-                                            view_id,
-                                            action.boxed_clone(),
-                                            style.keystroke.container,
-                                            style.keystroke.text.clone(),
-                                        )
-                                        .flex_float(),
-                                    ),
-                                    ContextMenuItemAction::Handler(_) => None,
-                                };
 
                                 Flex::row()
                                     .with_child(match label {
                                         ContextMenuItemLabel::String(label) => {
                                             Label::new(label.clone(), style.label.clone())
                                                 .contained()
-                                                .into_any()
+                                                .boxed()
                                         }
                                         ContextMenuItemLabel::Element(element) => {
                                             element(state, style)
                                         }
                                     })
-                                    .with_children(keystroke)
+                                    .with_child({
+                                        KeystrokeLabel::new(
+                                            window_id,
+                                            view_id,
+                                            action.boxed_clone(),
+                                            style.keystroke.container,
+                                            style.keystroke.text.clone(),
+                                        )
+                                        .flex_float()
+                                        .boxed()
+                                    })
                                     .contained()
                                     .with_style(style.container)
+                                    .boxed()
                             })
                             .with_cursor_style(CursorStyle::PointingHand)
-                            .on_up(MouseButton::Left, |_, _, _| {}) // Capture these events
-                            .on_down(MouseButton::Left, |_, _, _| {}) // Capture these events
-                            .on_click(MouseButton::Left, move |_, menu, cx| {
-                                menu.cancel(&Default::default(), cx);
+                            .on_up(MouseButton::Left, |_, _| {}) // Capture these events
+                            .on_down(MouseButton::Left, |_, _| {}) // Capture these events
+                            .on_click(MouseButton::Left, move |_, cx| {
+                                cx.dispatch_action(Clicked);
                                 let window_id = cx.window_id();
-                                match &action {
-                                    ContextMenuItemAction::Action(action) => {
-                                        let action = action.boxed_clone();
-                                        cx.app_context()
-                                            .spawn(|mut cx| async move {
-                                                cx.dispatch_action(
-                                                    window_id,
-                                                    view_id,
-                                                    action.as_ref(),
-                                                )
-                                            })
-                                            .detach_and_log_err(cx);
-                                    }
-                                    ContextMenuItemAction::Handler(handler) => handler(cx),
-                                }
+                                cx.dispatch_any_action_at(window_id, view_id, action.boxed_clone());
                             })
-                            .on_drag(MouseButton::Left, |_, _, _| {})
-                            .into_any()
+                            .on_drag(MouseButton::Left, |_, _| {})
+                            .boxed()
                         }
 
                         ContextMenuItem::Static(f) => f(cx),
@@ -475,17 +484,14 @@ impl ContextMenu {
                             .with_height(1.)
                             .contained()
                             .with_style(style.separator)
-                            .into_any(),
+                            .boxed(),
                     }
                 }))
                 .contained()
                 .with_style(style.container)
+                .boxed()
         })
-        .on_down_out(MouseButton::Left, |_, this, cx| {
-            this.cancel(&Default::default(), cx);
-        })
-        .on_down_out(MouseButton::Right, |_, this, cx| {
-            this.cancel(&Default::default(), cx);
-        })
+        .on_down_out(MouseButton::Left, |_, cx| cx.dispatch_action(Cancel))
+        .on_down_out(MouseButton::Right, |_, cx| cx.dispatch_action(Cancel))
     }
 }

crates/copilot/Cargo.toml

@@ -30,20 +30,18 @@ node_runtime = { path = "../node_runtime"}
 util = { path = "../util" }
 async-compression = { version = "0.3", features = ["gzip", "futures-bufread"] }
 async-tar = "0.4.2"
-anyhow.workspace = true
-log.workspace = true
-serde.workspace = true
-serde_derive.workspace = true
-smol.workspace = true
-futures.workspace = true
+anyhow = "1.0"
+log = "0.4"
+serde = { workspace = true }
+serde_derive = { workspace = true }
+smol = "1.2.5"
+futures = "0.3"
 
 [dev-dependencies]
-clock = { path = "../clock" }
 collections = { path = "../collections", features = ["test-support"] }
-fs = { path = "../fs", features = ["test-support"] }
 gpui = { path = "../gpui", features = ["test-support"] }
 language = { path = "../language", features = ["test-support"] }
-lsp = { path = "../lsp", features = ["test-support"] }
-rpc = { path = "../rpc", features = ["test-support"] }
 settings = { path = "../settings", features = ["test-support"] }
+lsp = { path = "../lsp", features = ["test-support"] }
 util = { path = "../util", features = ["test-support"] }
+workspace = { path = "../workspace", features = ["test-support"] }

crates/copilot/src/request.rs

@@ -99,11 +99,14 @@ pub struct GetCompletionsParams {
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct GetCompletionsDocument {
+    pub source: String,
     pub tab_size: u32,
     pub indent_size: u32,
     pub insert_spaces: bool,
     pub uri: lsp::Url,
+    pub path: String,
     pub relative_path: String,
+    pub language_id: String,
     pub position: lsp::Position,
     pub version: usize,
 }
@@ -143,8 +146,8 @@ pub enum LogMessage {}
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct LogMessageParams {
-    pub level: u8,
     pub message: String,
+    pub level: u8,
     pub metadata_str: String,
     pub extra: Vec<String>,
 }
@@ -166,60 +169,3 @@ impl lsp::notification::Notification for StatusNotification {
     type Params = StatusNotificationParams;
     const METHOD: &'static str = "statusNotification";
 }
-
-pub enum SetEditorInfo {}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct SetEditorInfoParams {
-    pub editor_info: EditorInfo,
-    pub editor_plugin_info: EditorPluginInfo,
-}
-
-impl lsp::request::Request for SetEditorInfo {
-    type Params = SetEditorInfoParams;
-    type Result = String;
-    const METHOD: &'static str = "setEditorInfo";
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct EditorInfo {
-    pub name: String,
-    pub version: String,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct EditorPluginInfo {
-    pub name: String,
-    pub version: String,
-}
-
-pub enum NotifyAccepted {}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct NotifyAcceptedParams {
-    pub uuid: String,
-}
-
-impl lsp::request::Request for NotifyAccepted {
-    type Params = NotifyAcceptedParams;
-    type Result = String;
-    const METHOD: &'static str = "notifyAccepted";
-}
-
-pub enum NotifyRejected {}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct NotifyRejectedParams {
-    pub uuids: Vec<String>,
-}
-
-impl lsp::request::Request for NotifyRejected {
-    type Params = NotifyRejectedParams;
-    type Result = String;
-    const METHOD: &'static str = "notifyRejected";
-}

crates/copilot/src/sign_in.rs

@@ -3,9 +3,9 @@ use gpui::{
     elements::*,
     geometry::rect::RectF,
     platform::{WindowBounds, WindowKind, WindowOptions},
-    AnyElement, AnyViewHandle, AppContext, ClipboardItem, Element, Entity, View, ViewContext,
-    ViewHandle,
+    AppContext, ClipboardItem, Element, Entity, View, ViewContext, ViewHandle,
 };
+use settings::Settings;
 use theme::ui::modal;
 
 #[derive(PartialEq, Eq, Debug, Clone)]
@@ -17,63 +17,58 @@ struct OpenGithub;
 const COPILOT_SIGN_UP_URL: &'static str = "https://github.com/features/copilot";
 
 pub fn init(cx: &mut AppContext) {
-    if let Some(copilot) = Copilot::global(cx) {
-        let mut code_verification: Option<ViewHandle<CopilotCodeVerification>> = None;
-        cx.observe(&copilot, move |copilot, cx| {
-            let status = copilot.read(cx).status();
+    let copilot = Copilot::global(cx).unwrap();
 
-            match &status {
-                crate::Status::SigningIn { prompt } => {
-                    if let Some(code_verification_handle) = code_verification.as_mut() {
-                        let window_id = code_verification_handle.window_id();
-                        let updated = cx.update_window(window_id, |cx| {
-                            code_verification_handle.update(cx, |code_verification, cx| {
-                                code_verification.set_status(status.clone(), cx)
-                            });
-                            cx.activate_window();
-                        });
-                        if updated.is_none() {
-                            code_verification = Some(create_copilot_auth_window(cx, &status));
-                        }
-                    } else if let Some(_prompt) = prompt {
-                        code_verification = Some(create_copilot_auth_window(cx, &status));
-                    }
-                }
-                Status::Authorized | Status::Unauthorized => {
-                    if let Some(code_verification) = code_verification.as_ref() {
-                        let window_id = code_verification.window_id();
-                        cx.update_window(window_id, |cx| {
-                            code_verification.update(cx, |code_verification, cx| {
-                                code_verification.set_status(status, cx)
-                            });
+    let mut code_verification: Option<ViewHandle<CopilotCodeVerification>> = None;
+    cx.observe(&copilot, move |copilot, cx| {
+        let status = copilot.read(cx).status();
 
-                            cx.platform().activate(true);
-                            cx.activate_window();
+        match &status {
+            crate::Status::SigningIn { prompt } => {
+                if let Some(code_verification_handle) = code_verification.as_mut() {
+                    if cx.has_window(code_verification_handle.window_id()) {
+                        code_verification_handle.update(cx, |code_verification_view, cx| {
+                            code_verification_view.set_status(status, cx)
                         });
+                        cx.activate_window(code_verification_handle.window_id());
+                    } else {
+                        create_copilot_auth_window(cx, &status, &mut code_verification);
                     }
-                }
-                _ => {
-                    if let Some(code_verification) = code_verification.take() {
-                        cx.update_window(code_verification.window_id(), |cx| cx.remove_window());
-                    }
+                } else if let Some(_prompt) = prompt {
+                    create_copilot_auth_window(cx, &status, &mut code_verification);
                 }
             }
-        })
-        .detach();
-    }
+            Status::Authorized | Status::Unauthorized => {
+                if let Some(code_verification) = code_verification.as_ref() {
+                    code_verification.update(cx, |code_verification, cx| {
+                        code_verification.set_status(status, cx)
+                    });
+
+                    cx.platform().activate(true);
+                    cx.activate_window(code_verification.window_id());
+                }
+            }
+            _ => {
+                if let Some(code_verification) = code_verification.take() {
+                    cx.remove_window(code_verification.window_id());
+                }
+            }
+        }
+    })
+    .detach();
 }
 
 fn create_copilot_auth_window(
     cx: &mut AppContext,
     status: &Status,
-) -> ViewHandle<CopilotCodeVerification> {
-    let window_size = theme::current(cx).copilot.modal.dimensions();
+    code_verification: &mut Option<ViewHandle<CopilotCodeVerification>>,
+) {
+    let window_size = cx.global::<Settings>().theme.copilot.modal.dimensions();
     let window_options = WindowOptions {
         bounds: WindowBounds::Fixed(RectF::new(Default::default(), window_size)),
         titlebar: None,
         center: true,
         focus: true,
-        show: true,
         kind: WindowKind::Normal,
         is_movable: true,
         screen: None,
@@ -81,20 +76,16 @@ fn create_copilot_auth_window(
     let (_, view) = cx.add_window(window_options, |_cx| {
         CopilotCodeVerification::new(status.clone())
     });
-    view
+    *code_verification = Some(view);
 }
 
 pub struct CopilotCodeVerification {
     status: Status,
-    connect_clicked: bool,
 }
 
 impl CopilotCodeVerification {
     pub fn new(status: Status) -> Self {
-        Self {
-            status,
-            connect_clicked: false,
-        }
+        Self { status }
     }
 
     pub fn set_status(&mut self, status: Status, cx: &mut ViewContext<Self>) {
@@ -105,8 +96,8 @@ impl CopilotCodeVerification {
     fn render_device_code(
         data: &PromptUserDeviceFlow,
         style: &theme::Copilot,
-        cx: &mut ViewContext<Self>,
-    ) -> impl Element<Self> {
+        cx: &mut gpui::RenderContext<Self>,
+    ) -> ElementBox {
         let copied = cx
             .read_from_clipboard()
             .map(|item| item.text() == &data.user_code)
@@ -114,17 +105,16 @@ impl CopilotCodeVerification {
 
         let device_code_style = &style.auth.prompting.device_code;
 
-        MouseEventHandler::<Self, _>::new(0, cx, |state, _cx| {
+        MouseEventHandler::<Self>::new(0, cx, |state, _cx| {
             Flex::row()
-                .with_child(
+                .with_children([
                     Label::new(data.user_code.clone(), device_code_style.text.clone())
                         .aligned()
                         .contained()
                         .with_style(device_code_style.left_container)
                         .constrained()
-                        .with_width(device_code_style.left),
-                )
-                .with_child(
+                        .with_width(device_code_style.left)
+                        .boxed(),
                     Label::new(
                         if copied { "Copied!" } else { "Copy" },
                         device_code_style.cta.style_for(state, false).text.clone(),
@@ -133,188 +123,196 @@ impl CopilotCodeVerification {
                     .contained()
                     .with_style(*device_code_style.right_container.style_for(state, false))
                     .constrained()
-                    .with_width(device_code_style.right),
-                )
+                    .with_width(device_code_style.right)
+                    .boxed(),
+                ])
                 .contained()
                 .with_style(device_code_style.cta.style_for(state, false).container)
+                .boxed()
         })
         .on_click(gpui::platform::MouseButton::Left, {
             let user_code = data.user_code.clone();
-            move |_, _, cx| {
+            move |_, cx| {
                 cx.platform()
                     .write_to_clipboard(ClipboardItem::new(user_code.clone()));
                 cx.notify();
             }
         })
         .with_cursor_style(gpui::platform::CursorStyle::PointingHand)
+        .boxed()
     }
 
     fn render_prompting_modal(
-        connect_clicked: bool,
         data: &PromptUserDeviceFlow,
         style: &theme::Copilot,
-        cx: &mut ViewContext<Self>,
-    ) -> AnyElement<Self> {
-        enum ConnectButton {}
-
+        cx: &mut gpui::RenderContext<Self>,
+    ) -> ElementBox {
         Flex::column()
-            .with_child(
+            .with_children([
                 Flex::column()
                     .with_children([
                         Label::new(
                             "Enable Copilot by connecting",
                             style.auth.prompting.subheading.text.clone(),
                         )
-                        .aligned(),
+                        .aligned()
+                        .boxed(),
                         Label::new(
                             "your existing license.",
                             style.auth.prompting.subheading.text.clone(),
                         )
-                        .aligned(),
+                        .aligned()
+                        .boxed(),
                     ])
                     .align_children_center()
                     .contained()
-                    .with_style(style.auth.prompting.subheading.container),
-            )
-            .with_child(Self::render_device_code(data, &style, cx))
-            .with_child(
+                    .with_style(style.auth.prompting.subheading.container)
+                    .boxed(),
+                Self::render_device_code(data, &style, cx),
                 Flex::column()
                     .with_children([
                         Label::new(
                             "Paste this code into GitHub after",
                             style.auth.prompting.hint.text.clone(),
                         )
-                        .aligned(),
+                        .aligned()
+                        .boxed(),
                         Label::new(
                             "clicking the button below.",
                             style.auth.prompting.hint.text.clone(),
                         )
-                        .aligned(),
+                        .aligned()
+                        .boxed(),
                     ])
                     .align_children_center()
                     .contained()
-                    .with_style(style.auth.prompting.hint.container.clone()),
-            )
-            .with_child(theme::ui::cta_button::<ConnectButton, _, _, _>(
-                if connect_clicked {
-                    "Waiting for connection..."
-                } else {
-                    "Connect to GitHub"
-                },
-                style.auth.content_width,
-                &style.auth.cta_button,
-                cx,
-                {
-                    let verification_uri = data.verification_uri.clone();
-                    move |_, verification, cx| {
-                        cx.platform().open_url(&verification_uri);
-                        verification.connect_clicked = true;
-                    }
-                },
-            ))
+                    .with_style(style.auth.prompting.hint.container.clone())
+                    .boxed(),
+                theme::ui::cta_button_with_click(
+                    "Connect to GitHub",
+                    style.auth.content_width,
+                    &style.auth.cta_button,
+                    cx,
+                    {
+                        let verification_uri = data.verification_uri.clone();
+                        move |_, cx| cx.platform().open_url(&verification_uri)
+                    },
+                )
+                .boxed(),
+            ])
             .align_children_center()
-            .into_any()
+            .boxed()
     }
-
     fn render_enabled_modal(
         style: &theme::Copilot,
-        cx: &mut ViewContext<Self>,
-    ) -> AnyElement<Self> {
-        enum DoneButton {}
-
+        cx: &mut gpui::RenderContext<Self>,
+    ) -> ElementBox {
         let enabled_style = &style.auth.authorized;
         Flex::column()
-            .with_child(
+            .with_children([
                 Label::new("Copilot Enabled!", enabled_style.subheading.text.clone())
                     .contained()
                     .with_style(enabled_style.subheading.container)
-                    .aligned(),
-            )
-            .with_child(
+                    .aligned()
+                    .boxed(),
                 Flex::column()
                     .with_children([
                         Label::new(
                             "You can update your settings or",
                             enabled_style.hint.text.clone(),
                         )
-                        .aligned(),
+                        .aligned()
+                        .boxed(),
                         Label::new(
                             "sign out from the Copilot menu in",
                             enabled_style.hint.text.clone(),
                         )
-                        .aligned(),
-                        Label::new("the status bar.", enabled_style.hint.text.clone()).aligned(),
+                        .aligned()
+                        .boxed(),
+                        Label::new("the status bar.", enabled_style.hint.text.clone())
+                            .aligned()
+                            .boxed(),
                     ])
                     .align_children_center()
                     .contained()
-                    .with_style(enabled_style.hint.container),
-            )
-            .with_child(theme::ui::cta_button::<DoneButton, _, _, _>(
-                "Done",
-                style.auth.content_width,
-                &style.auth.cta_button,
-                cx,
-                |_, _, cx| cx.remove_window(),
-            ))
+                    .with_style(enabled_style.hint.container)
+                    .boxed(),
+                theme::ui::cta_button_with_click(
+                    "Done",
+                    style.auth.content_width,
+                    &style.auth.cta_button,
+                    cx,
+                    |_, cx| {
+                        let window_id = cx.window_id();
+                        cx.remove_window(window_id)
+                    },
+                )
+                .boxed(),
+            ])
             .align_children_center()
-            .into_any()
+            .boxed()
     }
-
     fn render_unauthorized_modal(
         style: &theme::Copilot,
-        cx: &mut ViewContext<Self>,
-    ) -> AnyElement<Self> {
+        cx: &mut gpui::RenderContext<Self>,
+    ) -> ElementBox {
         let unauthorized_style = &style.auth.not_authorized;
 
         Flex::column()
-            .with_child(
+            .with_children([
                 Flex::column()
                     .with_children([
                         Label::new(
                             "Enable Copilot by connecting",
                             unauthorized_style.subheading.text.clone(),
                         )
-                        .aligned(),
+                        .aligned()
+                        .boxed(),
                         Label::new(
                             "your existing license.",
                             unauthorized_style.subheading.text.clone(),
                         )
-                        .aligned(),
+                        .aligned()
+                        .boxed(),
                     ])
                     .align_children_center()
                     .contained()
-                    .with_style(unauthorized_style.subheading.container),
-            )
-            .with_child(
+                    .with_style(unauthorized_style.subheading.container)
+                    .boxed(),
                 Flex::column()
                     .with_children([
                         Label::new(
                             "You must have an active copilot",
                             unauthorized_style.warning.text.clone(),
                         )
-                        .aligned(),
+                        .aligned()
+                        .boxed(),
                         Label::new(
                             "license to use it in Zed.",
                             unauthorized_style.warning.text.clone(),
                         )
-                        .aligned(),
+                        .aligned()
+                        .boxed(),
                     ])
                     .align_children_center()
                     .contained()
-                    .with_style(unauthorized_style.warning.container),
-            )
-            .with_child(theme::ui::cta_button::<Self, _, _, _>(
-                "Subscribe on GitHub",
-                style.auth.content_width,
-                &style.auth.cta_button,
-                cx,
-                |_, _, cx| {
-                    cx.remove_window();
-                    cx.platform().open_url(COPILOT_SIGN_UP_URL)
-                },
-            ))
+                    .with_style(unauthorized_style.warning.container)
+                    .boxed(),
+                theme::ui::cta_button_with_click(
+                    "Subscribe on GitHub",
+                    style.auth.content_width,
+                    &style.auth.cta_button,
+                    cx,
+                    |_, cx| {
+                        let window_id = cx.window_id();
+                        cx.remove_window(window_id);
+                        cx.platform().open_url(COPILOT_SIGN_UP_URL)
+                    },
+                )
+                .boxed(),
+            ])
             .align_children_center()
-            .into_any()
+            .boxed()
     }
 }
 
@@ -327,50 +325,32 @@ impl View for CopilotCodeVerification {
         "CopilotCodeVerification"
     }
 
-    fn focus_in(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_in(&mut self, _: gpui::AnyViewHandle, cx: &mut gpui::ViewContext<Self>) {
         cx.notify()
     }
 
-    fn focus_out(&mut self, _: AnyViewHandle, cx: &mut ViewContext<Self>) {
+    fn focus_out(&mut self, _: gpui::AnyViewHandle, cx: &mut gpui::ViewContext<Self>) {
         cx.notify()
     }
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
-        enum ConnectModal {}
+    fn render(&mut self, cx: &mut gpui::RenderContext<'_, Self>) -> gpui::ElementBox {
+        let style = cx.global::<Settings>().theme.clone();
 
-        let style = theme::current(cx).clone();
-
-        modal::<ConnectModal, _, _, _, _>(
-            "Connect Copilot to Zed",
-            &style.copilot.modal,
-            cx,
-            |cx| {
-                Flex::column()
-                    .with_children([
-                        theme::ui::icon(&style.copilot.auth.header).into_any(),
-                        match &self.status {
-                            Status::SigningIn {
-                                prompt: Some(prompt),
-                            } => Self::render_prompting_modal(
-                                self.connect_clicked,
-                                &prompt,
-                                &style.copilot,
-                                cx,
-                            ),
-                            Status::Unauthorized => {
-                                self.connect_clicked = false;
-                                Self::render_unauthorized_modal(&style.copilot, cx)
-                            }
-                            Status::Authorized => {
-                                self.connect_clicked = false;
-                                Self::render_enabled_modal(&style.copilot, cx)
-                            }
-                            _ => Empty::new().into_any(),
-                        },
-                    ])
-                    .align_children_center()
-            },
-        )
-        .into_any()
+        modal("Connect Copilot to Zed", &style.copilot.modal, cx, |cx| {
+            Flex::column()
+                .with_children([
+                    theme::ui::icon(&style.copilot.auth.header).boxed(),
+                    match &self.status {
+                        Status::SigningIn {
+                            prompt: Some(prompt),
+                        } => Self::render_prompting_modal(&prompt, &style.copilot, cx),
+                        Status::Unauthorized => Self::render_unauthorized_modal(&style.copilot, cx),
+                        Status::Authorized => Self::render_enabled_modal(&style.copilot, cx),
+                        _ => Empty::new().boxed(),
+                    },
+                ])
+                .align_children_center()
+                .boxed()
+        })
     }
 }

crates/copilot_button/Cargo.toml

@@ -9,20 +9,14 @@ path = "src/copilot_button.rs"
 doctest = false
 
 [dependencies]
-assets = { path = "../assets" }
 copilot = { path = "../copilot" }
 editor = { path = "../editor" }
-fs = { path = "../fs" }
 context_menu = { path = "../context_menu" }
 gpui = { path = "../gpui" }
-language = { path = "../language" }
 settings = { path = "../settings" }
 theme = { path = "../theme" }
 util = { path = "../util" }
 workspace = { path = "../workspace" }
-anyhow.workspace = true
-smol.workspace = true
-futures.workspace = true
-
-[dev-dependencies]
-editor = { path = "../editor", features = ["test-support"] }
+anyhow = "1.0"
+smol = "1.2.5"
+futures = "0.3"

crates/copilot_button/src/copilot_button.rs

@@ -1,34 +1,85 @@
-use anyhow::Result;
+use std::sync::Arc;
+
 use context_menu::{ContextMenu, ContextMenuItem};
-use copilot::{Copilot, SignOut, Status};
-use editor::{scroll::autoscroll::Autoscroll, Editor};
-use fs::Fs;
+use editor::Editor;
 use gpui::{
     elements::*,
+    impl_internal_actions,
     platform::{CursorStyle, MouseButton},
-    AnyElement, AppContext, AsyncAppContext, Element, Entity, MouseState, Subscription, View,
-    ViewContext, ViewHandle, WeakViewHandle, WindowContext,
+    AppContext, Element, ElementBox, Entity, MouseState, RenderContext, Subscription, View,
+    ViewContext, ViewHandle,
 };
-use language::language_settings::{self, all_language_settings, AllLanguageSettings};
-use settings::{update_settings_file, SettingsStore};
-use std::{path::Path, sync::Arc};
-use util::{paths, ResultExt};
+use settings::{settings_file::SettingsFile, Settings};
 use workspace::{
-    create_and_open_local_file, item::ItemHandle,
-    notifications::simple_message_notification::OsOpen, StatusItemView, Toast, Workspace,
+    item::ItemHandle, notifications::simple_message_notification::OsOpen, DismissToast,
+    StatusItemView,
 };
 
+use copilot::{Copilot, Reinstall, SignIn, SignOut, Status};
+
 const COPILOT_SETTINGS_URL: &str = "https://github.com/settings/copilot";
 const COPILOT_STARTING_TOAST_ID: usize = 1337;
 const COPILOT_ERROR_TOAST_ID: usize = 1338;
 
+#[derive(Clone, PartialEq)]
+pub struct DeployCopilotMenu;
+
+#[derive(Clone, PartialEq)]
+pub struct ToggleCopilotForLanguage {
+    language: Arc<str>,
+}
+
+#[derive(Clone, PartialEq)]
+pub struct ToggleCopilotGlobally;
+
+// TODO: Make the other code path use `get_or_insert` logic for this modal
+#[derive(Clone, PartialEq)]
+pub struct DeployCopilotModal;
+
+impl_internal_actions!(
+    copilot,
+    [
+        DeployCopilotMenu,
+        DeployCopilotModal,
+        ToggleCopilotForLanguage,
+        ToggleCopilotGlobally,
+    ]
+);
+
+pub fn init(cx: &mut AppContext) {
+    cx.add_action(CopilotButton::deploy_copilot_menu);
+    cx.add_action(
+        |_: &mut CopilotButton, action: &ToggleCopilotForLanguage, cx| {
+            let language = action.language.to_owned();
+
+            let current_langauge = cx.global::<Settings>().copilot_on(Some(&language));
+
+            SettingsFile::update(cx, move |file_contents| {
+                file_contents.languages.insert(
+                    language.to_owned(),
+                    settings::EditorSettings {
+                        copilot: Some((!current_langauge).into()),
+                        ..Default::default()
+                    },
+                );
+            })
+        },
+    );
+
+    cx.add_action(|_: &mut CopilotButton, _: &ToggleCopilotGlobally, cx| {
+        let copilot_on = cx.global::<Settings>().copilot_on(None);
+
+        SettingsFile::update(cx, move |file_contents| {
+            file_contents.editor.copilot = Some((!copilot_on).into())
+        })
+    });
+}
+
 pub struct CopilotButton {
     popup_menu: ViewHandle<ContextMenu>,
     editor_subscription: Option<(Subscription, usize)>,
     editor_enabled: Option<bool>,
     language: Option<Arc<str>>,
-    path: Option<Arc<Path>>,
-    fs: Arc<dyn Fs>,
 }
 
 impl Entity for CopilotButton {
@@ -40,34 +91,35 @@ impl View for CopilotButton {
         "CopilotButton"
     }
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
-        let all_language_settings = &all_language_settings(cx);
-        if !all_language_settings.copilot.feature_enabled {
-            return Empty::new().into_any();
+    fn render(&mut self, cx: &mut RenderContext<'_, Self>) -> ElementBox {
+        let settings = cx.global::<Settings>();
+
+        if !settings.enable_copilot_integration {
+            return Empty::new().boxed();
         }
 
-        let theme = theme::current(cx).clone();
+        let theme = settings.theme.clone();
         let active = self.popup_menu.read(cx).visible();
         let Some(copilot) = Copilot::global(cx) else {
-            return Empty::new().into_any();
+            return Empty::new().boxed();
         };
         let status = copilot.read(cx).status();
 
-        let enabled = self
-            .editor_enabled
-            .unwrap_or_else(|| all_language_settings.copilot_enabled(None, None));
+        let enabled = self.editor_enabled.unwrap_or(settings.copilot_on(None));
+
+        let view_id = cx.view_id();
 
         Stack::new()
             .with_child(
-                MouseEventHandler::<Self, _>::new(0, cx, {
+                MouseEventHandler::<Self>::new(0, cx, {
                     let theme = theme.clone();
                     let status = status.clone();
                     move |state, _cx| {
                         let style = theme
                             .workspace
                             .status_bar
-                            .panel_buttons
-                            .button
+                            .sidebar_buttons
+                            .item
                             .style_for(state, active);
 
                         Flex::row()
@@ -89,66 +141,88 @@ impl View for CopilotButton {
                                 .constrained()
                                 .with_width(style.icon_size)
                                 .aligned()
-                                .into_any_named("copilot-icon"),
+                                .named("copilot-icon"),
                             )
                             .constrained()
                             .with_height(style.icon_size)
                             .contained()
                             .with_style(style.container)
+                            .boxed()
                     }
                 })
                 .with_cursor_style(CursorStyle::PointingHand)
                 .on_click(MouseButton::Left, {
                     let status = status.clone();
-                    move |_, this, cx| match status {
-                        Status::Authorized => this.deploy_copilot_menu(cx),
-                        Status::Error(ref e) => {
-                            if let Some(workspace) = cx.root_view().clone().downcast::<Workspace>()
-                            {
-                                workspace.update(cx, |workspace, cx| {
-                                    workspace.show_toast(
-                                        Toast::new(
-                                            COPILOT_ERROR_TOAST_ID,
-                                            format!("Copilot can't be started: {}", e),
-                                        )
-                                        .on_click(
-                                            "Reinstall Copilot",
-                                            |cx| {
-                                                if let Some(copilot) = Copilot::global(cx) {
-                                                    copilot
-                                                        .update(cx, |copilot, cx| {
-                                                            copilot.reinstall(cx)
-                                                        })
-                                                        .detach();
-                                                }
-                                            },
-                                        ),
-                                        cx,
-                                    );
-                                });
-                            }
+                    move |_, cx| match status {
+                        Status::Authorized => cx.dispatch_action(DeployCopilotMenu),
+                        Status::Starting { ref task } => {
+                            cx.dispatch_action(workspace::Toast::new(
+                                COPILOT_STARTING_TOAST_ID,
+                                "Copilot is starting...",
+                            ));
+                            let window_id = cx.window_id();
+                            let task = task.to_owned();
+                            cx.spawn(|mut cx| async move {
+                                task.await;
+                                cx.update(|cx| {
+                                    if let Some(copilot) = Copilot::global(cx) {
+                                        let status = copilot.read(cx).status();
+                                        match status {
+                                            Status::Authorized => cx.dispatch_action_at(
+                                                window_id,
+                                                view_id,
+                                                workspace::Toast::new(
+                                                    COPILOT_STARTING_TOAST_ID,
+                                                    "Copilot has started!",
+                                                ),
+                                            ),
+                                            _ => {
+                                                cx.dispatch_action_at(
+                                                    window_id,
+                                                    view_id,
+                                                    DismissToast::new(COPILOT_STARTING_TOAST_ID),
+                                                );
+                                                cx.dispatch_global_action(SignIn)
+                                            }
+                                        }
+                                    }
+                                })
+                            })
+                            .detach();
                         }
-                        _ => this.deploy_copilot_start_menu(cx),
+                        Status::Error(ref e) => cx.dispatch_action(workspace::Toast::new_action(
+                            COPILOT_ERROR_TOAST_ID,
+                            format!("Copilot can't be started: {}", e),
+                            "Reinstall Copilot",
+                            Reinstall,
+                        )),
+                        _ => cx.dispatch_action(SignIn),
                     }
                 })
-                .with_tooltip::<Self>(
+                .with_tooltip::<Self, _>(
                     0,
                     "GitHub Copilot".into(),
                     None,
                     theme.tooltip.clone(),
                     cx,
-                ),
+                )
+                .boxed(),
             )
-            .with_child(ChildView::new(&self.popup_menu, cx).aligned().top().right())
-            .into_any()
+            .with_child(
+                ChildView::new(&self.popup_menu, cx)
+                    .aligned()
+                    .top()
+                    .right()
+                    .boxed(),
+            )
+            .boxed()
     }
 }
 
 impl CopilotButton {
-    pub fn new(fs: Arc<dyn Fs>, cx: &mut ViewContext<Self>) -> Self {
-        let button_view_id = cx.view_id();
+    pub fn new(cx: &mut ViewContext<Self>) -> Self {
         let menu = cx.add_view(|cx| {
-            let mut menu = ContextMenu::new(button_view_id, cx);
+            let mut menu = ContextMenu::new(cx);
             menu.set_position_mode(OverlayPositionMode::Local);
             menu
         });
@@ -157,7 +231,7 @@ impl CopilotButton {
 
         Copilot::global(cx).map(|copilot| cx.observe(&copilot, |_, _, cx| cx.notify()).detach());
 
-        cx.observe_global::<SettingsStore, _>(move |_, cx| cx.notify())
+        cx.observe_global::<Settings, _>(move |_, cx| cx.notify())
             .detach();
 
         Self {
@@ -165,102 +239,62 @@ impl CopilotButton {
             editor_subscription: None,
             editor_enabled: None,
             language: None,
-            path: None,
-            fs,
         }
     }
 
-    pub fn deploy_copilot_start_menu(&mut self, cx: &mut ViewContext<Self>) {
-        let mut menu_options = Vec::with_capacity(2);
-        let fs = self.fs.clone();
+    pub fn deploy_copilot_menu(&mut self, _: &DeployCopilotMenu, cx: &mut ViewContext<Self>) {
+        let settings = cx.global::<Settings>();
 
-        menu_options.push(ContextMenuItem::handler("Sign In", |cx| {
-            initiate_sign_in(cx)
-        }));
-        menu_options.push(ContextMenuItem::handler("Disable Copilot", move |cx| {
-            hide_copilot(fs.clone(), cx)
-        }));
+        let mut menu_options = Vec::with_capacity(6);
 
-        self.popup_menu.update(cx, |menu, cx| {
-            menu.show(
-                Default::default(),
-                AnchorCorner::BottomRight,
-                menu_options,
-                cx,
-            );
-        });
-    }
+        if let Some(language) = &self.language {
+            let language_enabled = settings.copilot_on(Some(language.as_ref()));
 
-    pub fn deploy_copilot_menu(&mut self, cx: &mut ViewContext<Self>) {
-        let fs = self.fs.clone();
-        let mut menu_options = Vec::with_capacity(8);
-
-        if let Some(language) = self.language.clone() {
-            let fs = fs.clone();
-            let language_enabled =
-                language_settings::language_settings(Some(language.as_ref()), cx)
-                    .show_copilot_suggestions;
-            menu_options.push(ContextMenuItem::handler(
+            menu_options.push(ContextMenuItem::item(
                 format!(
-                    "{} Suggestions for {}",
-                    if language_enabled { "Hide" } else { "Show" },
+                    "{} Copilot for {}",
+                    if language_enabled {
+                        "Disable"
+                    } else {
+                        "Enable"
+                    },
                     language
                 ),
-                move |cx| toggle_copilot_for_language(language.clone(), fs.clone(), cx),
-            ));
-        }
-
-        let settings = settings::get::<AllLanguageSettings>(cx);
-
-        if let Some(path) = self.path.as_ref() {
-            let path_enabled = settings.copilot_enabled_for_path(path);
-            let path = path.clone();
-            menu_options.push(ContextMenuItem::handler(
-                format!(
-                    "{} Suggestions for This Path",
-                    if path_enabled { "Hide" } else { "Show" }
-                ),
-                move |cx| {
-                    if let Some(workspace) = cx.root_view().clone().downcast::<Workspace>() {
-                        let workspace = workspace.downgrade();
-                        cx.spawn(|_, cx| {
-                            configure_disabled_globs(
-                                workspace,
-                                path_enabled.then_some(path.clone()),
-                                cx,
-                            )
-                        })
-                        .detach_and_log_err(cx);
-                    }
+                ToggleCopilotForLanguage {
+                    language: language.to_owned(),
                 },
             ));
         }
 
-        let globally_enabled = settings.copilot_enabled(None, None);
-        menu_options.push(ContextMenuItem::handler(
+        let globally_enabled = cx.global::<Settings>().copilot_on(None);
+        menu_options.push(ContextMenuItem::item(
             if globally_enabled {
-                "Hide Suggestions for All Files"
+                "Disable Copilot Globally"
             } else {
-                "Show Suggestions for All Files"
+                "Enable Copilot Globally"
             },
-            move |cx| toggle_copilot_globally(fs.clone(), cx),
+            ToggleCopilotGlobally,
         ));
 
         menu_options.push(ContextMenuItem::Separator);
 
-        let icon_style = theme::current(cx).copilot.out_link_icon.clone();
-        menu_options.push(ContextMenuItem::action(
-            move |state: &mut MouseState, style: &theme::ContextMenuItem| {
-                Flex::row()
-                    .with_child(Label::new("Copilot Settings", style.label.clone()))
-                    .with_child(theme::ui::icon(icon_style.style_for(state, false)))
-                    .align_children_center()
-                    .into_any()
-            },
+        let icon_style = settings.theme.copilot.out_link_icon.clone();
+        menu_options.push(ContextMenuItem::element_item(
+            Box::new(
+                move |state: &mut MouseState, style: &theme::ContextMenuItem| {
+                    Flex::row()
+                        .with_children([
+                            Label::new("Copilot Settings", style.label.clone()).boxed(),
+                            theme::ui::icon(icon_style.style_for(state, false)).boxed(),
+                        ])
+                        .align_children_center()
+                        .boxed()
+                },
+            ),
             OsOpen::new(COPILOT_SETTINGS_URL),
         ));
 
-        menu_options.push(ContextMenuItem::action("Sign Out", SignOut));
+        menu_options.push(ContextMenuItem::item("Sign Out", SignOut));
 
         self.popup_menu.update(cx, |menu, cx| {
             menu.show(
@@ -274,19 +308,18 @@ impl CopilotButton {
 
     pub fn update_enabled(&mut self, editor: ViewHandle<Editor>, cx: &mut ViewContext<Self>) {
         let editor = editor.read(cx);
+
         let snapshot = editor.buffer().read(cx).snapshot(cx);
+        let settings = cx.global::<Settings>();
         let suggestion_anchor = editor.selections.newest_anchor().start;
+
         let language_name = snapshot
             .language_at(suggestion_anchor)
             .map(|language| language.name());
-        let path = snapshot.file_at(suggestion_anchor).map(|file| file.path());
 
-        self.editor_enabled = Some(
-            all_language_settings(cx)
-                .copilot_enabled(language_name.as_deref(), path.map(|p| p.as_ref())),
-        );
-        self.language = language_name;
-        self.path = path.cloned();
+        self.language = language_name.clone();
+
+        self.editor_enabled = Some(settings.copilot_on(language_name.as_deref()));
 
         cx.notify()
     }
@@ -306,129 +339,3 @@ impl StatusItemView for CopilotButton {
         cx.notify();
     }
 }
-
-async fn configure_disabled_globs(
-    workspace: WeakViewHandle<Workspace>,
-    path_to_disable: Option<Arc<Path>>,
-    mut cx: AsyncAppContext,
-) -> Result<()> {
-    let settings_editor = workspace
-        .update(&mut cx, |_, cx| {
-            create_and_open_local_file(&paths::SETTINGS, cx, || {
-                settings::initial_user_settings_content(&assets::Assets)
-                    .as_ref()
-                    .into()
-            })
-        })?
-        .await?
-        .downcast::<Editor>()
-        .unwrap();
-
-    settings_editor.downgrade().update(&mut cx, |item, cx| {
-        let text = item.buffer().read(cx).snapshot(cx).text();
-
-        let settings = cx.global::<SettingsStore>();
-        let edits = settings.edits_for_update::<AllLanguageSettings>(&text, |file| {
-            let copilot = file.copilot.get_or_insert_with(Default::default);
-            let globs = copilot.disabled_globs.get_or_insert_with(|| {
-                settings
-                    .get::<AllLanguageSettings>(None)
-                    .copilot
-                    .disabled_globs
-                    .iter()
-                    .map(|glob| glob.glob().to_string())
-                    .collect()
-            });
-
-            if let Some(path_to_disable) = &path_to_disable {
-                globs.push(path_to_disable.to_string_lossy().into_owned());
-            } else {
-                globs.clear();
-            }
-        });
-
-        if !edits.is_empty() {
-            item.change_selections(Some(Autoscroll::newest()), cx, |selections| {
-                selections.select_ranges(edits.iter().map(|e| e.0.clone()));
-            });
-
-            // When *enabling* a path, don't actually perform an edit, just select the range.
-            if path_to_disable.is_some() {
-                item.edit(edits.iter().cloned(), cx);
-            }
-        }
-    })?;
-
-    anyhow::Ok(())
-}
-
-fn toggle_copilot_globally(fs: Arc<dyn Fs>, cx: &mut AppContext) {
-    let show_copilot_suggestions = all_language_settings(cx).copilot_enabled(None, None);
-    update_settings_file::<AllLanguageSettings>(fs, cx, move |file| {
-        file.defaults.show_copilot_suggestions = Some((!show_copilot_suggestions).into())
-    });
-}
-
-fn toggle_copilot_for_language(language: Arc<str>, fs: Arc<dyn Fs>, cx: &mut AppContext) {
-    let show_copilot_suggestions = all_language_settings(cx).copilot_enabled(Some(&language), None);
-    update_settings_file::<AllLanguageSettings>(fs, cx, move |file| {
-        file.languages
-            .entry(language)
-            .or_default()
-            .show_copilot_suggestions = Some(!show_copilot_suggestions);
-    });
-}
-
-fn hide_copilot(fs: Arc<dyn Fs>, cx: &mut AppContext) {
-    update_settings_file::<AllLanguageSettings>(fs, cx, move |file| {
-        file.features.get_or_insert(Default::default()).copilot = Some(false);
-    });
-}
-
-fn initiate_sign_in(cx: &mut WindowContext) {
-    let Some(copilot) = Copilot::global(cx) else {
-        return;
-    };
-    let status = copilot.read(cx).status();
-
-    match status {
-        Status::Starting { task } => {
-            let Some(workspace) = cx.root_view().clone().downcast::<Workspace>() else {
-                return;
-            };
-
-            workspace.update(cx, |workspace, cx| {
-                workspace.show_toast(
-                    Toast::new(COPILOT_STARTING_TOAST_ID, "Copilot is starting..."),
-                    cx,
-                )
-            });
-            let workspace = workspace.downgrade();
-            cx.spawn(|mut cx| async move {
-                task.await;
-                if let Some(copilot) = cx.read(Copilot::global) {
-                    workspace
-                        .update(&mut cx, |workspace, cx| match copilot.read(cx).status() {
-                            Status::Authorized => workspace.show_toast(
-                                Toast::new(COPILOT_STARTING_TOAST_ID, "Copilot has started!"),
-                                cx,
-                            ),
-                            _ => {
-                                workspace.dismiss_toast(COPILOT_STARTING_TOAST_ID, cx);
-                                copilot
-                                    .update(cx, |copilot, cx| copilot.sign_in(cx))
-                                    .detach_and_log_err(cx);
-                            }
-                        })
-                        .log_err();
-                }
-            })
-            .detach();
-        }
-        _ => {
-            copilot
-                .update(cx, |copilot, cx| copilot.sign_in(cx))
-                .detach_and_log_err(cx);
-        }
-    }
-}

crates/db/Cargo.toml

@@ -17,17 +17,17 @@ gpui = { path = "../gpui" }
 sqlez = { path = "../sqlez" }
 sqlez_macros = { path = "../sqlez_macros" }
 util = { path = "../util" }
-anyhow.workspace = true
-indoc.workspace = true
-async-trait.workspace = true
-lazy_static.workspace = true
-log.workspace = true
-parking_lot.workspace = true
-serde.workspace = true
-serde_derive.workspace = true
-smol.workspace = true
+anyhow = "1.0.57"
+indoc = "1.0.4"
+async-trait = "0.1"
+lazy_static = "1.4.0"
+log = { version = "0.4.16", features = ["kv_unstable_serde"] }
+parking_lot = "0.11.1"
+serde = { workspace = true }
+serde_derive = { workspace = true }
+smol = "1.2"
 
 [dev-dependencies]
 gpui = { path = "../gpui", features = ["test-support"] }
-env_logger.workspace = true
-tempdir.workspace = true
+env_logger = "0.9.1"
+tempdir = { version = "0.3.7" }

crates/diagnostics/Cargo.toml

@@ -9,29 +9,24 @@ path = "src/diagnostics.rs"
 doctest = false
 
 [dependencies]
+anyhow = "1.0"
+smallvec = { version = "1.6", features = ["union"] }
 collections = { path = "../collections" }
 editor = { path = "../editor" }
-gpui = { path = "../gpui" }
 language = { path = "../language" }
-lsp = { path = "../lsp" }
+gpui = { path = "../gpui" }
 project = { path = "../project" }
 settings = { path = "../settings" }
 theme = { path = "../theme" }
 util = { path = "../util" }
 workspace = { path = "../workspace" }
-
-anyhow.workspace = true
-smallvec.workspace = true
-postage.workspace = true
+postage = { workspace = true }
 
 [dev-dependencies]
+unindent = "0.1"
 client = { path = "../client", features = ["test-support"] }
 editor = { path = "../editor", features = ["test-support"] }
 language = { path = "../language", features = ["test-support"] }
-lsp = { path = "../lsp", features = ["test-support"] }
 gpui = { path = "../gpui", features = ["test-support"] }
 workspace = { path = "../workspace", features = ["test-support"] }
-theme = { path = "../theme", features = ["test-support"] }
-
-serde_json.workspace = true
-unindent.workspace = true
+serde_json = { workspace = true }

crates/diagnostics/src/diagnostics.rs

@@ -1,7 +1,7 @@
 pub mod items;
 
 use anyhow::Result;
-use collections::{BTreeSet, HashSet};
+use collections::{BTreeMap, HashSet};
 use editor::{
     diagnostic_block_renderer,
     display_map::{BlockDisposition, BlockId, BlockProperties, BlockStyle, RenderBlock},
@@ -10,34 +10,35 @@ use editor::{
     Editor, ExcerptId, ExcerptRange, MultiBuffer, ToOffset,
 };
 use gpui::{
-    actions, elements::*, fonts::TextStyle, serde_json, AnyViewHandle, AppContext, Entity,
-    ModelHandle, Task, View, ViewContext, ViewHandle, WeakViewHandle,
+    actions, elements::*, fonts::TextStyle, impl_internal_actions, serde_json, AnyViewHandle,
+    AppContext, Entity, ModelHandle, RenderContext, Task, View, ViewContext, ViewHandle,
+    WeakViewHandle,
 };
 use language::{
     Anchor, Bias, Buffer, Diagnostic, DiagnosticEntry, DiagnosticSeverity, Point, Selection,
     SelectionGoal,
 };
-use lsp::LanguageServerId;
 use project::{DiagnosticSummary, Project, ProjectPath};
 use serde_json::json;
+use settings::Settings;
 use smallvec::SmallVec;
 use std::{
     any::{Any, TypeId},
-    borrow::Cow,
     cmp::Ordering,
     ops::Range,
     path::PathBuf,
     sync::Arc,
 };
-use theme::ThemeSettings;
 use util::TryFutureExt;
 use workspace::{
-    item::{BreadcrumbText, Item, ItemEvent, ItemHandle},
-    ItemNavHistory, Pane, PaneBackdrop, ToolbarItemLocation, Workspace,
+    item::{Item, ItemEvent, ItemHandle},
+    ItemNavHistory, Pane, Workspace,
 };
 
 actions!(diagnostics, [Deploy]);
 
+impl_internal_actions!(diagnostics, [Jump]);
+
 const CONTEXT_LINE_COUNT: u32 = 1;
 
 pub fn init(cx: &mut AppContext) {
@@ -54,7 +55,7 @@ struct ProjectDiagnosticsEditor {
     summary: DiagnosticSummary,
     excerpts: ModelHandle<MultiBuffer>,
     path_states: Vec<PathState>,
-    paths_to_update: BTreeSet<(ProjectPath, LanguageServerId)>,
+    paths_to_update: BTreeMap<ProjectPath, usize>,
 }
 
 struct PathState {
@@ -70,7 +71,6 @@ struct Jump {
 }
 
 struct DiagnosticGroupState {
-    language_server_id: LanguageServerId,
     primary_diagnostic: DiagnosticEntry<language::Anchor>,
     primary_excerpt_ix: usize,
     excerpts: Vec<ExcerptId>,
@@ -87,20 +87,16 @@ impl View for ProjectDiagnosticsEditor {
         "ProjectDiagnosticsEditor"
     }
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
         if self.path_states.is_empty() {
-            let theme = &theme::current(cx).project_diagnostics;
-            PaneBackdrop::new(
-                cx.view_id(),
-                Label::new("No problems in workspace", theme.empty_message.clone())
-                    .aligned()
-                    .contained()
-                    .with_style(theme.container)
-                    .into_any(),
-            )
-            .into_any()
+            let theme = &cx.global::<Settings>().theme.project_diagnostics;
+            Label::new("No problems in workspace", theme.empty_message.clone())
+                .aligned()
+                .contained()
+                .with_style(theme.container)
+                .boxed()
         } else {
-            ChildView::new(&self.editor, cx).into_any()
+            ChildView::new(&self.editor, cx).boxed()
         }
     }
 
@@ -119,7 +115,7 @@ impl View for ProjectDiagnosticsEditor {
             }),
             "summary": self.summary,
             "paths_to_update": self.paths_to_update.iter().map(|(path, server_id)|
-                (path.path.to_string_lossy(), server_id.0)
+                (path.path.to_string_lossy(), server_id)
             ).collect::<Vec<_>>(),
             "paths_states": self.path_states.iter().map(|state|
                 json!({
@@ -152,7 +148,7 @@ impl ProjectDiagnosticsEditor {
                 path,
             } => {
                 this.paths_to_update
-                    .insert((path.clone(), *language_server_id));
+                    .insert(path.clone(), *language_server_id);
             }
             _ => {}
         })
@@ -165,18 +161,13 @@ impl ProjectDiagnosticsEditor {
             editor.set_vertical_scroll_margin(5, cx);
             editor
         });
-        cx.subscribe(&editor, |this, _, event, cx| {
-            cx.emit(event.clone());
-            if event == &editor::Event::Focused && this.path_states.is_empty() {
-                cx.focus_self()
-            }
-        })
-        .detach();
+        cx.subscribe(&editor, |_, _, event, cx| cx.emit(event.clone()))
+            .detach();
 
         let project = project_handle.read(cx);
         let paths_to_update = project
             .diagnostic_summaries(cx)
-            .map(|(path, server_id, _)| (path, server_id))
+            .map(|e| (e.0, e.1.language_server_id))
             .collect();
         let summary = project.diagnostic_summary(cx);
         let mut this = Self {
@@ -204,13 +195,9 @@ impl ProjectDiagnosticsEditor {
         }
     }
 
-    fn update_excerpts(
-        &mut self,
-        language_server_id: Option<LanguageServerId>,
-        cx: &mut ViewContext<Self>,
-    ) {
+    fn update_excerpts(&mut self, language_server_id: Option<usize>, cx: &mut ViewContext<Self>) {
         let mut paths = Vec::new();
-        self.paths_to_update.retain(|(path, server_id)| {
+        self.paths_to_update.retain(|path, server_id| {
             if language_server_id
                 .map_or(true, |language_server_id| language_server_id == *server_id)
             {
@@ -227,9 +214,7 @@ impl ProjectDiagnosticsEditor {
                     let buffer = project
                         .update(&mut cx, |project, cx| project.open_buffer(path.clone(), cx))
                         .await?;
-                    this.update(&mut cx, |this, cx| {
-                        this.populate_excerpts(path, language_server_id, buffer, cx)
-                    })?;
+                    this.update(&mut cx, |this, cx| this.populate_excerpts(path, buffer, cx))
                 }
                 Result::<_, anyhow::Error>::Ok(())
             }
@@ -241,7 +226,6 @@ impl ProjectDiagnosticsEditor {
     fn populate_excerpts(
         &mut self,
         path: ProjectPath,
-        language_server_id: Option<LanguageServerId>,
         buffer: ModelHandle<Buffer>,
         cx: &mut ViewContext<Self>,
     ) {
@@ -280,9 +264,9 @@ impl ProjectDiagnosticsEditor {
         let excerpts_snapshot = self.excerpts.update(cx, |excerpts, excerpts_cx| {
             let mut old_groups = path_state.diagnostic_groups.iter().enumerate().peekable();
             let mut new_groups = snapshot
-                .diagnostic_groups(language_server_id)
+                .diagnostic_groups()
                 .into_iter()
-                .filter(|(_, group)| {
+                .filter(|group| {
                     group.entries[group.primary_ix].diagnostic.severity
                         <= DiagnosticSeverity::WARNING
                 })
@@ -294,27 +278,12 @@ impl ProjectDiagnosticsEditor {
                 match (old_groups.peek(), new_groups.peek()) {
                     (None, None) => break,
                     (None, Some(_)) => to_insert = new_groups.next(),
-                    (Some((_, old_group)), None) => {
-                        if language_server_id.map_or(true, |id| id == old_group.language_server_id)
-                        {
-                            to_remove = old_groups.next();
-                        } else {
-                            to_keep = old_groups.next();
-                        }
-                    }
-                    (Some((_, old_group)), Some((_, new_group))) => {
+                    (Some(_), None) => to_remove = old_groups.next(),
+                    (Some((_, old_group)), Some(new_group)) => {
                         let old_primary = &old_group.primary_diagnostic;
                         let new_primary = &new_group.entries[new_group.primary_ix];
                         match compare_diagnostics(old_primary, new_primary, &snapshot) {
-                            Ordering::Less => {
-                                if language_server_id
-                                    .map_or(true, |id| id == old_group.language_server_id)
-                                {
-                                    to_remove = old_groups.next();
-                                } else {
-                                    to_keep = old_groups.next();
-                                }
-                            }
+                            Ordering::Less => to_remove = old_groups.next(),
                             Ordering::Equal => {
                                 to_keep = old_groups.next();
                                 new_groups.next();
@@ -324,9 +293,8 @@ impl ProjectDiagnosticsEditor {
                     }
                 }
 
-                if let Some((language_server_id, group)) = to_insert {
+                if let Some(group) = to_insert {
                     let mut group_state = DiagnosticGroupState {
-                        language_server_id,
                         primary_diagnostic: group.entries[group.primary_ix].clone(),
                         primary_excerpt_ix: 0,
                         excerpts: Default::default(),
@@ -537,16 +505,16 @@ impl ProjectDiagnosticsEditor {
 }
 
 impl Item for ProjectDiagnosticsEditor {
-    fn tab_content<T: View>(
+    fn tab_content(
         &self,
         _detail: Option<usize>,
         style: &theme::Tab,
         cx: &AppContext,
-    ) -> AnyElement<T> {
+    ) -> ElementBox {
         render_summary(
             &self.summary,
             &style.label.text,
-            &theme::current(cx).project_diagnostics,
+            &cx.global::<Settings>().theme.project_diagnostics,
         )
     }
 
@@ -558,20 +526,11 @@ impl Item for ProjectDiagnosticsEditor {
         false
     }
 
-    fn added_to_workspace(&mut self, workspace: &mut Workspace, cx: &mut ViewContext<Self>) {
-        self.editor
-            .update(cx, |editor, cx| editor.added_to_workspace(workspace, cx));
-    }
-
     fn navigate(&mut self, data: Box<dyn Any>, cx: &mut ViewContext<Self>) -> bool {
         self.editor
             .update(cx, |editor, cx| editor.navigate(data, cx))
     }
 
-    fn tab_tooltip_text(&self, _: &AppContext) -> Option<Cow<str>> {
-        Some("Project Diagnostics".into())
-    }
-
     fn is_dirty(&self, cx: &AppContext) -> bool {
         self.excerpts.read(cx).is_dirty(cx)
     }
@@ -666,14 +625,6 @@ impl Item for ProjectDiagnosticsEditor {
         Some("diagnostics")
     }
 
-    fn breadcrumbs(&self, theme: &theme::Theme, cx: &AppContext) -> Option<Vec<BreadcrumbText>> {
-        self.editor.breadcrumbs(theme, cx)
-    }
-
-    fn breadcrumb_location(&self) -> ToolbarItemLocation {
-        ToolbarItemLocation::PrimaryLeft { flex: None }
-    }
-
     fn deserialize(
         project: ModelHandle<Project>,
         workspace: WeakViewHandle<Workspace>,
@@ -686,12 +637,12 @@ impl Item for ProjectDiagnosticsEditor {
 }
 
 fn diagnostic_header_renderer(diagnostic: Diagnostic) -> RenderBlock {
-    let (message, highlights) = highlight_diagnostic_message(Vec::new(), &diagnostic.message);
+    let (message, highlights) = highlight_diagnostic_message(&diagnostic.message);
     Arc::new(move |cx| {
-        let settings = settings::get::<ThemeSettings>(cx);
+        let settings = cx.global::<Settings>();
         let theme = &settings.theme.editor;
         let style = theme.diagnostic_header.clone();
-        let font_size = (style.text_scale_factor * settings.buffer_font_size(cx)).round();
+        let font_size = (style.text_scale_factor * settings.buffer_font_size).round();
         let icon_width = cx.em_width * style.icon_width_factor;
         let icon = if diagnostic.severity == DiagnosticSeverity::ERROR {
             Svg::new("icons/circle_x_mark_12.svg")
@@ -707,17 +658,8 @@ fn diagnostic_header_renderer(diagnostic: Diagnostic) -> RenderBlock {
                     .with_width(icon_width)
                     .aligned()
                     .contained()
-                    .with_margin_right(cx.gutter_padding),
+                    .boxed(),
             )
-            .with_children(diagnostic.source.as_ref().map(|source| {
-                Label::new(
-                    format!("{source}: "),
-                    style.source.label.clone().with_font_size(font_size),
-                )
-                .contained()
-                .with_style(style.message.container)
-                .aligned()
-            }))
             .with_child(
                 Label::new(
                     message.clone(),
@@ -726,45 +668,47 @@ fn diagnostic_header_renderer(diagnostic: Diagnostic) -> RenderBlock {
                 .with_highlights(highlights.clone())
                 .contained()
                 .with_style(style.message.container)
-                .aligned(),
+                .with_margin_left(cx.gutter_padding)
+                .aligned()
+                .boxed(),
             )
             .with_children(diagnostic.code.clone().map(|code| {
                 Label::new(code, style.code.text.clone().with_font_size(font_size))
                     .contained()
                     .with_style(style.code.container)
                     .aligned()
+                    .boxed()
             }))
             .contained()
             .with_style(style.container)
             .with_padding_left(cx.gutter_padding)
             .with_padding_right(cx.gutter_padding)
             .expanded()
-            .into_any_named("diagnostic header")
+            .named("diagnostic header")
     })
 }
 
-pub(crate) fn render_summary<T: View>(
+pub(crate) fn render_summary(
     summary: &DiagnosticSummary,
     text_style: &TextStyle,
     theme: &theme::ProjectDiagnostics,
-) -> AnyElement<T> {
+) -> ElementBox {
     if summary.error_count == 0 && summary.warning_count == 0 {
-        Label::new("No problems", text_style.clone()).into_any()
+        Label::new("No problems", text_style.clone()).boxed()
     } else {
         let icon_width = theme.tab_icon_width;
         let icon_spacing = theme.tab_icon_spacing;
         let summary_spacing = theme.tab_summary_spacing;
         Flex::row()
-            .with_child(
+            .with_children([
                 Svg::new("icons/circle_x_mark_12.svg")
                     .with_color(text_style.color)
                     .constrained()
                     .with_width(icon_width)
                     .aligned()
                     .contained()
-                    .with_margin_right(icon_spacing),
-            )
-            .with_child(
+                    .with_margin_right(icon_spacing)
+                    .named("no-icon"),
                 Label::new(
                     summary.error_count.to_string(),
                     LabelStyle {
@@ -772,9 +716,8 @@ pub(crate) fn render_summary<T: View>(
                         highlight_text: None,
                     },
                 )
-                .aligned(),
-            )
-            .with_child(
+                .aligned()
+                .boxed(),
                 Svg::new("icons/triangle_exclamation_12.svg")
                     .with_color(text_style.color)
                     .constrained()
@@ -782,9 +725,8 @@ pub(crate) fn render_summary<T: View>(
                     .aligned()
                     .contained()
                     .with_margin_left(summary_spacing)
-                    .with_margin_right(icon_spacing),
-            )
-            .with_child(
+                    .with_margin_right(icon_spacing)
+                    .named("warn-icon"),
                 Label::new(
                     summary.warning_count.to_string(),
                     LabelStyle {
@@ -792,9 +734,10 @@ pub(crate) fn render_summary<T: View>(
                         highlight_text: None,
                     },
                 )
-                .aligned(),
-            )
-            .into_any()
+                .aligned()
+                .boxed(),
+            ])
+            .boxed()
     }
 }
 
@@ -823,53 +766,52 @@ mod tests {
         display_map::{BlockContext, TransformBlock},
         DisplayPoint,
     };
-    use gpui::{TestAppContext, WindowContext};
+    use gpui::TestAppContext;
     use language::{Diagnostic, DiagnosticEntry, DiagnosticSeverity, PointUtf16, Unclipped};
-    use project::FakeFs;
     use serde_json::json;
-    use settings::SettingsStore;
     use unindent::Unindent as _;
+    use workspace::AppState;
 
     #[gpui::test]
     async fn test_diagnostics(cx: &mut TestAppContext) {
-        init_test(cx);
+        let app_state = cx.update(AppState::test);
+        app_state
+            .fs
+            .as_fake()
+            .insert_tree(
+                "/test",
+                json!({
+                    "consts.rs": "
+                        const a: i32 = 'a';
+                        const b: i32 = c;
+                    "
+                    .unindent(),
 
-        let fs = FakeFs::new(cx.background());
-        fs.insert_tree(
-            "/test",
-            json!({
-                "consts.rs": "
-                    const a: i32 = 'a';
-                    const b: i32 = c;
-                "
-                .unindent(),
+                    "main.rs": "
+                        fn main() {
+                            let x = vec![];
+                            let y = vec![];
+                            a(x);
+                            b(y);
+                            // comment 1
+                            // comment 2
+                            c(y);
+                            d(x);
+                        }
+                    "
+                    .unindent(),
+                }),
+            )
+            .await;
 
-                "main.rs": "
-                    fn main() {
-                        let x = vec![];
-                        let y = vec![];
-                        a(x);
-                        b(y);
-                        // comment 1
-                        // comment 2
-                        c(y);
-                        d(x);
-                    }
-                "
-                .unindent(),
-            }),
-        )
-        .await;
-
-        let language_server_id = LanguageServerId(0);
-        let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await;
-        let (window_id, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
+        let project = Project::test(app_state.fs.clone(), ["/test".as_ref()], cx).await;
+        let (_, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
 
         // Create some diagnostics
         project.update(cx, |project, cx| {
             project
                 .update_diagnostic_entries(
-                    language_server_id,
+                    0,
                     PathBuf::from("/test/main.rs"),
                     None,
                     vec![
@@ -950,7 +892,7 @@ mod tests {
         });
 
         // Open the project diagnostics view while there are already diagnostics.
-        let view = cx.add_view(window_id, |cx| {
+        let view = cx.add_view(&workspace, |cx| {
             ProjectDiagnosticsEditor::new(project.clone(), workspace.downgrade(), cx)
         });
 
@@ -1018,10 +960,10 @@ mod tests {
 
         // Diagnostics are added for another earlier path.
         project.update(cx, |project, cx| {
-            project.disk_based_diagnostics_started(language_server_id, cx);
+            project.disk_based_diagnostics_started(0, cx);
             project
                 .update_diagnostic_entries(
-                    language_server_id,
+                    0,
                     PathBuf::from("/test/consts.rs"),
                     None,
                     vec![DiagnosticEntry {
@@ -1038,7 +980,7 @@ mod tests {
                     cx,
                 )
                 .unwrap();
-            project.disk_based_diagnostics_finished(language_server_id, cx);
+            project.disk_based_diagnostics_finished(0, cx);
         });
 
         view.next_notification(cx).await;
@@ -1118,10 +1060,10 @@ mod tests {
 
         // Diagnostics are added to the first path
         project.update(cx, |project, cx| {
-            project.disk_based_diagnostics_started(language_server_id, cx);
+            project.disk_based_diagnostics_started(0, cx);
             project
                 .update_diagnostic_entries(
-                    language_server_id,
+                    0,
                     PathBuf::from("/test/consts.rs"),
                     None,
                     vec![
@@ -1154,7 +1096,7 @@ mod tests {
                     cx,
                 )
                 .unwrap();
-            project.disk_based_diagnostics_finished(language_server_id, cx);
+            project.disk_based_diagnostics_finished(0, cx);
         });
 
         view.next_notification(cx).await;
@@ -1234,285 +1176,10 @@ mod tests {
         });
     }
 
-    #[gpui::test]
-    async fn test_diagnostics_multiple_servers(cx: &mut TestAppContext) {
-        init_test(cx);
-
-        let fs = FakeFs::new(cx.background());
-        fs.insert_tree(
-            "/test",
-            json!({
-                "main.js": "
-                    a();
-                    b();
-                    c();
-                    d();
-                    e();
-                ".unindent()
-            }),
-        )
-        .await;
-
-        let server_id_1 = LanguageServerId(100);
-        let server_id_2 = LanguageServerId(101);
-        let project = Project::test(fs.clone(), ["/test".as_ref()], cx).await;
-        let (window_id, workspace) = cx.add_window(|cx| Workspace::test_new(project.clone(), cx));
-
-        let view = cx.add_view(window_id, |cx| {
-            ProjectDiagnosticsEditor::new(project.clone(), workspace.downgrade(), cx)
-        });
-
-        // Two language servers start updating diagnostics
-        project.update(cx, |project, cx| {
-            project.disk_based_diagnostics_started(server_id_1, cx);
-            project.disk_based_diagnostics_started(server_id_2, cx);
-            project
-                .update_diagnostic_entries(
-                    server_id_1,
-                    PathBuf::from("/test/main.js"),
-                    None,
-                    vec![DiagnosticEntry {
-                        range: Unclipped(PointUtf16::new(0, 0))..Unclipped(PointUtf16::new(0, 1)),
-                        diagnostic: Diagnostic {
-                            message: "error 1".to_string(),
-                            severity: DiagnosticSeverity::WARNING,
-                            is_primary: true,
-                            is_disk_based: true,
-                            group_id: 1,
-                            ..Default::default()
-                        },
-                    }],
-                    cx,
-                )
-                .unwrap();
-            project
-                .update_diagnostic_entries(
-                    server_id_2,
-                    PathBuf::from("/test/main.js"),
-                    None,
-                    vec![DiagnosticEntry {
-                        range: Unclipped(PointUtf16::new(1, 0))..Unclipped(PointUtf16::new(1, 1)),
-                        diagnostic: Diagnostic {
-                            message: "warning 1".to_string(),
-                            severity: DiagnosticSeverity::ERROR,
-                            is_primary: true,
-                            is_disk_based: true,
-                            group_id: 2,
-                            ..Default::default()
-                        },
-                    }],
-                    cx,
-                )
-                .unwrap();
-        });
-
-        // The first language server finishes
-        project.update(cx, |project, cx| {
-            project.disk_based_diagnostics_finished(server_id_1, cx);
-        });
-
-        // Only the first language server's diagnostics are shown.
-        cx.foreground().run_until_parked();
-        view.update(cx, |view, cx| {
-            assert_eq!(
-                editor_blocks(&view.editor, cx),
-                [
-                    (0, "path header block".into()),
-                    (2, "diagnostic header".into()),
-                ]
-            );
-            assert_eq!(
-                view.editor.update(cx, |editor, cx| editor.display_text(cx)),
-                concat!(
-                    "\n", // filename
-                    "\n", // padding
-                    // diagnostic group 1
-                    "\n",     // primary message
-                    "\n",     // padding
-                    "a();\n", //
-                    "b();",
-                )
-            );
-        });
-
-        // The second language server finishes
-        project.update(cx, |project, cx| {
-            project.disk_based_diagnostics_finished(server_id_2, cx);
-        });
-
-        // Both language server's diagnostics are shown.
-        cx.foreground().run_until_parked();
-        view.update(cx, |view, cx| {
-            assert_eq!(
-                editor_blocks(&view.editor, cx),
-                [
-                    (0, "path header block".into()),
-                    (2, "diagnostic header".into()),
-                    (6, "collapsed context".into()),
-                    (7, "diagnostic header".into()),
-                ]
-            );
-            assert_eq!(
-                view.editor.update(cx, |editor, cx| editor.display_text(cx)),
-                concat!(
-                    "\n", // filename
-                    "\n", // padding
-                    // diagnostic group 1
-                    "\n",     // primary message
-                    "\n",     // padding
-                    "a();\n", // location
-                    "b();\n", //
-                    "\n",     // collapsed context
-                    // diagnostic group 2
-                    "\n",     // primary message
-                    "\n",     // padding
-                    "a();\n", // context
-                    "b();\n", //
-                    "c();",   // context
-                )
-            );
-        });
-
-        // Both language servers start updating diagnostics, and the first server finishes.
-        project.update(cx, |project, cx| {
-            project.disk_based_diagnostics_started(server_id_1, cx);
-            project.disk_based_diagnostics_started(server_id_2, cx);
-            project
-                .update_diagnostic_entries(
-                    server_id_1,
-                    PathBuf::from("/test/main.js"),
-                    None,
-                    vec![DiagnosticEntry {
-                        range: Unclipped(PointUtf16::new(2, 0))..Unclipped(PointUtf16::new(2, 1)),
-                        diagnostic: Diagnostic {
-                            message: "warning 2".to_string(),
-                            severity: DiagnosticSeverity::WARNING,
-                            is_primary: true,
-                            is_disk_based: true,
-                            group_id: 1,
-                            ..Default::default()
-                        },
-                    }],
-                    cx,
-                )
-                .unwrap();
-            project
-                .update_diagnostic_entries(
-                    server_id_2,
-                    PathBuf::from("/test/main.rs"),
-                    None,
-                    vec![],
-                    cx,
-                )
-                .unwrap();
-            project.disk_based_diagnostics_finished(server_id_1, cx);
-        });
-
-        // Only the first language server's diagnostics are updated.
-        cx.foreground().run_until_parked();
-        view.update(cx, |view, cx| {
-            assert_eq!(
-                editor_blocks(&view.editor, cx),
-                [
-                    (0, "path header block".into()),
-                    (2, "diagnostic header".into()),
-                    (7, "collapsed context".into()),
-                    (8, "diagnostic header".into()),
-                ]
-            );
-            assert_eq!(
-                view.editor.update(cx, |editor, cx| editor.display_text(cx)),
-                concat!(
-                    "\n", // filename
-                    "\n", // padding
-                    // diagnostic group 1
-                    "\n",     // primary message
-                    "\n",     // padding
-                    "a();\n", // location
-                    "b();\n", //
-                    "c();\n", // context
-                    "\n",     // collapsed context
-                    // diagnostic group 2
-                    "\n",     // primary message
-                    "\n",     // padding
-                    "b();\n", // context
-                    "c();\n", //
-                    "d();",   // context
-                )
-            );
-        });
-
-        // The second language server finishes.
-        project.update(cx, |project, cx| {
-            project
-                .update_diagnostic_entries(
-                    server_id_2,
-                    PathBuf::from("/test/main.js"),
-                    None,
-                    vec![DiagnosticEntry {
-                        range: Unclipped(PointUtf16::new(3, 0))..Unclipped(PointUtf16::new(3, 1)),
-                        diagnostic: Diagnostic {
-                            message: "warning 2".to_string(),
-                            severity: DiagnosticSeverity::WARNING,
-                            is_primary: true,
-                            is_disk_based: true,
-                            group_id: 1,
-                            ..Default::default()
-                        },
-                    }],
-                    cx,
-                )
-                .unwrap();
-            project.disk_based_diagnostics_finished(server_id_2, cx);
-        });
-
-        // Both language servers' diagnostics are updated.
-        cx.foreground().run_until_parked();
-        view.update(cx, |view, cx| {
-            assert_eq!(
-                editor_blocks(&view.editor, cx),
-                [
-                    (0, "path header block".into()),
-                    (2, "diagnostic header".into()),
-                    (7, "collapsed context".into()),
-                    (8, "diagnostic header".into()),
-                ]
-            );
-            assert_eq!(
-                view.editor.update(cx, |editor, cx| editor.display_text(cx)),
-                concat!(
-                    "\n", // filename
-                    "\n", // padding
-                    // diagnostic group 1
-                    "\n",     // primary message
-                    "\n",     // padding
-                    "b();\n", // location
-                    "c();\n", //
-                    "d();\n", // context
-                    "\n",     // collapsed context
-                    // diagnostic group 2
-                    "\n",     // primary message
-                    "\n",     // padding
-                    "c();\n", // context
-                    "d();\n", //
-                    "e();",   // context
-                )
-            );
-        });
-    }
-
-    fn init_test(cx: &mut TestAppContext) {
-        cx.update(|cx| {
-            cx.set_global(SettingsStore::test(cx));
-            theme::init((), cx);
-            language::init(cx);
-            client::init_settings(cx);
-            workspace::init_settings(cx);
-        });
-    }
-
-    fn editor_blocks(editor: &ViewHandle<Editor>, cx: &mut WindowContext) -> Vec<(u32, String)> {
-        editor.update(cx, |editor, cx| {
+    fn editor_blocks(editor: &ViewHandle<Editor>, cx: &mut AppContext) -> Vec<(u32, String)> {
+        let mut presenter = cx.build_presenter(editor.id(), 0., Default::default());
+        let mut cx = presenter.build_layout_context(Default::default(), false, cx);
+        cx.render(editor, |editor, cx| {
             let snapshot = editor.snapshot(cx);
             snapshot
                 .blocks_in_range(0..snapshot.max_point().row())
@@ -1520,7 +1187,7 @@ mod tests {
                     let name = match block {
                         TransformBlock::Custom(block) => block
                             .render(&mut BlockContext {
-                                view_context: cx,
+                                cx,
                                 anchor_x: 0.,
                                 scroll_x: 0.,
                                 gutter_padding: 0.,

crates/diagnostics/src/items.rs

@@ -3,20 +3,19 @@ use editor::{Editor, GoToDiagnostic};
 use gpui::{
     elements::*,
     platform::{CursorStyle, MouseButton},
-    serde_json, AppContext, Entity, Subscription, View, ViewContext, ViewHandle, WeakViewHandle,
+    serde_json, AppContext, Entity, ModelHandle, RenderContext, Subscription, View, ViewContext,
+    ViewHandle, WeakViewHandle,
 };
 use language::Diagnostic;
-use lsp::LanguageServerId;
-use workspace::{item::ItemHandle, StatusItemView, Workspace};
-
-use crate::ProjectDiagnosticsEditor;
+use project::Project;
+use settings::Settings;
+use workspace::{item::ItemHandle, StatusItemView};
 
 pub struct DiagnosticIndicator {
     summary: project::DiagnosticSummary,
     active_editor: Option<WeakViewHandle<Editor>>,
-    workspace: WeakViewHandle<Workspace>,
     current_diagnostic: Option<Diagnostic>,
-    in_progress_checks: HashSet<LanguageServerId>,
+    in_progress_checks: HashSet<usize>,
     _observe_active_editor: Option<Subscription>,
 }
 
@@ -25,8 +24,7 @@ pub fn init(cx: &mut AppContext) {
 }
 
 impl DiagnosticIndicator {
-    pub fn new(workspace: &Workspace, cx: &mut ViewContext<Self>) -> Self {
-        let project = workspace.project();
+    pub fn new(project: &ModelHandle<Project>, cx: &mut ViewContext<Self>) -> Self {
         cx.subscribe(project, |this, project, event, cx| match event {
             project::Event::DiskBasedDiagnosticsStarted { language_server_id } => {
                 this.in_progress_checks.insert(*language_server_id);
@@ -47,7 +45,6 @@ impl DiagnosticIndicator {
                 .language_servers_running_disk_based_diagnostics()
                 .collect(),
             active_editor: None,
-            workspace: workspace.weak_handle(),
             current_diagnostic: None,
             _observe_active_editor: None,
         }
@@ -87,16 +84,17 @@ impl View for DiagnosticIndicator {
         "DiagnosticIndicator"
     }
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
         enum Summary {}
         enum Message {}
 
-        let tooltip_style = theme::current(cx).tooltip.clone();
+        let tooltip_style = cx.global::<Settings>().theme.tooltip.clone();
         let in_progress = !self.in_progress_checks.is_empty();
         let mut element = Flex::row().with_child(
-            MouseEventHandler::<Summary, _>::new(0, cx, |state, cx| {
-                let theme = theme::current(cx);
-                let style = theme
+            MouseEventHandler::<Summary>::new(0, cx, |state, cx| {
+                let style = cx
+                    .global::<Settings>()
+                    .theme
                     .workspace
                     .status_bar
                     .diagnostic_summary
@@ -104,23 +102,23 @@ impl View for DiagnosticIndicator {
 
                 let mut summary_row = Flex::row();
                 if self.summary.error_count > 0 {
-                    summary_row.add_child(
+                    summary_row.add_children([
                         Svg::new("icons/circle_x_mark_16.svg")
                             .with_color(style.icon_color_error)
                             .constrained()
                             .with_width(style.icon_width)
                             .aligned()
                             .contained()
-                            .with_margin_right(style.icon_spacing),
-                    );
-                    summary_row.add_child(
+                            .with_margin_right(style.icon_spacing)
+                            .named("error-icon"),
                         Label::new(self.summary.error_count.to_string(), style.text.clone())
-                            .aligned(),
-                    );
+                            .aligned()
+                            .boxed(),
+                    ]);
                 }
 
                 if self.summary.warning_count > 0 {
-                    summary_row.add_child(
+                    summary_row.add_children([
                         Svg::new("icons/triangle_exclamation_16.svg")
                             .with_color(style.icon_color_warning)
                             .constrained()
@@ -132,12 +130,12 @@ impl View for DiagnosticIndicator {
                                 style.summary_spacing
                             } else {
                                 0.
-                            }),
-                    );
-                    summary_row.add_child(
+                            })
+                            .named("warning-icon"),
                         Label::new(self.summary.warning_count.to_string(), style.text.clone())
-                            .aligned(),
-                    );
+                            .aligned()
+                            .boxed(),
+                    ]);
                 }
 
                 if self.summary.error_count == 0 && self.summary.warning_count == 0 {
@@ -147,7 +145,7 @@ impl View for DiagnosticIndicator {
                             .constrained()
                             .with_width(style.icon_width)
                             .aligned()
-                            .into_any_named("ok-icon"),
+                            .named("ok-icon"),
                     );
                 }
 
@@ -162,16 +160,11 @@ impl View for DiagnosticIndicator {
                     } else {
                         style.container_ok
                     })
+                    .boxed()
             })
             .with_cursor_style(CursorStyle::PointingHand)
-            .on_click(MouseButton::Left, |_, this, cx| {
-                if let Some(workspace) = this.workspace.upgrade(cx) {
-                    workspace.update(cx, |workspace, cx| {
-                        ProjectDiagnosticsEditor::deploy(workspace, &Default::default(), cx)
-                    })
-                }
-            })
-            .with_tooltip::<Summary>(
+            .on_click(MouseButton::Left, |_, cx| cx.dispatch_action(crate::Deploy))
+            .with_tooltip::<Summary, _>(
                 0,
                 "Project Diagnostics".to_string(),
                 Some(Box::new(crate::Deploy)),
@@ -179,10 +172,10 @@ impl View for DiagnosticIndicator {
                 cx,
             )
             .aligned()
-            .into_any(),
+            .boxed(),
         );
 
-        let style = &theme::current(cx).workspace.status_bar;
+        let style = &cx.global::<Settings>().theme.workspace.status_bar;
         let item_spacing = style.item_spacing;
 
         if in_progress {
@@ -190,12 +183,13 @@ impl View for DiagnosticIndicator {
                 Label::new("Checking…", style.diagnostic_message.default.text.clone())
                     .aligned()
                     .contained()
-                    .with_margin_left(item_spacing),
+                    .with_margin_left(item_spacing)
+                    .boxed(),
             );
         } else if let Some(diagnostic) = &self.current_diagnostic {
             let message_style = style.diagnostic_message.clone();
             element.add_child(
-                MouseEventHandler::<Message, _>::new(1, cx, |state, _| {
+                MouseEventHandler::<Message>::new(1, cx, |state, _| {
                     Label::new(
                         diagnostic.message.split('\n').next().unwrap().to_string(),
                         message_style.style_for(state, false).text.clone(),
@@ -203,15 +197,17 @@ impl View for DiagnosticIndicator {
                     .aligned()
                     .contained()
                     .with_margin_left(item_spacing)
+                    .boxed()
                 })
                 .with_cursor_style(CursorStyle::PointingHand)
-                .on_click(MouseButton::Left, |_, this, cx| {
-                    this.go_to_next_diagnostic(&Default::default(), cx)
-                }),
+                .on_click(MouseButton::Left, |_, cx| {
+                    cx.dispatch_action(GoToDiagnostic)
+                })
+                .boxed(),
             );
         }
 
-        element.into_any_named("diagnostic indicator")
+        element.named("diagnostic indicator")
     }
 
     fn debug_json(&self, _: &gpui::AppContext) -> serde_json::Value {

crates/drag_and_drop/src/drag_and_drop.rs

@@ -6,7 +6,7 @@ use gpui::{
     geometry::{rect::RectF, vector::Vector2F},
     platform::{CursorStyle, MouseButton},
     scene::{MouseDown, MouseDrag},
-    AnyElement, Element, View, ViewContext, WeakViewHandle, WindowContext,
+    AppContext, Element, ElementBox, EventContext, RenderContext, View, WeakViewHandle,
 };
 
 const DEAD_ZONE: f32 = 4.;
@@ -26,7 +26,7 @@ enum State<V: View> {
         region_offset: Vector2F,
         region: RectF,
         payload: Rc<dyn Any + 'static>,
-        render: Rc<dyn Fn(Rc<dyn Any>, &mut ViewContext<V>) -> AnyElement<V>>,
+        render: Rc<dyn Fn(Rc<dyn Any>, &mut RenderContext<V>) -> ElementBox>,
     },
     Canceled,
 }
@@ -111,7 +111,7 @@ impl<V: View> DragAndDrop<V> {
         })
     }
 
-    pub fn drag_started(event: MouseDown, cx: &mut WindowContext) {
+    pub fn drag_started(event: MouseDown, cx: &mut EventContext) {
         cx.update_global(|this: &mut Self, _| {
             this.currently_dragged = Some(State::Down {
                 region_offset: event.position - event.region.origin(),
@@ -123,8 +123,8 @@ impl<V: View> DragAndDrop<V> {
     pub fn dragging<T: Any>(
         event: MouseDrag,
         payload: Rc<T>,
-        cx: &mut WindowContext,
-        render: Rc<impl 'static + Fn(&T, &mut ViewContext<V>) -> AnyElement<V>>,
+        cx: &mut EventContext,
+        render: Rc<impl 'static + Fn(&T, &mut RenderContext<V>) -> ElementBox>,
     ) {
         let window_id = cx.window_id();
         cx.update_global(|this: &mut Self, cx| {
@@ -178,7 +178,7 @@ impl<V: View> DragAndDrop<V> {
         });
     }
 
-    pub fn render(cx: &mut ViewContext<V>) -> Option<AnyElement<V>> {
+    pub fn render(cx: &mut RenderContext<V>) -> Option<ElementBox> {
         enum DraggedElementHandler {}
         cx.global::<Self>()
             .currently_dragged
@@ -199,25 +199,23 @@ impl<V: View> DragAndDrop<V> {
                             return None;
                         }
 
-                        let position = (position - region_offset).round();
+                        let position = position - region_offset;
                         Some(
                             Overlay::new(
-                                MouseEventHandler::<DraggedElementHandler, V>::new(
-                                    0,
-                                    cx,
-                                    |_, cx| render(payload, cx),
-                                )
+                                MouseEventHandler::<DraggedElementHandler>::new(0, cx, |_, cx| {
+                                    render(payload, cx)
+                                })
                                 .with_cursor_style(CursorStyle::Arrow)
-                                .on_up(MouseButton::Left, |_, _, cx| {
-                                    cx.window_context().defer(|cx| {
+                                .on_up(MouseButton::Left, |_, cx| {
+                                    cx.defer(|cx| {
                                         cx.update_global::<Self, _, _>(|this, cx| {
                                             this.finish_dragging(cx)
                                         });
                                     });
                                     cx.propagate_event();
                                 })
-                                .on_up_out(MouseButton::Left, |_, _, cx| {
-                                    cx.window_context().defer(|cx| {
+                                .on_up_out(MouseButton::Left, |_, cx| {
+                                    cx.defer(|cx| {
                                         cx.update_global::<Self, _, _>(|this, cx| {
                                             this.finish_dragging(cx)
                                         });
@@ -227,38 +225,43 @@ impl<V: View> DragAndDrop<V> {
                                 .with_hoverable(false)
                                 .constrained()
                                 .with_width(region.width())
-                                .with_height(region.height()),
+                                .with_height(region.height())
+                                .boxed(),
                             )
                             .with_anchor_position(position)
-                            .into_any(),
+                            .boxed(),
                         )
                     }
 
                     State::Canceled => Some(
-                        MouseEventHandler::<DraggedElementHandler, V>::new(0, cx, |_, _| {
-                            Empty::new().constrained().with_width(0.).with_height(0.)
+                        MouseEventHandler::<DraggedElementHandler>::new(0, cx, |_, _| {
+                            Empty::new()
+                                .constrained()
+                                .with_width(0.)
+                                .with_height(0.)
+                                .boxed()
                         })
-                        .on_up(MouseButton::Left, |_, _, cx| {
-                            cx.window_context().defer(|cx| {
+                        .on_up(MouseButton::Left, |_, cx| {
+                            cx.defer(|cx| {
                                 cx.update_global::<Self, _, _>(|this, _| {
                                     this.currently_dragged = None;
                                 });
                             });
                         })
-                        .on_up_out(MouseButton::Left, |_, _, cx| {
-                            cx.window_context().defer(|cx| {
+                        .on_up_out(MouseButton::Left, |_, cx| {
+                            cx.defer(|cx| {
                                 cx.update_global::<Self, _, _>(|this, _| {
                                     this.currently_dragged = None;
                                 });
                             });
                         })
-                        .into_any(),
+                        .boxed(),
                     ),
                 }
             })
     }
 
-    pub fn cancel_dragging<P: Any>(&mut self, cx: &mut WindowContext) {
+    pub fn cancel_dragging<P: Any>(&mut self, cx: &mut AppContext) {
         if let Some(State::Dragging {
             payload, window_id, ..
         }) = &self.currently_dragged
@@ -271,13 +274,13 @@ impl<V: View> DragAndDrop<V> {
         }
     }
 
-    fn finish_dragging(&mut self, cx: &mut WindowContext) {
+    fn finish_dragging(&mut self, cx: &mut AppContext) {
         if let Some(State::Dragging { window_id, .. }) = self.currently_dragged.take() {
             self.notify_containers_for_window(window_id, cx);
         }
     }
 
-    fn notify_containers_for_window(&mut self, window_id: usize, cx: &mut WindowContext) {
+    fn notify_containers_for_window(&mut self, window_id: usize, cx: &mut AppContext) {
         self.containers.retain(|container| {
             if let Some(container) = container.upgrade(cx) {
                 if container.window_id() == window_id {
@@ -291,35 +294,35 @@ impl<V: View> DragAndDrop<V> {
     }
 }
 
-pub trait Draggable<V: View> {
-    fn as_draggable<D: View, P: Any>(
+pub trait Draggable {
+    fn as_draggable<V: View, P: Any>(
         self,
         payload: P,
-        render: impl 'static + Fn(&P, &mut ViewContext<D>) -> AnyElement<D>,
+        render: impl 'static + Fn(&P, &mut RenderContext<V>) -> ElementBox,
     ) -> Self
     where
         Self: Sized;
 }
 
-impl<Tag, V: View> Draggable<V> for MouseEventHandler<Tag, V> {
-    fn as_draggable<D: View, P: Any>(
+impl<Tag> Draggable for MouseEventHandler<Tag> {
+    fn as_draggable<V: View, P: Any>(
         self,
         payload: P,
-        render: impl 'static + Fn(&P, &mut ViewContext<D>) -> AnyElement<D>,
+        render: impl 'static + Fn(&P, &mut RenderContext<V>) -> ElementBox,
     ) -> Self
     where
         Self: Sized,
     {
         let payload = Rc::new(payload);
         let render = Rc::new(render);
-        self.on_down(MouseButton::Left, move |e, _, cx| {
+        self.on_down(MouseButton::Left, move |e, cx| {
             cx.propagate_event();
-            DragAndDrop::<D>::drag_started(e, cx);
+            DragAndDrop::<V>::drag_started(e, cx);
         })
-        .on_drag(MouseButton::Left, move |e, _, cx| {
+        .on_drag(MouseButton::Left, move |e, cx| {
             let payload = payload.clone();
             let render = render.clone();
-            DragAndDrop::<D>::dragging(e, payload, cx, render)
+            DragAndDrop::<V>::dragging(e, payload, cx, render)
         })
     }
 }

crates/editor/Cargo.toml

@@ -23,7 +23,6 @@ test-support = [
 ]
 
 [dependencies]
-client = { path = "../client" }
 clock = { path = "../clock" }
 copilot = { path = "../copilot" }
 db = { path = "../db" }
@@ -47,22 +46,20 @@ sqlez = { path = "../sqlez" }
 workspace = { path = "../workspace" }
 
 aho-corasick = "0.7"
-anyhow.workspace = true
-futures.workspace = true
+anyhow = "1.0"
+futures = "0.3"
 indoc = "1.0.4"
 itertools = "0.10"
-lazy_static.workspace = true
-log.workspace = true
-ordered-float.workspace = true
-parking_lot.workspace = true
-postage.workspace = true
-pulldown-cmark = { version = "0.9.2", default-features = false }
-rand = { workspace = true, optional = true }
-schemars.workspace = true
-serde.workspace = true
-serde_derive.workspace = true
-smallvec.workspace = true
-smol.workspace = true
+lazy_static = "1.4"
+log = { version = "0.4.16", features = ["kv_unstable_serde"] }
+ordered-float = "2.1.1"
+parking_lot = "0.11"
+postage = { workspace = true }
+rand = { version = "0.8.3", optional = true }
+serde = { workspace = true }
+serde_derive = { workspace = true }
+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 }
@@ -78,11 +75,10 @@ util = { path = "../util", features = ["test-support"] }
 project = { path = "../project", features = ["test-support"] }
 settings = { path = "../settings", features = ["test-support"] }
 workspace = { path = "../workspace", features = ["test-support"] }
-
-ctor.workspace = true
-env_logger.workspace = true
-rand.workspace = true
-unindent.workspace = true
+ctor = "0.1"
+env_logger = "0.9"
+rand = "0.8"
+unindent = "0.1.7"
 tree-sitter = "0.20"
 tree-sitter-rust = "0.20"
 tree-sitter-html = "0.19"

crates/editor/src/blink_manager.rs

@@ -1,9 +1,9 @@
-use crate::EditorSettings;
-use gpui::{Entity, ModelContext};
-use settings::SettingsStore;
-use smol::Timer;
 use std::time::Duration;
 
+use gpui::{Entity, ModelContext};
+use settings::Settings;
+use smol::Timer;
+
 pub struct BlinkManager {
     blink_interval: Duration,
 
@@ -15,8 +15,8 @@ pub struct BlinkManager {
 
 impl BlinkManager {
     pub fn new(blink_interval: Duration, cx: &mut ModelContext<Self>) -> Self {
-        // Make sure we blink the cursors if the setting is re-enabled
-        cx.observe_global::<SettingsStore, _>(move |this, cx| {
+        cx.observe_global::<Settings, _>(move |this, cx| {
+            // Make sure we blink the cursors if the setting is re-enabled
             this.blink_cursors(this.blink_epoch, cx)
         })
         .detach();
@@ -64,7 +64,7 @@ impl BlinkManager {
     }
 
     fn blink_cursors(&mut self, epoch: usize, cx: &mut ModelContext<Self>) {
-        if settings::get::<EditorSettings>(cx).cursor_blink {
+        if cx.global::<Settings>().cursor_blink {
             if epoch == self.blink_epoch && self.enabled && !self.blinking_paused {
                 self.visible = !self.visible;
                 cx.notify();

crates/editor/src/display_map.rs

@@ -13,9 +13,8 @@ use gpui::{
     fonts::{FontId, HighlightStyle},
     Entity, ModelContext, ModelHandle,
 };
-use language::{
-    language_settings::language_settings, OffsetUtf16, Point, Subscription as BufferSubscription,
-};
+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;
@@ -277,7 +276,8 @@ impl DisplayMap {
             .as_singleton()
             .and_then(|buffer| buffer.read(cx).language())
             .map(|language| language.name());
-        language_settings(language_name.as_deref(), cx).tab_size
+
+        cx.global::<Settings>().tab_size(language_name.as_deref())
     }
 
     #[cfg(test)]
@@ -844,12 +844,8 @@ pub mod tests {
     use super::*;
     use crate::{movement, test::marked_display_snapshot};
     use gpui::{color::Color, elements::*, test::observe, AppContext};
-    use language::{
-        language_settings::{AllLanguageSettings, AllLanguageSettingsContent},
-        Buffer, Language, LanguageConfig, SelectionGoal,
-    };
+    use language::{Buffer, Language, LanguageConfig, SelectionGoal};
     use rand::{prelude::*, Rng};
-    use settings::SettingsStore;
     use smol::stream::StreamExt;
     use std::{env, sync::Arc};
     use theme::SyntaxTheme;
@@ -886,7 +882,9 @@ pub mod tests {
         log::info!("wrap width: {:?}", wrap_width);
 
         cx.update(|cx| {
-            init_test(cx, |s| s.defaults.tab_size = NonZeroU32::new(tab_size));
+            let mut settings = Settings::test(cx);
+            settings.editor_overrides.tab_size = NonZeroU32::new(tab_size);
+            cx.set_global(settings)
         });
 
         let buffer = cx.update(|cx| {
@@ -941,11 +939,9 @@ pub mod tests {
                     tab_size = *tab_sizes.choose(&mut rng).unwrap();
                     log::info!("setting tab size to {:?}", tab_size);
                     cx.update(|cx| {
-                        cx.update_global::<SettingsStore, _, _>(|store, cx| {
-                            store.update_user_settings::<AllLanguageSettings>(cx, |s| {
-                                s.defaults.tab_size = NonZeroU32::new(tab_size);
-                            });
-                        });
+                        let mut settings = Settings::test(cx);
+                        settings.editor_overrides.tab_size = NonZeroU32::new(tab_size);
+                        cx.set_global(settings)
                     });
                 }
                 30..=44 => {
@@ -977,7 +973,7 @@ pub mod tests {
                                         position,
                                         height,
                                         disposition,
-                                        render: Arc::new(|_| Empty::new().into_any()),
+                                        render: Arc::new(|_| Empty::new().boxed()),
                                     }
                                 })
                                 .collect::<Vec<_>>();
@@ -1123,7 +1119,7 @@ pub mod tests {
     #[gpui::test(retries = 5)]
     fn test_soft_wraps(cx: &mut AppContext) {
         cx.foreground().set_block_on_ticks(usize::MAX..=usize::MAX);
-        init_test(cx, |_| {});
+        cx.foreground().forbid_parking();
 
         let font_cache = cx.font_cache();
 
@@ -1135,6 +1131,7 @@ pub mod tests {
             .unwrap();
         let font_size = 12.0;
         let wrap_width = Some(64.);
+        cx.set_global(Settings::test(cx));
 
         let text = "one two three four five\nsix seven eight";
         let buffer = MultiBuffer::build_simple(text, cx);
@@ -1214,8 +1211,7 @@ pub mod tests {
 
     #[gpui::test]
     fn test_text_chunks(cx: &mut gpui::AppContext) {
-        init_test(cx, |_| {});
-
+        cx.set_global(Settings::test(cx));
         let text = sample_text(6, 6, 'a');
         let buffer = MultiBuffer::build_simple(&text, cx);
         let family_id = cx
@@ -1229,7 +1225,6 @@ pub mod tests {
         let font_size = 14.0;
         let map =
             cx.add_model(|cx| DisplayMap::new(buffer.clone(), font_id, font_size, None, 1, 1, cx));
-
         buffer.update(cx, |buffer, cx| {
             buffer.edit(
                 vec![
@@ -1294,8 +1289,11 @@ pub mod tests {
             .unwrap(),
         );
         language.set_theme(&theme);
-
-        cx.update(|cx| init_test(cx, |s| s.defaults.tab_size = Some(2.try_into().unwrap())));
+        cx.update(|cx| {
+            let mut settings = Settings::test(cx);
+            settings.editor_defaults.tab_size = Some(2.try_into().unwrap());
+            cx.set_global(settings);
+        });
 
         let buffer = cx.add_model(|cx| Buffer::new(0, text, cx).with_language(language, cx));
         buffer.condition(cx, |buf, _| !buf.is_parsing()).await;
@@ -1384,7 +1382,7 @@ pub mod tests {
         );
         language.set_theme(&theme);
 
-        cx.update(|cx| init_test(cx, |_| {}));
+        cx.update(|cx| cx.set_global(Settings::test(cx)));
 
         let buffer = cx.add_model(|cx| Buffer::new(0, text, cx).with_language(language, cx));
         buffer.condition(cx, |buf, _| !buf.is_parsing()).await;
@@ -1431,8 +1429,9 @@ pub mod tests {
 
     #[gpui::test]
     async fn test_chunks_with_text_highlights(cx: &mut gpui::TestAppContext) {
-        cx.update(|cx| init_test(cx, |_| {}));
+        cx.foreground().set_block_on_ticks(usize::MAX..=usize::MAX);
 
+        cx.update(|cx| cx.set_global(Settings::test(cx)));
         let theme = SyntaxTheme::new(vec![
             ("operator".to_string(), Color::red().into()),
             ("string".to_string(), Color::green().into()),
@@ -1511,8 +1510,7 @@ pub mod tests {
 
     #[gpui::test]
     fn test_clip_point(cx: &mut gpui::AppContext) {
-        init_test(cx, |_| {});
-
+        cx.set_global(Settings::test(cx));
         fn assert(text: &str, shift_right: bool, bias: Bias, cx: &mut gpui::AppContext) {
             let (unmarked_snapshot, mut markers) = marked_display_snapshot(text, cx);
 
@@ -1561,7 +1559,7 @@ pub mod tests {
 
     #[gpui::test]
     fn test_clip_at_line_ends(cx: &mut gpui::AppContext) {
-        init_test(cx, |_| {});
+        cx.set_global(Settings::test(cx));
 
         fn assert(text: &str, cx: &mut gpui::AppContext) {
             let (mut unmarked_snapshot, markers) = marked_display_snapshot(text, cx);
@@ -1580,8 +1578,7 @@ pub mod tests {
 
     #[gpui::test]
     fn test_tabs_with_multibyte_chars(cx: &mut gpui::AppContext) {
-        init_test(cx, |_| {});
-
+        cx.set_global(Settings::test(cx));
         let text = "✅\t\tα\nβ\t\n🏀β\t\tγ";
         let buffer = MultiBuffer::build_simple(text, cx);
         let font_cache = cx.font_cache();
@@ -1642,8 +1639,7 @@ pub mod tests {
 
     #[gpui::test]
     fn test_max_point(cx: &mut gpui::AppContext) {
-        init_test(cx, |_| {});
-
+        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
@@ -1722,13 +1718,4 @@ pub mod tests {
         }
         chunks
     }
-
-    fn init_test(cx: &mut AppContext, f: impl Fn(&mut AllLanguageSettingsContent)) {
-        cx.foreground().forbid_parking();
-        cx.set_global(SettingsStore::test(cx));
-        language::init(cx);
-        cx.update_global::<SettingsStore, _, _>(|store, cx| {
-            store.update_user_settings::<AllLanguageSettings>(cx, f);
-        });
-    }
 }

crates/editor/src/display_map/block_map.rs

@@ -2,9 +2,9 @@ use super::{
     wrap_map::{self, WrapEdit, WrapPoint, WrapSnapshot},
     TextHighlights,
 };
-use crate::{Anchor, Editor, ExcerptId, ExcerptRange, ToPoint as _};
+use crate::{Anchor, ExcerptId, ExcerptRange, ToPoint as _};
 use collections::{Bound, HashMap, HashSet};
-use gpui::{fonts::HighlightStyle, AnyElement, ViewContext};
+use gpui::{fonts::HighlightStyle, ElementBox, RenderContext};
 use language::{BufferSnapshot, Chunk, Patch, Point};
 use parking_lot::Mutex;
 use std::{
@@ -50,7 +50,7 @@ struct BlockRow(u32);
 #[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq)]
 struct WrapRow(u32);
 
-pub type RenderBlock = Arc<dyn Fn(&mut BlockContext) -> AnyElement<Editor>>;
+pub type RenderBlock = Arc<dyn Fn(&mut BlockContext) -> ElementBox>;
 
 pub struct Block {
     id: BlockId,
@@ -69,7 +69,7 @@ where
     pub position: P,
     pub height: u8,
     pub style: BlockStyle,
-    pub render: Arc<dyn Fn(&mut BlockContext) -> AnyElement<Editor>>,
+    pub render: Arc<dyn Fn(&mut BlockContext) -> ElementBox>,
     pub disposition: BlockDisposition,
 }
 
@@ -80,8 +80,8 @@ pub enum BlockStyle {
     Sticky,
 }
 
-pub struct BlockContext<'a, 'b, 'c> {
-    pub view_context: &'c mut ViewContext<'a, 'b, Editor>,
+pub struct BlockContext<'a, 'b> {
+    pub cx: &'b mut RenderContext<'a, crate::Editor>,
     pub anchor_x: f32,
     pub scroll_x: f32,
     pub gutter_width: f32,
@@ -833,7 +833,10 @@ impl<'a> Iterator for BlockChunks<'a> {
 
             return Some(Chunk {
                 text: unsafe { std::str::from_utf8_unchecked(&NEWLINES[..line_count as usize]) },
-                ..Default::default()
+                syntax_highlight_id: None,
+                highlight_style: None,
+                diagnostic_severity: None,
+                is_unnecessary: false,
             });
         }
 
@@ -929,22 +932,22 @@ impl BlockDisposition {
     }
 }
 
-impl<'a, 'b, 'c> Deref for BlockContext<'a, 'b, 'c> {
-    type Target = ViewContext<'a, 'b, Editor>;
+impl<'a, 'b> Deref for BlockContext<'a, 'b> {
+    type Target = RenderContext<'a, crate::Editor>;
 
     fn deref(&self) -> &Self::Target {
-        self.view_context
+        self.cx
     }
 }
 
-impl DerefMut for BlockContext<'_, '_, '_> {
+impl<'a, 'b> DerefMut for BlockContext<'a, 'b> {
     fn deref_mut(&mut self) -> &mut Self::Target {
-        self.view_context
+        self.cx
     }
 }
 
 impl Block {
-    pub fn render(&self, cx: &mut BlockContext) -> AnyElement<Editor> {
+    pub fn render(&self, cx: &mut BlockContext) -> ElementBox {
         self.render.lock()(cx)
     }
 
@@ -993,7 +996,7 @@ mod tests {
     use crate::multi_buffer::MultiBuffer;
     use gpui::{elements::Empty, Element};
     use rand::prelude::*;
-    use settings::SettingsStore;
+    use settings::Settings;
     use std::env;
     use util::RandomCharIter;
 
@@ -1013,7 +1016,7 @@ mod tests {
 
     #[gpui::test]
     fn test_basic_blocks(cx: &mut gpui::AppContext) {
-        init_test(cx);
+        cx.set_global(Settings::test(cx));
 
         let family_id = cx
             .font_cache()
@@ -1042,21 +1045,21 @@ mod tests {
                 position: buffer_snapshot.anchor_after(Point::new(1, 0)),
                 height: 1,
                 disposition: BlockDisposition::Above,
-                render: Arc::new(|_| Empty::new().into_any_named("block 1")),
+                render: Arc::new(|_| Empty::new().named("block 1")),
             },
             BlockProperties {
                 style: BlockStyle::Fixed,
                 position: buffer_snapshot.anchor_after(Point::new(1, 2)),
                 height: 2,
                 disposition: BlockDisposition::Above,
-                render: Arc::new(|_| Empty::new().into_any_named("block 2")),
+                render: Arc::new(|_| Empty::new().named("block 2")),
             },
             BlockProperties {
                 style: BlockStyle::Fixed,
                 position: buffer_snapshot.anchor_after(Point::new(3, 3)),
                 height: 3,
                 disposition: BlockDisposition::Below,
-                render: Arc::new(|_| Empty::new().into_any_named("block 3")),
+                render: Arc::new(|_| Empty::new().named("block 3")),
             },
         ]);
 
@@ -1189,7 +1192,7 @@ mod tests {
 
     #[gpui::test]
     fn test_blocks_on_wrapped_lines(cx: &mut gpui::AppContext) {
-        init_test(cx);
+        cx.set_global(Settings::test(cx));
 
         let family_id = cx
             .font_cache()
@@ -1216,14 +1219,14 @@ mod tests {
                 style: BlockStyle::Fixed,
                 position: buffer_snapshot.anchor_after(Point::new(1, 12)),
                 disposition: BlockDisposition::Above,
-                render: Arc::new(|_| Empty::new().into_any_named("block 1")),
+                render: Arc::new(|_| Empty::new().named("block 1")),
                 height: 1,
             },
             BlockProperties {
                 style: BlockStyle::Fixed,
                 position: buffer_snapshot.anchor_after(Point::new(1, 1)),
                 disposition: BlockDisposition::Below,
-                render: Arc::new(|_| Empty::new().into_any_named("block 2")),
+                render: Arc::new(|_| Empty::new().named("block 2")),
                 height: 1,
             },
         ]);
@@ -1239,7 +1242,7 @@ mod tests {
 
     #[gpui::test(iterations = 100)]
     fn test_random_blocks(cx: &mut gpui::AppContext, mut rng: StdRng) {
-        init_test(cx);
+        cx.set_global(Settings::test(cx));
 
         let operations = env::var("OPERATIONS")
             .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
@@ -1326,7 +1329,7 @@ mod tests {
                                 position,
                                 height,
                                 disposition,
-                                render: Arc::new(|_| Empty::new().into_any()),
+                                render: Arc::new(|_| Empty::new().boxed()),
                             }
                         })
                         .collect::<Vec<_>>();
@@ -1647,11 +1650,6 @@ mod tests {
         }
     }
 
-    fn init_test(cx: &mut gpui::AppContext) {
-        cx.set_global(SettingsStore::test(cx));
-        theme::init((), cx);
-    }
-
     impl TransformBlock {
         fn as_custom(&self) -> Option<&Block> {
             match self {

crates/editor/src/display_map/fold_map.rs

@@ -1065,11 +1065,13 @@ impl<'a> Iterator for FoldChunks<'a> {
             self.output_offset += output_text.len();
             return Some(Chunk {
                 text: output_text,
+                syntax_highlight_id: None,
                 highlight_style: self.ellipses_color.map(|color| HighlightStyle {
                     color: Some(color),
                     ..Default::default()
                 }),
-                ..Default::default()
+                diagnostic_severity: None,
+                is_unnecessary: false,
             });
         }
 
@@ -1204,7 +1206,7 @@ mod tests {
     use crate::{MultiBuffer, ToPoint};
     use collections::HashSet;
     use rand::prelude::*;
-    use settings::SettingsStore;
+    use settings::Settings;
     use std::{cmp::Reverse, env, mem, sync::Arc};
     use sum_tree::TreeMap;
     use util::test::sample_text;
@@ -1213,7 +1215,7 @@ mod tests {
 
     #[gpui::test]
     fn test_basic_folds(cx: &mut gpui::AppContext) {
-        init_test(cx);
+        cx.set_global(Settings::test(cx));
         let buffer = MultiBuffer::build_simple(&sample_text(5, 6, 'a'), cx);
         let subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
         let buffer_snapshot = buffer.read(cx).snapshot(cx);
@@ -1286,7 +1288,7 @@ mod tests {
 
     #[gpui::test]
     fn test_adjacent_folds(cx: &mut gpui::AppContext) {
-        init_test(cx);
+        cx.set_global(Settings::test(cx));
         let buffer = MultiBuffer::build_simple("abcdefghijkl", cx);
         let subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
         let buffer_snapshot = buffer.read(cx).snapshot(cx);
@@ -1349,7 +1351,7 @@ mod tests {
 
     #[gpui::test]
     fn test_merging_folds_via_edit(cx: &mut gpui::AppContext) {
-        init_test(cx);
+        cx.set_global(Settings::test(cx));
         let buffer = MultiBuffer::build_simple(&sample_text(5, 6, 'a'), cx);
         let subscription = buffer.update(cx, |buffer, _| buffer.subscribe());
         let buffer_snapshot = buffer.read(cx).snapshot(cx);
@@ -1400,7 +1402,7 @@ mod tests {
 
     #[gpui::test(iterations = 100)]
     fn test_random_folds(cx: &mut gpui::AppContext, mut rng: StdRng) {
-        init_test(cx);
+        cx.set_global(Settings::test(cx));
         let operations = env::var("OPERATIONS")
             .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
             .unwrap_or(10);
@@ -1676,10 +1678,6 @@ mod tests {
         assert_eq!(snapshot.buffer_rows(3).collect::<Vec<_>>(), [Some(6)]);
     }
 
-    fn init_test(cx: &mut gpui::AppContext) {
-        cx.set_global(SettingsStore::test(cx));
-    }
-
     impl FoldMap {
         fn merged_fold_ranges(&self) -> Vec<Range<usize>> {
             let buffer = self.buffer.lock().clone();

crates/editor/src/display_map/suggestion_map.rs

@@ -531,8 +531,10 @@ impl<'a> Iterator for SuggestionChunks<'a> {
             if let Some(chunk) = chunks.next() {
                 return Some(Chunk {
                     text: chunk,
+                    syntax_highlight_id: None,
                     highlight_style: self.highlight_style,
-                    ..Default::default()
+                    diagnostic_severity: None,
+                    is_unnecessary: false,
                 });
             } else {
                 self.suggestion_chunks = None;
@@ -578,7 +580,7 @@ mod tests {
     use crate::{display_map::fold_map::FoldMap, MultiBuffer};
     use gpui::AppContext;
     use rand::{prelude::StdRng, Rng};
-    use settings::SettingsStore;
+    use settings::Settings;
     use std::{
         env,
         ops::{Bound, RangeBounds},
@@ -631,8 +633,7 @@ mod tests {
 
     #[gpui::test(iterations = 100)]
     fn test_random_suggestions(cx: &mut AppContext, mut rng: StdRng) {
-        init_test(cx);
-
+        cx.set_global(Settings::test(cx));
         let operations = env::var("OPERATIONS")
             .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
             .unwrap_or(10);
@@ -835,11 +836,6 @@ mod tests {
         }
     }
 
-    fn init_test(cx: &mut AppContext) {
-        cx.set_global(SettingsStore::test(cx));
-        theme::init((), cx);
-    }
-
     impl SuggestionMap {
         pub fn randomly_mutate(
             &self,

crates/editor/src/display_map/tab_map.rs

@@ -268,7 +268,6 @@ impl TabSnapshot {
             tab_size: self.tab_size,
             chunk: Chunk {
                 text: &SPACES[0..(to_next_stop as usize)],
-                is_tab: true,
                 ..Default::default()
             },
             inside_leading_tab: to_next_stop > 0,
@@ -546,7 +545,6 @@ impl<'a> Iterator for TabChunks<'a> {
                         self.output_position = next_output_position;
                         return Some(Chunk {
                             text: &SPACES[..len as usize],
-                            is_tab: true,
                             ..self.chunk
                         });
                     }
@@ -656,56 +654,6 @@ mod tests {
         assert_eq!(tab_snapshot.text(), input);
     }
 
-    #[gpui::test]
-    fn test_marking_tabs(cx: &mut gpui::AppContext) {
-        let input = "\t \thello";
-
-        let buffer = MultiBuffer::build_simple(&input, cx);
-        let buffer_snapshot = buffer.read(cx).snapshot(cx);
-        let (_, fold_snapshot) = FoldMap::new(buffer_snapshot.clone());
-        let (_, suggestion_snapshot) = SuggestionMap::new(fold_snapshot);
-        let (_, tab_snapshot) = TabMap::new(suggestion_snapshot, 4.try_into().unwrap());
-
-        assert_eq!(
-            chunks(&tab_snapshot, TabPoint::zero()),
-            vec![
-                ("    ".to_string(), true),
-                (" ".to_string(), false),
-                ("   ".to_string(), true),
-                ("hello".to_string(), false),
-            ]
-        );
-        assert_eq!(
-            chunks(&tab_snapshot, TabPoint::new(0, 2)),
-            vec![
-                ("  ".to_string(), true),
-                (" ".to_string(), false),
-                ("   ".to_string(), true),
-                ("hello".to_string(), false),
-            ]
-        );
-
-        fn chunks(snapshot: &TabSnapshot, start: TabPoint) -> Vec<(String, bool)> {
-            let mut chunks = Vec::new();
-            let mut was_tab = false;
-            let mut text = String::new();
-            for chunk in snapshot.chunks(start..snapshot.max_point(), false, None, None) {
-                if chunk.is_tab != was_tab {
-                    if !text.is_empty() {
-                        chunks.push((mem::take(&mut text), was_tab));
-                    }
-                    was_tab = chunk.is_tab;
-                }
-                text.push_str(chunk.text);
-            }
-
-            if !text.is_empty() {
-                chunks.push((text, was_tab));
-            }
-            chunks
-        }
-    }
-
     #[gpui::test(iterations = 100)]
     fn test_random_tabs(cx: &mut gpui::AppContext, mut rng: StdRng) {
         let tab_size = NonZeroU32::new(rng.gen_range(1..=4)).unwrap();

crates/editor/src/display_map/wrap_map.rs

@@ -1043,16 +1043,16 @@ mod tests {
     };
     use gpui::test::observe;
     use rand::prelude::*;
-    use settings::SettingsStore;
+    use settings::Settings;
     use smol::stream::StreamExt;
     use std::{cmp, env, num::NonZeroU32};
     use text::Rope;
 
     #[gpui::test(iterations = 100)]
     async fn test_random_wraps(cx: &mut gpui::TestAppContext, mut rng: StdRng) {
-        init_test(cx);
-
+        cx.update(|cx| cx.set_global(Settings::test(cx)));
         cx.foreground().set_block_on_ticks(0..=50);
+        cx.foreground().forbid_parking();
         let operations = env::var("OPERATIONS")
             .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
             .unwrap_or(10);
@@ -1287,14 +1287,6 @@ mod tests {
         wrap_map.read_with(cx, |map, _| assert!(map.pending_edits.is_empty()));
     }
 
-    fn init_test(cx: &mut gpui::TestAppContext) {
-        cx.foreground().forbid_parking();
-        cx.update(|cx| {
-            cx.set_global(SettingsStore::test(cx));
-            theme::init((), cx);
-        });
-    }
-
     fn wrap_text(
         unwrapped_text: &str,
         wrap_width: Option<f32>,

crates/editor/src/editor_settings.rs

@@ -1,54 +0,0 @@
-use schemars::JsonSchema;
-use serde::{Deserialize, Serialize};
-use settings::Setting;
-
-#[derive(Deserialize)]
-pub struct EditorSettings {
-    pub cursor_blink: bool,
-    pub hover_popover_enabled: bool,
-    pub show_completions_on_input: bool,
-    pub scrollbar: Scrollbar,
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
-pub struct Scrollbar {
-    pub show: ShowScrollbar,
-    pub git_diff: bool,
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
-#[serde(rename_all = "snake_case")]
-pub enum ShowScrollbar {
-    Auto,
-    System,
-    Always,
-    Never,
-}
-
-#[derive(Clone, Default, Serialize, Deserialize, JsonSchema)]
-pub struct EditorSettingsContent {
-    pub cursor_blink: Option<bool>,
-    pub hover_popover_enabled: Option<bool>,
-    pub show_completions_on_input: Option<bool>,
-    pub scrollbar: Option<ScrollbarContent>,
-}
-
-#[derive(Copy, Clone, Debug, Serialize, Deserialize, JsonSchema, PartialEq, Eq)]
-pub struct ScrollbarContent {
-    pub show: Option<ShowScrollbar>,
-    pub git_diff: Option<bool>,
-}
-
-impl Setting for EditorSettings {
-    const KEY: Option<&'static str> = None;
-
-    type FileContent = EditorSettingsContent;
-
-    fn load(
-        default_value: &Self::FileContent,
-        user_values: &[&Self::FileContent],
-        _: &gpui::AppContext,
-    ) -> anyhow::Result<Self> {
-        Self::load_via_json_merge(default_value, user_values)
-    }
-}

crates/editor/src/git.rs

@@ -1,4 +1,4 @@
-use std::ops::Range;
+use std::ops::RangeInclusive;
 
 use git::diff::{DiffHunk, DiffHunkStatus};
 use language::Point;
@@ -15,7 +15,7 @@ pub enum DisplayDiffHunk {
     },
 
     Unfolded {
-        display_row_range: Range<u32>,
+        display_row_range: RangeInclusive<u32>,
         status: DiffHunkStatus,
     },
 }
@@ -26,7 +26,7 @@ impl DisplayDiffHunk {
             &DisplayDiffHunk::Folded { display_row } => display_row,
             DisplayDiffHunk::Unfolded {
                 display_row_range, ..
-            } => display_row_range.start,
+            } => *display_row_range.start(),
         }
     }
 
@@ -36,7 +36,7 @@ impl DisplayDiffHunk {
 
             DisplayDiffHunk::Unfolded {
                 display_row_range, ..
-            } => display_row_range.start..=display_row_range.end - 1,
+            } => display_row_range.clone(),
         };
 
         range.contains(&display_row)
@@ -77,12 +77,16 @@ pub fn diff_hunk_to_display(hunk: DiffHunk<u32>, snapshot: &DisplaySnapshot) ->
     } else {
         let start = hunk_start_point.to_display_point(snapshot).row();
 
-        let hunk_end_row_inclusive = hunk.buffer_range.end.max(hunk.buffer_range.start);
+        let hunk_end_row_inclusive = hunk
+            .buffer_range
+            .end
+            .saturating_sub(1)
+            .max(hunk.buffer_range.start);
         let hunk_end_point = Point::new(hunk_end_row_inclusive, 0);
         let end = hunk_end_point.to_display_point(snapshot).row();
 
         DisplayDiffHunk::Unfolded {
-            display_row_range: start..end,
+            display_row_range: start..=end,
             status: hunk.status(),
         }
     }

crates/editor/src/highlight_matching_bracket.rs

@@ -33,14 +33,12 @@ pub fn refresh_matching_bracket_highlights(editor: &mut Editor, cx: &mut ViewCon
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{editor_tests::init_test, test::editor_lsp_test_context::EditorLspTestContext};
+    use crate::test::editor_lsp_test_context::EditorLspTestContext;
     use indoc::indoc;
     use language::{BracketPair, BracketPairConfig, Language, LanguageConfig};
 
     #[gpui::test]
     async fn test_matching_bracket_highlights(cx: &mut gpui::TestAppContext) {
-        init_test(cx, |_| {});
-
         let mut cx = EditorLspTestContext::new(
             Language::new(
                 LanguageConfig {

crates/editor/src/hover_popover.rs

@@ -1,20 +1,22 @@
-use crate::{
-    display_map::ToDisplayPoint, Anchor, AnchorRangeExt, DisplayPoint, Editor, EditorSettings,
-    EditorSnapshot, EditorStyle, RangeToAnchorExt,
-};
 use futures::FutureExt;
 use gpui::{
     actions,
-    elements::{Flex, MouseEventHandler, Padding, ParentElement, Text},
-    fonts::{HighlightStyle, Underline, Weight},
+    elements::{Flex, MouseEventHandler, Padding, Text},
+    impl_internal_actions,
     platform::{CursorStyle, MouseButton},
-    AnyElement, AppContext, CursorRegion, Element, ModelHandle, MouseRegion, Task, ViewContext,
+    AppContext, Axis, Element, ElementBox, ModelHandle, RenderContext, Task, ViewContext,
 };
-use language::{Bias, DiagnosticEntry, DiagnosticSeverity, Language, LanguageRegistry};
-use project::{HoverBlock, HoverBlockKind, Project};
-use std::{ops::Range, sync::Arc, time::Duration};
+use language::{Bias, DiagnosticEntry, DiagnosticSeverity};
+use project::{HoverBlock, Project};
+use settings::Settings;
+use std::{ops::Range, time::Duration};
 use util::TryFutureExt;
 
+use crate::{
+    display_map::ToDisplayPoint, Anchor, AnchorRangeExt, DisplayPoint, Editor, EditorSnapshot,
+    EditorStyle, GoToDiagnostic, RangeToAnchorExt,
+};
+
 pub const HOVER_DELAY_MILLIS: u64 = 350;
 pub const HOVER_REQUEST_DELAY_MILLIS: u64 = 200;
 
@@ -22,10 +24,21 @@ pub const MIN_POPOVER_CHARACTER_WIDTH: f32 = 20.;
 pub const MIN_POPOVER_LINE_HEIGHT: f32 = 4.;
 pub const HOVER_POPOVER_GAP: f32 = 10.;
 
+#[derive(Clone, PartialEq)]
+pub struct HoverAt {
+    pub point: Option<DisplayPoint>,
+}
+
+#[derive(Copy, Clone, PartialEq)]
+pub struct HideHover;
+
 actions!(editor, [Hover]);
+impl_internal_actions!(editor, [HoverAt, HideHover]);
 
 pub fn init(cx: &mut AppContext) {
     cx.add_action(hover);
+    cx.add_action(hover_at);
+    cx.add_action(hide_hover);
 }
 
 /// Bindable action which uses the most recent selection head to trigger a hover
@@ -36,12 +49,12 @@ pub fn hover(editor: &mut Editor, _: &Hover, cx: &mut ViewContext<Editor>) {
 
 /// The internal hover action dispatches between `show_hover` or `hide_hover`
 /// depending on whether a point to hover over is provided.
-pub fn hover_at(editor: &mut Editor, point: Option<DisplayPoint>, cx: &mut ViewContext<Editor>) {
-    if settings::get::<EditorSettings>(cx).hover_popover_enabled {
-        if let Some(point) = point {
+pub fn hover_at(editor: &mut Editor, action: &HoverAt, cx: &mut ViewContext<Editor>) {
+    if cx.global::<Settings>().hover_popover_enabled {
+        if let Some(point) = action.point {
             show_hover(editor, point, false, cx);
         } else {
-            hide_hover(editor, cx);
+            hide_hover(editor, &HideHover, cx);
         }
     }
 }
@@ -49,7 +62,7 @@ pub fn hover_at(editor: &mut Editor, point: Option<DisplayPoint>, cx: &mut ViewC
 /// Hides the type information popup.
 /// Triggered by the `Hover` action when the cursor is not over a symbol or when the
 /// selections changed.
-pub fn hide_hover(editor: &mut Editor, cx: &mut ViewContext<Editor>) -> bool {
+pub fn hide_hover(editor: &mut Editor, _: &HideHover, cx: &mut ViewContext<Editor>) -> bool {
     let did_hide = editor.hover_state.info_popover.take().is_some()
         | editor.hover_state.diagnostic_popover.take().is_some();
 
@@ -116,7 +129,7 @@ fn show_hover(
                 // Hover triggered from same location as last time. Don't show again.
                 return;
             } else {
-                hide_hover(editor, cx);
+                hide_hover(editor, &HideHover, cx);
             }
         }
     }
@@ -136,7 +149,7 @@ fn show_hover(
         }
     }
 
-    let task = cx.spawn(|this, mut cx| {
+    let task = cx.spawn_weak(|this, mut cx| {
         async move {
             // If we need to delay, delay a set amount initially before making the lsp request
             let delay = if !ignore_timeout {
@@ -188,13 +201,15 @@ fn show_hover(
                     })
             });
 
-            this.update(&mut cx, |this, _| {
-                this.hover_state.diagnostic_popover =
-                    local_diagnostic.map(|local_diagnostic| DiagnosticPopover {
-                        local_diagnostic,
-                        primary_diagnostic,
-                    });
-            })?;
+            if let Some(this) = this.upgrade(&cx) {
+                this.update(&mut cx, |this, _| {
+                    this.hover_state.diagnostic_popover =
+                        local_diagnostic.map(|local_diagnostic| DiagnosticPopover {
+                            local_diagnostic,
+                            primary_diagnostic,
+                        });
+                });
+            }
 
             // Construct new hover popover from hover request
             let hover_popover = hover_request.await.ok().flatten().and_then(|hover_result| {
@@ -220,27 +235,27 @@ fn show_hover(
                 Some(InfoPopover {
                     project: project.clone(),
                     symbol_range: range,
-                    blocks: hover_result.contents,
-                    rendered_content: None,
+                    contents: hover_result.contents,
                 })
             });
 
-            this.update(&mut cx, |this, cx| {
-                if let Some(hover_popover) = hover_popover.as_ref() {
-                    // Highlight the selected symbol using a background highlight
-                    this.highlight_background::<HoverState>(
-                        vec![hover_popover.symbol_range.clone()],
-                        |theme| theme.editor.hover_popover.highlight,
-                        cx,
-                    );
-                } else {
-                    this.clear_background_highlights::<HoverState>(cx);
-                }
-
-                this.hover_state.info_popover = hover_popover;
-                cx.notify();
-            })?;
+            if let Some(this) = this.upgrade(&cx) {
+                this.update(&mut cx, |this, cx| {
+                    if let Some(hover_popover) = hover_popover.as_ref() {
+                        // Highlight the selected symbol using a background highlight
+                        this.highlight_background::<HoverState>(
+                            vec![hover_popover.symbol_range.clone()],
+                            |theme| theme.editor.hover_popover.highlight,
+                            cx,
+                        );
+                    } else {
+                        this.clear_background_highlights::<HoverState>(cx);
+                    }
 
+                    this.hover_state.info_popover = hover_popover;
+                    cx.notify();
+                });
+            }
             Ok::<_, anyhow::Error>(())
         }
         .log_err()
@@ -249,225 +264,6 @@ fn show_hover(
     editor.hover_state.info_task = Some(task);
 }
 
-fn render_blocks(
-    theme_id: usize,
-    blocks: &[HoverBlock],
-    language_registry: &Arc<LanguageRegistry>,
-    style: &EditorStyle,
-) -> RenderedInfo {
-    let mut text = String::new();
-    let mut highlights = Vec::new();
-    let mut region_ranges = Vec::new();
-    let mut regions = Vec::new();
-
-    for block in blocks {
-        match &block.kind {
-            HoverBlockKind::PlainText => {
-                new_paragraph(&mut text, &mut Vec::new());
-                text.push_str(&block.text);
-            }
-            HoverBlockKind::Markdown => {
-                use pulldown_cmark::{CodeBlockKind, Event, Options, Parser, Tag};
-
-                let mut bold_depth = 0;
-                let mut italic_depth = 0;
-                let mut link_url = None;
-                let mut current_language = None;
-                let mut list_stack = Vec::new();
-
-                for event in Parser::new_ext(&block.text, Options::all()) {
-                    let prev_len = text.len();
-                    match event {
-                        Event::Text(t) => {
-                            if let Some(language) = &current_language {
-                                render_code(
-                                    &mut text,
-                                    &mut highlights,
-                                    t.as_ref(),
-                                    language,
-                                    style,
-                                );
-                            } else {
-                                text.push_str(t.as_ref());
-
-                                let mut style = HighlightStyle::default();
-                                if bold_depth > 0 {
-                                    style.weight = Some(Weight::BOLD);
-                                }
-                                if italic_depth > 0 {
-                                    style.italic = Some(true);
-                                }
-                                if let Some(link_url) = link_url.clone() {
-                                    region_ranges.push(prev_len..text.len());
-                                    regions.push(RenderedRegion {
-                                        link_url: Some(link_url),
-                                        code: false,
-                                    });
-                                    style.underline = Some(Underline {
-                                        thickness: 1.0.into(),
-                                        ..Default::default()
-                                    });
-                                }
-
-                                if style != HighlightStyle::default() {
-                                    let mut new_highlight = true;
-                                    if let Some((last_range, last_style)) = highlights.last_mut() {
-                                        if last_range.end == prev_len && last_style == &style {
-                                            last_range.end = text.len();
-                                            new_highlight = false;
-                                        }
-                                    }
-                                    if new_highlight {
-                                        highlights.push((prev_len..text.len(), style));
-                                    }
-                                }
-                            }
-                        }
-                        Event::Code(t) => {
-                            text.push_str(t.as_ref());
-                            region_ranges.push(prev_len..text.len());
-                            if link_url.is_some() {
-                                highlights.push((
-                                    prev_len..text.len(),
-                                    HighlightStyle {
-                                        underline: Some(Underline {
-                                            thickness: 1.0.into(),
-                                            ..Default::default()
-                                        }),
-                                        ..Default::default()
-                                    },
-                                ));
-                            }
-                            regions.push(RenderedRegion {
-                                code: true,
-                                link_url: link_url.clone(),
-                            });
-                        }
-                        Event::Start(tag) => match tag {
-                            Tag::Paragraph => new_paragraph(&mut text, &mut list_stack),
-                            Tag::Heading(_, _, _) => {
-                                new_paragraph(&mut text, &mut list_stack);
-                                bold_depth += 1;
-                            }
-                            Tag::CodeBlock(kind) => {
-                                new_paragraph(&mut text, &mut list_stack);
-                                if let CodeBlockKind::Fenced(language) = kind {
-                                    current_language = language_registry
-                                        .language_for_name(language.as_ref())
-                                        .now_or_never()
-                                        .and_then(Result::ok);
-                                }
-                            }
-                            Tag::Emphasis => italic_depth += 1,
-                            Tag::Strong => bold_depth += 1,
-                            Tag::Link(_, url, _) => link_url = Some(url.to_string()),
-                            Tag::List(number) => {
-                                list_stack.push((number, false));
-                            }
-                            Tag::Item => {
-                                let len = list_stack.len();
-                                if let Some((list_number, has_content)) = list_stack.last_mut() {
-                                    *has_content = false;
-                                    if !text.is_empty() && !text.ends_with('\n') {
-                                        text.push('\n');
-                                    }
-                                    for _ in 0..len - 1 {
-                                        text.push_str("  ");
-                                    }
-                                    if let Some(number) = list_number {
-                                        text.push_str(&format!("{}. ", number));
-                                        *number += 1;
-                                        *has_content = false;
-                                    } else {
-                                        text.push_str("- ");
-                                    }
-                                }
-                            }
-                            _ => {}
-                        },
-                        Event::End(tag) => match tag {
-                            Tag::Heading(_, _, _) => bold_depth -= 1,
-                            Tag::CodeBlock(_) => current_language = None,
-                            Tag::Emphasis => italic_depth -= 1,
-                            Tag::Strong => bold_depth -= 1,
-                            Tag::Link(_, _, _) => link_url = None,
-                            Tag::List(_) => drop(list_stack.pop()),
-                            _ => {}
-                        },
-                        Event::HardBreak => text.push('\n'),
-                        Event::SoftBreak => text.push(' '),
-                        _ => {}
-                    }
-                }
-            }
-            HoverBlockKind::Code { language } => {
-                if let Some(language) = language_registry
-                    .language_for_name(language)
-                    .now_or_never()
-                    .and_then(Result::ok)
-                {
-                    render_code(&mut text, &mut highlights, &block.text, &language, style);
-                } else {
-                    text.push_str(&block.text);
-                }
-            }
-        }
-    }
-
-    if !text.is_empty() && !text.ends_with('\n') {
-        text.push('\n');
-    }
-
-    RenderedInfo {
-        theme_id,
-        text,
-        highlights,
-        region_ranges,
-        regions,
-    }
-}
-
-fn render_code(
-    text: &mut String,
-    highlights: &mut Vec<(Range<usize>, HighlightStyle)>,
-    content: &str,
-    language: &Arc<Language>,
-    style: &EditorStyle,
-) {
-    let prev_len = text.len();
-    text.push_str(content);
-    for (range, highlight_id) in language.highlight_text(&content.into(), 0..content.len()) {
-        if let Some(style) = highlight_id.style(&style.syntax) {
-            highlights.push((prev_len + range.start..prev_len + range.end, style));
-        }
-    }
-}
-
-fn new_paragraph(text: &mut String, list_stack: &mut Vec<(Option<u64>, bool)>) {
-    let mut is_subsequent_paragraph_of_list = false;
-    if let Some((_, has_content)) = list_stack.last_mut() {
-        if *has_content {
-            is_subsequent_paragraph_of_list = true;
-        } else {
-            *has_content = true;
-            return;
-        }
-    }
-
-    if !text.is_empty() {
-        if !text.ends_with('\n') {
-            text.push('\n');
-        }
-        text.push('\n');
-    }
-    for _ in 0..list_stack.len().saturating_sub(1) {
-        text.push_str("  ");
-    }
-    if is_subsequent_paragraph_of_list {
-        text.push_str("  ");
-    }
-}
-
 #[derive(Default)]
 pub struct HoverState {
     pub info_popover: Option<InfoPopover>,
@@ -482,12 +278,12 @@ impl HoverState {
     }
 
     pub fn render(
-        &mut self,
+        &self,
         snapshot: &EditorSnapshot,
         style: &EditorStyle,
         visible_rows: Range<u32>,
-        cx: &mut ViewContext<Editor>,
-    ) -> Option<(DisplayPoint, Vec<AnyElement<Editor>>)> {
+        cx: &mut RenderContext<Editor>,
+    ) -> Option<(DisplayPoint, Vec<ElementBox>)> {
         // If there is a diagnostic, position the popovers based on that.
         // Otherwise use the start of the hover range
         let anchor = self
@@ -511,7 +307,7 @@ impl HoverState {
         if let Some(diagnostic_popover) = self.diagnostic_popover.as_ref() {
             elements.push(diagnostic_popover.render(style, cx));
         }
-        if let Some(info_popover) = self.info_popover.as_mut() {
+        if let Some(info_popover) = self.info_popover.as_ref() {
             elements.push(info_popover.render(style, cx));
         }
 
@@ -523,101 +319,55 @@ impl HoverState {
 pub struct InfoPopover {
     pub project: ModelHandle<Project>,
     pub symbol_range: Range<Anchor>,
-    pub blocks: Vec<HoverBlock>,
-    rendered_content: Option<RenderedInfo>,
-}
-
-#[derive(Debug, Clone)]
-struct RenderedInfo {
-    theme_id: usize,
-    text: String,
-    highlights: Vec<(Range<usize>, HighlightStyle)>,
-    region_ranges: Vec<Range<usize>>,
-    regions: Vec<RenderedRegion>,
-}
-
-#[derive(Debug, Clone)]
-struct RenderedRegion {
-    code: bool,
-    link_url: Option<String>,
+    pub contents: Vec<HoverBlock>,
 }
 
 impl InfoPopover {
-    pub fn render(
-        &mut self,
-        style: &EditorStyle,
-        cx: &mut ViewContext<Editor>,
-    ) -> AnyElement<Editor> {
-        if let Some(rendered) = &self.rendered_content {
-            if rendered.theme_id != style.theme_id {
-                self.rendered_content = None;
-            }
-        }
+    pub fn render(&self, style: &EditorStyle, cx: &mut RenderContext<Editor>) -> ElementBox {
+        MouseEventHandler::<InfoPopover>::new(0, cx, |_, cx| {
+            let mut flex = Flex::new(Axis::Vertical).scrollable::<HoverBlock, _>(1, None, cx);
+            flex.extend(self.contents.iter().map(|content| {
+                let languages = self.project.read(cx).languages();
+                if let Some(language) = content.language.clone().and_then(|language| {
+                    languages.language_for_name(&language).now_or_never()?.ok()
+                }) {
+                    let runs = language
+                        .highlight_text(&content.text.as_str().into(), 0..content.text.len());
 
-        let rendered_content = self.rendered_content.get_or_insert_with(|| {
-            render_blocks(
-                style.theme_id,
-                &self.blocks,
-                self.project.read(cx).languages(),
-                style,
-            )
-        });
-
-        MouseEventHandler::<InfoPopover, _>::new(0, cx, |_, cx| {
-            let mut region_id = 0;
-            let view_id = cx.view_id();
-
-            let code_span_background_color = style.document_highlight_read_background;
-            let regions = rendered_content.regions.clone();
-            Flex::column()
-                .scrollable::<HoverBlock>(1, None, cx)
-                .with_child(
-                    Text::new(rendered_content.text.clone(), style.text.clone())
-                        .with_highlights(rendered_content.highlights.clone())
-                        .with_custom_runs(
-                            rendered_content.region_ranges.clone(),
-                            move |ix, bounds, scene, _| {
-                                region_id += 1;
-                                let region = regions[ix].clone();
-                                if let Some(url) = region.link_url {
-                                    scene.push_cursor_region(CursorRegion {
-                                        bounds,
-                                        style: CursorStyle::PointingHand,
-                                    });
-                                    scene.push_mouse_region(
-                                        MouseRegion::new::<Self>(view_id, region_id, bounds)
-                                            .on_click::<Editor, _>(
-                                                MouseButton::Left,
-                                                move |_, _, cx| {
-                                                    println!("clicked link {url}");
-                                                    cx.platform().open_url(&url);
-                                                },
-                                            ),
-                                    );
-                                }
-                                if region.code {
-                                    scene.push_quad(gpui::Quad {
-                                        bounds,
-                                        background: Some(code_span_background_color),
-                                        border: Default::default(),
-                                        corner_radius: 2.0,
-                                    });
-                                }
-                            },
+                    Text::new(content.text.clone(), style.text.clone())
+                        .with_soft_wrap(true)
+                        .with_highlights(
+                            runs.iter()
+                                .filter_map(|(range, id)| {
+                                    id.style(style.theme.syntax.as_ref())
+                                        .map(|style| (range.clone(), style))
+                                })
+                                .collect(),
                         )
-                        .with_soft_wrap(true),
-                )
-                .contained()
+                        .boxed()
+                } else {
+                    let mut text_style = style.hover_popover.prose.clone();
+                    text_style.font_size = style.text.font_size;
+
+                    Text::new(content.text.clone(), text_style)
+                        .with_soft_wrap(true)
+                        .contained()
+                        .with_style(style.hover_popover.block_style)
+                        .boxed()
+                }
+            }));
+            flex.contained()
                 .with_style(style.hover_popover.container)
+                .boxed()
         })
-        .on_move(|_, _, _| {}) // Consume move events so they don't reach regions underneath.
+        .on_move(|_, _| {}) // Consume move events so they don't reach regions underneath.
         .with_cursor_style(CursorStyle::Arrow)
         .with_padding(Padding {
             bottom: HOVER_POPOVER_GAP,
             top: HOVER_POPOVER_GAP,
             ..Default::default()
         })
-        .into_any()
+        .boxed()
     }
 }
 
@@ -628,22 +378,11 @@ pub struct DiagnosticPopover {
 }
 
 impl DiagnosticPopover {
-    pub fn render(&self, style: &EditorStyle, cx: &mut ViewContext<Editor>) -> AnyElement<Editor> {
+    pub fn render(&self, style: &EditorStyle, cx: &mut RenderContext<Editor>) -> ElementBox {
         enum PrimaryDiagnostic {}
 
         let mut text_style = style.hover_popover.prose.clone();
         text_style.font_size = style.text.font_size;
-        let diagnostic_source_style = style.hover_popover.diagnostic_source_highlight.clone();
-
-        let text = match &self.local_diagnostic.diagnostic.source {
-            Some(source) => Text::new(
-                format!("{source}: {}", self.local_diagnostic.diagnostic.message),
-                text_style,
-            )
-            .with_highlights(vec![(0..source.len(), diagnostic_source_style)]),
-
-            None => Text::new(self.local_diagnostic.diagnostic.message.clone(), text_style),
-        };
 
         let container_style = match self.local_diagnostic.diagnostic.severity {
             DiagnosticSeverity::HINT => style.hover_popover.info_container,
@@ -653,31 +392,33 @@ impl DiagnosticPopover {
             _ => style.hover_popover.container,
         };
 
-        let tooltip_style = theme::current(cx).tooltip.clone();
+        let tooltip_style = cx.global::<Settings>().theme.tooltip.clone();
 
-        MouseEventHandler::<DiagnosticPopover, _>::new(0, cx, |_, _| {
-            text.with_soft_wrap(true)
+        MouseEventHandler::<DiagnosticPopover>::new(0, cx, |_, _| {
+            Text::new(self.local_diagnostic.diagnostic.message.clone(), text_style)
+                .with_soft_wrap(true)
                 .contained()
                 .with_style(container_style)
+                .boxed()
         })
         .with_padding(Padding {
             top: HOVER_POPOVER_GAP,
             bottom: HOVER_POPOVER_GAP,
             ..Default::default()
         })
-        .on_move(|_, _, _| {}) // Consume move events so they don't reach regions underneath.
-        .on_click(MouseButton::Left, |_, this, cx| {
-            this.go_to_diagnostic(&Default::default(), cx)
+        .on_move(|_, _| {}) // Consume move events so they don't reach regions underneath.
+        .on_click(MouseButton::Left, |_, cx| {
+            cx.dispatch_action(GoToDiagnostic)
         })
         .with_cursor_style(CursorStyle::PointingHand)
-        .with_tooltip::<PrimaryDiagnostic>(
+        .with_tooltip::<PrimaryDiagnostic, _>(
             0,
             "Go To Diagnostic".to_string(),
             Some(Box::new(crate::GoToDiagnostic)),
             tooltip_style,
             cx,
         )
-        .into_any()
+        .boxed()
     }
 
     pub fn activation_info(&self) -> (usize, Anchor) {
@@ -692,21 +433,18 @@ impl DiagnosticPopover {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::{editor_tests::init_test, test::editor_lsp_test_context::EditorLspTestContext};
-    use gpui::fonts::Weight;
     use indoc::indoc;
+
     use language::{Diagnostic, DiagnosticSet};
-    use lsp::LanguageServerId;
-    use project::{HoverBlock, HoverBlockKind};
+    use project::HoverBlock;
     use smol::stream::StreamExt;
-    use unindent::Unindent;
-    use util::test::marked_text_ranges;
+
+    use crate::test::editor_lsp_test_context::EditorLspTestContext;
+
+    use super::*;
 
     #[gpui::test]
     async fn test_mouse_hover_info_popover(cx: &mut gpui::TestAppContext) {
-        init_test(cx, |_| {});
-
         let mut cx = EditorLspTestContext::new_rust(
             lsp::ServerCapabilities {
                 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
@@ -724,7 +462,15 @@ mod tests {
             fn test() { printˇln!(); }
         "});
 
-        cx.update_editor(|editor, cx| hover_at(editor, Some(hover_point), cx));
+        cx.update_editor(|editor, cx| {
+            hover_at(
+                editor,
+                &HoverAt {
+                    point: Some(hover_point),
+                },
+                cx,
+            )
+        });
         assert!(!cx.editor(|editor, _| editor.hover_state.visible()));
 
         // After delay, hover should be visible.
@@ -736,7 +482,10 @@ mod tests {
                 Ok(Some(lsp::Hover {
                     contents: lsp::HoverContents::Markup(lsp::MarkupContent {
                         kind: lsp::MarkupKind::Markdown,
-                        value: "some basic docs".to_string(),
+                        value: indoc! {"
+                            # Some basic docs
+                            Some test documentation"}
+                        .to_string(),
                     }),
                     range: Some(symbol_range),
                 }))
@@ -748,11 +497,17 @@ mod tests {
         cx.editor(|editor, _| {
             assert!(editor.hover_state.visible());
             assert_eq!(
-                editor.hover_state.info_popover.clone().unwrap().blocks,
-                vec![HoverBlock {
-                    text: "some basic docs".to_string(),
-                    kind: HoverBlockKind::Markdown,
-                },]
+                editor.hover_state.info_popover.clone().unwrap().contents,
+                vec![
+                    HoverBlock {
+                        text: "Some basic docs".to_string(),
+                        language: None
+                    },
+                    HoverBlock {
+                        text: "Some test documentation".to_string(),
+                        language: None
+                    }
+                ]
             )
         });
 
@@ -763,7 +518,15 @@ mod tests {
         let mut request = cx
             .lsp
             .handle_request::<lsp::request::HoverRequest, _, _>(|_, _| async move { Ok(None) });
-        cx.update_editor(|editor, cx| hover_at(editor, Some(hover_point), cx));
+        cx.update_editor(|editor, cx| {
+            hover_at(
+                editor,
+                &HoverAt {
+                    point: Some(hover_point),
+                },
+                cx,
+            )
+        });
         cx.foreground()
             .advance_clock(Duration::from_millis(HOVER_DELAY_MILLIS + 100));
         request.next().await;
@@ -774,8 +537,6 @@ mod tests {
 
     #[gpui::test]
     async fn test_keyboard_hover_info_popover(cx: &mut gpui::TestAppContext) {
-        init_test(cx, |_| {});
-
         let mut cx = EditorLspTestContext::new_rust(
             lsp::ServerCapabilities {
                 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
@@ -797,7 +558,10 @@ mod tests {
             Ok(Some(lsp::Hover {
                 contents: lsp::HoverContents::Markup(lsp::MarkupContent {
                     kind: lsp::MarkupKind::Markdown,
-                    value: "some other basic docs".to_string(),
+                    value: indoc! {"
+                        # Some other basic docs
+                        Some other test documentation"}
+                    .to_string(),
                 }),
                 range: Some(symbol_range),
             }))
@@ -808,19 +572,23 @@ mod tests {
         cx.condition(|editor, _| editor.hover_state.visible()).await;
         cx.editor(|editor, _| {
             assert_eq!(
-                editor.hover_state.info_popover.clone().unwrap().blocks,
-                vec![HoverBlock {
-                    text: "some other basic docs".to_string(),
-                    kind: HoverBlockKind::Markdown,
-                }]
+                editor.hover_state.info_popover.clone().unwrap().contents,
+                vec![
+                    HoverBlock {
+                        text: "Some other basic docs".to_string(),
+                        language: None
+                    },
+                    HoverBlock {
+                        text: "Some other test documentation".to_string(),
+                        language: None
+                    }
+                ]
             )
         });
     }
 
     #[gpui::test]
     async fn test_hover_diagnostic_and_info_popovers(cx: &mut gpui::TestAppContext) {
-        init_test(cx, |_| {});
-
         let mut cx = EditorLspTestContext::new_rust(
             lsp::ServerCapabilities {
                 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
@@ -852,7 +620,7 @@ mod tests {
                 }],
                 &snapshot,
             );
-            buffer.update_diagnostics(LanguageServerId(0), set, cx);
+            buffer.update_diagnostics(set, cx);
         });
 
         // Hover pops diagnostic immediately
@@ -871,7 +639,10 @@ mod tests {
             Ok(Some(lsp::Hover {
                 contents: lsp::HoverContents::Markup(lsp::MarkupContent {
                     kind: lsp::MarkupKind::Markdown,
-                    value: "some new docs".to_string(),
+                    value: indoc! {"
+                        # Some other basic docs
+                        Some other test documentation"}
+                    .to_string(),
                 }),
                 range: Some(range),
             }))
@@ -884,144 +655,4 @@ mod tests {
             hover_state.diagnostic_popover.is_some() && hover_state.info_task.is_some()
         });
     }
-
-    #[gpui::test]
-    fn test_render_blocks(cx: &mut gpui::TestAppContext) {
-        init_test(cx, |_| {});
-
-        cx.add_window(|cx| {
-            let editor = Editor::single_line(None, cx);
-            let style = editor.style(cx);
-
-            struct Row {
-                blocks: Vec<HoverBlock>,
-                expected_marked_text: String,
-                expected_styles: Vec<HighlightStyle>,
-            }
-
-            let rows = &[
-                // Strong emphasis
-                Row {
-                    blocks: vec![HoverBlock {
-                        text: "one **two** three".to_string(),
-                        kind: HoverBlockKind::Markdown,
-                    }],
-                    expected_marked_text: "one «two» three\n".to_string(),
-                    expected_styles: vec![HighlightStyle {
-                        weight: Some(Weight::BOLD),
-                        ..Default::default()
-                    }],
-                },
-                // Links
-                Row {
-                    blocks: vec![HoverBlock {
-                        text: "one [two](the-url) three".to_string(),
-                        kind: HoverBlockKind::Markdown,
-                    }],
-                    expected_marked_text: "one «two» three\n".to_string(),
-                    expected_styles: vec![HighlightStyle {
-                        underline: Some(Underline {
-                            thickness: 1.0.into(),
-                            ..Default::default()
-                        }),
-                        ..Default::default()
-                    }],
-                },
-                // Lists
-                Row {
-                    blocks: vec![HoverBlock {
-                        text: "
-                            lists:
-                            * one
-                                - a
-                                - b
-                            * two
-                                - [c](the-url)
-                                - d
-                        "
-                        .unindent(),
-                        kind: HoverBlockKind::Markdown,
-                    }],
-                    expected_marked_text: "
-                        lists:
-                        - one
-                          - a
-                          - b
-                        - two
-                          - «c»
-                          - d
-                    "
-                    .unindent(),
-                    expected_styles: vec![HighlightStyle {
-                        underline: Some(Underline {
-                            thickness: 1.0.into(),
-                            ..Default::default()
-                        }),
-                        ..Default::default()
-                    }],
-                },
-                // Multi-paragraph list items
-                Row {
-                    blocks: vec![HoverBlock {
-                        text: "
-                            * one two
-                              three
-
-                            * four five
-                                * six seven
-                                  eight
-
-                                  nine
-                                * ten
-                            * six
-                        "
-                        .unindent(),
-                        kind: HoverBlockKind::Markdown,
-                    }],
-                    expected_marked_text: "
-                        - one two three
-                        - four five
-                          - six seven eight
-
-                            nine
-                          - ten
-                        - six
-                    "
-                    .unindent(),
-                    expected_styles: vec![HighlightStyle {
-                        underline: Some(Underline {
-                            thickness: 1.0.into(),
-                            ..Default::default()
-                        }),
-                        ..Default::default()
-                    }],
-                },
-            ];
-
-            for Row {
-                blocks,
-                expected_marked_text,
-                expected_styles,
-            } in &rows[0..]
-            {
-                let rendered = render_blocks(0, &blocks, &Default::default(), &style);
-
-                let (expected_text, ranges) = marked_text_ranges(expected_marked_text, false);
-                let expected_highlights = ranges
-                    .into_iter()
-                    .zip(expected_styles.iter().cloned())
-                    .collect::<Vec<_>>();
-                assert_eq!(
-                    rendered.text, expected_text,
-                    "wrong text for input {blocks:?}"
-                );
-                assert_eq!(
-                    rendered.highlights, expected_highlights,
-                    "wrong highlights for input {blocks:?}"
-                );
-            }
-
-            editor
-        });
-    }
 }

crates/editor/src/items.rs

@@ -3,11 +3,11 @@ use crate::{
     movement::surrounding_word, persistence::DB, scroll::ScrollAnchor, Anchor, Autoscroll, Editor,
     Event, ExcerptId, ExcerptRange, MultiBuffer, MultiBufferSnapshot, NavigationData, ToPoint as _,
 };
-use anyhow::{Context, Result};
+use anyhow::{anyhow, Context, Result};
 use collections::HashSet;
 use futures::future::try_join_all;
 use gpui::{
-    elements::*, geometry::vector::vec2f, AppContext, AsyncAppContext, Entity, ModelHandle,
+    elements::*, geometry::vector::vec2f, AppContext, Entity, ModelHandle, RenderContext,
     Subscription, Task, View, ViewContext, ViewHandle, WeakViewHandle,
 };
 use language::{
@@ -16,6 +16,7 @@ use language::{
 };
 use project::{FormatTrigger, Item as _, Project, ProjectPath};
 use rpc::proto::{self, update_view};
+use settings::Settings;
 use smallvec::SmallVec;
 use std::{
     borrow::Cow,
@@ -26,8 +27,8 @@ use std::{
     path::{Path, PathBuf},
 };
 use text::Selection;
-use util::{paths::FILE_ROW_COLUMN_DELIMITER, ResultExt, TryFutureExt};
-use workspace::item::{BreadcrumbText, FollowableItemHandle};
+use util::{ResultExt, TryFutureExt};
+use workspace::item::FollowableItemHandle;
 use workspace::{
     item::{FollowableItem, Item, ItemEvent, ItemHandle, ProjectItem},
     searchable::{Direction, SearchEvent, SearchableItem, SearchableItemHandle},
@@ -66,23 +67,20 @@ impl FollowableItem for Editor {
                 .collect::<Vec<_>>()
         });
 
-        let pane = pane.downgrade();
         Some(cx.spawn(|mut cx| async move {
             let mut buffers = futures::future::try_join_all(buffers).await?;
             let editor = pane.read_with(&cx, |pane, cx| {
                 let mut editors = pane.items_of_type::<Self>();
                 editors.find(|editor| {
-                    let ids_match = editor.remote_id(&client, cx) == Some(remote_id);
-                    let singleton_buffer_matches = state.singleton
-                        && buffers.first()
-                            == editor.read(cx).buffer.read(cx).as_singleton().as_ref();
-                    ids_match || singleton_buffer_matches
+                    editor.remote_id(&client, cx) == Some(remote_id)
+                        || state.singleton
+                            && buffers.len() == 1
+                            && editor.read(cx).buffer.read(cx).as_singleton().as_ref()
+                                == Some(&buffers[0])
                 })
-            })?;
+            });
 
-            let editor = if let Some(editor) = editor {
-                editor
-            } else {
+            let editor = editor.unwrap_or_else(|| {
                 pane.update(&mut cx, |_, cx| {
                     let multibuffer = cx.add_model(|cx| {
                         let mut multibuffer;
@@ -117,29 +115,46 @@ impl FollowableItem for Editor {
                         multibuffer
                     });
 
-                    cx.add_view(|cx| {
-                        let mut editor =
-                            Editor::for_multibuffer(multibuffer, Some(project.clone()), cx);
-                        editor.remote_id = Some(remote_id);
-                        editor
-                    })
-                })?
-            };
+                    cx.add_view(|cx| Editor::for_multibuffer(multibuffer, Some(project), cx))
+                })
+            });
 
-            update_editor_from_message(
-                editor.downgrade(),
-                project,
-                proto::update_view::Editor {
-                    selections: state.selections,
-                    pending_selection: state.pending_selection,
-                    scroll_top_anchor: state.scroll_top_anchor,
-                    scroll_x: state.scroll_x,
-                    scroll_y: state.scroll_y,
-                    ..Default::default()
-                },
-                &mut cx,
-            )
-            .await?;
+            editor.update(&mut cx, |editor, cx| {
+                editor.remote_id = Some(remote_id);
+                let buffer = editor.buffer.read(cx).read(cx);
+                let selections = state
+                    .selections
+                    .into_iter()
+                    .map(|selection| {
+                        deserialize_selection(&buffer, selection)
+                            .ok_or_else(|| anyhow!("invalid selection"))
+                    })
+                    .collect::<Result<Vec<_>>>()?;
+                let pending_selection = state
+                    .pending_selection
+                    .map(|selection| deserialize_selection(&buffer, selection))
+                    .flatten();
+                let scroll_top_anchor = state
+                    .scroll_top_anchor
+                    .and_then(|anchor| deserialize_anchor(&buffer, anchor));
+                drop(buffer);
+
+                if !selections.is_empty() || pending_selection.is_some() {
+                    editor.set_selections_from_remote(selections, pending_selection, cx);
+                }
+
+                if let Some(scroll_top_anchor) = scroll_top_anchor {
+                    editor.set_scroll_anchor_remote(
+                        ScrollAnchor {
+                            top_anchor: scroll_top_anchor,
+                            offset: vec2f(state.scroll_x, state.scroll_y),
+                        },
+                        cx,
+                    );
+                }
+
+                anyhow::Ok(())
+            })?;
 
             Ok(editor)
         }))
@@ -284,9 +299,96 @@ impl FollowableItem for Editor {
         cx: &mut ViewContext<Self>,
     ) -> Task<Result<()>> {
         let update_view::Variant::Editor(message) = message;
+        let multibuffer = self.buffer.read(cx);
+        let multibuffer = multibuffer.read(cx);
+
+        let buffer_ids = message
+            .inserted_excerpts
+            .iter()
+            .filter_map(|insertion| Some(insertion.excerpt.as_ref()?.buffer_id))
+            .collect::<HashSet<_>>();
+
+        let mut removals = message
+            .deleted_excerpts
+            .into_iter()
+            .map(ExcerptId::from_proto)
+            .collect::<Vec<_>>();
+        removals.sort_by(|a, b| a.cmp(&b, &multibuffer));
+
+        let selections = message
+            .selections
+            .into_iter()
+            .filter_map(|selection| deserialize_selection(&multibuffer, selection))
+            .collect::<Vec<_>>();
+        let pending_selection = message
+            .pending_selection
+            .and_then(|selection| deserialize_selection(&multibuffer, selection));
+
+        let scroll_top_anchor = message
+            .scroll_top_anchor
+            .and_then(|anchor| deserialize_anchor(&multibuffer, anchor));
+        drop(multibuffer);
+
+        let buffers = project.update(cx, |project, cx| {
+            buffer_ids
+                .into_iter()
+                .map(|id| project.open_buffer_by_id(id, cx))
+                .collect::<Vec<_>>()
+        });
+
         let project = project.clone();
         cx.spawn(|this, mut cx| async move {
-            update_editor_from_message(this, project, message, &mut cx).await
+            let _buffers = try_join_all(buffers).await?;
+            this.update(&mut cx, |this, cx| {
+                this.buffer.update(cx, |multibuffer, cx| {
+                    let mut insertions = message.inserted_excerpts.into_iter().peekable();
+                    while let Some(insertion) = insertions.next() {
+                        let Some(excerpt) = insertion.excerpt else { continue };
+                        let Some(previous_excerpt_id) = insertion.previous_excerpt_id else { continue };
+                        let buffer_id = excerpt.buffer_id;
+                        let Some(buffer) = project.read(cx).buffer_for_id(buffer_id, cx) else { continue };
+
+                        let adjacent_excerpts = iter::from_fn(|| {
+                            let insertion = insertions.peek()?;
+                            if insertion.previous_excerpt_id.is_none()
+                                && insertion.excerpt.as_ref()?.buffer_id == buffer_id
+                            {
+                                insertions.next()?.excerpt
+                            } else {
+                                None
+                            }
+                        });
+
+                        multibuffer.insert_excerpts_with_ids_after(
+                            ExcerptId::from_proto(previous_excerpt_id),
+                            buffer,
+                            [excerpt]
+                                .into_iter()
+                                .chain(adjacent_excerpts)
+                                .filter_map(|excerpt| {
+                                    Some((
+                                        ExcerptId::from_proto(excerpt.id),
+                                        deserialize_excerpt_range(excerpt)?,
+                                    ))
+                                }),
+                            cx,
+                        );
+                    }
+
+                    multibuffer.remove_excerpts(removals, cx);
+                });
+
+                if !selections.is_empty() || pending_selection.is_some() {
+                    this.set_selections_from_remote(selections, pending_selection, cx);
+                    this.request_autoscroll_remotely(Autoscroll::newest(), cx);
+                } else if let Some(anchor) = scroll_top_anchor {
+                    this.set_scroll_anchor_remote(ScrollAnchor {
+                        top_anchor: anchor,
+                        offset: vec2f(message.scroll_x, message.scroll_y)
+                    }, cx);
+                }
+            });
+            Ok(())
         })
     }
 
@@ -300,128 +402,6 @@ impl FollowableItem for Editor {
     }
 }
 
-async fn update_editor_from_message(
-    this: WeakViewHandle<Editor>,
-    project: ModelHandle<Project>,
-    message: proto::update_view::Editor,
-    cx: &mut AsyncAppContext,
-) -> Result<()> {
-    // Open all of the buffers of which excerpts were added to the editor.
-    let inserted_excerpt_buffer_ids = message
-        .inserted_excerpts
-        .iter()
-        .filter_map(|insertion| Some(insertion.excerpt.as_ref()?.buffer_id))
-        .collect::<HashSet<_>>();
-    let inserted_excerpt_buffers = project.update(cx, |project, cx| {
-        inserted_excerpt_buffer_ids
-            .into_iter()
-            .map(|id| project.open_buffer_by_id(id, cx))
-            .collect::<Vec<_>>()
-    });
-    let _inserted_excerpt_buffers = try_join_all(inserted_excerpt_buffers).await?;
-
-    // Update the editor's excerpts.
-    this.update(cx, |editor, cx| {
-        editor.buffer.update(cx, |multibuffer, cx| {
-            let mut removed_excerpt_ids = message
-                .deleted_excerpts
-                .into_iter()
-                .map(ExcerptId::from_proto)
-                .collect::<Vec<_>>();
-            removed_excerpt_ids.sort_by({
-                let multibuffer = multibuffer.read(cx);
-                move |a, b| a.cmp(&b, &multibuffer)
-            });
-
-            let mut insertions = message.inserted_excerpts.into_iter().peekable();
-            while let Some(insertion) = insertions.next() {
-                let Some(excerpt) = insertion.excerpt else { continue };
-                let Some(previous_excerpt_id) = insertion.previous_excerpt_id else { continue };
-                let buffer_id = excerpt.buffer_id;
-                let Some(buffer) = project.read(cx).buffer_for_id(buffer_id, cx) else { continue };
-
-                let adjacent_excerpts = iter::from_fn(|| {
-                    let insertion = insertions.peek()?;
-                    if insertion.previous_excerpt_id.is_none()
-                        && insertion.excerpt.as_ref()?.buffer_id == buffer_id
-                    {
-                        insertions.next()?.excerpt
-                    } else {
-                        None
-                    }
-                });
-
-                multibuffer.insert_excerpts_with_ids_after(
-                    ExcerptId::from_proto(previous_excerpt_id),
-                    buffer,
-                    [excerpt]
-                        .into_iter()
-                        .chain(adjacent_excerpts)
-                        .filter_map(|excerpt| {
-                            Some((
-                                ExcerptId::from_proto(excerpt.id),
-                                deserialize_excerpt_range(excerpt)?,
-                            ))
-                        }),
-                    cx,
-                );
-            }
-
-            multibuffer.remove_excerpts(removed_excerpt_ids, cx);
-        });
-    })?;
-
-    // Deserialize the editor state.
-    let (selections, pending_selection, scroll_top_anchor) = this.update(cx, |editor, cx| {
-        let buffer = editor.buffer.read(cx).read(cx);
-        let selections = message
-            .selections
-            .into_iter()
-            .filter_map(|selection| deserialize_selection(&buffer, selection))
-            .collect::<Vec<_>>();
-        let pending_selection = message
-            .pending_selection
-            .and_then(|selection| deserialize_selection(&buffer, selection));
-        let scroll_top_anchor = message
-            .scroll_top_anchor
-            .and_then(|anchor| deserialize_anchor(&buffer, anchor));
-        anyhow::Ok((selections, pending_selection, scroll_top_anchor))
-    })??;
-
-    // Wait until the buffer has received all of the operations referenced by
-    // the editor's new state.
-    this.update(cx, |editor, cx| {
-        editor.buffer.update(cx, |buffer, cx| {
-            buffer.wait_for_anchors(
-                selections
-                    .iter()
-                    .chain(pending_selection.as_ref())
-                    .flat_map(|selection| [selection.start, selection.end])
-                    .chain(scroll_top_anchor),
-                cx,
-            )
-        })
-    })?
-    .await?;
-
-    // Update the editor's state.
-    this.update(cx, |editor, cx| {
-        if !selections.is_empty() || pending_selection.is_some() {
-            editor.set_selections_from_remote(selections, pending_selection, cx);
-            editor.request_autoscroll_remotely(Autoscroll::newest(), cx);
-        } else if let Some(scroll_top_anchor) = scroll_top_anchor {
-            editor.set_scroll_anchor_remote(
-                ScrollAnchor {
-                    top_anchor: scroll_top_anchor,
-                    offset: vec2f(message.scroll_x, message.scroll_y),
-                },
-                cx,
-            );
-        }
-    })?;
-    Ok(())
-}
-
 fn serialize_excerpt(
     buffer_id: u64,
     id: &ExcerptId,
@@ -534,38 +514,25 @@ impl Item for Editor {
         }
     }
 
-    fn tab_tooltip_text(&self, cx: &AppContext) -> Option<Cow<str>> {
-        let file_path = self
-            .buffer()
-            .read(cx)
-            .as_singleton()?
-            .read(cx)
-            .file()
-            .and_then(|f| f.as_local())?
-            .abs_path(cx);
-
-        let file_path = util::paths::compact(&file_path)
-            .to_string_lossy()
-            .to_string();
-
-        Some(file_path.into())
-    }
-
-    fn tab_description<'a>(&'a self, detail: usize, cx: &'a AppContext) -> Option<Cow<str>> {
+    fn tab_description<'a>(&'a self, detail: usize, cx: &'a AppContext) -> Option<Cow<'a, str>> {
         match path_for_buffer(&self.buffer, detail, true, cx)? {
             Cow::Borrowed(path) => Some(path.to_string_lossy()),
             Cow::Owned(path) => Some(path.to_string_lossy().to_string().into()),
         }
     }
 
-    fn tab_content<T: View>(
+    fn tab_content(
         &self,
         detail: Option<usize>,
         style: &theme::Tab,
         cx: &AppContext,
-    ) -> AnyElement<T> {
+    ) -> ElementBox {
         Flex::row()
-            .with_child(Label::new(self.title(cx).to_string(), style.label.clone()).into_any())
+            .with_child(
+                Label::new(self.title(cx).to_string(), style.label.clone())
+                    .aligned()
+                    .boxed(),
+            )
             .with_children(detail.and_then(|detail| {
                 let path = path_for_buffer(&self.buffer, detail, false, cx)?;
                 let description = path.to_string_lossy();
@@ -576,11 +543,11 @@ impl Item for Editor {
                     )
                     .contained()
                     .with_style(style.description.container)
-                    .aligned(),
+                    .aligned()
+                    .boxed(),
                 )
             }))
-            .align_children_center()
-            .into_any()
+            .boxed()
     }
 
     fn for_each_project_item(&self, cx: &AppContext, f: &mut dyn FnMut(usize, &dyn project::Item)) {
@@ -636,10 +603,10 @@ impl Item for Editor {
         project: ModelHandle<Project>,
         cx: &mut ViewContext<Self>,
     ) -> Task<Result<()>> {
-        self.report_editor_event("save", None, cx);
+        self.report_event("save editor", cx);
         let format = self.perform_format(project.clone(), FormatTrigger::Save, cx);
         let buffers = self.buffer().clone().read(cx).all_buffers();
-        cx.spawn(|_, mut cx| async move {
+        cx.as_mut().spawn(|mut cx| async move {
             format.await?;
 
             if buffers.len() == 1 {
@@ -685,11 +652,6 @@ impl Item for Editor {
             .as_singleton()
             .expect("cannot call save_as on an excerpt list");
 
-        let file_extension = abs_path
-            .extension()
-            .map(|a| a.to_string_lossy().to_string());
-        self.report_editor_event("save", file_extension, cx);
-
         project.update(cx, |project, cx| {
             project.save_buffer_as(buffer, abs_path, cx)
         })
@@ -708,11 +670,11 @@ impl Item for Editor {
             let transaction = reload_buffers.log_err().await;
             this.update(&mut cx, |editor, cx| {
                 editor.request_autoscroll(Autoscroll::fit(), cx)
-            })?;
-            buffer.update(&mut cx, |buffer, cx| {
+            });
+            buffer.update(&mut cx, |buffer, _| {
                 if let Some(transaction) = transaction {
                     if !buffer.is_singleton() {
-                        buffer.push_transaction(&transaction.0, cx);
+                        buffer.push_transaction(&transaction.0);
                     }
                 }
             });
@@ -765,7 +727,7 @@ impl Item for Editor {
         ToolbarItemLocation::PrimaryLeft { flex: None }
     }
 
-    fn breadcrumbs(&self, theme: &theme::Theme, cx: &AppContext) -> Option<Vec<BreadcrumbText>> {
+    fn breadcrumbs(&self, theme: &theme::Theme, cx: &AppContext) -> Option<Vec<ElementBox>> {
         let cursor = self.selections.newest_anchor().head();
         let multibuffer = &self.buffer().read(cx);
         let (buffer_id, symbols) =
@@ -785,13 +747,15 @@ impl Item for Editor {
             .map(|path| path.to_string_lossy().to_string())
             .unwrap_or_else(|| "untitled".to_string());
 
-        let mut breadcrumbs = vec![BreadcrumbText {
-            text: filename,
-            highlights: None,
-        }];
-        breadcrumbs.extend(symbols.into_iter().map(|symbol| BreadcrumbText {
-            text: symbol.text,
-            highlights: Some(symbol.highlight_ranges),
+        let filename_label = Label::new(filename, theme.workspace.breadcrumbs.default.text.clone());
+        let mut breadcrumbs = vec![filename_label.boxed()];
+        breadcrumbs.extend(symbols.into_iter().map(|symbol| {
+            Text::new(
+                symbol.text,
+                theme.workspace.breadcrumbs.default.text.clone(),
+            )
+            .with_highlights(symbol.highlight_ranges)
+            .boxed()
         }));
         Some(breadcrumbs)
     }
@@ -799,7 +763,7 @@ impl Item for Editor {
     fn added_to_workspace(&mut self, workspace: &mut Workspace, cx: &mut ViewContext<Self>) {
         let workspace_id = workspace.database_id();
         let item_id = cx.view_id();
-        self.workspace = Some((workspace.weak_handle(), workspace.database_id()));
+        self.workspace_id = Some(workspace_id);
 
         fn serialize(
             buffer: ModelHandle<Buffer>,
@@ -824,9 +788,9 @@ impl Item for Editor {
             serialize(buffer.clone(), workspace_id, item_id, cx);
 
             cx.subscribe(&buffer, |this, buffer, event, cx| {
-                if let Some((_, workspace_id)) = this.workspace.as_ref() {
+                if let Some(workspace_id) = this.workspace_id {
                     if let language::Event::FileHandleChanged = event {
-                        serialize(buffer, *workspace_id, cx.view_id(), cx);
+                        serialize(buffer, workspace_id, cx.view_id(), cx);
                     }
                 }
             })
@@ -869,13 +833,14 @@ impl Item for Editor {
                     let buffer = project_item
                         .downcast::<Buffer>()
                         .context("Project item at stored path was not a buffer")?;
-                    Ok(pane.update(&mut cx, |_, cx| {
-                        cx.add_view(|cx| {
+
+                    Ok(cx.update(|cx| {
+                        cx.add_view(&pane, |cx| {
                             let mut editor = Editor::for_buffer(buffer, Some(project), cx);
                             editor.read_scroll_position_from_db(item_id, workspace_id, cx);
                             editor
                         })
-                    })?)
+                    }))
                 })
             })
             .unwrap_or_else(|error| Task::ready(Err(error)))
@@ -1113,20 +1078,16 @@ impl View for CursorPosition {
         "CursorPosition"
     }
 
-    fn render(&mut self, cx: &mut ViewContext<Self>) -> AnyElement<Self> {
+    fn render(&mut self, cx: &mut RenderContext<Self>) -> ElementBox {
         if let Some(position) = self.position {
-            let theme = &theme::current(cx).workspace.status_bar;
-            let mut text = format!(
-                "{}{FILE_ROW_COLUMN_DELIMITER}{}",
-                position.row + 1,
-                position.column + 1
-            );
+            let theme = &cx.global::<Settings>().theme.workspace.status_bar;
+            let mut text = format!("{},{}", position.row + 1, position.column + 1);
             if self.selected_count > 0 {
                 write!(text, " ({} selected)", self.selected_count).unwrap();
             }
-            Label::new(text, theme.cursor_position.clone()).into_any()
+            Label::new(text, theme.cursor_position.clone()).boxed()
         } else {
-            Empty::new().into_any()
+            Empty::new().boxed()
         }
     }
 }
@@ -1231,27 +1192,27 @@ mod tests {
         }
 
         fn as_local(&self) -> Option<&dyn language::LocalFile> {
-            unimplemented!()
+            todo!()
         }
 
         fn mtime(&self) -> SystemTime {
-            unimplemented!()
+            todo!()
         }
 
         fn file_name<'a>(&'a self, _: &'a gpui::AppContext) -> &'a std::ffi::OsStr {
-            unimplemented!()
+            todo!()
         }
 
         fn is_deleted(&self) -> bool {
-            unimplemented!()
+            todo!()
         }
 
         fn as_any(&self) -> &dyn std::any::Any {
-            unimplemented!()
+            todo!()
         }
 
         fn to_proto(&self) -> rpc::proto::File {
-            unimplemented!()
+            todo!()
         }
     }
 }

crates/editor/src/link_go_to_definition.rs

@@ -1,9 +1,48 @@
-use crate::{Anchor, DisplayPoint, Editor, EditorSnapshot, SelectPhase};
-use gpui::{Task, ViewContext};
+use std::ops::Range;
+
+use gpui::{impl_internal_actions, AppContext, Task, ViewContext};
 use language::{Bias, ToOffset};
 use project::LocationLink;
-use std::ops::Range;
+use settings::Settings;
 use util::TryFutureExt;
+use workspace::Workspace;
+
+use crate::{
+    Anchor, DisplayPoint, Editor, EditorSnapshot, GoToDefinition, GoToTypeDefinition, Select,
+    SelectPhase,
+};
+
+#[derive(Clone, PartialEq)]
+pub struct UpdateGoToDefinitionLink {
+    pub point: Option<DisplayPoint>,
+    pub cmd_held: bool,
+    pub shift_held: bool,
+}
+
+#[derive(Clone, PartialEq)]
+pub struct GoToFetchedDefinition {
+    pub point: DisplayPoint,
+}
+
+#[derive(Clone, PartialEq)]
+pub struct GoToFetchedTypeDefinition {
+    pub point: DisplayPoint,
+}
+
+impl_internal_actions!(
+    editor,
+    [
+        UpdateGoToDefinitionLink,
+        GoToFetchedDefinition,
+        GoToFetchedTypeDefinition
+    ]
+);
+
+pub fn init(cx: &mut AppContext) {
+    cx.add_action(update_go_to_definition_link);
+    cx.add_action(go_to_fetched_definition);
+    cx.add_action(go_to_fetched_type_definition);
+}
 
 #[derive(Debug, Default)]
 pub struct LinkGoToDefinitionState {
@@ -16,9 +55,11 @@ pub struct LinkGoToDefinitionState {
 
 pub fn update_go_to_definition_link(
     editor: &mut Editor,
-    point: Option<DisplayPoint>,
-    cmd_held: bool,
-    shift_held: bool,
+    &UpdateGoToDefinitionLink {
+        point,
+        cmd_held,
+        shift_held,
+    }: &UpdateGoToDefinitionLink,
     cx: &mut ViewContext<Editor>,
 ) {
     let pending_nonempty_selection = editor.has_pending_nonempty_selection();
@@ -130,7 +171,7 @@ pub fn show_link_definition(
         }
     }
 
-    let task = cx.spawn(|this, mut cx| {
+    let task = cx.spawn_weak(|this, mut cx| {
         async move {
             // query the LSP for definition info
             let definition_request = cx.update(|cx| {
@@ -161,65 +202,67 @@ pub fn show_link_definition(
                 )
             });
 
-            this.update(&mut cx, |this, cx| {
-                // Clear any existing highlights
-                this.clear_text_highlights::<LinkGoToDefinitionState>(cx);
-                this.link_go_to_definition_state.kind = Some(definition_kind);
-                this.link_go_to_definition_state.symbol_range = result
-                    .as_ref()
-                    .and_then(|(symbol_range, _)| symbol_range.clone());
+            if let Some(this) = this.upgrade(&cx) {
+                this.update(&mut cx, |this, cx| {
+                    // Clear any existing highlights
+                    this.clear_text_highlights::<LinkGoToDefinitionState>(cx);
+                    this.link_go_to_definition_state.kind = Some(definition_kind);
+                    this.link_go_to_definition_state.symbol_range = result
+                        .as_ref()
+                        .and_then(|(symbol_range, _)| symbol_range.clone());
 
-                if let Some((symbol_range, definitions)) = result {
-                    this.link_go_to_definition_state.definitions = definitions.clone();
+                    if let Some((symbol_range, definitions)) = result {
+                        this.link_go_to_definition_state.definitions = definitions.clone();
 
-                    let buffer_snapshot = buffer.read(cx).snapshot();
+                        let buffer_snapshot = buffer.read(cx).snapshot();
 
-                    // Only show highlight if there exists a definition to jump to that doesn't contain
-                    // the current location.
-                    let any_definition_does_not_contain_current_location =
-                        definitions.iter().any(|definition| {
-                            let target = &definition.target;
-                            if target.buffer == buffer {
-                                let range = &target.range;
-                                // Expand range by one character as lsp definition ranges include positions adjacent
-                                // but not contained by the symbol range
-                                let start = buffer_snapshot.clip_offset(
-                                    range.start.to_offset(&buffer_snapshot).saturating_sub(1),
-                                    Bias::Left,
-                                );
-                                let end = buffer_snapshot.clip_offset(
-                                    range.end.to_offset(&buffer_snapshot) + 1,
-                                    Bias::Right,
-                                );
-                                let offset = buffer_position.to_offset(&buffer_snapshot);
-                                !(start <= offset && end >= offset)
-                            } else {
-                                true
-                            }
-                        });
+                        // Only show highlight if there exists a definition to jump to that doesn't contain
+                        // the current location.
+                        let any_definition_does_not_contain_current_location =
+                            definitions.iter().any(|definition| {
+                                let target = &definition.target;
+                                if target.buffer == buffer {
+                                    let range = &target.range;
+                                    // Expand range by one character as lsp definition ranges include positions adjacent
+                                    // but not contained by the symbol range
+                                    let start = buffer_snapshot.clip_offset(
+                                        range.start.to_offset(&buffer_snapshot).saturating_sub(1),
+                                        Bias::Left,
+                                    );
+                                    let end = buffer_snapshot.clip_offset(
+                                        range.end.to_offset(&buffer_snapshot) + 1,
+                                        Bias::Right,
+                                    );
+                                    let offset = buffer_position.to_offset(&buffer_snapshot);
+                                    !(start <= offset && end >= offset)
+                                } else {
+                                    true
+                                }
+                            });
 
-                    if any_definition_does_not_contain_current_location {
-                        // If no symbol range returned from language server, use the surrounding word.
-                        let highlight_range = symbol_range.unwrap_or_else(|| {
-                            let snapshot = &snapshot.buffer_snapshot;
-                            let (offset_range, _) = snapshot.surrounding_word(trigger_point);
+                        if any_definition_does_not_contain_current_location {
+                            // If no symbol range returned from language server, use the surrounding word.
+                            let highlight_range = symbol_range.unwrap_or_else(|| {
+                                let snapshot = &snapshot.buffer_snapshot;
+                                let (offset_range, _) = snapshot.surrounding_word(trigger_point);
 
-                            snapshot.anchor_before(offset_range.start)
-                                ..snapshot.anchor_after(offset_range.end)
-                        });
+                                snapshot.anchor_before(offset_range.start)
+                                    ..snapshot.anchor_after(offset_range.end)
+                            });
 
-                        // Highlight symbol using theme link definition highlight style
-                        let style = theme::current(cx).editor.link_definition;
-                        this.highlight_text::<LinkGoToDefinitionState>(
-                            vec![highlight_range],
-                            style,
-                            cx,
-                        );
-                    } else {
-                        hide_link_definition(this, cx);
+                            // Highlight symbol using theme link definition highlight style
+                            let style = cx.global::<Settings>().theme.editor.link_definition;
+                            this.highlight_text::<LinkGoToDefinitionState>(
+                                vec![highlight_range],
+                                style,
+                                cx,
+                            );
+                        } else {
+                            hide_link_definition(this, cx);
+                        }
                     }
-                }
-            })?;
+                })
+            }
 
             Ok::<_, anyhow::Error>(())
         }
@@ -244,59 +287,76 @@ pub fn hide_link_definition(editor: &mut Editor, cx: &mut ViewContext<Editor>) {
 }
 
 pub fn go_to_fetched_definition(
-    editor: &mut Editor,
-    point: DisplayPoint,
-    cx: &mut ViewContext<Editor>,
+    workspace: &mut Workspace,
+    &GoToFetchedDefinition { point }: &GoToFetchedDefinition,
+    cx: &mut ViewContext<Workspace>,
 ) {
-    go_to_fetched_definition_of_kind(LinkDefinitionKind::Symbol, editor, point, cx);
+    go_to_fetched_definition_of_kind(LinkDefinitionKind::Symbol, workspace, point, cx);
 }
 
 pub fn go_to_fetched_type_definition(
-    editor: &mut Editor,
-    point: DisplayPoint,
-    cx: &mut ViewContext<Editor>,
+    workspace: &mut Workspace,
+    &GoToFetchedTypeDefinition { point }: &GoToFetchedTypeDefinition,
+    cx: &mut ViewContext<Workspace>,
 ) {
-    go_to_fetched_definition_of_kind(LinkDefinitionKind::Type, editor, point, cx);
+    go_to_fetched_definition_of_kind(LinkDefinitionKind::Type, workspace, point, cx);
 }
 
 fn go_to_fetched_definition_of_kind(
     kind: LinkDefinitionKind,
-    editor: &mut Editor,
+    workspace: &mut Workspace,
     point: DisplayPoint,
-    cx: &mut ViewContext<Editor>,
+    cx: &mut ViewContext<Workspace>,
 ) {
-    let cached_definitions = editor.link_go_to_definition_state.definitions.clone();
-    hide_link_definition(editor, cx);
-    let cached_definitions_kind = editor.link_go_to_definition_state.kind;
+    let active_item = workspace.active_item(cx);
+    let editor_handle = if let Some(editor) = active_item
+        .as_ref()
+        .and_then(|item| item.act_as::<Editor>(cx))
+    {
+        editor
+    } else {
+        return;
+    };
+
+    let (cached_definitions, cached_definitions_kind) = editor_handle.update(cx, |editor, cx| {
+        let definitions = editor.link_go_to_definition_state.definitions.clone();
+        hide_link_definition(editor, cx);
+        (definitions, editor.link_go_to_definition_state.kind)
+    });
 
     let is_correct_kind = cached_definitions_kind == Some(kind);
     if !cached_definitions.is_empty() && is_correct_kind {
-        if !editor.focused {
-            cx.focus_self();
-        }
+        editor_handle.update(cx, |editor, cx| {
+            if !editor.focused {
+                cx.focus_self();
+            }
+        });
 
-        editor.navigate_to_definitions(cached_definitions, cx);
+        Editor::navigate_to_definitions(workspace, editor_handle, cached_definitions, cx);
     } else {
-        editor.select(
-            SelectPhase::Begin {
-                position: point,
-                add: false,
-                click_count: 1,
-            },
-            cx,
-        );
+        editor_handle.update(cx, |editor, cx| {
+            editor.select(
+                &Select(SelectPhase::Begin {
+                    position: point,
+                    add: false,
+                    click_count: 1,
+                }),
+                cx,
+            );
+        });
 
         match kind {
-            LinkDefinitionKind::Symbol => editor.go_to_definition(&Default::default(), cx),
-            LinkDefinitionKind::Type => editor.go_to_type_definition(&Default::default(), cx),
+            LinkDefinitionKind::Symbol => Editor::go_to_definition(workspace, &GoToDefinition, cx),
+
+            LinkDefinitionKind::Type => {
+                Editor::go_to_type_definition(workspace, &GoToTypeDefinition, cx)
+            }
         }
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::{editor_tests::init_test, test::editor_lsp_test_context::EditorLspTestContext};
     use futures::StreamExt;
     use gpui::{
         platform::{self, Modifiers, ModifiersChangedEvent},
@@ -305,10 +365,12 @@ mod tests {
     use indoc::indoc;
     use lsp::request::{GotoDefinition, GotoTypeDefinition};
 
+    use crate::test::editor_lsp_test_context::EditorLspTestContext;
+
+    use super::*;
+
     #[gpui::test]
     async fn test_link_go_to_type_definition(cx: &mut gpui::TestAppContext) {
-        init_test(cx, |_| {});
-
         let mut cx = EditorLspTestContext::new_rust(
             lsp::ServerCapabilities {
                 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
@@ -351,7 +413,15 @@ mod tests {
 
         // Press cmd+shift to trigger highlight
         cx.update_editor(|editor, cx| {
-            update_go_to_definition_link(editor, Some(hover_point), true, true, cx);
+            update_go_to_definition_link(
+                editor,
+                &UpdateGoToDefinitionLink {
+                    point: Some(hover_point),
+                    cmd_held: true,
+                    shift_held: true,
+                },
+                cx,
+            );
         });
         requests.next().await;
         cx.foreground().run_until_parked();
@@ -401,8 +471,12 @@ mod tests {
                 ])))
             });
 
-        cx.update_editor(|editor, cx| {
-            go_to_fetched_type_definition(editor, hover_point, cx);
+        cx.update_workspace(|workspace, cx| {
+            go_to_fetched_type_definition(
+                workspace,
+                &GoToFetchedTypeDefinition { point: hover_point },
+                cx,
+            );
         });
         requests.next().await;
         cx.foreground().run_until_parked();
@@ -415,8 +489,6 @@ mod tests {
 
     #[gpui::test]
     async fn test_link_go_to_definition(cx: &mut gpui::TestAppContext) {
-        init_test(cx, |_| {});
-
         let mut cx = EditorLspTestContext::new_rust(
             lsp::ServerCapabilities {
                 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
@@ -457,7 +529,15 @@ mod tests {
         });
 
         cx.update_editor(|editor, cx| {
-            update_go_to_definition_link(editor, Some(hover_point), true, false, cx);
+            update_go_to_definition_link(
+                editor,
+                &UpdateGoToDefinitionLink {
+                    point: Some(hover_point),
+                    cmd_held: true,
+                    shift_held: false,
+                },
+                cx,
+            );
         });
         requests.next().await;
         cx.foreground().run_until_parked();
@@ -491,7 +571,15 @@ mod tests {
             ])))
         });
         cx.update_editor(|editor, cx| {
-            update_go_to_definition_link(editor, Some(hover_point), true, false, cx);
+            update_go_to_definition_link(
+                editor,
+                &UpdateGoToDefinitionLink {
+                    point: Some(hover_point),
+                    cmd_held: true,
+                    shift_held: false,
+                },
+                cx,
+            );
         });
         requests.next().await;
         cx.foreground().run_until_parked();
@@ -513,7 +601,15 @@ mod tests {
                 Ok(Some(lsp::GotoDefinitionResponse::Link(vec![])))
             });
         cx.update_editor(|editor, cx| {
-            update_go_to_definition_link(editor, Some(hover_point), true, false, cx);
+            update_go_to_definition_link(
+                editor,
+                &UpdateGoToDefinitionLink {
+                    point: Some(hover_point),
+                    cmd_held: true,
+                    shift_held: false,
+                },
+                cx,
+            );
         });
         requests.next().await;
         cx.foreground().run_until_parked();
@@ -530,7 +626,15 @@ mod tests {
             fn do_work() { teˇst(); }
         "});
         cx.update_editor(|editor, cx| {
-            update_go_to_definition_link(editor, Some(hover_point), false, false, cx);
+            update_go_to_definition_link(
+                editor,
+                &UpdateGoToDefinitionLink {
+                    point: Some(hover_point),
+                    cmd_held: false,
+                    shift_held: false,
+                },
+                cx,
+            );
         });
         cx.foreground().run_until_parked();
 
@@ -589,7 +693,15 @@ mod tests {
 
         // Moving the mouse restores the highlights.
         cx.update_editor(|editor, cx| {
-            update_go_to_definition_link(editor, Some(hover_point), true, false, cx);
+            update_go_to_definition_link(
+                editor,
+                &UpdateGoToDefinitionLink {
+                    point: Some(hover_point),
+                    cmd_held: true,
+                    shift_held: false,
+                },
+                cx,
+            );
         });
         cx.foreground().run_until_parked();
         cx.assert_editor_text_highlights::<LinkGoToDefinitionState>(indoc! {"
@@ -603,7 +715,15 @@ mod tests {
             fn do_work() { tesˇt(); }
         "});
         cx.update_editor(|editor, cx| {
-            update_go_to_definition_link(editor, Some(hover_point), true, false, cx);
+            update_go_to_definition_link(
+                editor,
+                &UpdateGoToDefinitionLink {
+                    point: Some(hover_point),
+                    cmd_held: true,
+                    shift_held: false,
+                },
+                cx,
+            );
         });
         cx.foreground().run_until_parked();
         cx.assert_editor_text_highlights::<LinkGoToDefinitionState>(indoc! {"
@@ -612,8 +732,8 @@ mod tests {
         "});
 
         // Cmd click with existing definition doesn't re-request and dismisses highlight
-        cx.update_editor(|editor, cx| {
-            go_to_fetched_definition(editor, hover_point, cx);
+        cx.update_workspace(|workspace, cx| {
+            go_to_fetched_definition(workspace, &GoToFetchedDefinition { point: hover_point }, cx);
         });
         // Assert selection moved to to definition
         cx.lsp
@@ -653,8 +773,8 @@ mod tests {
                 },
             ])))
         });
-        cx.update_editor(|editor, cx| {
-            go_to_fetched_definition(editor, hover_point, cx);
+        cx.update_workspace(|workspace, cx| {
+            go_to_fetched_definition(workspace, &GoToFetchedDefinition { point: hover_point }, cx);
         });
         requests.next().await;
         cx.foreground().run_until_parked();
@@ -699,7 +819,15 @@ mod tests {
             });
         });
         cx.update_editor(|editor, cx| {
-            update_go_to_definition_link(editor, Some(hover_point), true, false, cx);
+            update_go_to_definition_link(
+                editor,
+                &UpdateGoToDefinitionLink {
+                    point: Some(hover_point),
+                    cmd_held: true,
+                    shift_held: false,
+                },
+                cx,
+            );
         });
         cx.foreground().run_until_parked();
         assert!(requests.try_next().is_err());

crates/editor/src/mouse_context_menu.rs

@@ -1,14 +1,29 @@
+use context_menu::ContextMenuItem;
+use gpui::{
+    elements::AnchorCorner, geometry::vector::Vector2F, impl_internal_actions, AppContext,
+    ViewContext,
+};
+
 use crate::{
     DisplayPoint, Editor, EditorMode, FindAllReferences, GoToDefinition, GoToTypeDefinition,
     Rename, RevealInFinder, SelectMode, ToggleCodeActions,
 };
-use context_menu::ContextMenuItem;
-use gpui::{elements::AnchorCorner, geometry::vector::Vector2F, ViewContext};
+
+#[derive(Clone, PartialEq)]
+pub struct DeployMouseContextMenu {
+    pub position: Vector2F,
+    pub point: DisplayPoint,
+}
+
+impl_internal_actions!(editor, [DeployMouseContextMenu]);
+
+pub fn init(cx: &mut AppContext) {
+    cx.add_action(deploy_context_menu);
+}
 
 pub fn deploy_context_menu(
     editor: &mut Editor,
-    position: Vector2F,
-    point: DisplayPoint,
+    &DeployMouseContextMenu { position, point }: &DeployMouseContextMenu,
     cx: &mut ViewContext<Editor>,
 ) {
     if !editor.focused {
@@ -36,18 +51,18 @@ pub fn deploy_context_menu(
             position,
             AnchorCorner::TopLeft,
             vec![
-                ContextMenuItem::action("Rename Symbol", Rename),
-                ContextMenuItem::action("Go to Definition", GoToDefinition),
-                ContextMenuItem::action("Go to Type Definition", GoToTypeDefinition),
-                ContextMenuItem::action("Find All References", FindAllReferences),
-                ContextMenuItem::action(
+                ContextMenuItem::item("Rename Symbol", Rename),
+                ContextMenuItem::item("Go to Definition", GoToDefinition),
+                ContextMenuItem::item("Go to Type Definition", GoToTypeDefinition),
+                ContextMenuItem::item("Find All References", FindAllReferences),
+                ContextMenuItem::item(
                     "Code Actions",
                     ToggleCodeActions {
                         deployed_from_indicator: false,
                     },
                 ),
                 ContextMenuItem::Separator,
-                ContextMenuItem::action("Reveal in Finder", RevealInFinder),
+                ContextMenuItem::item("Reveal in Finder", RevealInFinder),
             ],
             cx,
         );
@@ -57,14 +72,13 @@ pub fn deploy_context_menu(
 
 #[cfg(test)]
 mod tests {
+    use crate::test::editor_lsp_test_context::EditorLspTestContext;
+
     use super::*;
-    use crate::{editor_tests::init_test, test::editor_lsp_test_context::EditorLspTestContext};
     use indoc::indoc;
 
     #[gpui::test]
     async fn test_mouse_context_menu(cx: &mut gpui::TestAppContext) {
-        init_test(cx, |_| {});
-
         let mut cx = EditorLspTestContext::new_rust(
             lsp::ServerCapabilities {
                 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
@@ -84,7 +98,16 @@ mod tests {
                 do_wˇork();
             }
         "});
-        cx.update_editor(|editor, cx| deploy_context_menu(editor, Default::default(), point, cx));
+        cx.update_editor(|editor, cx| {
+            deploy_context_menu(
+                editor,
+                &DeployMouseContextMenu {
+                    position: Default::default(),
+                    point,
+                },
+                cx,
+            )
+        });
 
         cx.assert_editor_state(indoc! {"
             fn test() {

crates/editor/src/movement.rs

@@ -193,44 +193,6 @@ pub fn next_subword_end(map: &DisplaySnapshot, point: DisplayPoint) -> DisplayPo
     })
 }
 
-pub fn start_of_paragraph(map: &DisplaySnapshot, display_point: DisplayPoint) -> DisplayPoint {
-    let point = display_point.to_point(map);
-    if point.row == 0 {
-        return map.max_point();
-    }
-
-    let mut found_non_blank_line = false;
-    for row in (0..point.row + 1).rev() {
-        let blank = map.buffer_snapshot.is_line_blank(row);
-        if found_non_blank_line && blank {
-            return Point::new(row, 0).to_display_point(map);
-        }
-
-        found_non_blank_line |= !blank;
-    }
-
-    DisplayPoint::zero()
-}
-
-pub fn end_of_paragraph(map: &DisplaySnapshot, display_point: DisplayPoint) -> DisplayPoint {
-    let point = display_point.to_point(map);
-    if point.row == map.max_buffer_row() {
-        return DisplayPoint::zero();
-    }
-
-    let mut found_non_blank_line = false;
-    for row in point.row..map.max_buffer_row() + 1 {
-        let blank = map.buffer_snapshot.is_line_blank(row);
-        if found_non_blank_line && blank {
-            return Point::new(row, 0).to_display_point(map);
-        }
-
-        found_non_blank_line |= !blank;
-    }
-
-    map.max_point()
-}
-
 /// Scans for a boundary preceding the given start point `from` until a boundary is found, indicated by the
 /// given predicate returning true. The predicate is called with the character to the left and right
 /// of the candidate boundary location, and will be called with `\n` characters indicating the start
@@ -407,12 +369,11 @@ pub fn split_display_range_by_lines(
 mod tests {
     use super::*;
     use crate::{test::marked_display_snapshot, Buffer, DisplayMap, ExcerptRange, MultiBuffer};
-    use settings::SettingsStore;
+    use settings::Settings;
 
     #[gpui::test]
     fn test_previous_word_start(cx: &mut gpui::AppContext) {
-        init_test(cx);
-
+        cx.set_global(Settings::test(cx));
         fn assert(marked_text: &str, cx: &mut gpui::AppContext) {
             let (snapshot, display_points) = marked_display_snapshot(marked_text, cx);
             assert_eq!(
@@ -439,8 +400,7 @@ mod tests {
 
     #[gpui::test]
     fn test_previous_subword_start(cx: &mut gpui::AppContext) {
-        init_test(cx);
-
+        cx.set_global(Settings::test(cx));
         fn assert(marked_text: &str, cx: &mut gpui::AppContext) {
             let (snapshot, display_points) = marked_display_snapshot(marked_text, cx);
             assert_eq!(
@@ -474,8 +434,7 @@ mod tests {
 
     #[gpui::test]
     fn test_find_preceding_boundary(cx: &mut gpui::AppContext) {
-        init_test(cx);
-
+        cx.set_global(Settings::test(cx));
         fn assert(
             marked_text: &str,
             cx: &mut gpui::AppContext,
@@ -507,8 +466,7 @@ mod tests {
 
     #[gpui::test]
     fn test_next_word_end(cx: &mut gpui::AppContext) {
-        init_test(cx);
-
+        cx.set_global(Settings::test(cx));
         fn assert(marked_text: &str, cx: &mut gpui::AppContext) {
             let (snapshot, display_points) = marked_display_snapshot(marked_text, cx);
             assert_eq!(
@@ -532,8 +490,7 @@ mod tests {
 
     #[gpui::test]
     fn test_next_subword_end(cx: &mut gpui::AppContext) {
-        init_test(cx);
-
+        cx.set_global(Settings::test(cx));
         fn assert(marked_text: &str, cx: &mut gpui::AppContext) {
             let (snapshot, display_points) = marked_display_snapshot(marked_text, cx);
             assert_eq!(
@@ -566,8 +523,7 @@ mod tests {
 
     #[gpui::test]
     fn test_find_boundary(cx: &mut gpui::AppContext) {
-        init_test(cx);
-
+        cx.set_global(Settings::test(cx));
         fn assert(
             marked_text: &str,
             cx: &mut gpui::AppContext,
@@ -599,8 +555,7 @@ mod tests {
 
     #[gpui::test]
     fn test_surrounding_word(cx: &mut gpui::AppContext) {
-        init_test(cx);
-
+        cx.set_global(Settings::test(cx));
         fn assert(marked_text: &str, cx: &mut gpui::AppContext) {
             let (snapshot, display_points) = marked_display_snapshot(marked_text, cx);
             assert_eq!(
@@ -621,8 +576,7 @@ mod tests {
 
     #[gpui::test]
     fn test_move_up_and_down_with_excerpts(cx: &mut gpui::AppContext) {
-        init_test(cx);
-
+        cx.set_global(Settings::test(cx));
         let family_id = cx
             .font_cache()
             .load_family(&["Helvetica"], &Default::default())
@@ -737,11 +691,4 @@ mod tests {
             (DisplayPoint::new(7, 2), SelectionGoal::Column(2)),
         );
     }
-
-    fn init_test(cx: &mut gpui::AppContext) {
-        cx.set_global(SettingsStore::test(cx));
-        theme::init((), cx);
-        language::init(cx);
-        crate::init(cx);
-    }
 }

crates/editor/src/multi_buffer.rs

@@ -1,7 +1,6 @@
 mod anchor;
 
 pub use anchor::{Anchor, AnchorRangeExt};
-use anyhow::{anyhow, Result};
 use clock::ReplicaId;
 use collections::{BTreeMap, Bound, HashMap, HashSet};
 use futures::{channel::mpsc, SinkExt};
@@ -9,19 +8,15 @@ use git::diff::DiffHunk;
 use gpui::{AppContext, Entity, ModelContext, ModelHandle, Task};
 pub use language::Completion;
 use language::{
-    char_kind,
-    language_settings::{language_settings, LanguageSettings},
-    AutoindentMode, Buffer, BufferChunks, BufferSnapshot, CharKind, Chunk, CursorShape,
-    DiagnosticEntry, File, IndentSize, Language, LanguageScope, OffsetRangeExt, OffsetUtf16,
-    Outline, OutlineItem, Point, PointUtf16, Selection, TextDimension, ToOffset as _,
-    ToOffsetUtf16 as _, ToPoint as _, ToPointUtf16 as _, TransactionId, Unclipped,
+    char_kind, AutoindentMode, Buffer, BufferChunks, BufferSnapshot, CharKind, Chunk, CursorShape,
+    DiagnosticEntry, IndentSize, Language, LanguageScope, OffsetRangeExt, OffsetUtf16, Outline,
+    OutlineItem, Point, PointUtf16, Selection, TextDimension, ToOffset as _, ToOffsetUtf16 as _,
+    ToPoint as _, ToPointUtf16 as _, TransactionId, Unclipped,
 };
 use std::{
     borrow::Cow,
     cell::{Ref, RefCell},
-    cmp, fmt,
-    future::Future,
-    io,
+    cmp, fmt, io,
     iter::{self, FromIterator},
     mem,
     ops::{Range, RangeBounds, Sub},
@@ -45,7 +40,7 @@ pub struct ExcerptId(usize);
 
 pub struct MultiBuffer {
     snapshot: RefCell<MultiBufferSnapshot>,
-    buffers: RefCell<HashMap<u64, BufferState>>,
+    buffers: RefCell<HashMap<usize, BufferState>>,
     next_excerpt_id: usize,
     subscriptions: Topic,
     singleton: bool,
@@ -66,7 +61,6 @@ pub enum Event {
     },
     Edited,
     Reloaded,
-    LanguageChanged,
     Reparsed,
     Saved,
     FileHandleChanged,
@@ -87,7 +81,7 @@ struct History {
 #[derive(Clone)]
 struct Transaction {
     id: TransactionId,
-    buffer_transactions: HashMap<u64, text::TransactionId>,
+    buffer_transactions: HashMap<usize, text::TransactionId>,
     first_edit_at: Instant,
     last_edit_at: Instant,
     suppress_grouping: bool,
@@ -147,7 +141,7 @@ pub struct ExcerptBoundary {
 struct Excerpt {
     id: ExcerptId,
     locator: Locator,
-    buffer_id: u64,
+    buffer_id: usize,
     buffer: BufferSnapshot,
     range: ExcerptRange<text::Anchor>,
     max_buffer_row: u32,
@@ -339,7 +333,7 @@ impl MultiBuffer {
         offset: T,
         theme: Option<&SyntaxTheme>,
         cx: &AppContext,
-    ) -> Option<(u64, Vec<OutlineItem<Anchor>>)> {
+    ) -> Option<(usize, Vec<OutlineItem<Anchor>>)> {
         self.read(cx).symbols_containing(offset, theme)
     }
 
@@ -396,7 +390,7 @@ impl MultiBuffer {
             is_insertion: bool,
             original_indent_column: u32,
         }
-        let mut buffer_edits: HashMap<u64, Vec<BufferEdit>> = Default::default();
+        let mut buffer_edits: HashMap<usize, Vec<BufferEdit>> = Default::default();
         let mut cursor = snapshot.excerpts.cursor::<usize>();
         for (ix, (range, new_text)) in edits.enumerate() {
             let new_text: Arc<str> = new_text.into();
@@ -595,7 +589,7 @@ impl MultiBuffer {
             if let Some(transaction_id) =
                 buffer.update(cx, |buffer, cx| buffer.end_transaction_at(now, cx))
             {
-                buffer_transactions.insert(buffer.read(cx).remote_id(), transaction_id);
+                buffer_transactions.insert(buffer.id(), transaction_id);
             }
         }
 
@@ -616,12 +610,12 @@ impl MultiBuffer {
         }
     }
 
-    pub fn push_transaction<'a, T>(&mut self, buffer_transactions: T, cx: &mut ModelContext<Self>)
+    pub fn push_transaction<'a, T>(&mut self, buffer_transactions: T)
     where
         T: IntoIterator<Item = (&'a ModelHandle<Buffer>, &'a language::Transaction)>,
     {
         self.history
-            .push_transaction(buffer_transactions, Instant::now(), cx);
+            .push_transaction(buffer_transactions, Instant::now());
         self.history.finalize_last_transaction();
     }
 
@@ -646,7 +640,7 @@ impl MultiBuffer {
         cursor_shape: CursorShape,
         cx: &mut ModelContext<Self>,
     ) {
-        let mut selections_by_buffer: HashMap<u64, Vec<Selection<text::Anchor>>> =
+        let mut selections_by_buffer: HashMap<usize, Vec<Selection<text::Anchor>>> =
             Default::default();
         let snapshot = self.read(cx);
         let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>();
@@ -787,8 +781,8 @@ impl MultiBuffer {
         let (mut tx, rx) = mpsc::channel(256);
         let task = cx.spawn(|this, mut cx| async move {
             for (buffer, ranges) in excerpts {
-                let (buffer_id, buffer_snapshot) =
-                    buffer.read_with(&cx, |buffer, _| (buffer.remote_id(), buffer.snapshot()));
+                let buffer_id = buffer.id();
+                let buffer_snapshot = buffer.read_with(&cx, |buffer, _| buffer.snapshot());
 
                 let mut excerpt_ranges = Vec::new();
                 let mut range_counts = Vec::new();
@@ -857,7 +851,7 @@ impl MultiBuffer {
     where
         O: text::ToPoint + text::ToOffset,
     {
-        let buffer_id = buffer.read(cx).remote_id();
+        let buffer_id = buffer.id();
         let buffer_snapshot = buffer.read(cx).snapshot();
         let (excerpt_ranges, range_counts) =
             build_excerpt_ranges(&buffer_snapshot, &ranges, context_line_count);
@@ -926,7 +920,7 @@ impl MultiBuffer {
 
         self.sync(cx);
 
-        let buffer_id = buffer.read(cx).remote_id();
+        let buffer_id = buffer.id();
         let buffer_snapshot = buffer.read(cx).snapshot();
 
         let mut buffers = self.buffers.borrow_mut();
@@ -1053,7 +1047,7 @@ impl MultiBuffer {
         let buffers = self.buffers.borrow();
         let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>();
         for locator in buffers
-            .get(&buffer.read(cx).remote_id())
+            .get(&buffer.id())
             .map(|state| &state.excerpts)
             .into_iter()
             .flatten()
@@ -1140,10 +1134,6 @@ impl MultiBuffer {
         let mut result = Vec::new();
         let mut cursor = snapshot.excerpts.cursor::<usize>();
         cursor.seek(&start, Bias::Right, &());
-        if cursor.item().is_none() {
-            cursor.prev(&());
-        }
-
         while let Some(excerpt) = cursor.item() {
             if *cursor.start() > end {
                 break;
@@ -1171,9 +1161,6 @@ impl MultiBuffer {
     ) {
         self.sync(cx);
         let ids = excerpt_ids.into_iter().collect::<Vec<_>>();
-        if ids.is_empty() {
-            return;
-        }
 
         let mut buffers = self.buffers.borrow_mut();
         let mut snapshot = self.snapshot.borrow_mut();
@@ -1251,39 +1238,6 @@ impl MultiBuffer {
         cx.notify();
     }
 
-    pub fn wait_for_anchors<'a>(
-        &self,
-        anchors: impl 'a + Iterator<Item = Anchor>,
-        cx: &mut ModelContext<Self>,
-    ) -> impl 'static + Future<Output = Result<()>> {
-        let borrow = self.buffers.borrow();
-        let mut error = None;
-        let mut futures = Vec::new();
-        for anchor in anchors {
-            if let Some(buffer_id) = anchor.buffer_id {
-                if let Some(buffer) = borrow.get(&buffer_id) {
-                    buffer.buffer.update(cx, |buffer, _| {
-                        futures.push(buffer.wait_for_anchors([anchor.text_anchor]))
-                    });
-                } else {
-                    error = Some(anyhow!(
-                        "buffer {buffer_id} is not part of this multi-buffer"
-                    ));
-                    break;
-                }
-            }
-        }
-        async move {
-            if let Some(error) = error {
-                Err(error)?;
-            }
-            for future in futures {
-                future.await?;
-            }
-            Ok(())
-        }
-    }
-
     pub fn text_anchor_for_position<T: ToOffset>(
         &self,
         position: T,
@@ -1312,7 +1266,6 @@ impl MultiBuffer {
             language::Event::Saved => Event::Saved,
             language::Event::FileHandleChanged => Event::FileHandleChanged,
             language::Event::Reloaded => Event::Reloaded,
-            language::Event::LanguageChanged => Event::LanguageChanged,
             language::Event::Reparsed => Event::Reparsed,
             language::Event::DiagnosticsUpdated => Event::DiagnosticsUpdated,
             language::Event::Closed => Event::Closed,
@@ -1330,7 +1283,7 @@ impl MultiBuffer {
             .collect()
     }
 
-    pub fn buffer(&self, buffer_id: u64) -> Option<ModelHandle<Buffer>> {
+    pub fn buffer(&self, buffer_id: usize) -> Option<ModelHandle<Buffer>> {
         self.buffers
             .borrow()
             .get(&buffer_id)
@@ -1381,15 +1334,6 @@ impl MultiBuffer {
             .and_then(|(buffer, offset)| buffer.read(cx).language_at(offset))
     }
 
-    pub fn settings_at<'a, T: ToOffset>(
-        &self,
-        point: T,
-        cx: &'a AppContext,
-    ) -> &'a LanguageSettings {
-        let language = self.language_at(point, cx);
-        language_settings(language.map(|l| l.name()).as_deref(), cx)
-    }
-
     pub fn for_each_buffer(&self, mut f: impl FnMut(&ModelHandle<Buffer>)) {
         self.buffers
             .borrow()
@@ -1496,8 +1440,8 @@ impl MultiBuffer {
         for (locator, buffer, buffer_edited) in excerpts_to_edit {
             new_excerpts.push_tree(cursor.slice(&Some(locator), Bias::Left, &()), &());
             let old_excerpt = cursor.item().unwrap();
+            let buffer_id = buffer.id();
             let buffer = buffer.read(cx);
-            let buffer_id = buffer.remote_id();
 
             let mut new_excerpt;
             if buffer_edited {
@@ -1623,11 +1567,11 @@ impl MultiBuffer {
                 let buffer_handle = if rng.gen() || self.buffers.borrow().is_empty() {
                     let text = RandomCharIter::new(&mut *rng).take(10).collect::<String>();
                     buffers.push(cx.add_model(|cx| Buffer::new(0, text, cx)));
-                    let buffer = buffers.last().unwrap().read(cx);
+                    let buffer = buffers.last().unwrap();
                     log::info!(
                         "Creating new buffer {} with text: {:?}",
-                        buffer.remote_id(),
-                        buffer.text()
+                        buffer.id(),
+                        buffer.read(cx).text()
                     );
                     buffers.last().unwrap().clone()
                 } else {
@@ -1655,7 +1599,7 @@ impl MultiBuffer {
                     .collect::<Vec<_>>();
                 log::info!(
                     "Inserting excerpts from buffer {} and ranges {:?}: {:?}",
-                    buffer_handle.read(cx).remote_id(),
+                    buffer_handle.id(),
                     ranges.iter().map(|r| &r.context).collect::<Vec<_>>(),
                     ranges
                         .iter()
@@ -1848,7 +1792,7 @@ impl MultiBufferSnapshot {
         (start..end, word_kind)
     }
 
-    pub fn as_singleton(&self) -> Option<(&ExcerptId, u64, &BufferSnapshot)> {
+    pub fn as_singleton(&self) -> Option<(&ExcerptId, usize, &BufferSnapshot)> {
         if self.singleton {
             self.excerpts
                 .iter()
@@ -2772,40 +2716,16 @@ impl MultiBufferSnapshot {
         self.trailing_excerpt_update_count
     }
 
-    pub fn file_at<'a, T: ToOffset>(&'a self, point: T) -> Option<&'a Arc<dyn File>> {
-        self.point_to_buffer_offset(point)
-            .and_then(|(buffer, _)| buffer.file())
-    }
-
     pub fn language_at<'a, T: ToOffset>(&'a self, point: T) -> Option<&'a Arc<Language>> {
         self.point_to_buffer_offset(point)
             .and_then(|(buffer, offset)| buffer.language_at(offset))
     }
 
-    pub fn settings_at<'a, T: ToOffset>(
-        &'a self,
-        point: T,
-        cx: &'a AppContext,
-    ) -> &'a LanguageSettings {
-        self.point_to_buffer_offset(point)
-            .map(|(buffer, offset)| buffer.settings_at(offset, cx))
-            .unwrap_or_else(|| language_settings(None, cx))
-    }
-
     pub fn language_scope_at<'a, T: ToOffset>(&'a self, point: T) -> Option<LanguageScope> {
         self.point_to_buffer_offset(point)
             .and_then(|(buffer, offset)| buffer.language_scope_at(offset))
     }
 
-    pub fn language_indent_size_at<T: ToOffset>(
-        &self,
-        position: T,
-        cx: &AppContext,
-    ) -> Option<IndentSize> {
-        let (buffer_snapshot, offset) = self.point_to_buffer_offset(position)?;
-        Some(buffer_snapshot.language_indent_size_at(offset, cx))
-    }
-
     pub fn is_dirty(&self) -> bool {
         self.is_dirty
     }
@@ -2833,7 +2753,7 @@ impl MultiBufferSnapshot {
     ) -> impl Iterator<Item = DiagnosticEntry<O>> + 'a
     where
         T: 'a + ToOffset,
-        O: 'a + text::FromAnchor + Ord,
+        O: 'a + text::FromAnchor,
     {
         self.as_singleton()
             .into_iter()
@@ -2845,87 +2765,21 @@ impl MultiBufferSnapshot {
             })
     }
 
-    pub fn has_git_diffs(&self) -> bool {
-        for excerpt in self.excerpts.iter() {
-            if !excerpt.buffer.git_diff.is_empty() {
-                return true;
-            }
-        }
-        false
-    }
-
-    pub fn git_diff_hunks_in_range_rev<'a>(
-        &'a self,
-        row_range: Range<u32>,
-    ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
-        let mut cursor = self.excerpts.cursor::<Point>();
-
-        cursor.seek(&Point::new(row_range.end, 0), Bias::Left, &());
-        if cursor.item().is_none() {
-            cursor.prev(&());
-        }
-
-        std::iter::from_fn(move || {
-            let excerpt = cursor.item()?;
-            let multibuffer_start = *cursor.start();
-            let multibuffer_end = multibuffer_start + excerpt.text_summary.lines;
-            if multibuffer_start.row >= row_range.end {
-                return None;
-            }
-
-            let mut buffer_start = excerpt.range.context.start;
-            let mut buffer_end = excerpt.range.context.end;
-            let excerpt_start_point = buffer_start.to_point(&excerpt.buffer);
-            let excerpt_end_point = excerpt_start_point + excerpt.text_summary.lines;
-
-            if row_range.start > multibuffer_start.row {
-                let buffer_start_point =
-                    excerpt_start_point + Point::new(row_range.start - multibuffer_start.row, 0);
-                buffer_start = excerpt.buffer.anchor_before(buffer_start_point);
-            }
-
-            if row_range.end < multibuffer_end.row {
-                let buffer_end_point =
-                    excerpt_start_point + Point::new(row_range.end - multibuffer_start.row, 0);
-                buffer_end = excerpt.buffer.anchor_before(buffer_end_point);
-            }
-
-            let buffer_hunks = excerpt
-                .buffer
-                .git_diff_hunks_intersecting_range_rev(buffer_start..buffer_end)
-                .filter_map(move |hunk| {
-                    let start = multibuffer_start.row
-                        + hunk
-                            .buffer_range
-                            .start
-                            .saturating_sub(excerpt_start_point.row);
-                    let end = multibuffer_start.row
-                        + hunk
-                            .buffer_range
-                            .end
-                            .min(excerpt_end_point.row + 1)
-                            .saturating_sub(excerpt_start_point.row);
-
-                    Some(DiffHunk {
-                        buffer_range: start..end,
-                        diff_base_byte_range: hunk.diff_base_byte_range.clone(),
-                    })
-                });
-
-            cursor.prev(&());
-
-            Some(buffer_hunks)
-        })
-        .flatten()
-    }
-
     pub fn git_diff_hunks_in_range<'a>(
         &'a self,
         row_range: Range<u32>,
+        reversed: bool,
     ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
         let mut cursor = self.excerpts.cursor::<Point>();
 
-        cursor.seek(&Point::new(row_range.start, 0), Bias::Right, &());
+        if reversed {
+            cursor.seek(&Point::new(row_range.end, 0), Bias::Left, &());
+            if cursor.item().is_none() {
+                cursor.prev(&());
+            }
+        } else {
+            cursor.seek(&Point::new(row_range.start, 0), Bias::Right, &());
+        }
 
         std::iter::from_fn(move || {
             let excerpt = cursor.item()?;
@@ -2954,7 +2808,7 @@ impl MultiBufferSnapshot {
 
             let buffer_hunks = excerpt
                 .buffer
-                .git_diff_hunks_intersecting_range(buffer_start..buffer_end)
+                .git_diff_hunks_intersecting_range(buffer_start..buffer_end, reversed)
                 .filter_map(move |hunk| {
                     let start = multibuffer_start.row
                         + hunk
@@ -2974,7 +2828,11 @@ impl MultiBufferSnapshot {
                     })
                 });
 
-            cursor.next(&());
+            if reversed {
+                cursor.prev(&());
+            } else {
+                cursor.next(&());
+            }
 
             Some(buffer_hunks)
         })
@@ -3028,7 +2886,7 @@ impl MultiBufferSnapshot {
         &self,
         offset: T,
         theme: Option<&SyntaxTheme>,
-    ) -> Option<(u64, Vec<OutlineItem<Anchor>>)> {
+    ) -> Option<(usize, Vec<OutlineItem<Anchor>>)> {
         let anchor = self.anchor_before(offset);
         let excerpt_id = anchor.excerpt_id();
         let excerpt = self.excerpt(excerpt_id)?;
@@ -3068,7 +2926,7 @@ impl MultiBufferSnapshot {
         }
     }
 
-    pub fn buffer_id_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<u64> {
+    pub fn buffer_id_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<usize> {
         Some(self.excerpt(excerpt_id)?.buffer_id)
     }
 
@@ -3206,7 +3064,7 @@ impl History {
     fn end_transaction(
         &mut self,
         now: Instant,
-        buffer_transactions: HashMap<u64, TransactionId>,
+        buffer_transactions: HashMap<usize, TransactionId>,
     ) -> bool {
         assert_ne!(self.transaction_depth, 0);
         self.transaction_depth -= 1;
@@ -3231,12 +3089,8 @@ impl History {
         }
     }
 
-    fn push_transaction<'a, T>(
-        &mut self,
-        buffer_transactions: T,
-        now: Instant,
-        cx: &mut ModelContext<MultiBuffer>,
-    ) where
+    fn push_transaction<'a, T>(&mut self, buffer_transactions: T, now: Instant)
+    where
         T: IntoIterator<Item = (&'a ModelHandle<Buffer>, &'a language::Transaction)>,
     {
         assert_eq!(self.transaction_depth, 0);
@@ -3244,7 +3098,7 @@ impl History {
             id: self.next_transaction_id.tick(),
             buffer_transactions: buffer_transactions
                 .into_iter()
-                .map(|(buffer, transaction)| (buffer.read(cx).remote_id(), transaction.id))
+                .map(|(buffer, transaction)| (buffer.id(), transaction.id))
                 .collect(),
             first_edit_at: now,
             last_edit_at: now,
@@ -3341,7 +3195,7 @@ impl Excerpt {
     fn new(
         id: ExcerptId,
         locator: Locator,
-        buffer_id: u64,
+        buffer_id: usize,
         buffer: BufferSnapshot,
         range: ExcerptRange<text::Anchor>,
         has_trailing_newline: bool,
@@ -3875,9 +3729,10 @@ mod tests {
     use gpui::{AppContext, TestAppContext};
     use language::{Buffer, Rope};
     use rand::prelude::*;
-    use settings::SettingsStore;
+    use settings::Settings;
     use std::{env, rc::Rc};
     use unindent::Unindent;
+
     use util::test::sample_text;
 
     #[gpui::test]
@@ -4169,25 +4024,19 @@ mod tests {
 
         let leader_multibuffer = cx.add_model(|_| MultiBuffer::new(0));
         let follower_multibuffer = cx.add_model(|_| MultiBuffer::new(0));
-        let follower_edit_event_count = Rc::new(RefCell::new(0));
 
         follower_multibuffer.update(cx, |_, cx| {
-            let follower_edit_event_count = follower_edit_event_count.clone();
-            cx.subscribe(
-                &leader_multibuffer,
-                move |follower, _, event, cx| match event.clone() {
+            cx.subscribe(&leader_multibuffer, |follower, _, event, cx| {
+                match event.clone() {
                     Event::ExcerptsAdded {
                         buffer,
                         predecessor,
                         excerpts,
                     } => follower.insert_excerpts_with_ids_after(predecessor, buffer, excerpts, cx),
                     Event::ExcerptsRemoved { ids } => follower.remove_excerpts(ids, cx),
-                    Event::Edited => {
-                        *follower_edit_event_count.borrow_mut() += 1;
-                    }
                     _ => {}
-                },
-            )
+                }
+            })
             .detach();
         });
 
@@ -4226,7 +4075,6 @@ mod tests {
             leader_multibuffer.read(cx).snapshot(cx).text(),
             follower_multibuffer.read(cx).snapshot(cx).text(),
         );
-        assert_eq!(*follower_edit_event_count.borrow(), 2);
 
         leader_multibuffer.update(cx, |leader, cx| {
             let excerpt_ids = leader.excerpt_ids();
@@ -4236,27 +4084,6 @@ mod tests {
             leader_multibuffer.read(cx).snapshot(cx).text(),
             follower_multibuffer.read(cx).snapshot(cx).text(),
         );
-        assert_eq!(*follower_edit_event_count.borrow(), 3);
-
-        // Removing an empty set of excerpts is a noop.
-        leader_multibuffer.update(cx, |leader, cx| {
-            leader.remove_excerpts([], cx);
-        });
-        assert_eq!(
-            leader_multibuffer.read(cx).snapshot(cx).text(),
-            follower_multibuffer.read(cx).snapshot(cx).text(),
-        );
-        assert_eq!(*follower_edit_event_count.borrow(), 3);
-
-        // Adding an empty set of excerpts is a noop.
-        leader_multibuffer.update(cx, |leader, cx| {
-            leader.push_excerpts::<usize>(buffer_2.clone(), [], cx);
-        });
-        assert_eq!(
-            leader_multibuffer.read(cx).snapshot(cx).text(),
-            follower_multibuffer.read(cx).snapshot(cx).text(),
-        );
-        assert_eq!(*follower_edit_event_count.borrow(), 3);
 
         leader_multibuffer.update(cx, |leader, cx| {
             leader.clear(cx);
@@ -4265,7 +4092,6 @@ mod tests {
             leader_multibuffer.read(cx).snapshot(cx).text(),
             follower_multibuffer.read(cx).snapshot(cx).text(),
         );
-        assert_eq!(*follower_edit_event_count.borrow(), 4);
     }
 
     #[gpui::test]
@@ -4713,7 +4539,7 @@ mod tests {
 
         assert_eq!(
             snapshot
-                .git_diff_hunks_in_range(0..12)
+                .git_diff_hunks_in_range(0..12, false)
                 .map(|hunk| (hunk.status(), hunk.buffer_range))
                 .collect::<Vec<_>>(),
             &expected,
@@ -4721,7 +4547,7 @@ mod tests {
 
         assert_eq!(
             snapshot
-                .git_diff_hunks_in_range_rev(0..12)
+                .git_diff_hunks_in_range(0..12, true)
                 .map(|hunk| (hunk.status(), hunk.buffer_range))
                 .collect::<Vec<_>>(),
             expected
@@ -4837,7 +4663,7 @@ mod tests {
                         "Inserting excerpt at {} of {} for buffer {}: {:?}[{:?}] = {:?}",
                         excerpt_ix,
                         expected_excerpts.len(),
-                        buffer_handle.read(cx).remote_id(),
+                        buffer_handle.id(),
                         buffer.text(),
                         start_ix..end_ix,
                         &buffer.text()[start_ix..end_ix]
@@ -4923,8 +4749,8 @@ mod tests {
 
             let mut excerpt_starts = excerpt_starts.into_iter();
             for (buffer, range) in &expected_excerpts {
+                let buffer_id = buffer.id();
                 let buffer = buffer.read(cx);
-                let buffer_id = buffer.remote_id();
                 let buffer_range = range.to_offset(buffer);
                 let buffer_start_point = buffer.offset_to_point(buffer_range.start);
                 let buffer_start_point_utf16 =
@@ -5076,19 +4902,16 @@ mod tests {
                     .read(cx)
                     .range_to_buffer_ranges(start_ix..end_ix, cx);
                 let excerpted_buffers_text = excerpted_buffer_ranges
-                    .iter()
+                    .into_iter()
                     .map(|(buffer, buffer_range)| {
                         buffer
                             .read(cx)
-                            .text_for_range(buffer_range.clone())
+                            .text_for_range(buffer_range)
                             .collect::<String>()
                     })
                     .collect::<Vec<_>>()
                     .join("\n");
                 assert_eq!(excerpted_buffers_text, text_for_range);
-                if !expected_excerpts.is_empty() {
-                    assert!(!excerpted_buffer_ranges.is_empty());
-                }
 
                 let expected_summary = TextSummary::from(&expected_text[start_ix..end_ix]);
                 assert_eq!(
@@ -5155,8 +4978,7 @@ mod tests {
 
     #[gpui::test]
     fn test_history(cx: &mut AppContext) {
-        cx.set_global(SettingsStore::test(cx));
-
+        cx.set_global(Settings::test(cx));
         let buffer_1 = cx.add_model(|cx| Buffer::new(0, "1234", cx));
         let buffer_2 = cx.add_model(|cx| Buffer::new(0, "5678", cx));
         let multibuffer = cx.add_model(|_| MultiBuffer::new(0));

crates/editor/src/multi_buffer/anchor.rs

@@ -8,7 +8,7 @@ use sum_tree::Bias;
 
 #[derive(Clone, Copy, Eq, PartialEq, Debug, Hash)]
 pub struct Anchor {
-    pub(crate) buffer_id: Option<u64>,
+    pub(crate) buffer_id: Option<usize>,
     pub(crate) excerpt_id: ExcerptId,
     pub(crate) text_anchor: text::Anchor,
 }

crates/editor/src/scroll.rs

@@ -17,7 +17,7 @@ use workspace::WorkspaceId;
 
 use crate::{
     display_map::{DisplaySnapshot, ToDisplayPoint},
-    hover_popover::hide_hover,
+    hover_popover::{hide_hover, HideHover},
     persistence::DB,
     Anchor, DisplayPoint, Editor, EditorMode, Event, MultiBufferSnapshot, ToPoint,
 };
@@ -245,14 +245,14 @@ impl ScrollManager {
         }
 
         if cx.default_global::<ScrollbarAutoHide>().0 {
-            self.hide_scrollbar_task = Some(cx.spawn(|editor, mut cx| async move {
+            self.hide_scrollbar_task = Some(cx.spawn_weak(|editor, mut cx| async move {
                 cx.background().timer(SCROLLBAR_SHOW_INTERVAL).await;
-                editor
-                    .update(&mut cx, |editor, cx| {
+                if let Some(editor) = editor.upgrade(&cx) {
+                    editor.update(&mut cx, |editor, cx| {
                         editor.scroll_manager.show_scrollbars = false;
                         cx.notify();
-                    })
-                    .log_err();
+                    });
+                }
             }));
         } else {
             self.hide_scrollbar_task = None;
@@ -307,10 +307,14 @@ impl Editor {
     ) {
         let map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
 
-        hide_hover(self, cx);
-        let workspace_id = self.workspace.as_ref().map(|workspace| workspace.1);
-        self.scroll_manager
-            .set_scroll_position(scroll_position, &map, local, workspace_id, cx);
+        hide_hover(self, &HideHover, cx);
+        self.scroll_manager.set_scroll_position(
+            scroll_position,
+            &map,
+            local,
+            self.workspace_id,
+            cx,
+        );
     }
 
     pub fn scroll_position(&self, cx: &mut ViewContext<Self>) -> Vector2F {
@@ -319,14 +323,13 @@ impl Editor {
     }
 
     pub fn set_scroll_anchor(&mut self, scroll_anchor: ScrollAnchor, cx: &mut ViewContext<Self>) {
-        hide_hover(self, cx);
-        let workspace_id = self.workspace.as_ref().map(|workspace| workspace.1);
+        hide_hover(self, &HideHover, cx);
         let top_row = scroll_anchor
             .top_anchor
             .to_point(&self.buffer().read(cx).snapshot(cx))
             .row;
         self.scroll_manager
-            .set_anchor(scroll_anchor, top_row, true, workspace_id, cx);
+            .set_anchor(scroll_anchor, top_row, true, self.workspace_id, cx);
     }
 
     pub(crate) fn set_scroll_anchor_remote(
@@ -334,14 +337,13 @@ impl Editor {
         scroll_anchor: ScrollAnchor,
         cx: &mut ViewContext<Self>,
     ) {
-        hide_hover(self, cx);
-        let workspace_id = self.workspace.as_ref().map(|workspace| workspace.1);
+        hide_hover(self, &HideHover, cx);
         let top_row = scroll_anchor
             .top_anchor
             .to_point(&self.buffer().read(cx).snapshot(cx))
             .row;
         self.scroll_manager
-            .set_anchor(scroll_anchor, top_row, false, workspace_id, cx);
+            .set_anchor(scroll_anchor, top_row, false, self.workspace_id, cx);
     }
 
     pub fn scroll_screen(&mut self, amount: &ScrollAmount, cx: &mut ViewContext<Self>) {

crates/editor/src/scroll/actions.rs

@@ -1,4 +1,6 @@
-use gpui::{actions, geometry::vector::Vector2F, AppContext, Axis, ViewContext};
+use gpui::{
+    actions, geometry::vector::Vector2F, impl_internal_actions, AppContext, Axis, ViewContext,
+};
 use language::Bias;
 
 use crate::{Editor, EditorMode};
@@ -21,8 +23,17 @@ actions!(
     ]
 );
 
+#[derive(Clone, PartialEq)]
+pub struct Scroll {
+    pub scroll_position: Vector2F,
+    pub axis: Option<Axis>,
+}
+
+impl_internal_actions!(editor, [Scroll]);
+
 pub fn init(cx: &mut AppContext) {
     cx.add_action(Editor::next_screen);
+    cx.add_action(Editor::scroll);
     cx.add_action(Editor::scroll_cursor_top);
     cx.add_action(Editor::scroll_cursor_center);
     cx.add_action(Editor::scroll_cursor_bottom);
@@ -64,14 +75,9 @@ impl Editor {
         Some(())
     }
 
-    pub fn scroll(
-        &mut self,
-        scroll_position: Vector2F,
-        axis: Option<Axis>,
-        cx: &mut ViewContext<Self>,
-    ) {
-        self.scroll_manager.update_ongoing_scroll(axis);
-        self.set_scroll_position(scroll_position, cx);
+    fn scroll(&mut self, action: &Scroll, cx: &mut ViewContext<Self>) {
+        self.scroll_manager.update_ongoing_scroll(action.axis);
+        self.set_scroll_position(action.scroll_position, cx);
     }
 
     fn scroll_cursor_top(editor: &mut Editor, _: &ScrollCursorTop, cx: &mut ViewContext<Editor>) {

crates/editor/src/scroll/autoscroll.rs

@@ -1,9 +1,9 @@
 use std::cmp;
 
-use gpui::ViewContext;
+use gpui::{text_layout, ViewContext};
 use language::Point;
 
-use crate::{display_map::ToDisplayPoint, Editor, EditorMode, LineWithInvisibles};
+use crate::{display_map::ToDisplayPoint, Editor, EditorMode};
 
 #[derive(PartialEq, Eq)]
 pub enum Autoscroll {
@@ -172,7 +172,7 @@ impl Editor {
         viewport_width: f32,
         scroll_width: f32,
         max_glyph_width: f32,
-        layouts: &[LineWithInvisibles],
+        layouts: &[text_layout::Line],
         cx: &mut ViewContext<Self>,
     ) -> bool {
         let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
@@ -194,13 +194,10 @@ impl Editor {
                     let end_column = cmp::min(display_map.line_len(head.row()), head.column() + 3);
                     target_left = target_left.min(
                         layouts[(head.row() - start_row) as usize]
-                            .line
                             .x_for_index(start_column as usize),
                     );
                     target_right = target_right.max(
-                        layouts[(head.row() - start_row) as usize]
-                            .line
-                            .x_for_index(end_column as usize)
+                        layouts[(head.row() - start_row) as usize].x_for_index(end_column as usize)
                             + max_glyph_width,
                     );
                 }