Add test

.github/ISSUE_TEMPLATE/01_bug_ai.yml

@@ -1,4 +1,4 @@
-name: Bug Report (AI)
+name: Bug Report (AI Related)
 description: Zed Agent Panel Bugs
 type: "Bug"
 labels: ["ai"]
@@ -19,14 +19,15 @@ body:
         2.
         3.
 
-        **Expected Behavior**:
-        **Actual Behavior**:
+        Actual Behavior:
+        Expected Behavior:
 
         ### Model Provider Details
         - Provider: (Anthropic via ZedPro, Anthropic via API key, Copilot Chat, Mistral, OpenAI, etc)
         - Model Name:
         - Mode: (Agent Panel, Inline Assistant, Terminal Assistant or Text Threads)
-        - Other Details (MCPs, other settings, etc):
+        - MCP Servers in-use:
+        - Other Details:
     validations:
       required: true
 

.github/ISSUE_TEMPLATE/02_bug_edit_predictions.yml

@@ -0,0 +1,36 @@
+name: Bug Report (Edit Predictions)
+description: Zed Edit Predictions bugs
+type: "Bug"
+labels: ["ai", "inline completion", "zeta"]
+title: "Edit Predictions: <a short description of the Edit Prediction bug>"
+body:
+  - type: textarea
+    attributes:
+      label: Summary
+      description: Describe the bug with a one line summary, and provide detailed reproduction steps
+      value: |
+        <!-- Please insert a one line summary of the issue below -->
+        SUMMARY_SENTENCE_HERE
+
+        ### Description
+        <!--  Describe with sufficient detail to reproduce from a clean Zed install. -->
+        <!--  Please include the LLM provider and model name you are using -->
+        Steps to trigger the problem:
+        1.
+        2.
+        3.
+
+        Actual Behavior:
+        Expected Behavior:
+    validations:
+      required: true
+
+  - type: textarea
+    id: environment
+    attributes:
+      label: Zed Version and System Specs
+      description: 'Open Zed, and in the command palette select "zed: copy system specs into clipboard"'
+      placeholder: |
+        Output of "zed: copy system specs into clipboard"
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/03_bug_git.yml

@@ -0,0 +1,35 @@
+name: Bug Report (Git)
+description: Zed Git-Related Bugs
+type: "Bug"
+labels: ["git"]
+title: "Git: <a short description of the Git bug>"
+body:
+  - type: textarea
+    attributes:
+      label: Summary
+      description: Describe the bug with a one line summary, and provide detailed reproduction steps
+      value: |
+        <!-- Please insert a one line summary of the issue below -->
+        SUMMARY_SENTENCE_HERE
+
+        ### Description
+        <!--  Describe with sufficient detail to reproduce from a clean Zed install. -->
+        Steps to trigger the problem:
+        1.
+        2.
+        3.
+
+        Actual Behavior:
+        Expected Behavior:
+
+    validations:
+      required: true
+  - type: textarea
+    id: environment
+    attributes:
+      label: Zed Version and System Specs
+      description: 'Open Zed, and in the command palette select "zed: copy system specs into clipboard"'
+      placeholder: |
+        Output of "zed: copy system specs into clipboard"
+    validations:
+      required: true

.github/ISSUE_TEMPLATE/04_bug_debugger.yml

@@ -19,8 +19,8 @@ body:
         2.
         3.
 
-        **Expected Behavior**:
-        **Actual Behavior**:
+        Actual Behavior:
+        Expected Behavior:
 
     validations:
       required: true

.github/ISSUE_TEMPLATE/10_bug_report.yml

@@ -18,16 +18,14 @@ body:
           - Issues with insufficient detail may be summarily closed.
         -->
 
-        DESCRIPTION_HERE
-
         Steps to reproduce:
         1.
         2.
         3.
         4.
 
-        **Expected Behavior**:
-        **Actual Behavior**:
+        Expected Behavior:
+        Actual Behavior:
 
         <!-- Before Submitting, did you:
           1. Include settings.json, keymap.json, .editorconfig if relevant?

.github/actions/run_tests/action.yml

@@ -1,12 +1,6 @@
 name: "Run tests"
 description: "Runs the tests"
 
-inputs:
-  use-xvfb:
-    description: "Whether to run tests with xvfb"
-    required: false
-    default: "false"
-
 runs:
   using: "composite"
   steps:
@@ -26,9 +20,4 @@ runs:
 
     - name: Run tests
       shell: bash -euxo pipefail {0}
-      run: |
-        if [ "${{ inputs.use-xvfb }}" == "true" ]; then
-          xvfb-run --auto-servernum --server-args="-screen 0 1024x768x24 -nolisten tcp" cargo nextest run --workspace --no-fail-fast
-        else
-          cargo nextest run --workspace --no-fail-fast
-        fi
+      run: cargo nextest run --workspace --no-fail-fast

.github/workflows/ci.yml

@@ -319,8 +319,6 @@ jobs:
 
       - name: Run tests
         uses: ./.github/actions/run_tests
-        with:
-          use-xvfb: true
 
       - name: Build other binaries and features
         run: |

.github/workflows/unit_evals.yml

@@ -62,7 +62,7 @@ jobs:
 
       - name: Run unit evals
         shell: bash -euxo pipefail {0}
-        run: cargo nextest run --workspace --no-fail-fast --features eval --no-capture -E 'test(::eval_)'
+        run: cargo nextest run --workspace --no-fail-fast --features eval --no-capture -E 'test(::eval_)' --test-threads 1
         env:
           ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
 

Cargo.lock

@@ -99,7 +99,6 @@ dependencies = [
  "paths",
  "picker",
  "postage",
- "pretty_assertions",
  "project",
  "prompt_store",
  "proto",
@@ -705,7 +704,6 @@ dependencies = [
  "serde_json",
  "settings",
  "smallvec",
- "smol",
  "streaming_diff",
  "strsim",
  "task",
@@ -3161,16 +3159,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "command-fds"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2ec1052629a80c28594777d1252efc8a6b005d13f9edfd8c3fc0f44d5b32489a"
-dependencies = [
- "nix 0.30.1",
- "thiserror 2.0.12",
-]
-
 [[package]]
 name = "command_palette"
 version = "0.1.0"
@@ -4063,7 +4051,6 @@ version = "0.1.0"
 dependencies = [
  "anyhow",
  "async-trait",
- "collections",
  "dap",
  "futures 0.3.31",
  "gpui",
@@ -10142,18 +10129,6 @@ dependencies = [
  "memoffset",
 ]
 
-[[package]]
-name = "nix"
-version = "0.30.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74523f3a35e05aba87a1d978330aef40f67b0304ac79c1c00b294c9830543db6"
-dependencies = [
- "bitflags 2.9.0",
- "cfg-if",
- "cfg_aliases 0.2.1",
- "libc",
-]
-
 [[package]]
 name = "node_runtime"
 version = "0.1.0"
@@ -12134,6 +12109,7 @@ dependencies = [
  "unindent",
  "url",
  "util",
+ "uuid",
  "which 6.0.3",
  "workspace-hack",
  "worktree",
@@ -17145,7 +17121,6 @@ dependencies = [
  "async-fs",
  "async_zip",
  "collections",
- "command-fds",
  "dirs 4.0.0",
  "dunce",
  "futures 0.3.31",

assets/settings/default.json

@@ -605,7 +605,7 @@
       //    "never"
       "show": "always"
     },
-    // Whether to hide the root entry when only one folder is open in the window.
+    /// Hide main root dir
     "hide_root": false
   },
   "outline_panel": {

assets/themes/one/one.json

@@ -99,8 +99,6 @@
         "version_control.added": "#27a657ff",
         "version_control.modified": "#d3b020ff",
         "version_control.deleted": "#e06c76ff",
-        "version_control.conflict_marker.ours": "#a1c1811a",
-        "version_control.conflict_marker.theirs": "#74ade81a",
         "conflict": "#dec184ff",
         "conflict.background": "#dec1841a",
         "conflict.border": "#5d4c2fff",

crates/agent/Cargo.toml

@@ -109,6 +109,5 @@ gpui = { workspace = true, "features" = ["test-support"] }
 indoc.workspace = true
 language = { workspace = true, "features" = ["test-support"] }
 language_model = { workspace = true, "features" = ["test-support"] }
-pretty_assertions.workspace = true
 project = { workspace = true, features = ["test-support"] }
 rand.workspace = true

crates/agent/src/active_thread.rs

@@ -1788,31 +1788,12 @@ impl ActiveThread {
 
     fn render_message(&self, ix: usize, window: &mut Window, cx: &mut Context<Self>) -> AnyElement {
         let message_id = self.messages[ix];
-        let workspace = self.workspace.clone();
-        let thread = self.thread.read(cx);
-
-        let is_first_message = ix == 0;
-        let is_last_message = ix == self.messages.len() - 1;
-
-        let Some(message) = thread.message(message_id) else {
+        let Some(message) = self.thread.read(cx).message(message_id) else {
             return Empty.into_any();
         };
 
-        let is_generating = thread.is_generating();
-        let is_generating_stale = thread.is_generation_stale().unwrap_or(false);
-
-        let loading_dots = (is_generating && is_last_message).then(|| {
-            h_flex()
-                .h_8()
-                .my_3()
-                .mx_5()
-                .when(is_generating_stale || message.is_hidden, |this| {
-                    this.child(AnimatedLabel::new("").size(LabelSize::Small))
-                })
-        });
-
         if message.is_hidden {
-            return div().children(loading_dots).into_any();
+            return Empty.into_any();
         }
 
         let message_creases = message.creases.clone();
@@ -1821,6 +1802,9 @@ impl ActiveThread {
             return Empty.into_any();
         };
 
+        let workspace = self.workspace.clone();
+        let thread = self.thread.read(cx);
+
         // Get all the data we need from thread before we start using it in closures
         let checkpoint = thread.checkpoint_for_message(message_id);
         let configured_model = thread.configured_model().map(|m| m.model);
@@ -1831,6 +1815,14 @@ impl ActiveThread {
 
         let tool_uses = thread.tool_uses_for_message(message_id, cx);
         let has_tool_uses = !tool_uses.is_empty();
+        let is_generating = thread.is_generating();
+        let is_generating_stale = thread.is_generation_stale().unwrap_or(false);
+
+        let is_first_message = ix == 0;
+        let is_last_message = ix == self.messages.len() - 1;
+
+        let loading_dots = (is_generating_stale && is_last_message)
+            .then(|| AnimatedLabel::new("").size(LabelSize::Small));
 
         let editing_message_state = self
             .editing_message
@@ -2246,7 +2238,17 @@ impl ActiveThread {
                 parent.child(self.render_rules_item(cx))
             })
             .child(styled_message)
-            .children(loading_dots)
+            .when(is_generating && is_last_message, |this| {
+                this.child(
+                    h_flex()
+                        .h_8()
+                        .mt_2()
+                        .mb_4()
+                        .ml_4()
+                        .py_1p5()
+                        .when_some(loading_dots, |this, loading_dots| this.child(loading_dots)),
+                )
+            })
             .when(show_feedback, move |parent| {
                 parent.child(feedback_items).when_some(
                     self.open_feedback_editors.get(&message_id),

crates/agent/src/agent_configuration.rs

@@ -12,7 +12,7 @@ use context_server::ContextServerId;
 use fs::Fs;
 use gpui::{
     Action, Animation, AnimationExt as _, AnyView, App, Entity, EventEmitter, FocusHandle,
-    Focusable, ScrollHandle, Subscription, Transformation, percentage,
+    Focusable, ScrollHandle, Subscription, pulsating_between,
 };
 use language_model::{LanguageModelProvider, LanguageModelProviderId, LanguageModelRegistry};
 use project::context_server_store::{ContextServerStatus, ContextServerStore};
@@ -475,6 +475,7 @@ impl AgentConfiguration {
             .get(&context_server_id)
             .copied()
             .unwrap_or_default();
+
         let tools = tools_by_source
             .get(&ToolSource::ContextServer {
                 id: context_server_id.0.clone().into(),
@@ -483,23 +484,25 @@ impl AgentConfiguration {
         let tool_count = tools.len();
 
         let border_color = cx.theme().colors().border.opacity(0.6);
+        let success_color = Color::Success.color(cx);
 
         let (status_indicator, tooltip_text) = match server_status {
             ContextServerStatus::Starting => (
-                Icon::new(IconName::LoadCircle)
-                    .size(IconSize::XSmall)
-                    .color(Color::Accent)
+                Indicator::dot()
+                    .color(Color::Success)
                     .with_animation(
                         SharedString::from(format!("{}-starting", context_server_id.0.clone(),)),
-                        Animation::new(Duration::from_secs(3)).repeat(),
-                        |icon, delta| icon.transform(Transformation::rotate(percentage(delta))),
+                        Animation::new(Duration::from_secs(2))
+                            .repeat()
+                            .with_easing(pulsating_between(0.4, 1.)),
+                        move |this, delta| this.color(success_color.alpha(delta).into()),
                     )
                     .into_any_element(),
                 "Server is starting.",
             ),
             ContextServerStatus::Running => (
                 Indicator::dot().color(Color::Success).into_any_element(),
-                "Server is active.",
+                "Server is running.",
             ),
             ContextServerStatus::Error(_) => (
                 Indicator::dot().color(Color::Error).into_any_element(),
@@ -523,11 +526,12 @@ impl AgentConfiguration {
                     .p_1()
                     .justify_between()
                     .when(
-                        error.is_some() || are_tools_expanded && tool_count >= 1,
+                        error.is_some() || are_tools_expanded && tool_count > 1,
                         |element| element.border_b_1().border_color(border_color),
                     )
                     .child(
                         h_flex()
+                            .gap_1p5()
                             .child(
                                 Disclosure::new(
                                     "tool-list-disclosure",
@@ -547,16 +551,12 @@ impl AgentConfiguration {
                                 })),
                             )
                             .child(
-                                h_flex()
-                                    .id(SharedString::from(format!("tooltip-{}", item_id)))
-                                    .h_full()
-                                    .w_3()
-                                    .mx_1()
-                                    .justify_center()
+                                div()
+                                    .id(item_id.clone())
                                     .tooltip(Tooltip::text(tooltip_text))
                                     .child(status_indicator),
                             )
-                            .child(Label::new(item_id).ml_0p5().mr_1p5())
+                            .child(Label::new(context_server_id.0.clone()).ml_0p5())
                             .when(is_running, |this| {
                                 this.child(
                                     Label::new(if tool_count == 1 {

crates/agent/src/buffer_codegen.rs

@@ -386,10 +386,8 @@ impl CodegenAlternative {
                 async { Ok(LanguageModelTextStream::default()) }.boxed_local()
             } else {
                 let request = self.build_request(&model, user_prompt, cx)?;
-                cx.spawn(async move |_, cx| {
-                    Ok(model.stream_completion_text(request.await, &cx).await?)
-                })
-                .boxed_local()
+                cx.spawn(async move |_, cx| model.stream_completion_text(request.await, &cx).await)
+                    .boxed_local()
             };
         self.handle_stream(telemetry_id, provider_id.to_string(), api_key, stream, cx);
         Ok(())

crates/agent/src/context_server_tool.rs

@@ -105,7 +105,7 @@ impl Tool for ContextServerTool {
                     arguments
                 );
                 let response = protocol
-                    .request::<context_server::types::requests::CallTool>(
+                    .request::<context_server::types::request::CallTool>(
                         context_server::types::CallToolParams {
                             name: tool_name,
                             arguments,
@@ -123,9 +123,6 @@ impl Tool for ContextServerTool {
                         types::ToolResponseContent::Image { .. } => {
                             log::warn!("Ignoring image content from tool response");
                         }
-                        types::ToolResponseContent::Audio { .. } => {
-                            log::warn!("Ignoring audio content from tool response");
-                        }
                         types::ToolResponseContent::Resource { .. } => {
                             log::warn!("Ignoring resource content from tool response");
                         }

crates/agent/src/inline_assistant.rs

@@ -1331,7 +1331,7 @@ impl InlineAssistant {
                 editor.clear_gutter_highlights::<GutterPendingRange>(cx);
             } else {
                 editor.highlight_gutter::<GutterPendingRange>(
-                    gutter_pending_ranges,
+                    &gutter_pending_ranges,
                     |cx| cx.theme().status().info_background,
                     cx,
                 )
@@ -1342,7 +1342,7 @@ impl InlineAssistant {
                 editor.clear_gutter_highlights::<GutterTransformedRange>(cx);
             } else {
                 editor.highlight_gutter::<GutterTransformedRange>(
-                    gutter_transformed_ranges,
+                    &gutter_transformed_ranges,
                     |cx| cx.theme().status().info,
                     cx,
                 )

crates/agent/src/thread.rs

@@ -195,20 +195,20 @@ impl MessageSegment {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ProjectSnapshot {
     pub worktree_snapshots: Vec<WorktreeSnapshot>,
     pub unsaved_buffer_paths: Vec<String>,
     pub timestamp: DateTime<Utc>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct WorktreeSnapshot {
     pub worktree_path: String,
     pub git_state: Option<GitState>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct GitState {
     pub remote_url: Option<String>,
     pub head_sha: Option<String>,
@@ -247,7 +247,7 @@ impl LastRestoreCheckpoint {
     }
 }
 
-#[derive(Clone, Debug, Default, Serialize, Deserialize, PartialEq)]
+#[derive(Clone, Debug, Default, Serialize, Deserialize)]
 pub enum DetailedSummaryState {
     #[default]
     NotGenerated,
@@ -391,7 +391,7 @@ impl ThreadSummary {
     }
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ExceededWindowError {
     /// Model used when last message exceeded context window
     model_id: LanguageModelId,
@@ -1563,9 +1563,6 @@ impl Thread {
                             Err(LanguageModelCompletionError::Other(error)) => {
                                 return Err(error);
                             }
-                            Err(err @ LanguageModelCompletionError::RateLimit(..)) => {
-                                return Err(err.into());
-                            }
                         };
 
                         match event {

crates/agent/src/thread_store.rs

@@ -89,7 +89,7 @@ pub fn init(cx: &mut App) {
 pub struct SharedProjectContext(Rc<RefCell<Option<ProjectContext>>>);
 
 impl SharedProjectContext {
-    pub fn borrow(&self) -> Ref<'_, Option<ProjectContext>> {
+    pub fn borrow(&self) -> Ref<Option<ProjectContext>> {
         self.0.borrow()
     }
 }
@@ -562,7 +562,7 @@ impl ThreadStore {
 
             if protocol.capable(context_server::protocol::ServerCapability::Tools) {
                 if let Some(response) = protocol
-                    .request::<context_server::types::requests::ListTools>(())
+                    .request::<context_server::types::request::ListTools>(())
                     .await
                     .log_err()
                 {
@@ -603,7 +603,7 @@ pub struct SerializedThreadMetadata {
     pub updated_at: DateTime<Utc>,
 }
 
-#[derive(Serialize, Deserialize, Debug, PartialEq)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct SerializedThread {
     pub version: String,
     pub summary: SharedString,
@@ -629,7 +629,7 @@ pub struct SerializedThread {
     pub profile: Option<AgentProfileId>,
 }
 
-#[derive(Serialize, Deserialize, Debug, PartialEq)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct SerializedLanguageModel {
     pub provider: String,
     pub model: String,
@@ -690,15 +690,11 @@ impl SerializedThreadV0_1_0 {
             messages.push(message);
         }
 
-        SerializedThread {
-            messages,
-            version: SerializedThread::VERSION.to_string(),
-            ..self.0
-        }
+        SerializedThread { messages, ..self.0 }
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct SerializedMessage {
     pub id: MessageId,
     pub role: Role,
@@ -716,7 +712,7 @@ pub struct SerializedMessage {
     pub is_hidden: bool,
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Serialize, Deserialize)]
 #[serde(tag = "type")]
 pub enum SerializedMessageSegment {
     #[serde(rename = "text")]
@@ -734,14 +730,14 @@ pub enum SerializedMessageSegment {
     },
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct SerializedToolUse {
     pub id: LanguageModelToolUseId,
     pub name: SharedString,
     pub input: serde_json::Value,
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct SerializedToolResult {
     pub tool_use_id: LanguageModelToolUseId,
     pub is_error: bool,
@@ -804,7 +800,7 @@ impl LegacySerializedMessage {
     }
 }
 
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Serialize, Deserialize)]
 pub struct SerializedCrease {
     pub start: usize,
     pub end: usize,
@@ -923,7 +919,7 @@ impl ThreadsDatabase {
 
             fn bytes_encode(
                 item: &Self::EItem,
-            ) -> Result<std::borrow::Cow<'_, [u8]>, heed::BoxedError> {
+            ) -> Result<std::borrow::Cow<[u8]>, heed::BoxedError> {
                 serde_json::to_vec(&item.0)
                     .map(std::borrow::Cow::Owned)
                     .map_err(Into::into)
@@ -1061,181 +1057,3 @@ impl ThreadsDatabase {
         })
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::thread::{DetailedSummaryState, MessageId};
-    use chrono::Utc;
-    use language_model::{Role, TokenUsage};
-    use pretty_assertions::assert_eq;
-
-    #[test]
-    fn test_legacy_serialized_thread_upgrade() {
-        let updated_at = Utc::now();
-        let legacy_thread = LegacySerializedThread {
-            summary: "Test conversation".into(),
-            updated_at,
-            messages: vec![LegacySerializedMessage {
-                id: MessageId(1),
-                role: Role::User,
-                text: "Hello, world!".to_string(),
-                tool_uses: vec![],
-                tool_results: vec![],
-            }],
-            initial_project_snapshot: None,
-        };
-
-        let upgraded = legacy_thread.upgrade();
-
-        assert_eq!(
-            upgraded,
-            SerializedThread {
-                summary: "Test conversation".into(),
-                updated_at,
-                messages: vec![SerializedMessage {
-                    id: MessageId(1),
-                    role: Role::User,
-                    segments: vec![SerializedMessageSegment::Text {
-                        text: "Hello, world!".to_string()
-                    }],
-                    tool_uses: vec![],
-                    tool_results: vec![],
-                    context: "".to_string(),
-                    creases: vec![],
-                    is_hidden: false
-                }],
-                version: SerializedThread::VERSION.to_string(),
-                initial_project_snapshot: None,
-                cumulative_token_usage: TokenUsage::default(),
-                request_token_usage: vec![],
-                detailed_summary_state: DetailedSummaryState::default(),
-                exceeded_window_error: None,
-                model: None,
-                completion_mode: None,
-                tool_use_limit_reached: false,
-                profile: None
-            }
-        )
-    }
-
-    #[test]
-    fn test_serialized_threadv0_1_0_upgrade() {
-        let updated_at = Utc::now();
-        let thread_v0_1_0 = SerializedThreadV0_1_0(SerializedThread {
-            summary: "Test conversation".into(),
-            updated_at,
-            messages: vec![
-                SerializedMessage {
-                    id: MessageId(1),
-                    role: Role::User,
-                    segments: vec![SerializedMessageSegment::Text {
-                        text: "Use tool_1".to_string(),
-                    }],
-                    tool_uses: vec![],
-                    tool_results: vec![],
-                    context: "".to_string(),
-                    creases: vec![],
-                    is_hidden: false,
-                },
-                SerializedMessage {
-                    id: MessageId(2),
-                    role: Role::Assistant,
-                    segments: vec![SerializedMessageSegment::Text {
-                        text: "I want to use a tool".to_string(),
-                    }],
-                    tool_uses: vec![SerializedToolUse {
-                        id: "abc".into(),
-                        name: "tool_1".into(),
-                        input: serde_json::Value::Null,
-                    }],
-                    tool_results: vec![],
-                    context: "".to_string(),
-                    creases: vec![],
-                    is_hidden: false,
-                },
-                SerializedMessage {
-                    id: MessageId(1),
-                    role: Role::User,
-                    segments: vec![SerializedMessageSegment::Text {
-                        text: "Here is the tool result".to_string(),
-                    }],
-                    tool_uses: vec![],
-                    tool_results: vec![SerializedToolResult {
-                        tool_use_id: "abc".into(),
-                        is_error: false,
-                        content: LanguageModelToolResultContent::Text("abcdef".into()),
-                        output: Some(serde_json::Value::Null),
-                    }],
-                    context: "".to_string(),
-                    creases: vec![],
-                    is_hidden: false,
-                },
-            ],
-            version: SerializedThreadV0_1_0::VERSION.to_string(),
-            initial_project_snapshot: None,
-            cumulative_token_usage: TokenUsage::default(),
-            request_token_usage: vec![],
-            detailed_summary_state: DetailedSummaryState::default(),
-            exceeded_window_error: None,
-            model: None,
-            completion_mode: None,
-            tool_use_limit_reached: false,
-            profile: None,
-        });
-        let upgraded = thread_v0_1_0.upgrade();
-
-        assert_eq!(
-            upgraded,
-            SerializedThread {
-                summary: "Test conversation".into(),
-                updated_at,
-                messages: vec![
-                    SerializedMessage {
-                        id: MessageId(1),
-                        role: Role::User,
-                        segments: vec![SerializedMessageSegment::Text {
-                            text: "Use tool_1".to_string()
-                        }],
-                        tool_uses: vec![],
-                        tool_results: vec![],
-                        context: "".to_string(),
-                        creases: vec![],
-                        is_hidden: false
-                    },
-                    SerializedMessage {
-                        id: MessageId(2),
-                        role: Role::Assistant,
-                        segments: vec![SerializedMessageSegment::Text {
-                            text: "I want to use a tool".to_string(),
-                        }],
-                        tool_uses: vec![SerializedToolUse {
-                            id: "abc".into(),
-                            name: "tool_1".into(),
-                            input: serde_json::Value::Null,
-                        }],
-                        tool_results: vec![SerializedToolResult {
-                            tool_use_id: "abc".into(),
-                            is_error: false,
-                            content: LanguageModelToolResultContent::Text("abcdef".into()),
-                            output: Some(serde_json::Value::Null),
-                        }],
-                        context: "".to_string(),
-                        creases: vec![],
-                        is_hidden: false,
-                    },
-                ],
-                version: SerializedThread::VERSION.to_string(),
-                initial_project_snapshot: None,
-                cumulative_token_usage: TokenUsage::default(),
-                request_token_usage: vec![],
-                detailed_summary_state: DetailedSummaryState::default(),
-                exceeded_window_error: None,
-                model: None,
-                completion_mode: None,
-                tool_use_limit_reached: false,
-                profile: None
-            }
-        )
-    }
-}

crates/anthropic/src/anthropic.rs

@@ -1,5 +1,4 @@
 use std::str::FromStr;
-use std::time::Duration;
 
 use anyhow::{Context as _, Result, anyhow};
 use chrono::{DateTime, Utc};
@@ -407,7 +406,6 @@ impl RateLimit {
 /// <https://docs.anthropic.com/en/api/rate-limits#response-headers>
 #[derive(Debug)]
 pub struct RateLimitInfo {
-    pub retry_after: Option<Duration>,
     pub requests: Option<RateLimit>,
     pub tokens: Option<RateLimit>,
     pub input_tokens: Option<RateLimit>,
@@ -419,11 +417,10 @@ impl RateLimitInfo {
         // Check if any rate limit headers exist
         let has_rate_limit_headers = headers
             .keys()
-            .any(|k| k == "retry-after" || k.as_str().starts_with("anthropic-ratelimit-"));
+            .any(|k| k.as_str().starts_with("anthropic-ratelimit-"));
 
         if !has_rate_limit_headers {
             return Self {
-                retry_after: None,
                 requests: None,
                 tokens: None,
                 input_tokens: None,
@@ -432,11 +429,6 @@ impl RateLimitInfo {
         }
 
         Self {
-            retry_after: headers
-                .get("retry-after")
-                .and_then(|v| v.to_str().ok())
-                .and_then(|v| v.parse::<u64>().ok())
-                .map(Duration::from_secs),
             requests: RateLimit::from_headers("requests", headers).ok(),
             tokens: RateLimit::from_headers("tokens", headers).ok(),
             input_tokens: RateLimit::from_headers("input-tokens", headers).ok(),
@@ -489,8 +481,8 @@ pub async fn stream_completion_with_rate_limit_info(
         .send(request)
         .await
         .context("failed to send request to Anthropic")?;
-    let rate_limits = RateLimitInfo::from_headers(response.headers());
     if response.status().is_success() {
+        let rate_limits = RateLimitInfo::from_headers(response.headers());
         let reader = BufReader::new(response.into_body());
         let stream = reader
             .lines()
@@ -508,8 +500,6 @@ pub async fn stream_completion_with_rate_limit_info(
             })
             .boxed();
         Ok((stream, Some(rate_limits)))
-    } else if let Some(retry_after) = rate_limits.retry_after {
-        Err(AnthropicError::RateLimit(retry_after))
     } else {
         let mut body = Vec::new();
         response
@@ -779,8 +769,6 @@ pub struct MessageDelta {
 
 #[derive(Error, Debug)]
 pub enum AnthropicError {
-    #[error("rate limit exceeded, retry after {0:?}")]
-    RateLimit(Duration),
     #[error("an error occurred while interacting with the Anthropic API: {error_type}: {message}", error_type = .0.error_type, message = .0.message)]
     ApiError(ApiError),
     #[error("{0}")]

crates/assistant_context_editor/src/context_store.rs

@@ -869,7 +869,7 @@ impl ContextStore {
 
             if protocol.capable(context_server::protocol::ServerCapability::Prompts) {
                 if let Some(response) = protocol
-                    .request::<context_server::types::requests::PromptsList>(())
+                    .request::<context_server::types::request::PromptsList>(())
                     .await
                     .log_err()
                 {

crates/assistant_context_editor/src/language_model_selector.rs

@@ -682,12 +682,11 @@ mod tests {
             _: &AsyncApp,
         ) -> BoxFuture<
             'static,
-            Result<
+            http_client::Result<
                 BoxStream<
                     'static,
-                    Result<LanguageModelCompletionEvent, LanguageModelCompletionError>,
+                    http_client::Result<LanguageModelCompletionEvent, LanguageModelCompletionError>,
                 >,
-                LanguageModelCompletionError,
             >,
         > {
             unimplemented!()

crates/assistant_slash_commands/src/context_server_command.rs

@@ -87,7 +87,7 @@ impl SlashCommand for ContextServerSlashCommand {
                 let protocol = server.client().context("Context server not initialized")?;
 
                 let response = protocol
-                    .request::<context_server::types::requests::CompletionComplete>(
+                    .request::<context_server::types::request::CompletionComplete>(
                         context_server::types::CompletionCompleteParams {
                             reference: context_server::types::CompletionReference::Prompt(
                                 context_server::types::PromptReference {
@@ -145,7 +145,7 @@ impl SlashCommand for ContextServerSlashCommand {
             cx.foreground_executor().spawn(async move {
                 let protocol = server.client().context("Context server not initialized")?;
                 let response = protocol
-                    .request::<context_server::types::requests::PromptsGet>(
+                    .request::<context_server::types::request::PromptsGet>(
                         context_server::types::PromptsGetParams {
                             name: prompt_name.clone(),
                             arguments: Some(prompt_args),

crates/assistant_tool/src/tool_schema.rs

@@ -46,19 +46,15 @@ fn adapt_to_json_schema_subset(json: &mut Value) -> Result<()> {
             );
         }
 
-        const KEYS_TO_REMOVE: [(&str, fn(&Value) -> bool); 5] = [
-            ("format", |value| value.is_string()),
-            ("additionalProperties", |value| value.is_boolean()),
-            ("exclusiveMinimum", |value| value.is_number()),
-            ("exclusiveMaximum", |value| value.is_number()),
-            ("optional", |value| value.is_boolean()),
+        const KEYS_TO_REMOVE: [&str; 5] = [
+            "format",
+            "additionalProperties",
+            "exclusiveMinimum",
+            "exclusiveMaximum",
+            "optional",
         ];
-        for (key, predicate) in KEYS_TO_REMOVE {
-            if let Some(value) = obj.get(key) {
-                if predicate(value) {
-                    obj.remove(key);
-                }
-            }
+        for key in KEYS_TO_REMOVE {
+            obj.remove(key);
         }
 
         // If a type is not specified for an input parameter, add a default type
@@ -157,24 +153,6 @@ mod tests {
                 "type": "integer"
             })
         );
-
-        // Ensure that we do not remove keys that are actually supported (e.g. "format" can just be used as another property)
-        let mut json = json!({
-            "description": "A test field",
-            "type": "integer",
-            "format": {},
-        });
-
-        adapt_to_json_schema_subset(&mut json).unwrap();
-
-        assert_eq!(
-            json,
-            json!({
-                "description": "A test field",
-                "type": "integer",
-                "format": {},
-            })
-        );
     }
 
     #[test]

crates/assistant_tools/Cargo.toml

@@ -80,7 +80,6 @@ rand.workspace = true
 pretty_assertions.workspace = true
 reqwest_client.workspace = true
 settings = { workspace = true, features = ["test-support"] }
-smol.workspace = true
 task = { workspace = true, features = ["test-support"]}
 tempfile.workspace = true
 theme.workspace = true

crates/assistant_tools/src/edit_agent/evals.rs

@@ -11,7 +11,7 @@ use client::{Client, UserStore};
 use collections::HashMap;
 use fs::FakeFs;
 use futures::{FutureExt, future::LocalBoxFuture};
-use gpui::{AppContext, TestAppContext, Timer};
+use gpui::{AppContext, TestAppContext};
 use indoc::{formatdoc, indoc};
 use language_model::{
     LanguageModelRegistry, LanguageModelRequestTool, LanguageModelToolResult,
@@ -1255,12 +1255,9 @@ impl EvalAssertion {
                 }],
                 ..Default::default()
             };
-            let mut response = retry_on_rate_limit(async || {
-                Ok(judge
-                    .stream_completion_text(request.clone(), &cx.to_async())
-                    .await?)
-            })
-            .await?;
+            let mut response = judge
+                .stream_completion_text(request, &cx.to_async())
+                .await?;
             let mut output = String::new();
             while let Some(chunk) = response.stream.next().await {
                 let chunk = chunk?;
@@ -1311,17 +1308,10 @@ fn eval(
     run_eval(eval.clone(), tx.clone());
 
     let executor = gpui::background_executor();
-    let semaphore = Arc::new(smol::lock::Semaphore::new(32));
     for _ in 1..iterations {
         let eval = eval.clone();
         let tx = tx.clone();
-        let semaphore = semaphore.clone();
-        executor
-            .spawn(async move {
-                let _guard = semaphore.acquire().await;
-                run_eval(eval, tx)
-            })
-            .detach();
+        executor.spawn(async move { run_eval(eval, tx) }).detach();
     }
     drop(tx);
 
@@ -1587,31 +1577,21 @@ impl EditAgentTest {
             if let Some(input_content) = eval.input_content.as_deref() {
                 buffer.update(cx, |buffer, cx| buffer.set_text(input_content, cx));
             }
-            retry_on_rate_limit(async || {
-                self.agent
-                    .edit(
-                        buffer.clone(),
-                        eval.edit_file_input.display_description.clone(),
-                        &conversation,
-                        &mut cx.to_async(),
-                    )
-                    .0
-                    .await
-            })
-            .await?
+            let (edit_output, _) = self.agent.edit(
+                buffer.clone(),
+                eval.edit_file_input.display_description,
+                &conversation,
+                &mut cx.to_async(),
+            );
+            edit_output.await?
         } else {
-            retry_on_rate_limit(async || {
-                self.agent
-                    .overwrite(
-                        buffer.clone(),
-                        eval.edit_file_input.display_description.clone(),
-                        &conversation,
-                        &mut cx.to_async(),
-                    )
-                    .0
-                    .await
-            })
-            .await?
+            let (edit_output, _) = self.agent.overwrite(
+                buffer.clone(),
+                eval.edit_file_input.display_description,
+                &conversation,
+                &mut cx.to_async(),
+            );
+            edit_output.await?
         };
 
         let buffer_text = buffer.read_with(cx, |buffer, _| buffer.text());
@@ -1633,26 +1613,6 @@ impl EditAgentTest {
     }
 }
 
-async fn retry_on_rate_limit<R>(mut request: impl AsyncFnMut() -> Result<R>) -> Result<R> {
-    loop {
-        match request().await {
-            Ok(result) => return Ok(result),
-            Err(err) => match err.downcast::<LanguageModelCompletionError>() {
-                Ok(err) => match err {
-                    LanguageModelCompletionError::RateLimit(duration) => {
-                        // Wait until after we are allowed to try again
-                        eprintln!("Rate limit exceeded. Waiting for {duration:?}...",);
-                        Timer::after(duration).await;
-                        continue;
-                    }
-                    _ => return Err(err.into()),
-                },
-                Err(err) => return Err(err),
-            },
-        }
-    }
-}
-
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]
 struct EvalAssertionOutcome {
     score: usize,

crates/assistant_tools/src/terminal_tool.rs

@@ -638,36 +638,29 @@ impl ToolCard for TerminalToolCard {
                             .bg(cx.theme().colors().editor_background)
                             .rounded_b_md()
                             .text_ui_sm(cx)
-                            .child({
-                                let content_mode = terminal.read(cx).content_mode(window, cx);
-
-                                if content_mode.is_scrollable() {
-                                    div().h_72().child(terminal.clone()).into_any_element()
-                                } else {
-                                    ToolOutputPreview::new(
-                                        terminal.clone().into_any_element(),
-                                        terminal.entity_id(),
-                                    )
-                                    .with_total_lines(self.content_line_count)
-                                    .toggle_state(!content_mode.is_limited())
-                                    .on_toggle({
-                                        let terminal = terminal.clone();
-                                        move |is_expanded, _, cx| {
-                                            terminal.update(cx, |terminal, cx| {
-                                                terminal.set_embedded_mode(
-                                                    if is_expanded {
-                                                        None
-                                                    } else {
-                                                        Some(COLLAPSED_LINES)
-                                                    },
-                                                    cx,
-                                                );
-                                            });
-                                        }
-                                    })
-                                    .into_any_element()
-                                }
-                            }),
+                            .child(
+                                ToolOutputPreview::new(
+                                    terminal.clone().into_any_element(),
+                                    terminal.entity_id(),
+                                )
+                                .with_total_lines(self.content_line_count)
+                                .toggle_state(!terminal.read(cx).is_content_limited(window))
+                                .on_toggle({
+                                    let terminal = terminal.clone();
+                                    move |is_expanded, _, cx| {
+                                        terminal.update(cx, |terminal, cx| {
+                                            terminal.set_embedded_mode(
+                                                if is_expanded {
+                                                    None
+                                                } else {
+                                                    Some(COLLAPSED_LINES)
+                                                },
+                                                cx,
+                                            );
+                                        });
+                                    }
+                                }),
+                            ),
                     )
                 },
             )

crates/bedrock/src/models.rs

@@ -452,10 +452,6 @@ impl Model {
                 | Model::Claude3_5SonnetV2
                 | Model::Claude3_7Sonnet
                 | Model::Claude3_7SonnetThinking
-                | Model::ClaudeSonnet4
-                | Model::ClaudeSonnet4Thinking
-                | Model::ClaudeOpus4
-                | Model::ClaudeOpus4Thinking
                 | Model::Claude3Haiku
                 | Model::Claude3Opus
                 | Model::Claude3Sonnet

crates/channel/src/channel_store.rs

@@ -111,7 +111,7 @@ pub struct ChannelMembership {
     pub role: proto::ChannelRole,
 }
 impl ChannelMembership {
-    pub fn sort_key(&self) -> MembershipSortKey<'_> {
+    pub fn sort_key(&self) -> MembershipSortKey {
         MembershipSortKey {
             role_order: match self.role {
                 proto::ChannelRole::Admin => 0,

crates/channel/src/channel_store/channel_index.rs

@@ -32,7 +32,7 @@ impl ChannelIndex {
             .retain(|channel_id| !channels.contains(channel_id));
     }
 
-    pub fn bulk_insert(&mut self) -> ChannelPathsInsertGuard<'_> {
+    pub fn bulk_insert(&mut self) -> ChannelPathsInsertGuard {
         ChannelPathsInsertGuard {
             channels_ordered: &mut self.channels_ordered,
             channels_by_id: &mut self.channels_by_id,

crates/client/src/proxy.rs

@@ -39,7 +39,7 @@ enum ProxyType<'t> {
     HttpProxy(HttpProxyType<'t>),
 }
 
-fn parse_proxy_type(proxy: &Url) -> Option<((String, u16), ProxyType<'_>)> {
+fn parse_proxy_type(proxy: &Url) -> Option<((String, u16), ProxyType)> {
     let scheme = proxy.scheme();
     let host = proxy.host()?.to_string();
     let port = proxy.port_or_known_default()?;

crates/collab/src/db/queries/channels.rs

@@ -501,10 +501,8 @@ impl Database {
 
     /// Returns all channels for the user with the given ID.
     pub async fn get_channels_for_user(&self, user_id: UserId) -> Result<ChannelsForUser> {
-        self.weak_transaction(
-            |tx| async move { self.get_user_channels(user_id, None, true, &tx).await },
-        )
-        .await
+        self.transaction(|tx| async move { self.get_user_channels(user_id, None, true, &tx).await })
+            .await
     }
 
     /// Returns all channels for the user with the given ID that are descendants

crates/collab/src/db/queries/contacts.rs

@@ -15,7 +15,7 @@ impl Database {
             user_b_busy: bool,
         }
 
-        self.weak_transaction(|tx| async move {
+        self.transaction(|tx| async move {
             let user_a_participant = Alias::new("user_a_participant");
             let user_b_participant = Alias::new("user_b_participant");
             let mut db_contacts = contact::Entity::find()
@@ -91,7 +91,7 @@ impl Database {
 
     /// Returns whether the given user is a busy (on a call).
     pub async fn is_user_busy(&self, user_id: UserId) -> Result<bool> {
-        self.weak_transaction(|tx| async move {
+        self.transaction(|tx| async move {
             let participant = room_participant::Entity::find()
                 .filter(room_participant::Column::UserId.eq(user_id))
                 .one(&*tx)

crates/collab/src/db/queries/rooms.rs

@@ -80,7 +80,7 @@ impl Database {
         &self,
         user_id: UserId,
     ) -> Result<Option<proto::IncomingCall>> {
-        self.weak_transaction(|tx| async move {
+        self.transaction(|tx| async move {
             let pending_participant = room_participant::Entity::find()
                 .filter(
                     room_participant::Column::UserId

crates/collab/src/llm.rs

@@ -7,12 +7,6 @@ pub use token::*;
 
 pub const AGENT_EXTENDED_TRIAL_FEATURE_FLAG: &str = "agent-extended-trial";
 
-/// The name of the feature flag that bypasses the account age check.
-pub const BYPASS_ACCOUNT_AGE_CHECK_FEATURE_FLAG: &str = "bypass-account-age-check";
-
-/// The minimum account age an account must have in order to use the LLM service.
-pub const MIN_ACCOUNT_AGE_FOR_LLM_USE: chrono::Duration = chrono::Duration::days(30);
-
 /// The default value to use for maximum spend per month if the user did not
 /// explicitly set a maximum spend.
 ///

crates/collab/src/llm/token.rs

@@ -1,6 +1,6 @@
 use crate::db::billing_subscription::SubscriptionKind;
 use crate::db::{billing_customer, billing_subscription, user};
-use crate::llm::{AGENT_EXTENDED_TRIAL_FEATURE_FLAG, BYPASS_ACCOUNT_AGE_CHECK_FEATURE_FLAG};
+use crate::llm::AGENT_EXTENDED_TRIAL_FEATURE_FLAG;
 use crate::{Config, db::billing_preference};
 use anyhow::{Context as _, Result};
 use chrono::{NaiveDateTime, Utc};
@@ -84,7 +84,7 @@ impl LlmTokenClaims {
                 .any(|flag| flag == "llm-closed-beta"),
             bypass_account_age_check: feature_flags
                 .iter()
-                .any(|flag| flag == BYPASS_ACCOUNT_AGE_CHECK_FEATURE_FLAG),
+                .any(|flag| flag == "bypass-account-age-check"),
             can_use_web_search_tool: true,
             use_llm_request_queue: feature_flags.iter().any(|flag| flag == "llm-request-queue"),
             plan,

crates/collab/src/rpc.rs

@@ -4,10 +4,7 @@ use crate::api::billing::find_or_create_billing_customer;
 use crate::api::{CloudflareIpCountryHeader, SystemIdHeader};
 use crate::db::billing_subscription::SubscriptionKind;
 use crate::llm::db::LlmDatabase;
-use crate::llm::{
-    AGENT_EXTENDED_TRIAL_FEATURE_FLAG, BYPASS_ACCOUNT_AGE_CHECK_FEATURE_FLAG, LlmTokenClaims,
-    MIN_ACCOUNT_AGE_FOR_LLM_USE,
-};
+use crate::llm::{AGENT_EXTENDED_TRIAL_FEATURE_FLAG, LlmTokenClaims};
 use crate::stripe_client::StripeCustomerId;
 use crate::{
     AppState, Error, Result, auth,
@@ -68,7 +65,7 @@ use std::{
     rc::Rc,
     sync::{
         Arc, OnceLock,
-        atomic::{AtomicBool, AtomicUsize, Ordering::SeqCst},
+        atomic::{AtomicBool, Ordering::SeqCst},
     },
     time::{Duration, Instant},
 };
@@ -89,36 +86,10 @@ pub const CLEANUP_TIMEOUT: Duration = Duration::from_secs(15);
 const MESSAGE_COUNT_PER_PAGE: usize = 100;
 const MAX_MESSAGE_LEN: usize = 1024;
 const NOTIFICATION_COUNT_PER_PAGE: usize = 50;
-const MAX_CONCURRENT_CONNECTIONS: usize = 512;
-
-static CONCURRENT_CONNECTIONS: AtomicUsize = AtomicUsize::new(0);
 
 type MessageHandler =
     Box<dyn Send + Sync + Fn(Box<dyn AnyTypedEnvelope>, Session) -> BoxFuture<'static, ()>>;
 
-pub struct ConnectionGuard;
-
-impl ConnectionGuard {
-    pub fn try_acquire() -> Result<Self, ()> {
-        let current_connections = CONCURRENT_CONNECTIONS.fetch_add(1, SeqCst);
-        if current_connections >= MAX_CONCURRENT_CONNECTIONS {
-            CONCURRENT_CONNECTIONS.fetch_sub(1, SeqCst);
-            tracing::error!(
-                "too many concurrent connections: {}",
-                current_connections + 1
-            );
-            return Err(());
-        }
-        Ok(ConnectionGuard)
-    }
-}
-
-impl Drop for ConnectionGuard {
-    fn drop(&mut self) {
-        CONCURRENT_CONNECTIONS.fetch_sub(1, SeqCst);
-    }
-}
-
 struct Response<R> {
     peer: Arc<Peer>,
     receipt: Receipt<R>,
@@ -751,7 +722,6 @@ impl Server {
         system_id: Option<String>,
         send_connection_id: Option<oneshot::Sender<ConnectionId>>,
         executor: Executor,
-        connection_guard: Option<ConnectionGuard>,
     ) -> impl Future<Output = ()> + use<> {
         let this = self.clone();
         let span = info_span!("handle connection", %address,
@@ -772,7 +742,6 @@ impl Server {
                 tracing::error!("server is tearing down");
                 return
             }
-
             let (connection_id, handle_io, mut incoming_rx) = this
                 .peer
                 .add_connection(connection, {
@@ -814,7 +783,6 @@ impl Server {
                 tracing::error!(?error, "failed to send initial client update");
                 return;
             }
-            drop(connection_guard);
 
             let handle_io = handle_io.fuse();
             futures::pin_mut!(handle_io);
@@ -1186,19 +1154,6 @@ pub async fn handle_websocket_request(
     }
 
     let socket_address = socket_address.to_string();
-
-    // Acquire connection guard before WebSocket upgrade
-    let connection_guard = match ConnectionGuard::try_acquire() {
-        Ok(guard) => guard,
-        Err(()) => {
-            return (
-                StatusCode::SERVICE_UNAVAILABLE,
-                "Too many concurrent connections",
-            )
-                .into_response();
-        }
-    };
-
     ws.on_upgrade(move |socket| {
         let socket = socket
             .map_ok(to_tungstenite_message)
@@ -1216,7 +1171,6 @@ pub async fn handle_websocket_request(
                     system_id_header.map(|header| header.to_string()),
                     None,
                     Executor::Production,
-                    Some(connection_guard),
                 )
                 .await;
         }
@@ -2819,12 +2773,8 @@ async fn make_update_user_plan_message(
         (None, None)
     };
 
-    let bypass_account_age_check = feature_flags
-        .iter()
-        .any(|flag| flag == BYPASS_ACCOUNT_AGE_CHECK_FEATURE_FLAG);
-    let account_too_young = !matches!(plan, proto::Plan::ZedPro)
-        && !bypass_account_age_check
-        && user.account_age() < MIN_ACCOUNT_AGE_FOR_LLM_USE;
+    let account_too_young =
+        !matches!(plan, proto::Plan::ZedPro) && user.account_age() < MIN_ACCOUNT_AGE_FOR_LLM_USE;
 
     Ok(proto::UpdateUserPlan {
         plan: plan.into(),
@@ -4125,6 +4075,9 @@ async fn accept_terms_of_service(
     Ok(())
 }
 
+/// The minimum account age an account must have in order to use the LLM service.
+pub const MIN_ACCOUNT_AGE_FOR_LLM_USE: chrono::Duration = chrono::Duration::days(30);
+
 async fn get_llm_api_token(
     _request: proto::GetLlmToken,
     response: Response<proto::GetLlmToken>,

crates/collab/src/tests/test_server.rs

@@ -258,7 +258,6 @@ impl TestServer {
                             None,
                             Some(connection_id_tx),
                             Executor::Deterministic(cx.background_executor().clone()),
-                            None,
                         ))
                         .detach();
                         let connection_id = connection_id_rx.await.map_err(|e| {

crates/context_server/src/protocol.rs

@@ -8,7 +8,7 @@
 use anyhow::Result;
 
 use crate::client::Client;
-use crate::types::{self, Notification, Request};
+use crate::types::{self, Request};
 
 pub struct ModelContextProtocol {
     inner: Client,
@@ -20,10 +20,9 @@ impl ModelContextProtocol {
     }
 
     fn supported_protocols() -> Vec<types::ProtocolVersion> {
-        vec![
-            types::ProtocolVersion(types::LATEST_PROTOCOL_VERSION.to_string()),
-            types::ProtocolVersion(types::VERSION_2024_11_05.to_string()),
-        ]
+        vec![types::ProtocolVersion(
+            types::LATEST_PROTOCOL_VERSION.to_string(),
+        )]
     }
 
     pub async fn initialize(
@@ -43,7 +42,7 @@ impl ModelContextProtocol {
 
         let response: types::InitializeResponse = self
             .inner
-            .request(types::requests::Initialize::METHOD, params)
+            .request(types::request::Initialize::METHOD, params)
             .await?;
 
         anyhow::ensure!(
@@ -54,13 +53,16 @@ impl ModelContextProtocol {
 
         log::trace!("mcp server info {:?}", response.server_info);
 
+        self.inner.notify(
+            types::NotificationType::Initialized.as_str(),
+            serde_json::json!({}),
+        )?;
+
         let initialized_protocol = InitializedContextServerProtocol {
             inner: self.inner,
             initialize: response,
         };
 
-        initialized_protocol.notify::<types::notifications::Initialized>(())?;
-
         Ok(initialized_protocol)
     }
 }
@@ -94,8 +96,4 @@ impl InitializedContextServerProtocol {
     pub async fn request<T: Request>(&self, params: T::Params) -> Result<T::Response> {
         self.inner.request(T::METHOD, params).await
     }
-
-    pub fn notify<T: Notification>(&self, params: T::Params) -> Result<()> {
-        self.inner.notify(T::METHOD, params)
-    }
 }

crates/context_server/src/test.rs

@@ -14,7 +14,7 @@ pub fn create_fake_transport(
     executor: BackgroundExecutor,
 ) -> FakeTransport {
     let name = name.into();
-    FakeTransport::new(executor).on_request::<crate::types::requests::Initialize>(move |_params| {
+    FakeTransport::new(executor).on_request::<crate::types::request::Initialize>(move |_params| {
         create_initialize_response(name.clone())
     })
 }

crates/context_server/src/types.rs

@@ -3,10 +3,9 @@ use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 use url::Url;
 
-pub const LATEST_PROTOCOL_VERSION: &str = "2025-03-26";
-pub const VERSION_2024_11_05: &str = "2024-11-05";
+pub const LATEST_PROTOCOL_VERSION: &str = "2024-11-05";
 
-pub mod requests {
+pub mod request {
     use super::*;
 
     macro_rules! request {
@@ -83,57 +82,6 @@ pub trait Request {
     const METHOD: &'static str;
 }
 
-pub mod notifications {
-    use super::*;
-
-    macro_rules! notification {
-        ($method:expr, $name:ident, $params:ty) => {
-            pub struct $name;
-
-            impl Notification for $name {
-                type Params = $params;
-                const METHOD: &'static str = $method;
-            }
-        };
-    }
-
-    notification!("notifications/initialized", Initialized, ());
-    notification!("notifications/progress", Progress, ProgressParams);
-    notification!("notifications/message", Message, MessageParams);
-    notification!(
-        "notifications/resources/updated",
-        ResourcesUpdated,
-        ResourcesUpdatedParams
-    );
-    notification!(
-        "notifications/resources/list_changed",
-        ResourcesListChanged,
-        ()
-    );
-    notification!("notifications/tools/list_changed", ToolsListChanged, ());
-    notification!("notifications/prompts/list_changed", PromptsListChanged, ());
-    notification!("notifications/roots/list_changed", RootsListChanged, ());
-}
-
-pub trait Notification {
-    type Params: DeserializeOwned + Serialize + Send + Sync + 'static;
-    const METHOD: &'static str;
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct MessageParams {
-    pub level: LoggingLevel,
-    pub logger: Option<String>,
-    pub data: serde_json::Value,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ResourcesUpdatedParams {
-    pub uri: String,
-}
-
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(transparent)]
 pub struct ProtocolVersion(pub String);
@@ -343,20 +291,13 @@ pub enum MessageContent {
         #[serde(skip_serializing_if = "Option::is_none")]
         annotations: Option<MessageAnnotations>,
     },
-    #[serde(rename = "image", rename_all = "camelCase")]
+    #[serde(rename = "image")]
     Image {
         data: String,
         mime_type: String,
         #[serde(skip_serializing_if = "Option::is_none")]
         annotations: Option<MessageAnnotations>,
     },
-    #[serde(rename = "audio", rename_all = "camelCase")]
-    Audio {
-        data: String,
-        mime_type: String,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        annotations: Option<MessageAnnotations>,
-    },
     #[serde(rename = "resource")]
     Resource {
         resource: ResourceContents,
@@ -453,8 +394,6 @@ pub struct ServerCapabilities {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub logging: Option<serde_json::Value>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub completions: Option<serde_json::Value>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub prompts: Option<PromptsCapabilities>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub resources: Option<ResourcesCapabilities>,
@@ -499,28 +438,6 @@ pub struct Tool {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub description: Option<String>,
     pub input_schema: serde_json::Value,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub annotations: Option<ToolAnnotations>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub struct ToolAnnotations {
-    /// A human-readable title for the tool.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub title: Option<String>,
-    /// If true, the tool does not modify its environment.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub read_only_hint: Option<bool>,
-    /// If true, the tool may perform destructive updates to its environment.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub destructive_hint: Option<bool>,
-    /// If true, calling the tool repeatedly with the same arguments will have no additional effect on its environment.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub idempotent_hint: Option<bool>,
-    /// If true, this tool may interact with an "open world" of external entities.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub open_world_hint: Option<bool>,
 }
 
 #[derive(Debug, Serialize, Deserialize)]
@@ -611,6 +528,34 @@ pub struct ModelHint {
     pub name: Option<String>,
 }
 
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum NotificationType {
+    Initialized,
+    Progress,
+    Message,
+    ResourcesUpdated,
+    ResourcesListChanged,
+    ToolsListChanged,
+    PromptsListChanged,
+    RootsListChanged,
+}
+
+impl NotificationType {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            NotificationType::Initialized => "notifications/initialized",
+            NotificationType::Progress => "notifications/progress",
+            NotificationType::Message => "notifications/message",
+            NotificationType::ResourcesUpdated => "notifications/resources/updated",
+            NotificationType::ResourcesListChanged => "notifications/resources/list_changed",
+            NotificationType::ToolsListChanged => "notifications/tools/list_changed",
+            NotificationType::PromptsListChanged => "notifications/prompts/list_changed",
+            NotificationType::RootsListChanged => "notifications/roots/list_changed",
+        }
+    }
+}
+
 #[derive(Debug, Serialize)]
 #[serde(untagged)]
 pub enum ClientNotification {
@@ -631,14 +576,12 @@ pub enum ProgressToken {
     Number(f64),
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ProgressParams {
     pub progress_token: ProgressToken,
     pub progress: f64,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub message: Option<String>,
-    #[serde(skip_serializing_if = "Option::is_none")]
     pub total: Option<f64>,
     #[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
     pub meta: Option<HashMap<String, serde_json::Value>>,
@@ -682,8 +625,6 @@ pub enum ToolResponseContent {
     Text { text: String },
     #[serde(rename = "image", rename_all = "camelCase")]
     Image { data: String, mime_type: String },
-    #[serde(rename = "audio", rename_all = "camelCase")]
-    Audio { data: String, mime_type: String },
     #[serde(rename = "resource")]
     Resource { resource: ResourceContents },
 }

crates/copilot/src/copilot.rs

@@ -408,30 +408,24 @@ impl Copilot {
         let proxy_url = copilot_settings.proxy.clone()?;
         let no_verify = copilot_settings.proxy_no_verify;
         let http_or_https_proxy = if proxy_url.starts_with("http:") {
-            Some("HTTP_PROXY")
+            "HTTP_PROXY"
         } else if proxy_url.starts_with("https:") {
-            Some("HTTPS_PROXY")
+            "HTTPS_PROXY"
         } else {
             log::error!(
                 "Unsupported protocol scheme for language server proxy (must be http or https)"
             );
-            None
+            return None;
         };
 
         let mut env = HashMap::default();
+        env.insert(http_or_https_proxy.to_string(), proxy_url);
 
-        if let Some(proxy_type) = http_or_https_proxy {
-            env.insert(proxy_type.to_string(), proxy_url);
-            if let Some(true) = no_verify {
-                env.insert("NODE_TLS_REJECT_UNAUTHORIZED".to_string(), "0".to_string());
-            };
-        }
+        if let Some(true) = no_verify {
+            env.insert("NODE_TLS_REJECT_UNAUTHORIZED".to_string(), "0".to_string());
+        };
 
-        if let Ok(oauth_token) = env::var(copilot_chat::COPILOT_OAUTH_ENV_VAR) {
-            env.insert(copilot_chat::COPILOT_OAUTH_ENV_VAR.to_string(), oauth_token);
-        }
-
-        if env.is_empty() { None } else { Some(env) }
+        Some(env)
     }
 
     #[cfg(any(test, feature = "test-support"))]

crates/copilot/src/copilot_chat.rs

@@ -16,8 +16,6 @@ use paths::home_dir;
 use serde::{Deserialize, Serialize};
 use settings::watch_config_dir;
 
-pub const COPILOT_OAUTH_ENV_VAR: &str = "GH_COPILOT_TOKEN";
-
 #[derive(Default, Clone, Debug, PartialEq)]
 pub struct CopilotChatSettings {
     pub api_url: Arc<str>,
@@ -407,19 +405,13 @@ impl CopilotChat {
         })
         .detach_and_log_err(cx);
 
-        let this = Self {
-            oauth_token: std::env::var(COPILOT_OAUTH_ENV_VAR).ok(),
+        Self {
+            oauth_token: None,
             api_token: None,
             models: None,
             settings,
             client,
-        };
-        if this.oauth_token.is_some() {
-            cx.spawn(async move |this, mut cx| Self::update_models(&this, &mut cx).await)
-                .detach_and_log_err(cx);
         }
-
-        this
     }
 
     async fn update_models(this: &WeakEntity<Self>, cx: &mut AsyncApp) -> Result<()> {

crates/dap_adapters/Cargo.toml

@@ -23,7 +23,6 @@ doctest = false
 [dependencies]
 anyhow.workspace = true
 async-trait.workspace = true
-collections.workspace = true
 dap.workspace = true
 futures.workspace = true
 gpui.workspace = true

crates/dap_adapters/src/ruby.rs

@@ -1,18 +1,16 @@
-use anyhow::{Result, bail};
+use anyhow::Result;
 use async_trait::async_trait;
-use collections::FxHashMap;
 use dap::{
-    DebugRequest, StartDebuggingRequestArguments, StartDebuggingRequestArgumentsRequest,
+    DebugRequest, StartDebuggingRequestArguments,
     adapters::{
         DapDelegate, DebugAdapter, DebugAdapterBinary, DebugAdapterName, DebugTaskDefinition,
     },
 };
 use gpui::{AsyncApp, SharedString};
 use language::LanguageName;
-use serde::{Deserialize, Serialize};
 use serde_json::json;
 use std::path::PathBuf;
-use std::{ffi::OsStr, sync::Arc};
+use std::sync::Arc;
 use task::{DebugScenario, ZedDebugConfig};
 use util::command::new_smol_command;
 
@@ -23,18 +21,6 @@ impl RubyDebugAdapter {
     const ADAPTER_NAME: &'static str = "Ruby";
 }
 
-#[derive(Serialize, Deserialize)]
-struct RubyDebugConfig {
-    script_or_command: Option<String>,
-    script: Option<String>,
-    command: Option<String>,
-    #[serde(default)]
-    args: Vec<String>,
-    #[serde(default)]
-    env: FxHashMap<String, String>,
-    cwd: Option<PathBuf>,
-}
-
 #[async_trait(?Send)]
 impl DebugAdapter for RubyDebugAdapter {
     fn name(&self) -> DebugAdapterName {
@@ -45,70 +31,185 @@ impl DebugAdapter for RubyDebugAdapter {
         Some(SharedString::new_static("Ruby").into())
     }
 
-    fn request_kind(&self, _: &serde_json::Value) -> Result<StartDebuggingRequestArgumentsRequest> {
-        Ok(StartDebuggingRequestArgumentsRequest::Launch)
-    }
-
     async fn dap_schema(&self) -> serde_json::Value {
         json!({
-            "type": "object",
-            "properties": {
-                "command": {
-                    "type": "string",
-                    "description": "Command name (ruby, rake, bin/rails, bundle exec ruby, etc)",
+            "oneOf": [
+                {
+                    "allOf": [
+                        {
+                            "type": "object",
+                            "required": ["request"],
+                            "properties": {
+                                "request": {
+                                    "type": "string",
+                                    "enum": ["launch"],
+                                    "description": "Request to launch a new process"
+                                }
+                            }
+                        },
+                        {
+                            "type": "object",
+                            "required": ["script"],
+                            "properties": {
+                                "command": {
+                                    "type": "string",
+                                    "description": "Command name (ruby, rake, bin/rails, bundle exec ruby, etc)",
+                                    "default": "ruby"
+                                },
+                                "script": {
+                                    "type": "string",
+                                    "description": "Absolute path to a Ruby file."
+                                },
+                                "cwd": {
+                                    "type": "string",
+                                    "description": "Directory to execute the program in",
+                                    "default": "${ZED_WORKTREE_ROOT}"
+                                },
+                                "args": {
+                                    "type": "array",
+                                    "description": "Command line arguments passed to the program",
+                                    "items": {
+                                        "type": "string"
+                                    },
+                                    "default": []
+                                },
+                                "env": {
+                                    "type": "object",
+                                    "description": "Additional environment variables to pass to the debugging (and debugged) process",
+                                    "default": {}
+                                },
+                                "showProtocolLog": {
+                                    "type": "boolean",
+                                    "description": "Show a log of DAP requests, events, and responses",
+                                    "default": false
+                                },
+                                "useBundler": {
+                                    "type": "boolean",
+                                    "description": "Execute Ruby programs with `bundle exec` instead of directly",
+                                    "default": false
+                                },
+                                "bundlePath": {
+                                    "type": "string",
+                                    "description": "Location of the bundle executable"
+                                },
+                                "rdbgPath": {
+                                    "type": "string",
+                                    "description": "Location of the rdbg executable"
+                                },
+                                "askParameters": {
+                                    "type": "boolean",
+                                    "description": "Ask parameters at first."
+                                },
+                                "debugPort": {
+                                    "type": "string",
+                                    "description": "UNIX domain socket name or TPC/IP host:port"
+                                },
+                                "waitLaunchTime": {
+                                    "type": "number",
+                                    "description": "Wait time before connection in milliseconds"
+                                },
+                                "localfs": {
+                                    "type": "boolean",
+                                    "description": "true if the VSCode and debugger run on a same machine",
+                                    "default": false
+                                },
+                                "useTerminal": {
+                                    "type": "boolean",
+                                    "description": "Create a new terminal and then execute commands there",
+                                    "default": false
+                                }
+                            }
+                        }
+                    ]
                 },
-                "script": {
-                    "type": "string",
-                    "description": "Absolute path to a Ruby file."
-                },
-                "cwd": {
-                    "type": "string",
-                    "description": "Directory to execute the program in",
-                    "default": "${ZED_WORKTREE_ROOT}"
-                },
-                "args": {
-                    "type": "array",
-                    "description": "Command line arguments passed to the program",
-                    "items": {
-                        "type": "string"
-                    },
-                    "default": []
-                },
-                "env": {
-                    "type": "object",
-                    "description": "Additional environment variables to pass to the debugging (and debugged) process",
-                    "default": {}
-                },
-            }
+                {
+                    "allOf": [
+                        {
+                            "type": "object",
+                            "required": ["request"],
+                            "properties": {
+                                "request": {
+                                    "type": "string",
+                                    "enum": ["attach"],
+                                    "description": "Request to attach to an existing process"
+                                }
+                            }
+                        },
+                        {
+                            "type": "object",
+                            "properties": {
+                                "rdbgPath": {
+                                    "type": "string",
+                                    "description": "Location of the rdbg executable"
+                                },
+                                "debugPort": {
+                                    "type": "string",
+                                    "description": "UNIX domain socket name or TPC/IP host:port"
+                                },
+                                "showProtocolLog": {
+                                    "type": "boolean",
+                                    "description": "Show a log of DAP requests, events, and responses",
+                                    "default": false
+                                },
+                                "localfs": {
+                                    "type": "boolean",
+                                    "description": "true if the VSCode and debugger run on a same machine",
+                                    "default": false
+                                },
+                                "localfsMap": {
+                                    "type": "string",
+                                    "description": "Specify pairs of remote root path and local root path like `/remote_dir:/local_dir`. You can specify multiple pairs like `/rem1:/loc1,/rem2:/loc2` by concatenating with `,`."
+                                },
+                                "env": {
+                                    "type": "object",
+                                    "description": "Additional environment variables to pass to the rdbg process",
+                                    "default": {}
+                                }
+                            }
+                        }
+                    ]
+                }
+            ]
         })
     }
 
     fn config_from_zed_format(&self, zed_scenario: ZedDebugConfig) -> Result<DebugScenario> {
-        match zed_scenario.request {
+        let mut config = serde_json::Map::new();
+
+        match &zed_scenario.request {
             DebugRequest::Launch(launch) => {
-                let config = RubyDebugConfig {
-                    script_or_command: Some(launch.program),
-                    script: None,
-                    command: None,
-                    args: launch.args,
-                    env: launch.env,
-                    cwd: launch.cwd.clone(),
-                };
+                config.insert("request".to_string(), json!("launch"));
+                config.insert("script".to_string(), json!(launch.program));
+                config.insert("command".to_string(), json!("ruby"));
 
-                let config = serde_json::to_value(config)?;
+                if !launch.args.is_empty() {
+                    config.insert("args".to_string(), json!(launch.args));
+                }
 
-                Ok(DebugScenario {
-                    adapter: zed_scenario.adapter,
-                    label: zed_scenario.label,
-                    config,
-                    tcp_connection: None,
-                    build: None,
-                })
+                if !launch.env.is_empty() {
+                    config.insert("env".to_string(), json!(launch.env));
+                }
+
+                if let Some(cwd) = &launch.cwd {
+                    config.insert("cwd".to_string(), json!(cwd));
+                }
+
+                // Ruby stops on entry so there's no need to handle that case
             }
-            DebugRequest::Attach(_) => {
-                anyhow::bail!("Attach requests are unsupported");
+            DebugRequest::Attach(attach) => {
+                config.insert("request".to_string(), json!("attach"));
+
+                config.insert("processId".to_string(), json!(attach.process_id));
             }
         }
+
+        Ok(DebugScenario {
+            adapter: zed_scenario.adapter,
+            label: zed_scenario.label,
+            config: serde_json::Value::Object(config),
+            tcp_connection: None,
+            build: None,
+        })
     }
 
     async fn get_binary(
@@ -146,34 +247,13 @@ impl DebugAdapter for RubyDebugAdapter {
 
         let tcp_connection = definition.tcp_connection.clone().unwrap_or_default();
         let (host, port, timeout) = crate::configure_tcp_connection(tcp_connection).await?;
-        let ruby_config = serde_json::from_value::<RubyDebugConfig>(definition.config.clone())?;
 
-        let mut arguments = vec![
+        let arguments = vec![
             "--open".to_string(),
             format!("--port={}", port),
             format!("--host={}", host),
         ];
 
-        if let Some(script) = &ruby_config.script {
-            arguments.push(script.clone());
-        } else if let Some(command) = &ruby_config.command {
-            arguments.push("--command".to_string());
-            arguments.push(command.clone());
-        } else if let Some(command_or_script) = &ruby_config.script_or_command {
-            if delegate
-                .which(OsStr::new(&command_or_script))
-                .await
-                .is_some()
-            {
-                arguments.push("--command".to_string());
-            }
-            arguments.push(command_or_script.clone());
-        } else {
-            bail!("Ruby debug config must have 'script' or 'command' args");
-        }
-
-        arguments.extend(ruby_config.args);
-
         Ok(DebugAdapterBinary {
             command: rdbg_path.to_string_lossy().to_string(),
             arguments,
@@ -182,12 +262,8 @@ impl DebugAdapter for RubyDebugAdapter {
                 port,
                 timeout,
             }),
-            cwd: Some(
-                ruby_config
-                    .cwd
-                    .unwrap_or(delegate.worktree_root_path().to_owned()),
-            ),
-            envs: ruby_config.env.into_iter().collect(),
+            cwd: None,
+            envs: std::collections::HashMap::default(),
             request_args: StartDebuggingRequestArguments {
                 request: self.request_kind(&definition.config)?,
                 configuration: definition.config.clone(),

crates/debugger_ui/src/session/running/stack_frame_list.rs

@@ -5,8 +5,8 @@ use std::time::Duration;
 use anyhow::{Context as _, Result, anyhow};
 use dap::StackFrameId;
 use gpui::{
-    AnyElement, Entity, EventEmitter, FocusHandle, Focusable, ListState, MouseButton, Stateful,
-    Subscription, Task, WeakEntity, list,
+    AnyElement, Entity, EventEmitter, FocusHandle, Focusable, MouseButton, ScrollStrategy,
+    Stateful, Subscription, Task, UniformListScrollHandle, WeakEntity, uniform_list,
 };
 
 use crate::StackTraceView;
@@ -35,7 +35,7 @@ pub struct StackFrameList {
     selected_ix: Option<usize>,
     opened_stack_frame_id: Option<StackFrameId>,
     scrollbar_state: ScrollbarState,
-    list_state: ListState,
+    scroll_handle: UniformListScrollHandle,
     _refresh_task: Task<()>,
 }
 
@@ -54,6 +54,7 @@ impl StackFrameList {
         cx: &mut Context<Self>,
     ) -> Self {
         let focus_handle = cx.focus_handle();
+        let scroll_handle = UniformListScrollHandle::new();
 
         let _subscription =
             cx.subscribe_in(&session, window, |this, _, event, window, cx| match event {
@@ -66,16 +67,8 @@ impl StackFrameList {
                 _ => {}
             });
 
-        let list_state = ListState::new(0, gpui::ListAlignment::Top, px(1000.), {
-            let this = cx.weak_entity();
-            move |ix, _window, cx| {
-                this.update(cx, |this, cx| this.render_entry(ix, cx))
-                    .unwrap_or(div().into_any())
-            }
-        });
-        let scrollbar_state = ScrollbarState::new(list_state.clone());
-
         let mut this = Self {
+            scrollbar_state: ScrollbarState::new(scroll_handle.clone()),
             session,
             workspace,
             focus_handle,
@@ -84,8 +77,7 @@ impl StackFrameList {
             entries: Default::default(),
             selected_ix: None,
             opened_stack_frame_id: None,
-            list_state,
-            scrollbar_state,
+            scroll_handle,
             _refresh_task: Task::ready(()),
         };
         this.schedule_refresh(true, window, cx);
@@ -222,7 +214,6 @@ impl StackFrameList {
             self.selected_ix = ix;
         }
 
-        self.list_state.reset(self.entries.len());
         cx.emit(StackFrameListEvent::BuiltEntries);
         cx.notify();
     }
@@ -564,6 +555,10 @@ impl StackFrameList {
 
     fn select_ix(&mut self, ix: Option<usize>, cx: &mut Context<Self>) {
         self.selected_ix = ix;
+        if let Some(ix) = self.selected_ix {
+            self.scroll_handle
+                .scroll_to_item(ix, ScrollStrategy::Center);
+        }
         cx.notify();
     }
 
@@ -647,8 +642,15 @@ impl StackFrameList {
         self.activate_selected_entry(window, cx);
     }
 
-    fn render_list(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
-        list(self.list_state.clone()).size_full()
+    fn render_list(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+        uniform_list(
+            cx.entity(),
+            "stack-frame-list",
+            self.entries.len(),
+            |this, range, _window, cx| range.map(|ix| this.render_entry(ix, cx)).collect(),
+        )
+        .track_scroll(self.scroll_handle.clone())
+        .size_full()
     }
 }
 

crates/editor/src/display_map/block_map.rs

@@ -464,7 +464,7 @@ impl BlockMap {
         map
     }
 
-    pub fn read(&self, wrap_snapshot: WrapSnapshot, edits: Patch<u32>) -> BlockMapReader<'_> {
+    pub fn read(&self, wrap_snapshot: WrapSnapshot, edits: Patch<u32>) -> BlockMapReader {
         self.sync(&wrap_snapshot, edits);
         *self.wrap_snapshot.borrow_mut() = wrap_snapshot.clone();
         BlockMapReader {
@@ -479,7 +479,7 @@ impl BlockMap {
         }
     }
 
-    pub fn write(&mut self, wrap_snapshot: WrapSnapshot, edits: Patch<u32>) -> BlockMapWriter<'_> {
+    pub fn write(&mut self, wrap_snapshot: WrapSnapshot, edits: Patch<u32>) -> BlockMapWriter {
         self.sync(&wrap_snapshot, edits);
         *self.wrap_snapshot.borrow_mut() = wrap_snapshot;
         BlockMapWriter(self)
@@ -1327,7 +1327,7 @@ impl BlockSnapshot {
         }
     }
 
-    pub(super) fn row_infos(&self, start_row: BlockRow) -> BlockRows<'_> {
+    pub(super) fn row_infos(&self, start_row: BlockRow) -> BlockRows {
         let mut cursor = self.transforms.cursor::<(BlockRow, WrapRow)>(&());
         cursor.seek(&start_row, Bias::Right, &());
         let (output_start, input_start) = cursor.start();

crates/editor/src/display_map/fold_map.rs

@@ -357,7 +357,7 @@ impl FoldMap {
         &mut self,
         inlay_snapshot: InlaySnapshot,
         edits: Vec<InlayEdit>,
-    ) -> (FoldMapWriter<'_>, FoldSnapshot, Vec<FoldEdit>) {
+    ) -> (FoldMapWriter, FoldSnapshot, Vec<FoldEdit>) {
         let (snapshot, edits) = self.read(inlay_snapshot, edits);
         (FoldMapWriter(self), snapshot, edits)
     }
@@ -730,7 +730,7 @@ impl FoldSnapshot {
         (line_end - line_start) as u32
     }
 
-    pub fn row_infos(&self, start_row: u32) -> FoldRows<'_> {
+    pub fn row_infos(&self, start_row: u32) -> FoldRows {
         if start_row > self.transforms.summary().output.lines.row {
             panic!("invalid display row {}", start_row);
         }

crates/editor/src/display_map/wrap_map.rs

@@ -726,7 +726,7 @@ impl WrapSnapshot {
         self.transforms.summary().output.longest_row
     }
 
-    pub fn row_infos(&self, start_row: u32) -> WrapRows<'_> {
+    pub fn row_infos(&self, start_row: u32) -> WrapRows {
         let mut transforms = self.transforms.cursor::<(WrapPoint, TabPoint)>(&());
         transforms.seek(&WrapPoint::new(start_row, 0), Bias::Left, &());
         let mut input_row = transforms.start().1.row();

crates/editor/src/editor.rs

@@ -698,7 +698,7 @@ impl EditorActionId {
 // type OverrideTextStyle = dyn Fn(&EditorStyle) -> Option<HighlightStyle>;
 
 type BackgroundHighlight = (fn(&ThemeColors) -> Hsla, Arc<[Range<Anchor>]>);
-type GutterHighlight = (fn(&App) -> Hsla, Vec<Range<Anchor>>);
+type GutterHighlight = (fn(&App) -> Hsla, Arc<[Range<Anchor>]>);
 
 #[derive(Default)]
 struct ScrollbarMarkerState {
@@ -910,10 +910,7 @@ enum SelectionDragState {
     /// State when no drag related activity is detected.
     None,
     /// State when the mouse is down on a selection that is about to be dragged.
-    ReadyToDrag {
-        selection: Selection<Anchor>,
-        click_position: gpui::Point<Pixels>,
-    },
+    ReadyToDrag { selection: Selection<Anchor> },
     /// State when the mouse is dragging the selection in the editor.
     Dragging {
         selection: Selection<Anchor>,
@@ -923,7 +920,7 @@ enum SelectionDragState {
 
 /// Represents a breakpoint indicator that shows up when hovering over lines in the gutter that don't have
 /// a breakpoint on them.
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, Debug)]
 struct PhantomBreakpointIndicator {
     display_row: DisplayRow,
     /// There's a small debounce between hovering over the line and showing the indicator.
@@ -931,7 +928,6 @@ struct PhantomBreakpointIndicator {
     is_active: bool,
     collides_with_existing_breakpoint: bool,
 }
-
 /// Zed's primary implementation of text input, allowing users to edit a [`MultiBuffer`].
 ///
 /// See the [module level documentation](self) for more information.
@@ -1200,12 +1196,10 @@ struct SelectionHistoryEntry {
     add_selections_state: Option<AddSelectionsState>,
 }
 
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
 enum SelectionHistoryMode {
     Normal,
     Undoing,
     Redoing,
-    Skipping,
 }
 
 #[derive(Clone, PartialEq, Eq, Hash)]
@@ -1239,19 +1233,11 @@ struct SelectionHistory {
 }
 
 impl SelectionHistory {
-    #[track_caller]
     fn insert_transaction(
         &mut self,
         transaction_id: TransactionId,
         selections: Arc<[Selection<Anchor>]>,
     ) {
-        if selections.is_empty() {
-            log::error!(
-                "SelectionHistory::insert_transaction called with empty selections. Caller: {}",
-                std::panic::Location::caller()
-            );
-            return;
-        }
         self.selections_by_transaction
             .insert(transaction_id, (selections, None));
     }
@@ -1281,7 +1267,6 @@ impl SelectionHistory {
                 }
                 SelectionHistoryMode::Undoing => self.push_redo(entry),
                 SelectionHistoryMode::Redoing => self.push_undo(entry),
-                SelectionHistoryMode::Skipping => {}
             }
         }
     }
@@ -2101,11 +2086,7 @@ impl Editor {
             }
         }
 
-        // skip adding the initial selection to selection history
-        editor.selection_history.mode = SelectionHistoryMode::Skipping;
         editor.end_selection(window, cx);
-        editor.selection_history.mode = SelectionHistoryMode::Normal;
-
         editor.scroll_manager.show_scrollbars(window, cx);
         jsx_tag_auto_close::refresh_enabled_in_any_buffer(&mut editor, &buffer, cx);
 
@@ -10620,42 +10601,54 @@ impl Editor {
         });
     }
 
-    pub fn move_selection_on_drop(
+    pub fn drop_selection(
         &mut self,
-        selection: &Selection<Anchor>,
-        target: DisplayPoint,
+        point_for_position: Option<PointForPosition>,
         is_cut: bool,
         window: &mut Window,
         cx: &mut Context<Self>,
-    ) {
-        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
-        let buffer = &display_map.buffer_snapshot;
-        let mut edits = Vec::new();
-        let insert_point = display_map
-            .clip_point(target, Bias::Left)
-            .to_point(&display_map);
-        let text = buffer
-            .text_for_range(selection.start..selection.end)
-            .collect::<String>();
-        if is_cut {
-            edits.push(((selection.start..selection.end), String::new()));
+    ) -> bool {
+        if let Some(point_for_position) = point_for_position {
+            match self.selection_drag_state {
+                SelectionDragState::Dragging { ref selection, .. } => {
+                    let snapshot = self.snapshot(window, cx);
+                    let selection_display =
+                        selection.map(|anchor| anchor.to_display_point(&snapshot));
+                    if !point_for_position.intersects_selection(&selection_display) {
+                        let point = point_for_position.previous_valid;
+                        let display_map = self.display_map.update(cx, |map, cx| map.snapshot(cx));
+                        let buffer = &display_map.buffer_snapshot;
+                        let mut edits = Vec::new();
+                        let insert_point = display_map
+                            .clip_point(point, Bias::Left)
+                            .to_point(&display_map);
+                        let text = buffer
+                            .text_for_range(selection.start..selection.end)
+                            .collect::<String>();
+                        if is_cut {
+                            edits.push(((selection.start..selection.end), String::new()));
+                        }
+                        let insert_anchor = buffer.anchor_before(insert_point);
+                        edits.push(((insert_anchor..insert_anchor), text));
+                        let last_edit_start = insert_anchor.bias_left(buffer);
+                        let last_edit_end = insert_anchor.bias_right(buffer);
+                        self.transact(window, cx, |this, window, cx| {
+                            this.buffer.update(cx, |buffer, cx| {
+                                buffer.edit(edits, None, cx);
+                            });
+                            this.change_selections(Some(Autoscroll::fit()), window, cx, |s| {
+                                s.select_anchor_ranges([last_edit_start..last_edit_end]);
+                            });
+                        });
+                        self.selection_drag_state = SelectionDragState::None;
+                        return true;
+                    }
+                }
+                _ => {}
+            }
         }
-        let insert_anchor = buffer.anchor_before(insert_point);
-        edits.push(((insert_anchor..insert_anchor), text));
-        let last_edit_start = insert_anchor.bias_left(buffer);
-        let last_edit_end = insert_anchor.bias_right(buffer);
-        self.transact(window, cx, |this, window, cx| {
-            this.buffer.update(cx, |buffer, cx| {
-                buffer.edit(edits, None, cx);
-            });
-            this.change_selections(Some(Autoscroll::fit()), window, cx, |s| {
-                s.select_anchor_ranges([last_edit_start..last_edit_end]);
-            });
-        });
-    }
-
-    pub fn clear_selection_drag_state(&mut self) {
         self.selection_drag_state = SelectionDragState::None;
+        false
     }
 
     pub fn duplicate(
@@ -14227,20 +14220,18 @@ impl Editor {
         cx: &mut Context<Self>,
     ) {
         self.hide_mouse_cursor(&HideMouseCursorOrigin::MovementAction);
+        self.end_selection(window, cx);
+        self.selection_history.mode = SelectionHistoryMode::Undoing;
         if let Some(entry) = self.selection_history.undo_stack.pop_back() {
-            self.selection_history.mode = SelectionHistoryMode::Undoing;
-            self.with_selection_effects_deferred(window, cx, |this, window, cx| {
-                this.end_selection(window, cx);
-                this.change_selections(Some(Autoscroll::newest()), window, cx, |s| {
-                    s.select_anchors(entry.selections.to_vec())
-                });
+            self.change_selections(None, window, cx, |s| {
+                s.select_anchors(entry.selections.to_vec())
             });
-            self.selection_history.mode = SelectionHistoryMode::Normal;
-
             self.select_next_state = entry.select_next_state;
             self.select_prev_state = entry.select_prev_state;
             self.add_selections_state = entry.add_selections_state;
+            self.request_autoscroll(Autoscroll::newest(), cx);
         }
+        self.selection_history.mode = SelectionHistoryMode::Normal;
     }
 
     pub fn redo_selection(
@@ -14250,20 +14241,18 @@ impl Editor {
         cx: &mut Context<Self>,
     ) {
         self.hide_mouse_cursor(&HideMouseCursorOrigin::MovementAction);
+        self.end_selection(window, cx);
+        self.selection_history.mode = SelectionHistoryMode::Redoing;
         if let Some(entry) = self.selection_history.redo_stack.pop_back() {
-            self.selection_history.mode = SelectionHistoryMode::Redoing;
-            self.with_selection_effects_deferred(window, cx, |this, window, cx| {
-                this.end_selection(window, cx);
-                this.change_selections(Some(Autoscroll::newest()), window, cx, |s| {
-                    s.select_anchors(entry.selections.to_vec())
-                });
+            self.change_selections(None, window, cx, |s| {
+                s.select_anchors(entry.selections.to_vec())
             });
-            self.selection_history.mode = SelectionHistoryMode::Normal;
-
             self.select_next_state = entry.select_next_state;
             self.select_prev_state = entry.select_prev_state;
             self.add_selections_state = entry.add_selections_state;
+            self.request_autoscroll(Autoscroll::newest(), cx);
         }
+        self.selection_history.mode = SelectionHistoryMode::Normal;
     }
 
     pub fn expand_excerpts(
@@ -18397,12 +18386,12 @@ impl Editor {
 
     pub fn highlight_gutter<T: 'static>(
         &mut self,
-        ranges: impl Into<Vec<Range<Anchor>>>,
+        ranges: &[Range<Anchor>],
         color_fetcher: fn(&App) -> Hsla,
         cx: &mut Context<Self>,
     ) {
         self.gutter_highlights
-            .insert(TypeId::of::<T>(), (color_fetcher, ranges.into()));
+            .insert(TypeId::of::<T>(), (color_fetcher, Arc::from(ranges)));
         cx.notify();
     }
 
@@ -18414,65 +18403,6 @@ impl Editor {
         self.gutter_highlights.remove(&TypeId::of::<T>())
     }
 
-    pub fn insert_gutter_highlight<T: 'static>(
-        &mut self,
-        range: Range<Anchor>,
-        color_fetcher: fn(&App) -> Hsla,
-        cx: &mut Context<Self>,
-    ) {
-        let snapshot = self.buffer().read(cx).snapshot(cx);
-        let mut highlights = self
-            .gutter_highlights
-            .remove(&TypeId::of::<T>())
-            .map(|(_, highlights)| highlights)
-            .unwrap_or_default();
-        let ix = highlights.binary_search_by(|highlight| {
-            Ordering::Equal
-                .then_with(|| highlight.start.cmp(&range.start, &snapshot))
-                .then_with(|| highlight.end.cmp(&range.end, &snapshot))
-        });
-        if let Err(ix) = ix {
-            highlights.insert(ix, range);
-        }
-        self.gutter_highlights
-            .insert(TypeId::of::<T>(), (color_fetcher, highlights));
-    }
-
-    pub fn remove_gutter_highlights<T: 'static>(
-        &mut self,
-        ranges_to_remove: Vec<Range<Anchor>>,
-        cx: &mut Context<Self>,
-    ) {
-        let snapshot = self.buffer().read(cx).snapshot(cx);
-        let Some((color_fetcher, mut gutter_highlights)) =
-            self.gutter_highlights.remove(&TypeId::of::<T>())
-        else {
-            return;
-        };
-        let mut ranges_to_remove = ranges_to_remove.iter().peekable();
-        gutter_highlights.retain(|highlight| {
-            while let Some(range_to_remove) = ranges_to_remove.peek() {
-                match range_to_remove.end.cmp(&highlight.start, &snapshot) {
-                    Ordering::Less | Ordering::Equal => {
-                        ranges_to_remove.next();
-                    }
-                    Ordering::Greater => {
-                        match range_to_remove.start.cmp(&highlight.end, &snapshot) {
-                            Ordering::Less | Ordering::Equal => {
-                                return false;
-                            }
-                            Ordering::Greater => break,
-                        }
-                    }
-                }
-            }
-
-            true
-        });
-        self.gutter_highlights
-            .insert(TypeId::of::<T>(), (color_fetcher, gutter_highlights));
-    }
-
     #[cfg(feature = "test-support")]
     pub fn all_text_background_highlights(
         &self,
@@ -18928,7 +18858,7 @@ impl Editor {
                 cx.emit(EditorEvent::BufferEdited);
                 cx.emit(SearchEvent::MatchesInvalidated);
                 if *singleton_buffer_edited {
-                    if let Some(buffer) = edited_buffer {
+                    if let Some(buffer) = multibuffer.read(cx).as_singleton() {
                         if buffer.read(cx).file().is_none() {
                             cx.emit(EditorEvent::TitleChanged);
                         }
@@ -20018,15 +19948,12 @@ impl Editor {
                 if !selections.is_empty() {
                     let snapshot =
                         buffer_snapshot.get_or_init(|| self.buffer.read(cx).snapshot(cx));
-                    // skip adding the initial selection to selection history
-                    self.selection_history.mode = SelectionHistoryMode::Skipping;
                     self.change_selections(None, window, cx, |s| {
                         s.select_ranges(selections.into_iter().map(|(start, end)| {
                             snapshot.clip_offset(start, Bias::Left)
                                 ..snapshot.clip_offset(end, Bias::Right)
                         }));
                     });
-                    self.selection_history.mode = SelectionHistoryMode::Normal;
                 }
             };
         }

crates/editor/src/editor_tests.rs

@@ -1907,6 +1907,7 @@ fn test_prev_next_word_boundary(cx: &mut TestAppContext) {
                 DisplayPoint::new(DisplayRow(2), 4)..DisplayPoint::new(DisplayRow(2), 4),
             ])
         });
+
         editor.move_to_previous_word_start(&MoveToPreviousWordStart, window, cx);
         assert_selection_ranges("use std::ˇstr::{foo, bar}\n\n  {ˇbaz.qux()}", editor, cx);
 
@@ -1926,29 +1927,29 @@ fn test_prev_next_word_boundary(cx: &mut TestAppContext) {
         assert_selection_ranges("useˇ std::str::{foo, barˇ}\n\n  {baz.qux()}", editor, cx);
 
         editor.move_to_next_word_end(&MoveToNextWordEnd, window, cx);
-        assert_selection_ranges("use stdˇ::str::{foo, bar}ˇ\n\n  {baz.qux()}", editor, cx);
+        assert_selection_ranges("use stdˇ::str::{foo, bar}\nˇ\n  {baz.qux()}", editor, cx);
 
         editor.move_to_next_word_end(&MoveToNextWordEnd, window, cx);
-        assert_selection_ranges("use std::ˇstr::{foo, bar}\nˇ\n  {baz.qux()}", editor, cx);
+        assert_selection_ranges("use std::ˇstr::{foo, bar}\n\n  {ˇbaz.qux()}", editor, cx);
 
         editor.move_right(&MoveRight, window, cx);
         editor.select_to_previous_word_start(&SelectToPreviousWordStart, window, cx);
         assert_selection_ranges(
-            "use std::«ˇs»tr::{foo, bar}\n«ˇ\n»  {baz.qux()}",
+            "use std::«ˇs»tr::{foo, bar}\n\n  {«ˇb»az.qux()}",
             editor,
             cx,
         );
 
         editor.select_to_previous_word_start(&SelectToPreviousWordStart, window, cx);
         assert_selection_ranges(
-            "use std«ˇ::s»tr::{foo, bar«ˇ}\n\n»  {baz.qux()}",
+            "use std«ˇ::s»tr::{foo, bar}\n\n«ˇ  {b»az.qux()}",
             editor,
             cx,
         );
 
         editor.select_to_next_word_end(&SelectToNextWordEnd, window, cx);
         assert_selection_ranges(
-            "use std::«ˇs»tr::{foo, bar}«ˇ\n\n»  {baz.qux()}",
+            "use std::«ˇs»tr::{foo, bar}\n\n  {«ˇb»az.qux()}",
             editor,
             cx,
         );
@@ -21941,7 +21942,7 @@ async fn test_pulling_diagnostics(cx: &mut TestAppContext) {
                 .expect("created a singleton buffer")
                 .read(cx)
                 .remote_id();
-            let buffer_result_id = project.lsp_store().read(cx).result_id(buffer_id, cx);
+            let buffer_result_id = project.lsp_store().read(cx).result_id(buffer_id);
             assert_eq!(expected, buffer_result_id);
         });
     };
@@ -21987,6 +21988,7 @@ async fn test_pulling_diagnostics(cx: &mut TestAppContext) {
         "Cursor movement should not trigger diagnostic request"
     );
     ensure_result_id(Some("2".to_string()), cx);
+
     // Multiple rapid edits should be debounced
     for _ in 0..5 {
         editor.update_in(cx, |editor, window, cx| {

crates/editor/src/element.rs

@@ -641,7 +641,6 @@ impl EditorElement {
             if point_for_position.intersects_selection(&selection) {
                 editor.selection_drag_state = SelectionDragState::ReadyToDrag {
                     selection: newest_anchor.clone(),
-                    click_position: event.position,
                 };
                 cx.stop_propagation();
                 return;
@@ -833,44 +832,9 @@ impl EditorElement {
         let pending_nonempty_selections = editor.has_pending_nonempty_selection();
         let point_for_position = position_map.point_for_position(event.position);
 
-        match editor.selection_drag_state {
-            SelectionDragState::ReadyToDrag {
-                selection: _,
-                ref click_position,
-            } => {
-                if event.position == *click_position {
-                    editor.select(
-                        SelectPhase::Begin {
-                            position: point_for_position.previous_valid,
-                            add: false,
-                            click_count: 1, // ready to drag state only occurs on click count 1
-                        },
-                        window,
-                        cx,
-                    );
-                    editor.selection_drag_state = SelectionDragState::None;
-                    cx.stop_propagation();
-                    return;
-                }
-            }
-            SelectionDragState::Dragging { ref selection, .. } => {
-                let snapshot = editor.snapshot(window, cx);
-                let selection_display = selection.map(|anchor| anchor.to_display_point(&snapshot));
-                if !point_for_position.intersects_selection(&selection_display) {
-                    let is_cut = !event.modifiers.control;
-                    editor.move_selection_on_drop(
-                        &selection.clone(),
-                        point_for_position.previous_valid,
-                        is_cut,
-                        window,
-                        cx,
-                    );
-                    editor.selection_drag_state = SelectionDragState::None;
-                    cx.stop_propagation();
-                    return;
-                }
-            }
-            _ => {}
+        let is_cut = !event.modifiers.control;
+        if editor.drop_selection(Some(point_for_position), is_cut, window, cx) {
+            return;
         }
 
         if end_selection {
@@ -987,7 +951,7 @@ impl EditorElement {
                     drop_cursor.start = drop_anchor;
                     drop_cursor.end = drop_anchor;
                 }
-                SelectionDragState::ReadyToDrag { ref selection, .. } => {
+                SelectionDragState::ReadyToDrag { ref selection } => {
                     let drop_cursor = Selection {
                         id: post_inc(&mut editor.selections.next_selection_id),
                         start: drop_anchor,
@@ -1031,7 +995,7 @@ impl EditorElement {
         editor.set_gutter_hovered(gutter_hovered, cx);
         editor.mouse_cursor_hidden = false;
 
-        let breakpoint_indicator = if gutter_hovered {
+        if gutter_hovered {
             let new_point = position_map
                 .point_for_position(event.position)
                 .previous_valid;
@@ -1045,6 +1009,7 @@ impl EditorElement {
                 .buffer_for_excerpt(buffer_anchor.excerpt_id)
                 .and_then(|buffer| buffer.file().map(|file| (buffer, file)))
             {
+                let was_hovered = editor.gutter_breakpoint_indicator.0.is_some();
                 let as_point = text::ToPoint::to_point(&buffer_anchor.text_anchor, buffer_snapshot);
 
                 let is_visible = editor
@@ -1072,44 +1037,39 @@ impl EditorElement {
                             .is_some()
                     });
 
-                if !is_visible {
-                    editor.gutter_breakpoint_indicator.1.get_or_insert_with(|| {
-                        cx.spawn(async move |this, cx| {
-                            cx.background_executor()
-                                .timer(Duration::from_millis(200))
-                                .await;
-
-                            this.update(cx, |this, cx| {
-                                if let Some(indicator) = this.gutter_breakpoint_indicator.0.as_mut()
-                                {
-                                    indicator.is_active = true;
-                                    cx.notify();
-                                }
-                            })
-                            .ok();
-                        })
-                    });
-                }
-
-                Some(PhantomBreakpointIndicator {
+                editor.gutter_breakpoint_indicator.0 = Some(PhantomBreakpointIndicator {
                     display_row: new_point.row(),
                     is_active: is_visible,
                     collides_with_existing_breakpoint: has_existing_breakpoint,
-                })
+                });
+
+                editor.gutter_breakpoint_indicator.1.get_or_insert_with(|| {
+                    cx.spawn(async move |this, cx| {
+                        if !was_hovered {
+                            cx.background_executor()
+                                .timer(Duration::from_millis(200))
+                                .await;
+                        }
+
+                        this.update(cx, |this, cx| {
+                            if let Some(indicator) = this.gutter_breakpoint_indicator.0.as_mut() {
+                                indicator.is_active = true;
+                            }
+
+                            cx.notify();
+                        })
+                        .ok();
+                    })
+                });
             } else {
-                editor.gutter_breakpoint_indicator.1 = None;
-                None
+                editor.gutter_breakpoint_indicator = (None, None);
             }
         } else {
-            editor.gutter_breakpoint_indicator.1 = None;
-            None
-        };
-
-        if &breakpoint_indicator != &editor.gutter_breakpoint_indicator.0 {
-            editor.gutter_breakpoint_indicator.0 = breakpoint_indicator;
-            cx.notify();
+            editor.gutter_breakpoint_indicator = (None, None);
         }
 
+        cx.notify();
+
         // Don't trigger hover popover if mouse is hovering over context menu
         if text_hitbox.is_hovered(window) {
             let point_for_position = position_map.point_for_position(event.position);
@@ -7329,17 +7289,6 @@ impl LineWithInvisibles {
                 paint(window, cx);
             }),
 
-            ShowWhitespaceSetting::Trailing => {
-                let mut previous_start = self.len;
-                for ([start, end], paint) in invisible_iter.rev() {
-                    if previous_start != end {
-                        break;
-                    }
-                    previous_start = start;
-                    paint(window, cx);
-                }
-            }
-
             // For a whitespace to be on a boundary, any of the following conditions need to be met:
             // - It is a tab
             // - It is adjacent to an edge (start or end)

crates/editor/src/movement.rs

@@ -266,11 +266,10 @@ pub fn previous_word_start(map: &DisplaySnapshot, point: DisplayPoint) -> Displa
 
     let mut is_first_iteration = true;
     find_preceding_boundary_display_point(map, point, FindRange::MultiLine, |left, right| {
-        // Make alt-left skip punctuation to respect VSCode behaviour. For example: hello.| goes to |hello.
+        // Make alt-left skip punctuation on Mac OS to respect Mac VSCode behaviour. For example: hello.| goes to |hello.
         if is_first_iteration
             && classifier.is_punctuation(right)
             && !classifier.is_punctuation(left)
-            && left != '\n'
         {
             is_first_iteration = false;
             return false;
@@ -319,11 +318,10 @@ pub fn next_word_end(map: &DisplaySnapshot, point: DisplayPoint) -> DisplayPoint
     let classifier = map.buffer_snapshot.char_classifier_at(raw_point);
     let mut is_first_iteration = true;
     find_boundary(map, point, FindRange::MultiLine, |left, right| {
-        // Make alt-right skip punctuation to respect VSCode behaviour. For example: |.hello goes to .hello|
+        // Make alt-right skip punctuation on Mac OS to respect the Mac behaviour. For example: |.hello goes to .hello|
         if is_first_iteration
             && classifier.is_punctuation(left)
             && !classifier.is_punctuation(right)
-            && right != '\n'
         {
             is_first_iteration = false;
             return false;

crates/editor/src/selections_collection.rs

@@ -411,7 +411,7 @@ impl<'a> MutableSelectionsCollection<'a> {
         self.collection.display_map(self.cx)
     }
 
-    pub fn buffer(&self) -> Ref<'_, MultiBufferSnapshot> {
+    pub fn buffer(&self) -> Ref<MultiBufferSnapshot> {
         self.collection.buffer(self.cx)
     }
 

crates/editor/src/test/editor_test_context.rs

@@ -240,8 +240,7 @@ impl EditorTestContext {
     // unlike cx.simulate_keystrokes(), this does not run_until_parked
     // so you can use it to test detailed timing
     pub fn simulate_keystroke(&mut self, keystroke_text: &str) {
-        let keyboard_mapper = self.keyboard_mapper();
-        let keystroke = Keystroke::parse(keystroke_text, keyboard_mapper.as_ref()).unwrap();
+        let keystroke = Keystroke::parse(keystroke_text).unwrap();
         self.cx.dispatch_keystroke(self.window, keystroke);
     }
 

crates/extension_host/src/wasm_host.rs

@@ -724,7 +724,7 @@ impl IncrementalCompilationCache {
 }
 
 impl CacheStore for IncrementalCompilationCache {
-    fn get(&self, key: &[u8]) -> Option<Cow<'_, [u8]>> {
+    fn get(&self, key: &[u8]) -> Option<Cow<[u8]>> {
         self.cache.get(key).map(|v| v.into())
     }
 

crates/git/src/repository.rs

@@ -323,7 +323,7 @@ pub trait GitRepository: Send + Sync {
     /// Resolve a list of refs to SHAs.
     fn revparse_batch(&self, revs: Vec<String>) -> BoxFuture<Result<Vec<Option<String>>>>;
 
-    fn head_sha(&self) -> BoxFuture<'_, Option<String>> {
+    fn head_sha(&self) -> BoxFuture<Option<String>> {
         async move {
             self.revparse_batch(vec!["HEAD".into()])
                 .await
@@ -525,7 +525,7 @@ impl GitRepository for RealGitRepository {
         repo.commondir().into()
     }
 
-    fn show(&self, commit: String) -> BoxFuture<'_, Result<CommitDetails>> {
+    fn show(&self, commit: String) -> BoxFuture<Result<CommitDetails>> {
         let working_directory = self.working_directory();
         self.executor
             .spawn(async move {
@@ -561,7 +561,7 @@ impl GitRepository for RealGitRepository {
             .boxed()
     }
 
-    fn load_commit(&self, commit: String, cx: AsyncApp) -> BoxFuture<'_, Result<CommitDiff>> {
+    fn load_commit(&self, commit: String, cx: AsyncApp) -> BoxFuture<Result<CommitDiff>> {
         let Some(working_directory) = self.repository.lock().workdir().map(ToOwned::to_owned)
         else {
             return future::ready(Err(anyhow!("no working directory"))).boxed();
@@ -668,7 +668,7 @@ impl GitRepository for RealGitRepository {
         commit: String,
         mode: ResetMode,
         env: Arc<HashMap<String, String>>,
-    ) -> BoxFuture<'_, Result<()>> {
+    ) -> BoxFuture<Result<()>> {
         async move {
             let working_directory = self.working_directory();
 
@@ -698,7 +698,7 @@ impl GitRepository for RealGitRepository {
         commit: String,
         paths: Vec<RepoPath>,
         env: Arc<HashMap<String, String>>,
-    ) -> BoxFuture<'_, Result<()>> {
+    ) -> BoxFuture<Result<()>> {
         let working_directory = self.working_directory();
         let git_binary_path = self.git_binary_path.clone();
         async move {
@@ -723,7 +723,7 @@ impl GitRepository for RealGitRepository {
         .boxed()
     }
 
-    fn load_index_text(&self, path: RepoPath) -> BoxFuture<'_, Option<String>> {
+    fn load_index_text(&self, path: RepoPath) -> BoxFuture<Option<String>> {
         // https://git-scm.com/book/en/v2/Git-Internals-Git-Objects
         const GIT_MODE_SYMLINK: u32 = 0o120000;
 
@@ -756,7 +756,7 @@ impl GitRepository for RealGitRepository {
             .boxed()
     }
 
-    fn load_committed_text(&self, path: RepoPath) -> BoxFuture<'_, Option<String>> {
+    fn load_committed_text(&self, path: RepoPath) -> BoxFuture<Option<String>> {
         let repo = self.repository.clone();
         self.executor
             .spawn(async move {
@@ -777,7 +777,7 @@ impl GitRepository for RealGitRepository {
         path: RepoPath,
         content: Option<String>,
         env: Arc<HashMap<String, String>>,
-    ) -> BoxFuture<'_, anyhow::Result<()>> {
+    ) -> BoxFuture<anyhow::Result<()>> {
         let working_directory = self.working_directory();
         let git_binary_path = self.git_binary_path.clone();
         self.executor
@@ -841,7 +841,7 @@ impl GitRepository for RealGitRepository {
         remote.url().map(|url| url.to_string())
     }
 
-    fn revparse_batch(&self, revs: Vec<String>) -> BoxFuture<'_, Result<Vec<Option<String>>>> {
+    fn revparse_batch(&self, revs: Vec<String>) -> BoxFuture<Result<Vec<Option<String>>>> {
         let working_directory = self.working_directory();
         self.executor
             .spawn(async move {
@@ -891,14 +891,14 @@ impl GitRepository for RealGitRepository {
             .boxed()
     }
 
-    fn merge_message(&self) -> BoxFuture<'_, Option<String>> {
+    fn merge_message(&self) -> BoxFuture<Option<String>> {
         let path = self.path().join("MERGE_MSG");
         self.executor
             .spawn(async move { std::fs::read_to_string(&path).ok() })
             .boxed()
     }
 
-    fn status(&self, path_prefixes: &[RepoPath]) -> BoxFuture<'_, Result<GitStatus>> {
+    fn status(&self, path_prefixes: &[RepoPath]) -> BoxFuture<Result<GitStatus>> {
         let git_binary_path = self.git_binary_path.clone();
         let working_directory = self.working_directory();
         let path_prefixes = path_prefixes.to_owned();
@@ -919,7 +919,7 @@ impl GitRepository for RealGitRepository {
             .boxed()
     }
 
-    fn branches(&self) -> BoxFuture<'_, Result<Vec<Branch>>> {
+    fn branches(&self) -> BoxFuture<Result<Vec<Branch>>> {
         let working_directory = self.working_directory();
         let git_binary_path = self.git_binary_path.clone();
         self.executor
@@ -986,7 +986,7 @@ impl GitRepository for RealGitRepository {
             .boxed()
     }
 
-    fn change_branch(&self, name: String) -> BoxFuture<'_, Result<()>> {
+    fn change_branch(&self, name: String) -> BoxFuture<Result<()>> {
         let repo = self.repository.clone();
         self.executor
             .spawn(async move {
@@ -1018,7 +1018,7 @@ impl GitRepository for RealGitRepository {
             .boxed()
     }
 
-    fn create_branch(&self, name: String) -> BoxFuture<'_, Result<()>> {
+    fn create_branch(&self, name: String) -> BoxFuture<Result<()>> {
         let repo = self.repository.clone();
         self.executor
             .spawn(async move {
@@ -1030,7 +1030,7 @@ impl GitRepository for RealGitRepository {
             .boxed()
     }
 
-    fn blame(&self, path: RepoPath, content: Rope) -> BoxFuture<'_, Result<crate::blame::Blame>> {
+    fn blame(&self, path: RepoPath, content: Rope) -> BoxFuture<Result<crate::blame::Blame>> {
         let working_directory = self.working_directory();
         let git_binary_path = self.git_binary_path.clone();
 
@@ -1052,7 +1052,7 @@ impl GitRepository for RealGitRepository {
             .boxed()
     }
 
-    fn diff(&self, diff: DiffType) -> BoxFuture<'_, Result<String>> {
+    fn diff(&self, diff: DiffType) -> BoxFuture<Result<String>> {
         let working_directory = self.working_directory();
         let git_binary_path = self.git_binary_path.clone();
         self.executor
@@ -1083,7 +1083,7 @@ impl GitRepository for RealGitRepository {
         &self,
         paths: Vec<RepoPath>,
         env: Arc<HashMap<String, String>>,
-    ) -> BoxFuture<'_, Result<()>> {
+    ) -> BoxFuture<Result<()>> {
         let working_directory = self.working_directory();
         let git_binary_path = self.git_binary_path.clone();
         self.executor
@@ -1111,7 +1111,7 @@ impl GitRepository for RealGitRepository {
         &self,
         paths: Vec<RepoPath>,
         env: Arc<HashMap<String, String>>,
-    ) -> BoxFuture<'_, Result<()>> {
+    ) -> BoxFuture<Result<()>> {
         let working_directory = self.working_directory();
         let git_binary_path = self.git_binary_path.clone();
 
@@ -1143,7 +1143,7 @@ impl GitRepository for RealGitRepository {
         name_and_email: Option<(SharedString, SharedString)>,
         options: CommitOptions,
         env: Arc<HashMap<String, String>>,
-    ) -> BoxFuture<'_, Result<()>> {
+    ) -> BoxFuture<Result<()>> {
         let working_directory = self.working_directory();
         self.executor
             .spawn(async move {
@@ -1182,7 +1182,7 @@ impl GitRepository for RealGitRepository {
         ask_pass: AskPassDelegate,
         env: Arc<HashMap<String, String>>,
         cx: AsyncApp,
-    ) -> BoxFuture<'_, Result<RemoteCommandOutput>> {
+    ) -> BoxFuture<Result<RemoteCommandOutput>> {
         let working_directory = self.working_directory();
         let executor = cx.background_executor().clone();
         async move {
@@ -1214,7 +1214,7 @@ impl GitRepository for RealGitRepository {
         ask_pass: AskPassDelegate,
         env: Arc<HashMap<String, String>>,
         cx: AsyncApp,
-    ) -> BoxFuture<'_, Result<RemoteCommandOutput>> {
+    ) -> BoxFuture<Result<RemoteCommandOutput>> {
         let working_directory = self.working_directory();
         let executor = cx.background_executor().clone();
         async move {
@@ -1239,7 +1239,7 @@ impl GitRepository for RealGitRepository {
         ask_pass: AskPassDelegate,
         env: Arc<HashMap<String, String>>,
         cx: AsyncApp,
-    ) -> BoxFuture<'_, Result<RemoteCommandOutput>> {
+    ) -> BoxFuture<Result<RemoteCommandOutput>> {
         let working_directory = self.working_directory();
         let remote_name = format!("{}", fetch_options);
         let executor = cx.background_executor().clone();
@@ -1257,7 +1257,7 @@ impl GitRepository for RealGitRepository {
         .boxed()
     }
 
-    fn get_remotes(&self, branch_name: Option<String>) -> BoxFuture<'_, Result<Vec<Remote>>> {
+    fn get_remotes(&self, branch_name: Option<String>) -> BoxFuture<Result<Vec<Remote>>> {
         let working_directory = self.working_directory();
         let git_binary_path = self.git_binary_path.clone();
         self.executor
@@ -1303,7 +1303,7 @@ impl GitRepository for RealGitRepository {
             .boxed()
     }
 
-    fn check_for_pushed_commit(&self) -> BoxFuture<'_, Result<Vec<SharedString>>> {
+    fn check_for_pushed_commit(&self) -> BoxFuture<Result<Vec<SharedString>>> {
         let working_directory = self.working_directory();
         let git_binary_path = self.git_binary_path.clone();
         self.executor
@@ -1396,7 +1396,7 @@ impl GitRepository for RealGitRepository {
             .boxed()
     }
 
-    fn restore_checkpoint(&self, checkpoint: GitRepositoryCheckpoint) -> BoxFuture<'_, Result<()>> {
+    fn restore_checkpoint(&self, checkpoint: GitRepositoryCheckpoint) -> BoxFuture<Result<()>> {
         let working_directory = self.working_directory();
         let git_binary_path = self.git_binary_path.clone();
 
@@ -1435,7 +1435,7 @@ impl GitRepository for RealGitRepository {
         &self,
         left: GitRepositoryCheckpoint,
         right: GitRepositoryCheckpoint,
-    ) -> BoxFuture<'_, Result<bool>> {
+    ) -> BoxFuture<Result<bool>> {
         let working_directory = self.working_directory();
         let git_binary_path = self.git_binary_path.clone();
 
@@ -1474,7 +1474,7 @@ impl GitRepository for RealGitRepository {
         &self,
         base_checkpoint: GitRepositoryCheckpoint,
         target_checkpoint: GitRepositoryCheckpoint,
-    ) -> BoxFuture<'_, Result<String>> {
+    ) -> BoxFuture<Result<String>> {
         let working_directory = self.working_directory();
         let git_binary_path = self.git_binary_path.clone();
 

crates/git_ui/src/conflict_view.rs

@@ -248,8 +248,6 @@ fn conflicts_updated(
             removed_block_ids.insert(block_id);
         }
 
-        editor.remove_gutter_highlights::<ConflictsOuter>(removed_highlighted_ranges.clone(), cx);
-
         editor.remove_highlighted_rows::<ConflictsOuter>(removed_highlighted_ranges.clone(), cx);
         editor.remove_highlighted_rows::<ConflictsOurs>(removed_highlighted_ranges.clone(), cx);
         editor
@@ -327,7 +325,8 @@ fn update_conflict_highlighting(
     cx: &mut Context<Editor>,
 ) {
     log::debug!("update conflict highlighting for {conflict:?}");
-
+    let theme = cx.theme().clone();
+    let colors = theme.colors();
     let outer_start = buffer
         .anchor_in_excerpt(excerpt_id, conflict.range.start)
         .unwrap();
@@ -347,29 +346,26 @@ fn update_conflict_highlighting(
         .anchor_in_excerpt(excerpt_id, conflict.theirs.end)
         .unwrap();
 
-    let ours_background = cx.theme().colors().version_control_conflict_marker_ours;
-    let theirs_background = cx.theme().colors().version_control_conflict_marker_theirs;
+    let ours_background = colors.version_control_conflict_ours_background;
+    let ours_marker = colors.version_control_conflict_ours_marker_background;
+    let theirs_background = colors.version_control_conflict_theirs_background;
+    let theirs_marker = colors.version_control_conflict_theirs_marker_background;
+    let divider_background = colors.version_control_conflict_divider_background;
 
     let options = RowHighlightOptions {
-        include_gutter: true,
+        include_gutter: false,
         ..Default::default()
     };
 
-    editor.insert_gutter_highlight::<ConflictsOuter>(
-        outer_start..their_end,
-        |cx| cx.theme().colors().editor_background,
-        cx,
-    );
-
     // Prevent diff hunk highlighting within the entire conflict region.
-    editor.highlight_rows::<ConflictsOuter>(outer_start..outer_end, theirs_background, options, cx);
-    editor.highlight_rows::<ConflictsOurs>(our_start..our_end, ours_background, options, cx);
-    editor.highlight_rows::<ConflictsOursMarker>(
-        outer_start..our_start,
-        ours_background,
+    editor.highlight_rows::<ConflictsOuter>(
+        outer_start..outer_end,
+        divider_background,
         options,
         cx,
     );
+    editor.highlight_rows::<ConflictsOurs>(our_start..our_end, ours_background, options, cx);
+    editor.highlight_rows::<ConflictsOursMarker>(outer_start..our_start, ours_marker, options, cx);
     editor.highlight_rows::<ConflictsTheirs>(
         their_start..their_end,
         theirs_background,
@@ -378,7 +374,7 @@ fn update_conflict_highlighting(
     );
     editor.highlight_rows::<ConflictsTheirsMarker>(
         their_end..outer_end,
-        theirs_background,
+        theirs_marker,
         options,
         cx,
     );
@@ -516,9 +512,6 @@ pub(crate) fn resolve_conflict(
                 let end = snapshot
                     .anchor_in_excerpt(excerpt_id, resolved_conflict.range.end)
                     .unwrap();
-
-                editor.remove_gutter_highlights::<ConflictsOuter>(vec![start..end], cx);
-
                 editor.remove_highlighted_rows::<ConflictsOuter>(vec![start..end], cx);
                 editor.remove_highlighted_rows::<ConflictsOurs>(vec![start..end], cx);
                 editor.remove_highlighted_rows::<ConflictsTheirs>(vec![start..end], cx);

crates/git_ui/src/git_panel.rs

@@ -27,12 +27,11 @@ use git::status::StageStatus;
 use git::{Amend, ToggleStaged, repository::RepoPath, status::FileStatus};
 use git::{ExpandCommitEditor, RestoreTrackedFiles, StageAll, TrashUntrackedFiles, UnstageAll};
 use gpui::{
-    Action, Animation, AnimationExt as _, AsyncApp, AsyncWindowContext, Axis, ClickEvent, Corner,
-    DismissEvent, Entity, EventEmitter, FocusHandle, Focusable, KeyContext,
-    ListHorizontalSizingBehavior, ListSizingBehavior, Modifiers, ModifiersChangedEvent,
-    MouseButton, MouseDownEvent, Point, PromptLevel, ScrollStrategy, Subscription, Task,
-    Transformation, UniformListScrollHandle, WeakEntity, actions, anchored, deferred, percentage,
-    uniform_list,
+    Action, Animation, AnimationExt as _, Axis, ClickEvent, Corner, DismissEvent, Entity,
+    EventEmitter, FocusHandle, Focusable, KeyContext, ListHorizontalSizingBehavior,
+    ListSizingBehavior, Modifiers, ModifiersChangedEvent, MouseButton, MouseDownEvent, Point,
+    PromptLevel, ScrollStrategy, Subscription, Task, Transformation, UniformListScrollHandle,
+    WeakEntity, actions, anchored, deferred, percentage, uniform_list,
 };
 use itertools::Itertools;
 use language::{Buffer, File};
@@ -64,11 +63,11 @@ use ui::{
     Tooltip, prelude::*,
 };
 use util::{ResultExt, TryFutureExt, maybe};
-
+use workspace::AppState;
 use workspace::{
     Workspace,
     dock::{DockPosition, Panel, PanelEvent},
-    notifications::{DetachAndPromptErr, ErrorMessagePrompt, NotificationId},
+    notifications::DetachAndPromptErr,
 };
 use zed_llm_client::CompletionIntent;
 
@@ -390,148 +389,144 @@ pub(crate) fn commit_message_editor(
 }
 
 impl GitPanel {
-    fn new(
-        workspace: &mut Workspace,
+    pub fn new(
+        workspace: Entity<Workspace>,
+        project: Entity<Project>,
+        app_state: Arc<AppState>,
         window: &mut Window,
-        cx: &mut Context<Workspace>,
-    ) -> Entity<Self> {
-        let project = workspace.project().clone();
-        let app_state = workspace.app_state().clone();
+        cx: &mut Context<Self>,
+    ) -> Self {
         let fs = app_state.fs.clone();
         let git_store = project.read(cx).git_store().clone();
         let active_repository = project.read(cx).active_repository(cx);
+        let workspace = workspace.downgrade();
 
-        let git_panel = cx.new(|cx| {
-            let focus_handle = cx.focus_handle();
-            cx.on_focus(&focus_handle, window, Self::focus_in).detach();
-            cx.on_focus_out(&focus_handle, window, |this, _, window, cx| {
-                this.hide_scrollbars(window, cx);
-            })
-            .detach();
+        let focus_handle = cx.focus_handle();
+        cx.on_focus(&focus_handle, window, Self::focus_in).detach();
+        cx.on_focus_out(&focus_handle, window, |this, _, window, cx| {
+            this.hide_scrollbars(window, cx);
+        })
+        .detach();
 
-            let mut was_sort_by_path = GitPanelSettings::get_global(cx).sort_by_path;
-            cx.observe_global::<SettingsStore>(move |this, cx| {
-                let is_sort_by_path = GitPanelSettings::get_global(cx).sort_by_path;
-                if is_sort_by_path != was_sort_by_path {
-                    this.update_visible_entries(cx);
-                }
-                was_sort_by_path = is_sort_by_path
-            })
-            .detach();
+        let mut was_sort_by_path = GitPanelSettings::get_global(cx).sort_by_path;
+        cx.observe_global::<SettingsStore>(move |this, cx| {
+            let is_sort_by_path = GitPanelSettings::get_global(cx).sort_by_path;
+            if is_sort_by_path != was_sort_by_path {
+                this.update_visible_entries(cx);
+            }
+            was_sort_by_path = is_sort_by_path
+        })
+        .detach();
 
-            // just to let us render a placeholder editor.
-            // Once the active git repo is set, this buffer will be replaced.
-            let temporary_buffer = cx.new(|cx| Buffer::local("", cx));
-            let commit_editor = cx.new(|cx| {
-                commit_message_editor(temporary_buffer, None, project.clone(), true, window, cx)
-            });
-
-            commit_editor.update(cx, |editor, cx| {
-                editor.clear(window, cx);
-            });
-
-            let scroll_handle = UniformListScrollHandle::new();
-
-            let vertical_scrollbar = ScrollbarProperties {
-                axis: Axis::Vertical,
-                state: ScrollbarState::new(scroll_handle.clone()).parent_entity(&cx.entity()),
-                show_scrollbar: false,
-                show_track: false,
-                auto_hide: false,
-                hide_task: None,
-            };
-
-            let horizontal_scrollbar = ScrollbarProperties {
-                axis: Axis::Horizontal,
-                state: ScrollbarState::new(scroll_handle.clone()).parent_entity(&cx.entity()),
-                show_scrollbar: false,
-                show_track: false,
-                auto_hide: false,
-                hide_task: None,
-            };
-
-            let mut assistant_enabled = AgentSettings::get_global(cx).enabled;
-            let _settings_subscription = cx.observe_global::<SettingsStore>(move |_, cx| {
-                if assistant_enabled != AgentSettings::get_global(cx).enabled {
-                    assistant_enabled = AgentSettings::get_global(cx).enabled;
-                    cx.notify();
-                }
-            });
-
-            cx.subscribe_in(
-                &git_store,
-                window,
-                move |this, _git_store, event, window, cx| match event {
-                    GitStoreEvent::ActiveRepositoryChanged(_) => {
-                        this.active_repository = this.project.read(cx).active_repository(cx);
-                        this.schedule_update(true, window, cx);
-                    }
-                    GitStoreEvent::RepositoryUpdated(
-                        _,
-                        RepositoryEvent::Updated { full_scan },
-                        true,
-                    ) => {
-                        this.schedule_update(*full_scan, window, cx);
-                    }
-
-                    GitStoreEvent::RepositoryAdded(_) | GitStoreEvent::RepositoryRemoved(_) => {
-                        this.schedule_update(false, window, cx);
-                    }
-                    GitStoreEvent::IndexWriteError(error) => {
-                        this.workspace
-                            .update(cx, |workspace, cx| {
-                                workspace.show_error(error, cx);
-                            })
-                            .ok();
-                    }
-                    GitStoreEvent::RepositoryUpdated(_, _, _) => {}
-                    GitStoreEvent::JobsUpdated | GitStoreEvent::ConflictsUpdated => {}
-                },
-            )
-            .detach();
-
-            let mut this = Self {
-                active_repository,
-                commit_editor,
-                conflicted_count: 0,
-                conflicted_staged_count: 0,
-                current_modifiers: window.modifiers(),
-                add_coauthors: true,
-                generate_commit_message_task: None,
-                entries: Vec::new(),
-                focus_handle: cx.focus_handle(),
-                fs,
-                new_count: 0,
-                new_staged_count: 0,
-                pending: Vec::new(),
-                pending_commit: None,
-                amend_pending: false,
-                pending_serialization: Task::ready(None),
-                single_staged_entry: None,
-                single_tracked_entry: None,
-                project,
-                scroll_handle,
-                max_width_item_index: None,
-                selected_entry: None,
-                marked_entries: Vec::new(),
-                tracked_count: 0,
-                tracked_staged_count: 0,
-                update_visible_entries_task: Task::ready(()),
-                width: None,
-                show_placeholders: false,
-                context_menu: None,
-                workspace: workspace.weak_handle(),
-                modal_open: false,
-                entry_count: 0,
-                horizontal_scrollbar,
-                vertical_scrollbar,
-                _settings_subscription,
-            };
-
-            this.schedule_update(false, window, cx);
-            this
+        // just to let us render a placeholder editor.
+        // Once the active git repo is set, this buffer will be replaced.
+        let temporary_buffer = cx.new(|cx| Buffer::local("", cx));
+        let commit_editor = cx.new(|cx| {
+            commit_message_editor(temporary_buffer, None, project.clone(), true, window, cx)
         });
 
+        commit_editor.update(cx, |editor, cx| {
+            editor.clear(window, cx);
+        });
+
+        let scroll_handle = UniformListScrollHandle::new();
+
+        cx.subscribe_in(
+            &git_store,
+            window,
+            move |this, git_store, event, window, cx| match event {
+                GitStoreEvent::ActiveRepositoryChanged(_) => {
+                    this.active_repository = git_store.read(cx).active_repository();
+                    this.schedule_update(true, window, cx);
+                }
+                GitStoreEvent::RepositoryUpdated(
+                    _,
+                    RepositoryEvent::Updated { full_scan },
+                    true,
+                ) => {
+                    this.schedule_update(*full_scan, window, cx);
+                }
+
+                GitStoreEvent::RepositoryAdded(_) | GitStoreEvent::RepositoryRemoved(_) => {
+                    this.schedule_update(false, window, cx);
+                }
+                GitStoreEvent::IndexWriteError(error) => {
+                    this.workspace
+                        .update(cx, |workspace, cx| {
+                            workspace.show_error(error, cx);
+                        })
+                        .ok();
+                }
+                GitStoreEvent::RepositoryUpdated(_, _, _) => {}
+                GitStoreEvent::JobsUpdated | GitStoreEvent::ConflictsUpdated => {}
+            },
+        )
+        .detach();
+
+        let vertical_scrollbar = ScrollbarProperties {
+            axis: Axis::Vertical,
+            state: ScrollbarState::new(scroll_handle.clone()).parent_entity(&cx.entity()),
+            show_scrollbar: false,
+            show_track: false,
+            auto_hide: false,
+            hide_task: None,
+        };
+
+        let horizontal_scrollbar = ScrollbarProperties {
+            axis: Axis::Horizontal,
+            state: ScrollbarState::new(scroll_handle.clone()).parent_entity(&cx.entity()),
+            show_scrollbar: false,
+            show_track: false,
+            auto_hide: false,
+            hide_task: None,
+        };
+
+        let mut assistant_enabled = AgentSettings::get_global(cx).enabled;
+        let _settings_subscription = cx.observe_global::<SettingsStore>(move |_, cx| {
+            if assistant_enabled != AgentSettings::get_global(cx).enabled {
+                assistant_enabled = AgentSettings::get_global(cx).enabled;
+                cx.notify();
+            }
+        });
+
+        let mut git_panel = Self {
+            active_repository,
+            commit_editor,
+            conflicted_count: 0,
+            conflicted_staged_count: 0,
+            current_modifiers: window.modifiers(),
+            add_coauthors: true,
+            generate_commit_message_task: None,
+            entries: Vec::new(),
+            focus_handle: cx.focus_handle(),
+            fs,
+            new_count: 0,
+            new_staged_count: 0,
+            pending: Vec::new(),
+            pending_commit: None,
+            amend_pending: false,
+            pending_serialization: Task::ready(None),
+            single_staged_entry: None,
+            single_tracked_entry: None,
+            project,
+            scroll_handle,
+            max_width_item_index: None,
+            selected_entry: None,
+            marked_entries: Vec::new(),
+            tracked_count: 0,
+            tracked_staged_count: 0,
+            update_visible_entries_task: Task::ready(()),
+            width: None,
+            show_placeholders: false,
+            context_menu: None,
+            workspace,
+            modal_open: false,
+            entry_count: 0,
+            horizontal_scrollbar,
+            vertical_scrollbar,
+            _settings_subscription,
+        };
+        git_panel.schedule_update(false, window, cx);
         git_panel
     }
 
@@ -1779,19 +1774,7 @@ impl GitPanel {
                     this.generate_commit_message_task.take();
                 });
 
-                let mut diff_text = match diff.await {
-                    Ok(result) => match result {
-                        Ok(text) => text,
-                        Err(e) => {
-                            Self::show_commit_message_error(&this, &e, cx);
-                            return anyhow::Ok(());
-                        }
-                    },
-                    Err(e) => {
-                        Self::show_commit_message_error(&this, &e, cx);
-                        return anyhow::Ok(());
-                    }
-                };
+                let mut diff_text = diff.await??;
 
                 const ONE_MB: usize = 1_000_000;
                 if diff_text.len() > ONE_MB {
@@ -1829,37 +1812,26 @@ impl GitPanel {
                 };
 
                 let stream = model.stream_completion_text(request, &cx);
-                match stream.await {
-                    Ok(mut messages) => {
-                        if !text_empty {
-                            this.update(cx, |this, cx| {
-                                this.commit_message_buffer(cx).update(cx, |buffer, cx| {
-                                    let insert_position = buffer.anchor_before(buffer.len());
-                                    buffer.edit([(insert_position..insert_position, "\n")], None, cx)
-                                });
-                            })?;
-                        }
+                let mut messages = stream.await?;
 
-                        while let Some(message) = messages.stream.next().await {
-                            match message {
-                                Ok(text) => {
-                                    this.update(cx, |this, cx| {
-                                        this.commit_message_buffer(cx).update(cx, |buffer, cx| {
-                                            let insert_position = buffer.anchor_before(buffer.len());
-                                            buffer.edit([(insert_position..insert_position, text)], None, cx);
-                                        });
-                                    })?;
-                                }
-                                Err(e) => {
-                                    Self::show_commit_message_error(&this, &e, cx);
-                                    break;
-                                }
-                            }
-                        }
-                    }
-                    Err(e) => {
-                        Self::show_commit_message_error(&this, &e, cx);
-                    }
+                if !text_empty {
+                    this.update(cx, |this, cx| {
+                        this.commit_message_buffer(cx).update(cx, |buffer, cx| {
+                            let insert_position = buffer.anchor_before(buffer.len());
+                            buffer.edit([(insert_position..insert_position, "\n")], None, cx)
+                        });
+                    })?;
+                }
+
+                while let Some(message) = messages.stream.next().await {
+                    let text = message?;
+
+                    this.update(cx, |this, cx| {
+                        this.commit_message_buffer(cx).update(cx, |buffer, cx| {
+                            let insert_position = buffer.anchor_before(buffer.len());
+                            buffer.edit([(insert_position..insert_position, text)], None, cx);
+                        });
+                    })?;
                 }
 
                 anyhow::Ok(())
@@ -2717,26 +2689,6 @@ impl GitPanel {
         }
     }
 
-    fn show_commit_message_error<E>(weak_this: &WeakEntity<Self>, err: &E, cx: &mut AsyncApp)
-    where
-        E: std::fmt::Debug + std::fmt::Display,
-    {
-        if let Ok(Some(workspace)) = weak_this.update(cx, |this, _cx| this.workspace.upgrade()) {
-            let _ = workspace.update(cx, |workspace, cx| {
-                struct CommitMessageError;
-                let notification_id = NotificationId::unique::<CommitMessageError>();
-                workspace.show_notification(notification_id, cx, |cx| {
-                    cx.new(|cx| {
-                        ErrorMessagePrompt::new(
-                            format!("Failed to generate commit message: {err}"),
-                            cx,
-                        )
-                    })
-                });
-            });
-        }
-    }
-
     fn show_remote_output(&self, action: RemoteAction, info: RemoteCommandOutput, cx: &mut App) {
         let Some(workspace) = self.workspace.upgrade() else {
             return;
@@ -4189,32 +4141,6 @@ impl GitPanel {
         self.amend_pending = value;
         cx.notify();
     }
-
-    pub async fn load(
-        workspace: WeakEntity<Workspace>,
-        mut cx: AsyncWindowContext,
-    ) -> anyhow::Result<Entity<Self>> {
-        let serialized_panel = cx
-            .background_spawn(async move { KEY_VALUE_STORE.read_kvp(&GIT_PANEL_KEY) })
-            .await
-            .context("loading git panel")
-            .log_err()
-            .flatten()
-            .and_then(|panel| serde_json::from_str::<SerializedGitPanel>(&panel).log_err());
-
-        workspace.update_in(&mut cx, |workspace, window, cx| {
-            let panel = GitPanel::new(workspace, window, cx);
-
-            if let Some(serialized_panel) = serialized_panel {
-                panel.update(cx, |panel, cx| {
-                    panel.width = serialized_panel.width;
-                    cx.notify();
-                })
-            }
-
-            panel
-        })
-    }
 }
 
 fn current_language_model(cx: &Context<'_, GitPanel>) -> Option<Arc<dyn LanguageModel>> {
@@ -4926,7 +4852,7 @@ impl Component for PanelRepoFooter {
 #[cfg(test)]
 mod tests {
     use git::status::StatusCode;
-    use gpui::{TestAppContext, VisualTestContext};
+    use gpui::TestAppContext;
     use project::{FakeFs, WorktreeSettings};
     use serde_json::json;
     use settings::SettingsStore;
@@ -4990,9 +4916,8 @@ mod tests {
 
         let project =
             Project::test(fs.clone(), [path!("/root/zed/crates/gpui").as_ref()], cx).await;
-        let workspace =
-            cx.add_window(|window, cx| Workspace::test_new(project.clone(), window, cx));
-        let cx = &mut VisualTestContext::from_window(*workspace, cx);
+        let (workspace, cx) =
+            cx.add_window_view(|window, cx| Workspace::test_new(project.clone(), window, cx));
 
         cx.read(|cx| {
             project
@@ -5009,7 +4934,10 @@ mod tests {
 
         cx.executor().run_until_parked();
 
-        let panel = workspace.update(cx, GitPanel::new).unwrap();
+        let app_state = workspace.read_with(cx, |workspace, _| workspace.app_state().clone());
+        let panel = cx.new_window_entity(|window, cx| {
+            GitPanel::new(workspace.clone(), project.clone(), app_state, window, cx)
+        });
 
         let handle = cx.update_window_entity(&panel, |panel, _, _| {
             std::mem::replace(&mut panel.update_visible_entries_task, Task::ready(()))

crates/gpui/src/app.rs

@@ -37,10 +37,10 @@ use crate::{
     AssetSource, BackgroundExecutor, Bounds, ClipboardItem, CursorStyle, DispatchPhase, DisplayId,
     EventEmitter, FocusHandle, FocusMap, ForegroundExecutor, Global, KeyBinding, KeyContext,
     Keymap, Keystroke, LayoutId, Menu, MenuItem, OwnedMenu, PathPromptOptions, Pixels, Platform,
-    PlatformDisplay, PlatformKeyboardLayout, PlatformKeyboardMapper, Point, PromptBuilder,
-    PromptButton, PromptHandle, PromptLevel, Render, RenderImage, RenderablePromptHandle,
-    Reservation, ScreenCaptureSource, SharedString, SubscriberSet, Subscription, SvgRenderer, Task,
-    TextSystem, Window, WindowAppearance, WindowHandle, WindowId, WindowInvalidator,
+    PlatformDisplay, PlatformKeyboardLayout, Point, PromptBuilder, PromptButton, PromptHandle,
+    PromptLevel, Render, RenderImage, RenderablePromptHandle, Reservation, ScreenCaptureSource,
+    SharedString, SubscriberSet, Subscription, SvgRenderer, Task, TextSystem, Window,
+    WindowAppearance, WindowHandle, WindowId, WindowInvalidator,
     colors::{Colors, GlobalColors},
     current_platform, hash, init_app_menus,
 };
@@ -64,7 +64,7 @@ pub struct AppCell {
 impl AppCell {
     #[doc(hidden)]
     #[track_caller]
-    pub fn borrow(&self) -> AppRef<'_> {
+    pub fn borrow(&self) -> AppRef {
         if option_env!("TRACK_THREAD_BORROWS").is_some() {
             let thread_id = std::thread::current().id();
             eprintln!("borrowed {thread_id:?}");
@@ -74,7 +74,7 @@ impl AppCell {
 
     #[doc(hidden)]
     #[track_caller]
-    pub fn borrow_mut(&self) -> AppRefMut<'_> {
+    pub fn borrow_mut(&self) -> AppRefMut {
         if option_env!("TRACK_THREAD_BORROWS").is_some() {
             let thread_id = std::thread::current().id();
             eprintln!("borrowed {thread_id:?}");
@@ -84,7 +84,7 @@ impl AppCell {
 
     #[doc(hidden)]
     #[track_caller]
-    pub fn try_borrow_mut(&self) -> Result<AppRefMut<'_>, BorrowMutError> {
+    pub fn try_borrow_mut(&self) -> Result<AppRefMut, BorrowMutError> {
         if option_env!("TRACK_THREAD_BORROWS").is_some() {
             let thread_id = std::thread::current().id();
             eprintln!("borrowed {thread_id:?}");
@@ -262,7 +262,6 @@ pub struct App {
     pub(crate) window_handles: FxHashMap<WindowId, AnyWindowHandle>,
     pub(crate) focus_handles: Arc<FocusMap>,
     pub(crate) keymap: Rc<RefCell<Keymap>>,
-    pub(crate) keyboard_mapper: Box<dyn PlatformKeyboardMapper>,
     pub(crate) keyboard_layout: Box<dyn PlatformKeyboardLayout>,
     pub(crate) global_action_listeners:
         FxHashMap<TypeId, Vec<Rc<dyn Fn(&dyn Any, DispatchPhase, &mut Self)>>>,
@@ -309,7 +308,6 @@ impl App {
 
         let text_system = Arc::new(TextSystem::new(platform.text_system()));
         let entities = EntityMap::new();
-        let keyboard_mapper = platform.keyboard_mapper();
         let keyboard_layout = platform.keyboard_layout();
 
         let app = Rc::new_cyclic(|this| AppCell {
@@ -335,7 +333,6 @@ impl App {
                 window_handles: FxHashMap::default(),
                 focus_handles: Arc::new(RwLock::new(SlotMap::with_key())),
                 keymap: Rc::new(RefCell::new(Keymap::default())),
-                keyboard_mapper,
                 keyboard_layout,
                 global_action_listeners: FxHashMap::default(),
                 pending_effects: VecDeque::new(),
@@ -372,7 +369,6 @@ impl App {
             move || {
                 if let Some(app) = app.upgrade() {
                     let cx = &mut app.borrow_mut();
-                    cx.keyboard_mapper = cx.platform.keyboard_mapper();
                     cx.keyboard_layout = cx.platform.keyboard_layout();
                     cx.keyboard_layout_observers
                         .clone()
@@ -417,11 +413,6 @@ impl App {
         self.quitting = false;
     }
 
-    /// Get the keyboard mapper of current keyboard layout
-    pub fn keyboard_mapper(&self) -> &dyn PlatformKeyboardMapper {
-        self.keyboard_mapper.as_ref()
-    }
-
     /// Get the id of the current keyboard layout
     pub fn keyboard_layout(&self) -> &dyn PlatformKeyboardLayout {
         self.keyboard_layout.as_ref()

crates/gpui/src/app/test_context.rs

@@ -3,9 +3,9 @@ use crate::{
     BackgroundExecutor, BorrowAppContext, Bounds, ClipboardItem, DrawPhase, Drawable, Element,
     Empty, EventEmitter, ForegroundExecutor, Global, InputEvent, Keystroke, Modifiers,
     ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseMoveEvent, MouseUpEvent, Pixels,
-    Platform, PlatformKeyboardMapper, Point, Render, Result, Size, Task, TestDispatcher,
-    TestPlatform, TestScreenCaptureSource, TestWindow, TextSystem, VisualContext, Window,
-    WindowBounds, WindowHandle, WindowOptions,
+    Platform, Point, Render, Result, Size, Task, TestDispatcher, TestPlatform,
+    TestScreenCaptureSource, TestWindow, TextSystem, VisualContext, Window, WindowBounds,
+    WindowHandle, WindowOptions,
 };
 use anyhow::{anyhow, bail};
 use futures::{Stream, StreamExt, channel::oneshot};
@@ -397,20 +397,14 @@ impl TestAppContext {
         self.background_executor.run_until_parked()
     }
 
-    /// Returns the current keyboard mapper for this platform.
-    pub fn keyboard_mapper(&self) -> Box<dyn PlatformKeyboardMapper> {
-        self.test_platform.keyboard_mapper()
-    }
-
     /// simulate_keystrokes takes a space-separated list of keys to type.
     /// cx.simulate_keystrokes("cmd-shift-p b k s p enter")
     /// in Zed, this will run backspace on the current editor through the command palette.
     /// This will also run the background executor until it's parked.
     pub fn simulate_keystrokes(&mut self, window: AnyWindowHandle, keystrokes: &str) {
-        let keyboard_mapper = self.keyboard_mapper();
         for keystroke in keystrokes
             .split(' ')
-            .map(|source| Keystroke::parse(source, keyboard_mapper.as_ref()))
+            .map(Keystroke::parse)
             .map(Result::unwrap)
         {
             self.dispatch_keystroke(window, keystroke);
@@ -424,12 +418,7 @@ impl TestAppContext {
     /// will type abc into your current editor
     /// This will also run the background executor until it's parked.
     pub fn simulate_input(&mut self, window: AnyWindowHandle, input: &str) {
-        let keyboard_mapper = self.keyboard_mapper();
-        for keystroke in input
-            .split("")
-            .map(|source| Keystroke::parse(source, keyboard_mapper.as_ref()))
-            .map(Result::unwrap)
-        {
+        for keystroke in input.split("").map(Keystroke::parse).map(Result::unwrap) {
             self.dispatch_keystroke(window, keystroke);
         }
 

crates/gpui/src/interactive.rs

@@ -538,22 +538,8 @@ mod test {
             })
             .unwrap();
 
-        cx.dispatch_keystroke(
-            *window,
-            Keystroke {
-                modifiers: crate::Modifiers::none(),
-                key: "a".to_owned(),
-                key_char: None,
-            },
-        );
-        cx.dispatch_keystroke(
-            *window,
-            Keystroke {
-                modifiers: crate::Modifiers::control(),
-                key: "g".to_owned(),
-                key_char: None,
-            },
-        );
+        cx.dispatch_keystroke(*window, Keystroke::parse("a").unwrap());
+        cx.dispatch_keystroke(*window, Keystroke::parse("ctrl-g").unwrap());
 
         window
             .update(cx, |test_view, _, _| {

crates/gpui/src/keymap.rs

@@ -310,11 +310,7 @@ mod tests {
         assert!(
             keymap
                 .bindings_for_input(
-                    &[Keystroke {
-                        modifiers: crate::Modifiers::control(),
-                        key: "a".to_owned(),
-                        key_char: None
-                    }],
+                    &[Keystroke::parse("ctrl-a").unwrap()],
                     &[KeyContext::parse("barf").unwrap()],
                 )
                 .0
@@ -323,11 +319,7 @@ mod tests {
         assert!(
             !keymap
                 .bindings_for_input(
-                    &[Keystroke {
-                        modifiers: crate::Modifiers::control(),
-                        key: "a".to_owned(),
-                        key_char: None
-                    }],
+                    &[Keystroke::parse("ctrl-a").unwrap()],
                     &[KeyContext::parse("editor").unwrap()],
                 )
                 .0
@@ -338,11 +330,7 @@ mod tests {
         assert!(
             keymap
                 .bindings_for_input(
-                    &[Keystroke {
-                        modifiers: crate::Modifiers::control(),
-                        key: "a".to_owned(),
-                        key_char: None
-                    }],
+                    &[Keystroke::parse("ctrl-a").unwrap()],
                     &[KeyContext::parse("editor mode=full").unwrap()],
                 )
                 .0
@@ -353,11 +341,7 @@ mod tests {
         assert!(
             keymap
                 .bindings_for_input(
-                    &[Keystroke {
-                        modifiers: crate::Modifiers::control(),
-                        key: "b".to_owned(),
-                        key_char: None
-                    }],
+                    &[Keystroke::parse("ctrl-b").unwrap()],
                     &[KeyContext::parse("barf").unwrap()],
                 )
                 .0
@@ -376,16 +360,8 @@ mod tests {
         let mut keymap = Keymap::default();
         keymap.add_bindings(bindings.clone());
 
-        let space = || Keystroke {
-            modifiers: crate::Modifiers::none(),
-            key: "space".to_owned(),
-            key_char: None,
-        };
-        let w = || Keystroke {
-            modifiers: crate::Modifiers::none(),
-            key: "w".to_owned(),
-            key_char: None,
-        };
+        let space = || Keystroke::parse("space").unwrap();
+        let w = || Keystroke::parse("w").unwrap();
 
         let space_w = [space(), w()];
         let space_w_w = [space(), w(), w()];

crates/gpui/src/keymap/binding.rs

@@ -2,10 +2,7 @@ use std::rc::Rc;
 
 use collections::HashMap;
 
-use crate::{
-    Action, InvalidKeystrokeError, KeyBindingContextPredicate, Keystroke, PlatformKeyboardMapper,
-    TestKeyboardMapper,
-};
+use crate::{Action, InvalidKeystrokeError, KeyBindingContextPredicate, Keystroke};
 use smallvec::SmallVec;
 
 /// A keybinding and its associated metadata, from the keymap.
@@ -28,20 +25,12 @@ impl Clone for KeyBinding {
 impl KeyBinding {
     /// Construct a new keybinding from the given data. Panics on parse error.
     pub fn new<A: Action>(keystrokes: &str, action: A, context: Option<&str>) -> Self {
-        let keyboard_mapper = TestKeyboardMapper::new();
         let context_predicate = if let Some(context) = context {
             Some(KeyBindingContextPredicate::parse(context).unwrap().into())
         } else {
             None
         };
-        Self::load(
-            keystrokes,
-            Box::new(action),
-            context_predicate,
-            None,
-            &keyboard_mapper,
-        )
-        .unwrap()
+        Self::load(keystrokes, Box::new(action), context_predicate, None).unwrap()
     }
 
     /// Load a keybinding from the given raw data.
@@ -50,11 +39,10 @@ impl KeyBinding {
         action: Box<dyn Action>,
         context_predicate: Option<Rc<KeyBindingContextPredicate>>,
         key_equivalents: Option<&HashMap<char, char>>,
-        keyboard_mapper: &dyn PlatformKeyboardMapper,
     ) -> std::result::Result<Self, InvalidKeystrokeError> {
         let mut keystrokes: SmallVec<[Keystroke; 2]> = keystrokes
             .split_whitespace()
-            .map(|source| Keystroke::parse(source, keyboard_mapper))
+            .map(Keystroke::parse)
             .collect::<std::result::Result<_, _>>()?;
 
         if let Some(equivalents) = key_equivalents {

crates/gpui/src/platform.rs

@@ -1,6 +1,5 @@
 mod app_menu;
 mod keyboard;
-mod keycode;
 mod keystroke;
 
 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
@@ -67,7 +66,6 @@ use uuid::Uuid;
 
 pub use app_menu::*;
 pub use keyboard::*;
-pub use keycode::*;
 pub use keystroke::*;
 
 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
@@ -196,6 +194,7 @@ pub(crate) trait Platform: 'static {
 
     fn on_quit(&self, callback: Box<dyn FnMut()>);
     fn on_reopen(&self, callback: Box<dyn FnMut()>);
+    fn on_keyboard_layout_change(&self, callback: Box<dyn FnMut()>);
 
     fn set_menus(&self, menus: Vec<Menu>, keymap: &Keymap);
     fn get_menus(&self) -> Option<Vec<OwnedMenu>> {
@@ -215,6 +214,7 @@ pub(crate) trait Platform: 'static {
     fn on_app_menu_action(&self, callback: Box<dyn FnMut(&dyn Action)>);
     fn on_will_open_app_menu(&self, callback: Box<dyn FnMut()>);
     fn on_validate_app_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>);
+    fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout>;
 
     fn compositor_name(&self) -> &'static str {
         ""
@@ -235,10 +235,6 @@ pub(crate) trait Platform: 'static {
     fn write_credentials(&self, url: &str, username: &str, password: &[u8]) -> Task<Result<()>>;
     fn read_credentials(&self, url: &str) -> Task<Result<Option<(String, Vec<u8>)>>>;
     fn delete_credentials(&self, url: &str) -> Task<Result<()>>;
-
-    fn keyboard_mapper(&self) -> Box<dyn PlatformKeyboardMapper>;
-    fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout>;
-    fn on_keyboard_layout_change(&self, callback: Box<dyn FnMut()>);
 }
 
 /// A handle to a platform's display, e.g. a monitor or laptop screen.
@@ -722,7 +718,7 @@ impl<T> ops::Index<usize> for AtlasTextureList<T> {
 
 impl<T> AtlasTextureList<T> {
     #[allow(unused)]
-    fn drain(&mut self) -> std::vec::Drain<'_, Option<T>> {
+    fn drain(&mut self) -> std::vec::Drain<Option<T>> {
         self.free_list.clear();
         self.textures.drain(..)
     }

crates/gpui/src/platform/keyboard.rs

@@ -1,7 +1,3 @@
-use anyhow::Result;
-
-use crate::{Modifiers, ScanCode};
-
 /// A trait for platform-specific keyboard layouts
 pub trait PlatformKeyboardLayout {
     /// Get the keyboard layout ID, which should be unique to the layout
@@ -9,109 +5,3 @@ pub trait PlatformKeyboardLayout {
     /// Get the keyboard layout display name
     fn name(&self) -> &str;
 }
-
-/// TODO:
-pub trait PlatformKeyboardMapper {
-    /// TODO:
-    fn scan_code_to_key(&self, scan_code: ScanCode, modifiers: &mut Modifiers) -> Result<String>;
-}
-
-/// TODO:
-pub struct TestKeyboardMapper {
-    #[cfg(target_os = "windows")]
-    mapper: super::WindowsKeyboardMapper,
-    #[cfg(target_os = "macos")]
-    mapper: super::MacKeyboardMapper,
-    #[cfg(target_os = "linux")]
-    mapper: super::LinuxKeyboardMapper,
-}
-
-impl PlatformKeyboardMapper for TestKeyboardMapper {
-    fn scan_code_to_key(&self, scan_code: ScanCode, modifiers: &mut Modifiers) -> Result<String> {
-        self.mapper.scan_code_to_key(scan_code, modifiers)
-    }
-}
-
-impl TestKeyboardMapper {
-    /// TODO:
-    pub fn new() -> Self {
-        Self {
-            #[cfg(target_os = "windows")]
-            mapper: super::WindowsKeyboardMapper::new(),
-            #[cfg(target_os = "macos")]
-            mapper: super::MacKeyboardMapper::new(),
-            #[cfg(target_os = "linux")]
-            mapper: super::LinuxKeyboardMapper::new(),
-        }
-    }
-}
-
-/// A dummy keyboard mapper that does not support any key mappings
-pub struct EmptyKeyboardMapper;
-
-impl PlatformKeyboardMapper for EmptyKeyboardMapper {
-    fn scan_code_to_key(&self, _scan_code: ScanCode, _modifiers: &mut Modifiers) -> Result<String> {
-        anyhow::bail!("EmptyKeyboardMapper does not support scan codes")
-    }
-}
-
-#[allow(unused)]
-pub(crate) fn is_letter_key(key: &str) -> bool {
-    matches!(
-        key,
-        "a" | "b"
-            | "c"
-            | "d"
-            | "e"
-            | "f"
-            | "g"
-            | "h"
-            | "i"
-            | "j"
-            | "k"
-            | "l"
-            | "m"
-            | "n"
-            | "o"
-            | "p"
-            | "q"
-            | "r"
-            | "s"
-            | "t"
-            | "u"
-            | "v"
-            | "w"
-            | "x"
-            | "y"
-            | "z"
-    )
-}
-
-#[cfg(test)]
-mod tests {
-    use strum::IntoEnumIterator;
-
-    use crate::{Modifiers, ScanCode};
-
-    use super::{PlatformKeyboardMapper, TestKeyboardMapper};
-
-    #[test]
-    fn test_scan_code_to_key() {
-        let mapper = TestKeyboardMapper::new();
-        for scan_code in ScanCode::iter() {
-            let mut modifiers = Modifiers::default();
-            let key = mapper.scan_code_to_key(scan_code, &mut modifiers).unwrap();
-            assert_eq!(key, scan_code.to_key(false));
-            assert_eq!(modifiers, Modifiers::default());
-
-            let mut modifiers = Modifiers::shift();
-            let shifted_key = mapper.scan_code_to_key(scan_code, &mut modifiers).unwrap();
-            assert_eq!(shifted_key, scan_code.to_key(true));
-            if shifted_key != key {
-                assert_eq!(modifiers, Modifiers::default());
-            } else {
-                assert_eq!(modifiers, Modifiers::shift());
-            }
-        }
-    }
-}

crates/gpui/src/platform/keycode.rs

@@ -1,590 +0,0 @@
-use strum::EnumIter;
-
-/// Scan codes for the keyboard, which are used to identify keys in a keyboard layout-independent way.
-/// Currently, we only support a limited set of scan codes here:
-/// https://code.visualstudio.com/docs/configure/keybindings#_keyboard-layoutindependent-bindings
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EnumIter)]
-pub enum ScanCode {
-    /// F1 key
-    F1,
-    /// F1 key
-    F2,
-    /// F1 key
-    F3,
-    /// F1 key
-    F4,
-    /// F1 key
-    F5,
-    /// F1 key
-    F6,
-    /// F1 key
-    F7,
-    /// F1 key
-    F8,
-    /// F1 key
-    F9,
-    /// F1 key
-    F10,
-    /// F1 key
-    F11,
-    /// F1 key
-    F12,
-    /// F1 key
-    F13,
-    /// F1 key
-    F14,
-    /// F1 key
-    F15,
-    /// F1 key
-    F16,
-    /// F1 key
-    F17,
-    /// F1 key
-    F18,
-    /// F1 key
-    F19,
-    /// F20 key
-    F20,
-    /// F20 key
-    F21,
-    /// F20 key
-    F22,
-    /// F20 key
-    F23,
-    /// F20 key
-    F24,
-    /// A key on the main keyboard.
-    A,
-    /// B key on the main keyboard.
-    B,
-    /// C key on the main keyboard.
-    C,
-    /// D key on the main keyboard.
-    D,
-    /// E key on the main keyboard.
-    E,
-    /// F key on the main keyboard.
-    F,
-    /// G key on the main keyboard.
-    G,
-    /// H key on the main keyboard.
-    H,
-    /// I key on the main keyboard.
-    I,
-    /// J key on the main keyboard.
-    J,
-    /// K key on the main keyboard.
-    K,
-    /// L key on the main keyboard.
-    L,
-    /// M key on the main keyboard.
-    M,
-    /// N key on the main keyboard.
-    N,
-    /// O key on the main keyboard.
-    O,
-    /// P key on the main keyboard.
-    P,
-    /// Q key on the main keyboard.
-    Q,
-    /// R key on the main keyboard.
-    R,
-    /// S key on the main keyboard.
-    S,
-    /// T key on the main keyboard.
-    T,
-    /// U key on the main keyboard.
-    U,
-    /// V key on the main keyboard.
-    V,
-    /// W key on the main keyboard.
-    W,
-    /// X key on the main keyboard.
-    X,
-    /// Y key on the main keyboard.
-    Y,
-    /// Z key on the main keyboard.
-    Z,
-    /// 0 key on the main keyboard.
-    Digit0,
-    /// 1 key on the main keyboard.
-    Digit1,
-    /// 2 key on the main keyboard.
-    Digit2,
-    /// 3 key on the main keyboard.
-    Digit3,
-    /// 4 key on the main keyboard.
-    Digit4,
-    /// 5 key on the main keyboard.
-    Digit5,
-    /// 6 key on the main keyboard.
-    Digit6,
-    /// 7 key on the main keyboard.
-    Digit7,
-    /// 8 key on the main keyboard.
-    Digit8,
-    /// 9 key on the main keyboard.
-    Digit9,
-
-    /// Backquote key on the main keyboard: `
-    Backquote,
-    /// Minus key on the main keyboard: -
-    Minus,
-    /// Equal key on the main keyboard: =
-    Equal,
-    /// BracketLeft key on the main keyboard: [
-    BracketLeft,
-    /// BracketRight key on the main keyboard: ]
-    BracketRight,
-    /// Backslash key on the main keyboard: \
-    Backslash,
-    /// Semicolon key on the main keyboard: ;
-    Semicolon,
-    /// Quote key on the main keyboard: '
-    Quote,
-    /// Comma key on the main keyboard: ,
-    Comma,
-    /// Period key on the main keyboard: .
-    Period,
-    /// Slash key on the main keyboard: /
-    Slash,
-
-    /// Left arrow key
-    Left,
-    /// Up arrow key
-    Up,
-    /// Right arrow key
-    Right,
-    /// Down arrow key
-    Down,
-    /// PAGE UP key
-    PageUp,
-    /// PAGE DOWN key
-    PageDown,
-    /// END key
-    End,
-    /// HOME key
-    Home,
-
-    /// TAB key
-    Tab,
-    /// ENTER key, also known as RETURN key
-    /// This does not distinguish between the main Enter key and the numeric keypad Enter key.
-    Enter,
-    /// ESCAPE key
-    Escape,
-    /// SPACE key
-    Space,
-    /// BACKSPACE key
-    Backspace,
-    /// DELETE key
-    Delete,
-
-    // Pause, not supported yet
-    // CapsLock, not supported yet
-    /// INSERT key
-    Insert,
-    // The following keys are not supported yet:
-    // Numpad0,
-    // Numpad1,
-    // Numpad2,
-    // Numpad3,
-    // Numpad4,
-    // Numpad5,
-    // Numpad6,
-    // Numpad7,
-    // Numpad8,
-    // Numpad9,
-    // NumpadMultiply,
-    // NumpadAdd,
-    // NumpadComma,
-    // NumpadSubtract,
-    // NumpadDecimal,
-    // NumpadDivide,
-}
-
-impl ScanCode {
-    /// Parse a scan code from a string.
-    pub fn parse(source: &str) -> Option<Self> {
-        match source {
-            "[f1]" => Some(Self::F1),
-            "[f2]" => Some(Self::F2),
-            "[f3]" => Some(Self::F3),
-            "[f4]" => Some(Self::F4),
-            "[f5]" => Some(Self::F5),
-            "[f6]" => Some(Self::F6),
-            "[f7]" => Some(Self::F7),
-            "[f8]" => Some(Self::F8),
-            "[f9]" => Some(Self::F9),
-            "[f10]" => Some(Self::F10),
-            "[f11]" => Some(Self::F11),
-            "[f12]" => Some(Self::F12),
-            "[f13]" => Some(Self::F13),
-            "[f14]" => Some(Self::F14),
-            "[f15]" => Some(Self::F15),
-            "[f16]" => Some(Self::F16),
-            "[f17]" => Some(Self::F17),
-            "[f18]" => Some(Self::F18),
-            "[f19]" => Some(Self::F19),
-            "[f20]" => Some(Self::F20),
-            "[f21]" => Some(Self::F21),
-            "[f22]" => Some(Self::F22),
-            "[f23]" => Some(Self::F23),
-            "[f24]" => Some(Self::F24),
-            "[a]" | "[keya]" => Some(Self::A),
-            "[b]" | "[keyb]" => Some(Self::B),
-            "[c]" | "[keyc]" => Some(Self::C),
-            "[d]" | "[keyd]" => Some(Self::D),
-            "[e]" | "[keye]" => Some(Self::E),
-            "[f]" | "[keyf]" => Some(Self::F),
-            "[g]" | "[keyg]" => Some(Self::G),
-            "[h]" | "[keyh]" => Some(Self::H),
-            "[i]" | "[keyi]" => Some(Self::I),
-            "[j]" | "[keyj]" => Some(Self::J),
-            "[k]" | "[keyk]" => Some(Self::K),
-            "[l]" | "[keyl]" => Some(Self::L),
-            "[m]" | "[keym]" => Some(Self::M),
-            "[n]" | "[keyn]" => Some(Self::N),
-            "[o]" | "[keyo]" => Some(Self::O),
-            "[p]" | "[keyp]" => Some(Self::P),
-            "[q]" | "[keyq]" => Some(Self::Q),
-            "[r]" | "[keyr]" => Some(Self::R),
-            "[s]" | "[keys]" => Some(Self::S),
-            "[t]" | "[keyt]" => Some(Self::T),
-            "[u]" | "[keyu]" => Some(Self::U),
-            "[v]" | "[keyv]" => Some(Self::V),
-            "[w]" | "[keyw]" => Some(Self::W),
-            "[x]" | "[keyx]" => Some(Self::X),
-            "[y]" | "[keyy]" => Some(Self::Y),
-            "[z]" | "[keyz]" => Some(Self::Z),
-            "[0]" | "[digit0]" => Some(Self::Digit0),
-            "[1]" | "[digit1]" => Some(Self::Digit1),
-            "[2]" | "[digit2]" => Some(Self::Digit2),
-            "[3]" | "[digit3]" => Some(Self::Digit3),
-            "[4]" | "[digit4]" => Some(Self::Digit4),
-            "[5]" | "[digit5]" => Some(Self::Digit5),
-            "[6]" | "[digit6]" => Some(Self::Digit6),
-            "[7]" | "[digit7]" => Some(Self::Digit7),
-            "[8]" | "[digit8]" => Some(Self::Digit8),
-            "[9]" | "[digit9]" => Some(Self::Digit9),
-
-            "[backquote]" => Some(Self::Backquote),
-            "[minus]" => Some(Self::Minus),
-            "[equal]" => Some(Self::Equal),
-            "[bracketleft]" => Some(Self::BracketLeft),
-            "[bracketright]" => Some(Self::BracketRight),
-            "[backslash]" => Some(Self::Backslash),
-            "[semicolon]" => Some(Self::Semicolon),
-            "[quote]" => Some(Self::Quote),
-            "[comma]" => Some(Self::Comma),
-            "[period]" => Some(Self::Period),
-            "[slash]" => Some(Self::Slash),
-
-            "[left]" | "[arrowleft]" => Some(Self::Left),
-            "[up]" | "[arrowup]" => Some(Self::Up),
-            "[right]" | "[arrowright]" => Some(Self::Right),
-            "[down]" | "[arrowdown]" => Some(Self::Down),
-            "[pageup]" => Some(Self::PageUp),
-            "[pagedown]" => Some(Self::PageDown),
-            "[end]" => Some(Self::End),
-            "[home]" => Some(Self::Home),
-
-            "[tab]" => Some(Self::Tab),
-            "[enter]" => Some(Self::Enter),
-            "[escape]" => Some(Self::Escape),
-            "[space]" => Some(Self::Space),
-            "[backspace]" => Some(Self::Backspace),
-            "[delete]" => Some(Self::Delete),
-
-            // "[pause]" => Some(Self::Pause),
-            // "[capslock]" => Some(Self::CapsLock),
-            "[insert]" => Some(Self::Insert),
-
-            // "[numpad0]" => Some(Self::Numpad0),
-            // "[numpad1]" => Some(Self::Numpad1),
-            // "[numpad2]" => Some(Self::Numpad2),
-            // "[numpad3]" => Some(Self::Numpad3),
-            // "[numpad4]" => Some(Self::Numpad4),
-            // "[numpad5]" => Some(Self::Numpad5),
-            // "[numpad6]" => Some(Self::Numpad6),
-            // "[numpad7]" => Some(Self::Numpad7),
-            // "[numpad8]" => Some(Self::Numpad8),
-            // "[numpad9]" => Some(Self::Numpad9),
-            // "[numpadmultiply]" => Some(Self::NumpadMultiply),
-            // "[numpadadd]" => Some(Self::NumpadAdd),
-            // "[numpadcomma]" => Some(Self::NumpadComma),
-            // "[numpadsubtract]" => Some(Self::NumpadSubtract),
-            // "[numpaddecimal]" => Some(Self::NumpadDecimal),
-            // "[numpaddivide]" => Some(Self::NumpadDivide),
-            _ => None,
-        }
-    }
-
-    /// Convert the scan code to its key face for immutable keys.
-    pub fn try_to_key(&self) -> Option<String> {
-        Some(
-            match self {
-                ScanCode::F1 => "f1",
-                ScanCode::F2 => "f2",
-                ScanCode::F3 => "f3",
-                ScanCode::F4 => "f4",
-                ScanCode::F5 => "f5",
-                ScanCode::F6 => "f6",
-                ScanCode::F7 => "f7",
-                ScanCode::F8 => "f8",
-                ScanCode::F9 => "f9",
-                ScanCode::F10 => "f10",
-                ScanCode::F11 => "f11",
-                ScanCode::F12 => "f12",
-                ScanCode::F13 => "f13",
-                ScanCode::F14 => "f14",
-                ScanCode::F15 => "f15",
-                ScanCode::F16 => "f16",
-                ScanCode::F17 => "f17",
-                ScanCode::F18 => "f18",
-                ScanCode::F19 => "f19",
-                ScanCode::F20 => "f20",
-                ScanCode::F21 => "f21",
-                ScanCode::F22 => "f22",
-                ScanCode::F23 => "f23",
-                ScanCode::F24 => "f24",
-                ScanCode::Left => "left",
-                ScanCode::Up => "up",
-                ScanCode::Right => "right",
-                ScanCode::Down => "down",
-                ScanCode::PageUp => "pageup",
-                ScanCode::PageDown => "pagedown",
-                ScanCode::End => "end",
-                ScanCode::Home => "home",
-                ScanCode::Tab => "tab",
-                ScanCode::Enter => "enter",
-                ScanCode::Escape => "escape",
-                ScanCode::Space => "space",
-                ScanCode::Backspace => "backspace",
-                ScanCode::Delete => "delete",
-                ScanCode::Insert => "insert",
-                _ => return None,
-            }
-            .to_string(),
-        )
-    }
-
-    /// This function is used to convert the scan code to its key face on US keyboard layout.
-    /// Only used for tests.
-    pub fn to_key(&self, shift: bool) -> &str {
-        match self {
-            ScanCode::F1 => "f1",
-            ScanCode::F2 => "f2",
-            ScanCode::F3 => "f3",
-            ScanCode::F4 => "f4",
-            ScanCode::F5 => "f5",
-            ScanCode::F6 => "f6",
-            ScanCode::F7 => "f7",
-            ScanCode::F8 => "f8",
-            ScanCode::F9 => "f9",
-            ScanCode::F10 => "f10",
-            ScanCode::F11 => "f11",
-            ScanCode::F12 => "f12",
-            ScanCode::F13 => "f13",
-            ScanCode::F14 => "f14",
-            ScanCode::F15 => "f15",
-            ScanCode::F16 => "f16",
-            ScanCode::F17 => "f17",
-            ScanCode::F18 => "f18",
-            ScanCode::F19 => "f19",
-            ScanCode::F20 => "f20",
-            ScanCode::F21 => "f21",
-            ScanCode::F22 => "f22",
-            ScanCode::F23 => "f23",
-            ScanCode::F24 => "f24",
-            ScanCode::A => "a",
-            ScanCode::B => "b",
-            ScanCode::C => "c",
-            ScanCode::D => "d",
-            ScanCode::E => "e",
-            ScanCode::F => "f",
-            ScanCode::G => "g",
-            ScanCode::H => "h",
-            ScanCode::I => "i",
-            ScanCode::J => "j",
-            ScanCode::K => "k",
-            ScanCode::L => "l",
-            ScanCode::M => "m",
-            ScanCode::N => "n",
-            ScanCode::O => "o",
-            ScanCode::P => "p",
-            ScanCode::Q => "q",
-            ScanCode::R => "r",
-            ScanCode::S => "s",
-            ScanCode::T => "t",
-            ScanCode::U => "u",
-            ScanCode::V => "v",
-            ScanCode::W => "w",
-            ScanCode::X => "x",
-            ScanCode::Y => "y",
-            ScanCode::Z => "z",
-            ScanCode::Digit0 => {
-                if shift {
-                    ")"
-                } else {
-                    "0"
-                }
-            }
-            ScanCode::Digit1 => {
-                if shift {
-                    "!"
-                } else {
-                    "1"
-                }
-            }
-            ScanCode::Digit2 => {
-                if shift {
-                    "@"
-                } else {
-                    "2"
-                }
-            }
-            ScanCode::Digit3 => {
-                if shift {
-                    "#"
-                } else {
-                    "3"
-                }
-            }
-            ScanCode::Digit4 => {
-                if shift {
-                    "$"
-                } else {
-                    "4"
-                }
-            }
-            ScanCode::Digit5 => {
-                if shift {
-                    "%"
-                } else {
-                    "5"
-                }
-            }
-            ScanCode::Digit6 => {
-                if shift {
-                    "^"
-                } else {
-                    "6"
-                }
-            }
-            ScanCode::Digit7 => {
-                if shift {
-                    "&"
-                } else {
-                    "7"
-                }
-            }
-            ScanCode::Digit8 => {
-                if shift {
-                    "*"
-                } else {
-                    "8"
-                }
-            }
-            ScanCode::Digit9 => {
-                if shift {
-                    "("
-                } else {
-                    "9"
-                }
-            }
-            ScanCode::Backquote => {
-                if shift {
-                    "~"
-                } else {
-                    "`"
-                }
-            }
-            ScanCode::Minus => {
-                if shift {
-                    "_"
-                } else {
-                    "-"
-                }
-            }
-            ScanCode::Equal => {
-                if shift {
-                    "+"
-                } else {
-                    "="
-                }
-            }
-            ScanCode::BracketLeft => {
-                if shift {
-                    "{"
-                } else {
-                    "["
-                }
-            }
-            ScanCode::BracketRight => {
-                if shift {
-                    "}"
-                } else {
-                    "]"
-                }
-            }
-            ScanCode::Backslash => {
-                if shift {
-                    "|"
-                } else {
-                    "\\"
-                }
-            }
-            ScanCode::Semicolon => {
-                if shift {
-                    ":"
-                } else {
-                    ";"
-                }
-            }
-            ScanCode::Quote => {
-                if shift {
-                    "\""
-                } else {
-                    "'"
-                }
-            }
-            ScanCode::Comma => {
-                if shift {
-                    "<"
-                } else {
-                    ","
-                }
-            }
-            ScanCode::Period => {
-                if shift {
-                    ">"
-                } else {
-                    "."
-                }
-            }
-            ScanCode::Slash => {
-                if shift {
-                    "?"
-                } else {
-                    "/"
-                }
-            }
-            ScanCode::Left => "left",
-            ScanCode::Up => "up",
-            ScanCode::Right => "right",
-            ScanCode::Down => "down",
-            ScanCode::PageUp => "pageup",
-            ScanCode::PageDown => "pagedown",
-            ScanCode::End => "end",
-            ScanCode::Home => "home",
-            ScanCode::Tab => "tab",
-            ScanCode::Enter => "enter",
-            ScanCode::Escape => "escape",
-            ScanCode::Space => "space",
-            ScanCode::Backspace => "backspace",
-            ScanCode::Delete => "delete",
-            ScanCode::Insert => "insert",
-        }
-    }
-}

crates/gpui/src/platform/keystroke.rs

@@ -1,13 +1,9 @@
-use anyhow::Context;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use std::{
     error::Error,
     fmt::{Display, Write},
 };
-use util::ResultExt;
-
-use crate::{PlatformKeyboardMapper, ScanCode};
 
 /// A keystroke and associated metadata generated by the platform
 #[derive(Clone, Debug, Eq, PartialEq, Default, Deserialize, Hash)]
@@ -97,10 +93,7 @@ impl Keystroke {
     /// key_char syntax is only used for generating test events,
     /// secondary means "cmd" on macOS and "ctrl" on other platforms
     /// when matching a key with an key_char set will be matched without it.
-    pub fn parse(
-        source: &str,
-        keyboard_mapper: &dyn PlatformKeyboardMapper,
-    ) -> std::result::Result<Self, InvalidKeystrokeError> {
+    pub fn parse(source: &str) -> std::result::Result<Self, InvalidKeystrokeError> {
         let mut modifiers = Modifiers::none();
         let mut key = None;
         let mut key_char = None;
@@ -191,24 +184,9 @@ impl Keystroke {
             }
         });
 
-        // Create error once for reuse
-        let error = || InvalidKeystrokeError {
+        let key = key.ok_or_else(|| InvalidKeystrokeError {
             keystroke: source.to_owned(),
-        };
-
-        let key = {
-            let key = key.ok_or_else(error)?;
-            if key.starts_with('[') && key.ends_with(']') {
-                let scan_code = ScanCode::parse(&key).ok_or_else(error)?;
-                keyboard_mapper
-                    .scan_code_to_key(scan_code, &mut modifiers)
-                    .context("Failed to convert scan code to key")
-                    .log_err()
-                    .ok_or_else(error)?
-            } else {
-                key
-            }
-        };
+        })?;
 
         Ok(Keystroke {
             modifiers,

crates/gpui/src/platform/linux/keyboard.rs

@@ -1,20 +1,4 @@
-#[cfg(any(feature = "wayland", feature = "x11"))]
-use std::sync::LazyLock;
-
-#[cfg(any(feature = "wayland", feature = "x11"))]
-use collections::HashMap;
-#[cfg(any(feature = "wayland", feature = "x11"))]
-use x11rb::{protocol::xkb::ConnectionExt, xcb_ffi::XCBConnection};
-#[cfg(any(feature = "wayland", feature = "x11"))]
-use xkbcommon::xkb::{
-    Keycode,
-    x11::ffi::{XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION},
-};
-
-use crate::{Modifiers, PlatformKeyboardLayout, PlatformKeyboardMapper, ScanCode};
-
-#[cfg(any(feature = "wayland", feature = "x11"))]
-use crate::is_letter_key;
+use crate::PlatformKeyboardLayout;
 
 pub(crate) struct LinuxKeyboardLayout {
     id: String,
@@ -35,257 +19,3 @@ impl LinuxKeyboardLayout {
         Self { id }
     }
 }
-
-#[cfg(any(feature = "wayland", feature = "x11"))]
-pub(crate) struct LinuxKeyboardMapper {
-    code_to_key: HashMap<Keycode, String>,
-    code_to_shifted_key: HashMap<Keycode, String>,
-}
-
-#[cfg(any(feature = "wayland", feature = "x11"))]
-impl PlatformKeyboardMapper for LinuxKeyboardMapper {
-    fn scan_code_to_key(
-        &self,
-        scan_code: ScanCode,
-        modifiers: &mut Modifiers,
-    ) -> anyhow::Result<String> {
-        if let Some(key) = scan_code.try_to_key() {
-            return Ok(key);
-        }
-        let native_scan_code = get_scan_code(scan_code)
-            .map(Keycode::new)
-            .ok_or_else(|| anyhow::anyhow!("Unsupported scan code: {:?}", scan_code))?;
-        let key = self.code_to_key.get(&native_scan_code).ok_or_else(|| {
-            anyhow::anyhow!("Key not found for scan code: {:?}", native_scan_code)
-        })?;
-        if modifiers.shift && !is_letter_key(key) {
-            if let Some(key) = self.code_to_shifted_key.get(&native_scan_code) {
-                modifiers.shift = false;
-                return Ok(key.clone());
-            } else {
-                anyhow::bail!(
-                    "Shifted key not found for scan code: {:?}",
-                    native_scan_code
-                );
-            }
-        } else {
-            Ok(key.clone())
-        }
-    }
-}
-
-#[cfg(any(feature = "wayland", feature = "x11"))]
-static XCB_CONNECTION: LazyLock<XCBConnection> =
-    LazyLock::new(|| XCBConnection::connect(None).unwrap().0);
-
-#[cfg(any(feature = "wayland", feature = "x11"))]
-impl LinuxKeyboardMapper {
-    pub(crate) fn new() -> Self {
-        let _ = XCB_CONNECTION
-            .xkb_use_extension(XKB_X11_MIN_MAJOR_XKB_VERSION, XKB_X11_MIN_MINOR_XKB_VERSION)
-            .unwrap()
-            .reply()
-            .unwrap();
-        let xkb_context = xkbcommon::xkb::Context::new(xkbcommon::xkb::CONTEXT_NO_FLAGS);
-        let xkb_device_id = xkbcommon::xkb::x11::get_core_keyboard_device_id(&*XCB_CONNECTION);
-        let xkb_state = {
-            let xkb_keymap = xkbcommon::xkb::x11::keymap_new_from_device(
-                &xkb_context,
-                &*XCB_CONNECTION,
-                xkb_device_id,
-                xkbcommon::xkb::KEYMAP_COMPILE_NO_FLAGS,
-            );
-            xkbcommon::xkb::x11::state_new_from_device(&xkb_keymap, &*XCB_CONNECTION, xkb_device_id)
-        };
-        let mut code_to_key = HashMap::default();
-        let mut code_to_shifted_key = HashMap::default();
-
-        let keymap = xkb_state.get_keymap();
-        let mut shifted_state = xkbcommon::xkb::State::new(&keymap);
-
-        let shift_mod = keymap.mod_get_index(xkbcommon::xkb::MOD_NAME_SHIFT);
-        let shift_mask = 1 << shift_mod;
-        shifted_state.update_mask(shift_mask, 0, 0, 0, 0, 0);
-
-        for &scan_code in TYPEABLE_CODES {
-            let keycode = Keycode::new(scan_code);
-            let key = xkb_state.key_get_utf8(keycode);
-            if !is_letter_key(&key) {
-                let shifted_key = shifted_state.key_get_utf8(keycode);
-                code_to_shifted_key.insert(keycode, shifted_key);
-            }
-            code_to_key.insert(keycode, key);
-        }
-
-        Self {
-            code_to_key,
-            code_to_shifted_key,
-        }
-    }
-}
-
-// All typeable scan codes for the standard US keyboard layout, ANSI104
-#[cfg(any(feature = "wayland", feature = "x11"))]
-const TYPEABLE_CODES: &[u32] = &[
-    0x0026, // a
-    0x0038, // b
-    0x0036, // c
-    0x0028, // d
-    0x001a, // e
-    0x0029, // f
-    0x002a, // g
-    0x002b, // h
-    0x001f, // i
-    0x002c, // j
-    0x002d, // k
-    0x002e, // l
-    0x003a, // m
-    0x0039, // n
-    0x0020, // o
-    0x0021, // p
-    0x0018, // q
-    0x001b, // r
-    0x0027, // s
-    0x001c, // t
-    0x001e, // u
-    0x0037, // v
-    0x0019, // w
-    0x0035, // x
-    0x001d, // y
-    0x0034, // z
-    0x0013, // Digit 0
-    0x000a, // Digit 1
-    0x000b, // Digit 2
-    0x000c, // Digit 3
-    0x000d, // Digit 4
-    0x000e, // Digit 5
-    0x000f, // Digit 6
-    0x0010, // Digit 7
-    0x0011, // Digit 8
-    0x0012, // Digit 9
-    0x0031, // ` Backquote
-    0x0014, // - Minus
-    0x0015, // = Equal
-    0x0022, // [ Left bracket
-    0x0023, // ] Right bracket
-    0x0033, // \ Backslash
-    0x002f, // ; Semicolon
-    0x0030, // ' Quote
-    0x003b, // , Comma
-    0x003c, // . Period
-    0x003d, // / Slash
-];
-
-#[cfg(any(feature = "wayland", feature = "x11"))]
-fn get_scan_code(scan_code: ScanCode) -> Option<u32> {
-    // https://github.com/microsoft/node-native-keymap/blob/main/deps/chromium/dom_code_data.inc
-    Some(match scan_code {
-        ScanCode::F1 => 0x0043,
-        ScanCode::F2 => 0x0044,
-        ScanCode::F3 => 0x0045,
-        ScanCode::F4 => 0x0046,
-        ScanCode::F5 => 0x0047,
-        ScanCode::F6 => 0x0048,
-        ScanCode::F7 => 0x0049,
-        ScanCode::F8 => 0x004a,
-        ScanCode::F9 => 0x004b,
-        ScanCode::F10 => 0x004c,
-        ScanCode::F11 => 0x005f,
-        ScanCode::F12 => 0x0060,
-        ScanCode::F13 => 0x00bf,
-        ScanCode::F14 => 0x00c0,
-        ScanCode::F15 => 0x00c1,
-        ScanCode::F16 => 0x00c2,
-        ScanCode::F17 => 0x00c3,
-        ScanCode::F18 => 0x00c4,
-        ScanCode::F19 => 0x00c5,
-        ScanCode::F20 => 0x00c6,
-        ScanCode::F21 => 0x00c7,
-        ScanCode::F22 => 0x00c8,
-        ScanCode::F23 => 0x00c9,
-        ScanCode::F24 => 0x00ca,
-        ScanCode::A => 0x0026,
-        ScanCode::B => 0x0038,
-        ScanCode::C => 0x0036,
-        ScanCode::D => 0x0028,
-        ScanCode::E => 0x001a,
-        ScanCode::F => 0x0029,
-        ScanCode::G => 0x002a,
-        ScanCode::H => 0x002b,
-        ScanCode::I => 0x001f,
-        ScanCode::J => 0x002c,
-        ScanCode::K => 0x002d,
-        ScanCode::L => 0x002e,
-        ScanCode::M => 0x003a,
-        ScanCode::N => 0x0039,
-        ScanCode::O => 0x0020,
-        ScanCode::P => 0x0021,
-        ScanCode::Q => 0x0018,
-        ScanCode::R => 0x001b,
-        ScanCode::S => 0x0027,
-        ScanCode::T => 0x001c,
-        ScanCode::U => 0x001e,
-        ScanCode::V => 0x0037,
-        ScanCode::W => 0x0019,
-        ScanCode::X => 0x0035,
-        ScanCode::Y => 0x001d,
-        ScanCode::Z => 0x0034,
-        ScanCode::Digit0 => 0x0013,
-        ScanCode::Digit1 => 0x000a,
-        ScanCode::Digit2 => 0x000b,
-        ScanCode::Digit3 => 0x000c,
-        ScanCode::Digit4 => 0x000d,
-        ScanCode::Digit5 => 0x000e,
-        ScanCode::Digit6 => 0x000f,
-        ScanCode::Digit7 => 0x0010,
-        ScanCode::Digit8 => 0x0011,
-        ScanCode::Digit9 => 0x0012,
-        ScanCode::Backquote => 0x0031,
-        ScanCode::Minus => 0x0014,
-        ScanCode::Equal => 0x0015,
-        ScanCode::BracketLeft => 0x0022,
-        ScanCode::BracketRight => 0x0023,
-        ScanCode::Backslash => 0x0033,
-        ScanCode::Semicolon => 0x002f,
-        ScanCode::Quote => 0x0030,
-        ScanCode::Comma => 0x003b,
-        ScanCode::Period => 0x003c,
-        ScanCode::Slash => 0x003d,
-        ScanCode::Left => 0x0071,
-        ScanCode::Up => 0x006f,
-        ScanCode::Right => 0x0072,
-        ScanCode::Down => 0x0074,
-        ScanCode::PageUp => 0x0070,
-        ScanCode::PageDown => 0x0075,
-        ScanCode::End => 0x0073,
-        ScanCode::Home => 0x006e,
-        ScanCode::Tab => 0x0017,
-        ScanCode::Enter => 0x0024,
-        ScanCode::Escape => 0x0009,
-        ScanCode::Space => 0x0041,
-        ScanCode::Backspace => 0x0016,
-        ScanCode::Delete => 0x0077,
-        ScanCode::Insert => 0x0076,
-    })
-}
-
-#[cfg(not(any(feature = "wayland", feature = "x11")))]
-pub(crate) struct LinuxKeyboardMapper;
-
-#[cfg(not(any(feature = "wayland", feature = "x11")))]
-impl PlatformKeyboardMapper for LinuxKeyboardMapper {
-    fn scan_code_to_key(
-        &self,
-        _scan_code: ScanCode,
-        _modifiers: &mut Modifiers,
-    ) -> anyhow::Result<String> {
-        Err(anyhow::anyhow!("LinuxKeyboardMapper not supported"))
-    }
-}
-
-#[cfg(not(any(feature = "wayland", feature = "x11")))]
-impl LinuxKeyboardMapper {
-    pub(crate) fn new() -> Self {
-        Self
-    }
-}

crates/gpui/src/platform/linux/platform.rs

@@ -25,9 +25,8 @@ use xkbcommon::xkb::{self, Keycode, Keysym, State};
 use crate::{
     Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DisplayId,
     ForegroundExecutor, Keymap, LinuxDispatcher, Menu, MenuItem, OwnedMenu, PathPromptOptions,
-    Pixels, Platform, PlatformDisplay, PlatformKeyboardLayout, PlatformKeyboardMapper,
-    PlatformTextSystem, PlatformWindow, Point, Result, ScreenCaptureSource, Task, WindowAppearance,
-    WindowParams, px,
+    Pixels, Platform, PlatformDisplay, PlatformKeyboardLayout, PlatformTextSystem, PlatformWindow,
+    Point, Result, ScreenCaptureSource, Task, WindowAppearance, WindowParams, px,
 };
 
 #[cfg(any(feature = "wayland", feature = "x11"))]
@@ -139,10 +138,6 @@ impl<P: LinuxClient + 'static> Platform for P {
         self.with_common(|common| common.text_system.clone())
     }
 
-    fn keyboard_mapper(&self) -> Box<dyn PlatformKeyboardMapper> {
-        Box::new(super::LinuxKeyboardMapper::new())
-    }
-
     fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout> {
         self.keyboard_layout()
     }

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

@@ -1,14 +1,21 @@
 use crate::{
-    CMD_MOD, KeyDownEvent, KeyUpEvent, Keystroke, Modifiers, ModifiersChangedEvent, MouseButton,
-    MouseDownEvent, MouseExitEvent, MouseMoveEvent, MouseUpEvent, NO_MOD, NavigationDirection,
-    OPTION_MOD, Pixels, PlatformInput, SHIFT_MOD, ScrollDelta, ScrollWheelEvent, TouchPhase,
-    always_use_command_layout, chars_for_modified_key, platform::mac::NSStringExt, point, px,
+    KeyDownEvent, KeyUpEvent, Keystroke, Modifiers, ModifiersChangedEvent, MouseButton,
+    MouseDownEvent, MouseExitEvent, MouseMoveEvent, MouseUpEvent, NavigationDirection, Pixels,
+    PlatformInput, ScrollDelta, ScrollWheelEvent, TouchPhase,
+    platform::mac::{
+        LMGetKbdType, NSStringExt, TISCopyCurrentKeyboardLayoutInputSource,
+        TISGetInputSourceProperty, UCKeyTranslate, kTISPropertyUnicodeKeyLayoutData,
+    },
+    point, px,
 };
 use cocoa::{
     appkit::{NSEvent, NSEventModifierFlags, NSEventPhase, NSEventType},
     base::{YES, id},
 };
-use std::borrow::Cow;
+use core_foundation::data::{CFDataGetBytePtr, CFDataRef};
+use core_graphics::event::CGKeyCode;
+use objc::{msg_send, sel, sel_impl};
+use std::{borrow::Cow, ffi::c_void};
 
 const BACKSPACE_KEY: u16 = 0x7f;
 const SPACE_KEY: u16 = b' ' as u16;
@@ -18,7 +25,7 @@ pub(crate) const ESCAPE_KEY: u16 = 0x1b;
 const TAB_KEY: u16 = 0x09;
 const SHIFT_TAB_KEY: u16 = 0x19;
 
-pub fn key_to_native(key: &str) -> Cow<'_, str> {
+pub fn key_to_native(key: &str) -> Cow<str> {
     use cocoa::appkit::*;
     let code = match key {
         "space" => SPACE_KEY,
@@ -445,3 +452,80 @@ unsafe fn parse_keystroke(native_event: id) -> Keystroke {
         }
     }
 }
+
+fn always_use_command_layout() -> bool {
+    if chars_for_modified_key(0, NO_MOD).is_ascii() {
+        return false;
+    }
+
+    chars_for_modified_key(0, CMD_MOD).is_ascii()
+}
+
+const NO_MOD: u32 = 0;
+const CMD_MOD: u32 = 1;
+const SHIFT_MOD: u32 = 2;
+const OPTION_MOD: u32 = 8;
+
+fn chars_for_modified_key(code: CGKeyCode, modifiers: u32) -> String {
+    // Values from: https://github.com/phracker/MacOSX-SDKs/blob/master/MacOSX10.6.sdk/System/Library/Frameworks/Carbon.framework/Versions/A/Frameworks/HIToolbox.framework/Versions/A/Headers/Events.h#L126
+    // shifted >> 8 for UCKeyTranslate
+    const CG_SPACE_KEY: u16 = 49;
+    // https://github.com/phracker/MacOSX-SDKs/blob/master/MacOSX10.6.sdk/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/CarbonCore.framework/Versions/A/Headers/UnicodeUtilities.h#L278
+    #[allow(non_upper_case_globals)]
+    const kUCKeyActionDown: u16 = 0;
+    #[allow(non_upper_case_globals)]
+    const kUCKeyTranslateNoDeadKeysMask: u32 = 0;
+
+    let keyboard_type = unsafe { LMGetKbdType() as u32 };
+    const BUFFER_SIZE: usize = 4;
+    let mut dead_key_state = 0;
+    let mut buffer: [u16; BUFFER_SIZE] = [0; BUFFER_SIZE];
+    let mut buffer_size: usize = 0;
+
+    let keyboard = unsafe { TISCopyCurrentKeyboardLayoutInputSource() };
+    if keyboard.is_null() {
+        return "".to_string();
+    }
+    let layout_data = unsafe {
+        TISGetInputSourceProperty(keyboard, kTISPropertyUnicodeKeyLayoutData as *const c_void)
+            as CFDataRef
+    };
+    if layout_data.is_null() {
+        unsafe {
+            let _: () = msg_send![keyboard, release];
+        }
+        return "".to_string();
+    }
+    let keyboard_layout = unsafe { CFDataGetBytePtr(layout_data) };
+
+    unsafe {
+        UCKeyTranslate(
+            keyboard_layout as *const c_void,
+            code,
+            kUCKeyActionDown,
+            modifiers,
+            keyboard_type,
+            kUCKeyTranslateNoDeadKeysMask,
+            &mut dead_key_state,
+            BUFFER_SIZE,
+            &mut buffer_size as *mut usize,
+            &mut buffer as *mut u16,
+        );
+        if dead_key_state != 0 {
+            UCKeyTranslate(
+                keyboard_layout as *const c_void,
+                CG_SPACE_KEY,
+                kUCKeyActionDown,
+                modifiers,
+                keyboard_type,
+                kUCKeyTranslateNoDeadKeysMask,
+                &mut dead_key_state,
+                BUFFER_SIZE,
+                &mut buffer_size as *mut usize,
+                &mut buffer as *mut u16,
+            );
+        }
+        let _: () = msg_send![keyboard, release];
+    }
+    String::from_utf16(&buffer[..buffer_size]).unwrap_or_default()
+}

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

@@ -1,14 +1,8 @@
 use std::ffi::{CStr, c_void};
 
-use collections::HashMap;
-use core_foundation::data::{CFDataGetBytePtr, CFDataRef};
-use core_graphics::event::CGKeyCode;
 use objc::{msg_send, runtime::Object, sel, sel_impl};
 
-use crate::{
-    Modifiers, PlatformKeyboardLayout, PlatformKeyboardMapper, ScanCode, is_letter_key,
-    platform::mac::{LMGetKbdType, UCKeyTranslate, kTISPropertyUnicodeKeyLayoutData},
-};
+use crate::PlatformKeyboardLayout;
 
 use super::{
     TISCopyCurrentKeyboardLayoutInputSource, TISGetInputSourceProperty, kTISPropertyInputSourceID,
@@ -53,300 +47,3 @@ impl MacKeyboardLayout {
         }
     }
 }
-
-pub(crate) struct MacKeyboardMapper {
-    code_to_key: HashMap<u16, String>,
-    code_to_shifted_key: HashMap<u16, String>,
-}
-
-impl MacKeyboardMapper {
-    pub(crate) fn new() -> Self {
-        let mut code_to_key = HashMap::default();
-        let mut code_to_shifted_key = HashMap::default();
-
-        let always_use_cmd_layout = always_use_command_layout();
-        for &scan_code in TYPEABLE_CODES.iter() {
-            let (key, shifted_key) = generate_key_pairs(scan_code, always_use_cmd_layout);
-            if !is_letter_key(&key) {
-                code_to_shifted_key.insert(scan_code, shifted_key);
-            }
-            code_to_key.insert(scan_code, key);
-        }
-
-        Self {
-            code_to_key,
-            code_to_shifted_key,
-        }
-    }
-}
-
-impl PlatformKeyboardMapper for MacKeyboardMapper {
-    fn scan_code_to_key(
-        &self,
-        scan_code: ScanCode,
-        modifiers: &mut Modifiers,
-    ) -> anyhow::Result<String> {
-        if let Some(key) = scan_code.try_to_key() {
-            return Ok(key);
-        }
-        let native_scan_code = get_scan_code(scan_code)
-            .ok_or_else(|| anyhow::anyhow!("Unsupported scan code: {:?}", scan_code))?;
-        let key = self.code_to_key.get(&native_scan_code).ok_or_else(|| {
-            anyhow::anyhow!("Key not found for scan code: {:?}", native_scan_code)
-        })?;
-        if modifiers.shift && !is_letter_key(key) {
-            if let Some(key) = self.code_to_shifted_key.get(&native_scan_code) {
-                modifiers.shift = false;
-                return Ok(key.clone());
-            } else {
-                anyhow::bail!(
-                    "Shifted key not found for scan code: {:?}",
-                    native_scan_code
-                );
-            }
-        } else {
-            Ok(key.clone())
-        }
-    }
-}
-
-pub(crate) const NO_MOD: u32 = 0;
-pub(crate) const CMD_MOD: u32 = 1;
-pub(crate) const SHIFT_MOD: u32 = 2;
-pub(crate) const OPTION_MOD: u32 = 8;
-
-pub(crate) fn chars_for_modified_key(code: CGKeyCode, modifiers: u32) -> String {
-    // Values from: https://github.com/phracker/MacOSX-SDKs/blob/master/MacOSX10.6.sdk/System/Library/Frameworks/Carbon.framework/Versions/A/Frameworks/HIToolbox.framework/Versions/A/Headers/Events.h#L126
-    // shifted >> 8 for UCKeyTranslate
-    const CG_SPACE_KEY: u16 = 49;
-    // https://github.com/phracker/MacOSX-SDKs/blob/master/MacOSX10.6.sdk/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/CarbonCore.framework/Versions/A/Headers/UnicodeUtilities.h#L278
-    #[allow(non_upper_case_globals)]
-    const kUCKeyActionDown: u16 = 0;
-    #[allow(non_upper_case_globals)]
-    const kUCKeyTranslateNoDeadKeysMask: u32 = 0;
-
-    let keyboard_type = unsafe { LMGetKbdType() as u32 };
-    const BUFFER_SIZE: usize = 4;
-    let mut dead_key_state = 0;
-    let mut buffer: [u16; BUFFER_SIZE] = [0; BUFFER_SIZE];
-    let mut buffer_size: usize = 0;
-
-    let keyboard = unsafe { TISCopyCurrentKeyboardLayoutInputSource() };
-    if keyboard.is_null() {
-        return "".to_string();
-    }
-    let layout_data = unsafe {
-        TISGetInputSourceProperty(keyboard, kTISPropertyUnicodeKeyLayoutData as *const c_void)
-            as CFDataRef
-    };
-    if layout_data.is_null() {
-        unsafe {
-            let _: () = msg_send![keyboard, release];
-        }
-        return "".to_string();
-    }
-    let keyboard_layout = unsafe { CFDataGetBytePtr(layout_data) };
-
-    unsafe {
-        UCKeyTranslate(
-            keyboard_layout as *const c_void,
-            code,
-            kUCKeyActionDown,
-            modifiers,
-            keyboard_type,
-            kUCKeyTranslateNoDeadKeysMask,
-            &mut dead_key_state,
-            BUFFER_SIZE,
-            &mut buffer_size as *mut usize,
-            &mut buffer as *mut u16,
-        );
-        if dead_key_state != 0 {
-            UCKeyTranslate(
-                keyboard_layout as *const c_void,
-                CG_SPACE_KEY,
-                kUCKeyActionDown,
-                modifiers,
-                keyboard_type,
-                kUCKeyTranslateNoDeadKeysMask,
-                &mut dead_key_state,
-                BUFFER_SIZE,
-                &mut buffer_size as *mut usize,
-                &mut buffer as *mut u16,
-            );
-        }
-        let _: () = msg_send![keyboard, release];
-    }
-    String::from_utf16(&buffer[..buffer_size]).unwrap_or_default()
-}
-
-pub(crate) fn always_use_command_layout() -> bool {
-    if chars_for_modified_key(0, NO_MOD).is_ascii() {
-        return false;
-    }
-
-    chars_for_modified_key(0, CMD_MOD).is_ascii()
-}
-
-fn generate_key_pairs(scan_code: u16, always_use_cmd_layout: bool) -> (String, String) {
-    let mut chars_ignoring_modifiers = chars_for_modified_key(scan_code, NO_MOD);
-    let mut chars_with_shift = chars_for_modified_key(scan_code, SHIFT_MOD);
-
-    // Handle Dvorak+QWERTY / Russian / Armenian
-    if always_use_cmd_layout {
-        let chars_with_cmd = chars_for_modified_key(scan_code, CMD_MOD);
-        let chars_with_both = chars_for_modified_key(scan_code, CMD_MOD | SHIFT_MOD);
-
-        // We don't do this in the case that the shifted command key generates
-        // the same character as the unshifted command key (Norwegian, e.g.)
-        if chars_with_both != chars_with_cmd {
-            chars_with_shift = chars_with_both;
-
-        // Handle edge-case where cmd-shift-s reports cmd-s instead of
-        // cmd-shift-s (Ukrainian, etc.)
-        } else if chars_with_cmd.to_ascii_uppercase() != chars_with_cmd {
-            chars_with_shift = chars_with_cmd.to_ascii_uppercase();
-        }
-        chars_ignoring_modifiers = chars_with_cmd;
-    }
-    (chars_ignoring_modifiers, chars_with_shift)
-}
-
-// All typeable scan codes for the standard US keyboard layout, ANSI104
-const TYPEABLE_CODES: &[u16] = &[
-    0x0000, // a
-    0x000b, // b
-    0x0008, // c
-    0x0002, // d
-    0x000e, // e
-    0x0003, // f
-    0x0005, // g
-    0x0004, // h
-    0x0022, // i
-    0x0026, // j
-    0x0028, // k
-    0x0025, // l
-    0x002e, // m
-    0x002d, // n
-    0x001f, // o
-    0x0023, // p
-    0x000c, // q
-    0x000f, // r
-    0x0001, // s
-    0x0011, // t
-    0x0020, // u
-    0x0009, // v
-    0x000d, // w
-    0x0007, // x
-    0x0010, // y
-    0x0006, // z
-    0x001d, // Digit 0
-    0x0012, // Digit 1
-    0x0013, // Digit 2
-    0x0014, // Digit 3
-    0x0015, // Digit 4
-    0x0017, // Digit 5
-    0x0016, // Digit 6
-    0x001a, // Digit 7
-    0x001c, // Digit 8
-    0x0019, // Digit 9
-    0x0032, // ` Tilde
-    0x001b, // - Minus
-    0x0018, // = Equal
-    0x0021, // [ Left bracket
-    0x001e, // ] Right bracket
-    0x002a, // \ Backslash
-    0x0029, // ; Semicolon
-    0x0027, // ' Quote
-    0x002b, // , Comma
-    0x002f, // . Period
-    0x002c, // / Slash
-];
-
-fn get_scan_code(scan_code: ScanCode) -> Option<u16> {
-    // https://github.com/microsoft/node-native-keymap/blob/main/deps/chromium/dom_code_data.inc
-    Some(match scan_code {
-        ScanCode::F1 => 0x007a,
-        ScanCode::F2 => 0x0078,
-        ScanCode::F3 => 0x0063,
-        ScanCode::F4 => 0x0076,
-        ScanCode::F5 => 0x0060,
-        ScanCode::F6 => 0x0061,
-        ScanCode::F7 => 0x0062,
-        ScanCode::F8 => 0x0064,
-        ScanCode::F9 => 0x0065,
-        ScanCode::F10 => 0x006d,
-        ScanCode::F11 => 0x0067,
-        ScanCode::F12 => 0x006f,
-        ScanCode::F13 => 0x0069,
-        ScanCode::F14 => 0x006b,
-        ScanCode::F15 => 0x0071,
-        ScanCode::F16 => 0x006a,
-        ScanCode::F17 => 0x0040,
-        ScanCode::F18 => 0x004f,
-        ScanCode::F19 => 0x0050,
-        ScanCode::F20 => 0x005a,
-        ScanCode::F21 | ScanCode::F22 | ScanCode::F23 | ScanCode::F24 => return None,
-        ScanCode::A => 0x0000,
-        ScanCode::B => 0x000b,
-        ScanCode::C => 0x0008,
-        ScanCode::D => 0x0002,
-        ScanCode::E => 0x000e,
-        ScanCode::F => 0x0003,
-        ScanCode::G => 0x0005,
-        ScanCode::H => 0x0004,
-        ScanCode::I => 0x0022,
-        ScanCode::J => 0x0026,
-        ScanCode::K => 0x0028,
-        ScanCode::L => 0x0025,
-        ScanCode::M => 0x002e,
-        ScanCode::N => 0x002d,
-        ScanCode::O => 0x001f,
-        ScanCode::P => 0x0023,
-        ScanCode::Q => 0x000c,
-        ScanCode::R => 0x000f,
-        ScanCode::S => 0x0001,
-        ScanCode::T => 0x0011,
-        ScanCode::U => 0x0020,
-        ScanCode::V => 0x0009,
-        ScanCode::W => 0x000d,
-        ScanCode::X => 0x0007,
-        ScanCode::Y => 0x0010,
-        ScanCode::Z => 0x0006,
-        ScanCode::Digit0 => 0x001d,
-        ScanCode::Digit1 => 0x0012,
-        ScanCode::Digit2 => 0x0013,
-        ScanCode::Digit3 => 0x0014,
-        ScanCode::Digit4 => 0x0015,
-        ScanCode::Digit5 => 0x0017,
-        ScanCode::Digit6 => 0x0016,
-        ScanCode::Digit7 => 0x001a,
-        ScanCode::Digit8 => 0x001c,
-        ScanCode::Digit9 => 0x0019,
-        ScanCode::Backquote => 0x0032,
-        ScanCode::Minus => 0x001b,
-        ScanCode::Equal => 0x0018,
-        ScanCode::BracketLeft => 0x0021,
-        ScanCode::BracketRight => 0x001e,
-        ScanCode::Backslash => 0x002a,
-        ScanCode::Semicolon => 0x0029,
-        ScanCode::Quote => 0x0027,
-        ScanCode::Comma => 0x002b,
-        ScanCode::Period => 0x002f,
-        ScanCode::Slash => 0x002c,
-        ScanCode::Left => 0x007b,
-        ScanCode::Up => 0x007e,
-        ScanCode::Right => 0x007c,
-        ScanCode::Down => 0x007d,
-        ScanCode::PageUp => 0x0074,
-        ScanCode::PageDown => 0x0079,
-        ScanCode::End => 0x0077,
-        ScanCode::Home => 0x0073,
-        ScanCode::Tab => 0x0030,
-        ScanCode::Enter => 0x0024,
-        ScanCode::Escape => 0x0035,
-        ScanCode::Space => 0x0031,
-        ScanCode::Backspace => 0x0033,
-        ScanCode::Delete => 0x0075,
-        ScanCode::Insert => 0x0072,
-    })
-}

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

@@ -7,10 +7,9 @@ use super::{
 use crate::{
     Action, AnyWindowHandle, BackgroundExecutor, ClipboardEntry, ClipboardItem, ClipboardString,
     CursorStyle, ForegroundExecutor, Image, ImageFormat, KeyContext, Keymap, MacDispatcher,
-    MacDisplay, MacKeyboardMapper, MacWindow, Menu, MenuItem, PathPromptOptions, Platform,
-    PlatformDisplay, PlatformKeyboardLayout, PlatformKeyboardMapper, PlatformTextSystem,
-    PlatformWindow, Result, ScreenCaptureSource, SemanticVersion, Task, WindowAppearance,
-    WindowParams, hash,
+    MacDisplay, MacWindow, Menu, MenuItem, PathPromptOptions, Platform, PlatformDisplay,
+    PlatformKeyboardLayout, PlatformTextSystem, PlatformWindow, Result, ScreenCaptureSource,
+    SemanticVersion, Task, WindowAppearance, WindowParams, hash,
 };
 use anyhow::{Context as _, anyhow};
 use block::ConcreteBlock;
@@ -847,10 +846,6 @@ impl Platform for MacPlatform {
         self.0.lock().validate_menu_command = Some(callback);
     }
 
-    fn keyboard_mapper(&self) -> Box<dyn PlatformKeyboardMapper> {
-        Box::new(MacKeyboardMapper::new())
-    }
-
     fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout> {
         Box::new(MacKeyboardLayout::new())
     }

crates/gpui/src/platform/test/platform.rs

@@ -1,9 +1,8 @@
 use crate::{
     AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DevicePixels,
     ForegroundExecutor, Keymap, NoopTextSystem, Platform, PlatformDisplay, PlatformKeyboardLayout,
-    PlatformKeyboardMapper, PlatformTextSystem, PromptButton, ScreenCaptureFrame,
-    ScreenCaptureSource, ScreenCaptureStream, Size, Task, TestDisplay, TestKeyboardMapper,
-    TestWindow, WindowAppearance, WindowParams, size,
+    PlatformTextSystem, PromptButton, ScreenCaptureFrame, ScreenCaptureSource, ScreenCaptureStream,
+    Size, Task, TestDisplay, TestWindow, WindowAppearance, WindowParams, size,
 };
 use anyhow::Result;
 use collections::VecDeque;
@@ -224,10 +223,6 @@ impl Platform for TestPlatform {
         self.text_system.clone()
     }
 
-    fn keyboard_mapper(&self) -> Box<dyn PlatformKeyboardMapper> {
-        Box::new(TestKeyboardMapper::new())
-    }
-
     fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout> {
         Box::new(TestKeyboardLayout)
     }

crates/gpui/src/platform/windows/events.rs

@@ -702,7 +702,7 @@ fn handle_ime_composition_inner(
     } else {
         if lparam & GCS_COMPSTR.0 > 0 {
             let comp_string = parse_ime_composition_string(ctx, GCS_COMPSTR)?;
-            let caret_pos = (!comp_string.is_empty() && lparam & GCS_CURSORPOS.0 > 0).then(|| {
+            let caret_pos = (lparam & GCS_CURSORPOS.0 > 0).then(|| {
                 let pos = retrieve_composition_cursor_position(ctx);
                 pos..pos
             });

crates/gpui/src/platform/windows/keyboard.rs

@@ -1,16 +1,16 @@
-use anyhow::{Context, Result};
+use anyhow::Result;
 use windows::Win32::UI::{
     Input::KeyboardAndMouse::{
-        GetKeyboardLayoutNameW, MAPVK_VK_TO_CHAR, MAPVK_VSC_TO_VK, MapVirtualKeyW, ToUnicode,
-        VIRTUAL_KEY, VK_0, VK_1, VK_2, VK_3, VK_4, VK_5, VK_6, VK_7, VK_8, VK_9, VK_ABNT_C1,
-        VK_CONTROL, VK_MENU, VK_OEM_1, VK_OEM_2, VK_OEM_3, VK_OEM_4, VK_OEM_5, VK_OEM_6, VK_OEM_7,
-        VK_OEM_8, VK_OEM_102, VK_OEM_COMMA, VK_OEM_MINUS, VK_OEM_PERIOD, VK_OEM_PLUS, VK_SHIFT,
+        GetKeyboardLayoutNameW, MAPVK_VK_TO_CHAR, MapVirtualKeyW, ToUnicode, VIRTUAL_KEY, VK_0,
+        VK_1, VK_2, VK_3, VK_4, VK_5, VK_6, VK_7, VK_8, VK_9, VK_ABNT_C1, VK_CONTROL, VK_MENU,
+        VK_OEM_1, VK_OEM_2, VK_OEM_3, VK_OEM_4, VK_OEM_5, VK_OEM_6, VK_OEM_7, VK_OEM_8, VK_OEM_102,
+        VK_OEM_COMMA, VK_OEM_MINUS, VK_OEM_PERIOD, VK_OEM_PLUS, VK_SHIFT,
     },
     WindowsAndMessaging::KL_NAMELENGTH,
 };
 use windows_core::HSTRING;
 
-use crate::{Modifiers, PlatformKeyboardLayout, PlatformKeyboardMapper, ScanCode};
+use crate::{Modifiers, PlatformKeyboardLayout};
 
 pub(crate) struct WindowsKeyboardLayout {
     id: String,
@@ -48,29 +48,6 @@ impl WindowsKeyboardLayout {
     }
 }
 
-pub(crate) struct WindowsKeyboardMapper;
-
-impl PlatformKeyboardMapper for WindowsKeyboardMapper {
-    fn scan_code_to_key(&self, scan_code: ScanCode, modifiers: &mut Modifiers) -> Result<String> {
-        if let Some(key) = scan_code.try_to_key() {
-            return Ok(key);
-        }
-        let (win_scan_code, vkey) = get_virtual_key_from_scan_code(scan_code)?;
-        get_keystroke_key(vkey, win_scan_code, modifiers).with_context(|| {
-            format!(
-                "Failed to get key from scan code: {:?}, vkey: {:?}",
-                scan_code, vkey
-            )
-        })
-    }
-}
-
-impl WindowsKeyboardMapper {
-    pub(crate) fn new() -> Self {
-        Self
-    }
-}
-
 pub(crate) fn get_keystroke_key(
     vkey: VIRTUAL_KEY,
     scan_code: u32,
@@ -105,15 +82,15 @@ fn need_to_convert_to_shifted_key(vkey: VIRTUAL_KEY) -> bool {
             | VK_OEM_MINUS
             | VK_OEM_PLUS
             | VK_OEM_4
-            | VK_OEM_6
             | VK_OEM_5
+            | VK_OEM_6
             | VK_OEM_1
             | VK_OEM_7
             | VK_OEM_COMMA
             | VK_OEM_PERIOD
             | VK_OEM_2
             | VK_OEM_102
-            | VK_OEM_8 // Same as VK_OEM_2
+            | VK_OEM_8
             | VK_ABNT_C1
             | VK_0
             | VK_1
@@ -161,66 +138,3 @@ pub(crate) fn generate_key_char(
     }
     None
 }
-
-fn get_virtual_key_from_scan_code(gpui_scan_code: ScanCode) -> Result<(u32, VIRTUAL_KEY)> {
-    // https://github.com/microsoft/node-native-keymap/blob/main/deps/chromium/dom_code_data.inc
-    let scan_code = match gpui_scan_code {
-        ScanCode::A => 0x001e,
-        ScanCode::B => 0x0030,
-        ScanCode::C => 0x002e,
-        ScanCode::D => 0x0020,
-        ScanCode::E => 0x0012,
-        ScanCode::F => 0x0021,
-        ScanCode::G => 0x0022,
-        ScanCode::H => 0x0023,
-        ScanCode::I => 0x0017,
-        ScanCode::J => 0x0024,
-        ScanCode::K => 0x0025,
-        ScanCode::L => 0x0026,
-        ScanCode::M => 0x0032,
-        ScanCode::N => 0x0031,
-        ScanCode::O => 0x0018,
-        ScanCode::P => 0x0019,
-        ScanCode::Q => 0x0010,
-        ScanCode::R => 0x0013,
-        ScanCode::S => 0x001f,
-        ScanCode::T => 0x0014,
-        ScanCode::U => 0x0016,
-        ScanCode::V => 0x002f,
-        ScanCode::W => 0x0011,
-        ScanCode::X => 0x002d,
-        ScanCode::Y => 0x0015,
-        ScanCode::Z => 0x002c,
-        ScanCode::Digit0 => 0x000b,
-        ScanCode::Digit1 => 0x0002,
-        ScanCode::Digit2 => 0x0003,
-        ScanCode::Digit3 => 0x0004,
-        ScanCode::Digit4 => 0x0005,
-        ScanCode::Digit5 => 0x0006,
-        ScanCode::Digit6 => 0x0007,
-        ScanCode::Digit7 => 0x0008,
-        ScanCode::Digit8 => 0x0009,
-        ScanCode::Digit9 => 0x000a,
-        ScanCode::Backquote => 0x0029,
-        ScanCode::Minus => 0x000c,
-        ScanCode::Equal => 0x000d,
-        ScanCode::BracketLeft => 0x001a,
-        ScanCode::BracketRight => 0x001b,
-        ScanCode::Backslash => 0x002b,
-        ScanCode::Semicolon => 0x0027,
-        ScanCode::Quote => 0x0028,
-        ScanCode::Comma => 0x0033,
-        ScanCode::Period => 0x0034,
-        ScanCode::Slash => 0x0035,
-        _ => anyhow::bail!("Unsupported scan code: {:?}", gpui_scan_code),
-    };
-    let virtual_key = unsafe { MapVirtualKeyW(scan_code, MAPVK_VSC_TO_VK) };
-    if virtual_key == 0 {
-        anyhow::bail!(
-            "Failed to get virtual key from scan code: {:?}, {}",
-            gpui_scan_code,
-            scan_code
-        );
-    }
-    Ok((scan_code, VIRTUAL_KEY(virtual_key as u16)))
-}

crates/gpui/src/platform/windows/platform.rs

@@ -310,10 +310,6 @@ impl Platform for WindowsPlatform {
         self.text_system.clone()
     }
 
-    fn keyboard_mapper(&self) -> Box<dyn PlatformKeyboardMapper> {
-        Box::new(WindowsKeyboardMapper::new())
-    }
-
     fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout> {
         Box::new(
             WindowsKeyboardLayout::new()

crates/gpui/src/scene.rs

@@ -149,7 +149,7 @@ impl Scene {
         ),
         allow(dead_code)
     )]
-    pub(crate) fn batches(&self) -> impl Iterator<Item = PrimitiveBatch<'_>> {
+    pub(crate) fn batches(&self) -> impl Iterator<Item = PrimitiveBatch> {
         BatchIterator {
             shadows: &self.shadows,
             shadows_start: 0,

crates/gpui/src/text_system/line_layout.rs

@@ -616,7 +616,7 @@ impl Hash for (dyn AsCacheKeyRef + '_) {
 }
 
 impl AsCacheKeyRef for CacheKey {
-    fn as_cache_key_ref(&self) -> CacheKeyRef<'_> {
+    fn as_cache_key_ref(&self) -> CacheKeyRef {
         CacheKeyRef {
             text: &self.text,
             font_size: self.font_size,
@@ -645,7 +645,7 @@ impl<'a> Borrow<dyn AsCacheKeyRef + 'a> for Arc<CacheKey> {
 }
 
 impl AsCacheKeyRef for CacheKeyRef<'_> {
-    fn as_cache_key_ref(&self) -> CacheKeyRef<'_> {
+    fn as_cache_key_ref(&self) -> CacheKeyRef {
         *self
     }
 }

crates/language/src/buffer.rs

@@ -1874,12 +1874,9 @@ impl Buffer {
     }
 
     /// Ensures that the buffer ends with a single newline character, and
-    /// no other whitespace. Skips if the buffer is empty.
+    /// no other whitespace.
     pub fn ensure_final_newline(&mut self, cx: &mut Context<Self>) {
         let len = self.len();
-        if len == 0 {
-            return;
-        }
         let mut offset = len;
         for chunk in self.as_rope().reversed_chunks_in_range(0..len) {
             let non_whitespace_len = chunk
@@ -3130,7 +3127,7 @@ impl BufferSnapshot {
         None
     }
 
-    fn get_highlights(&self, range: Range<usize>) -> (SyntaxMapCaptures<'_>, Vec<HighlightMap>) {
+    fn get_highlights(&self, range: Range<usize>) -> (SyntaxMapCaptures, Vec<HighlightMap>) {
         let captures = self.syntax.captures(range, &self.text, |grammar| {
             grammar.highlights_query.as_ref()
         });
@@ -3146,7 +3143,7 @@ impl BufferSnapshot {
     /// in an arbitrary way due to being stored in a [`Rope`](text::Rope). The text is also
     /// returned in chunks where each chunk has a single syntax highlighting style and
     /// diagnostic status.
-    pub fn chunks<T: ToOffset>(&self, range: Range<T>, language_aware: bool) -> BufferChunks<'_> {
+    pub fn chunks<T: ToOffset>(&self, range: Range<T>, language_aware: bool) -> BufferChunks {
         let range = range.start.to_offset(self)..range.end.to_offset(self);
 
         let mut syntax = None;
@@ -3195,12 +3192,12 @@ impl BufferSnapshot {
     }
 
     /// Iterates over every [`SyntaxLayer`] in the buffer.
-    pub fn syntax_layers(&self) -> impl Iterator<Item = SyntaxLayer<'_>> + '_ {
+    pub fn syntax_layers(&self) -> impl Iterator<Item = SyntaxLayer> + '_ {
         self.syntax
             .layers_for_range(0..self.len(), &self.text, true)
     }
 
-    pub fn syntax_layer_at<D: ToOffset>(&self, position: D) -> Option<SyntaxLayer<'_>> {
+    pub fn syntax_layer_at<D: ToOffset>(&self, position: D) -> Option<SyntaxLayer> {
         let offset = position.to_offset(self);
         self.syntax
             .layers_for_range(offset..offset, &self.text, false)
@@ -3211,7 +3208,7 @@ impl BufferSnapshot {
     pub fn smallest_syntax_layer_containing<D: ToOffset>(
         &self,
         range: Range<D>,
-    ) -> Option<SyntaxLayer<'_>> {
+    ) -> Option<SyntaxLayer> {
         let range = range.to_offset(self);
         return self
             .syntax
@@ -3429,7 +3426,7 @@ impl BufferSnapshot {
     }
 
     /// Returns the root syntax node within the given row
-    pub fn syntax_root_ancestor(&self, position: Anchor) -> Option<tree_sitter::Node<'_>> {
+    pub fn syntax_root_ancestor(&self, position: Anchor) -> Option<tree_sitter::Node> {
         let start_offset = position.to_offset(self);
 
         let row = self.summary_for_anchor::<text::PointUtf16>(&position).row as usize;
@@ -3766,7 +3763,7 @@ impl BufferSnapshot {
         &self,
         range: Range<usize>,
         query: fn(&Grammar) -> Option<&tree_sitter::Query>,
-    ) -> SyntaxMapMatches<'_> {
+    ) -> SyntaxMapMatches {
         self.syntax.matches(range, self, query)
     }
 

crates/language/src/language_settings.rs

@@ -765,8 +765,6 @@ pub enum ShowWhitespaceSetting {
     /// - It is adjacent to an edge (start or end)
     /// - It is adjacent to a whitespace (left or right)
     Boundary,
-    /// Draw whitespaces only after non-whitespace characters.
-    Trailing,
 }
 
 /// Controls which formatter should be used when formatting code.
@@ -1454,8 +1452,7 @@ impl settings::Settings for AllLanguageSettings {
         vscode.bool_setting("editor.inlineSuggest.enabled", &mut d.show_edit_predictions);
         vscode.enum_setting("editor.renderWhitespace", &mut d.show_whitespaces, |s| {
             Some(match s {
-                "boundary" => ShowWhitespaceSetting::Boundary,
-                "trailing" => ShowWhitespaceSetting::Trailing,
+                "boundary" | "trailing" => ShowWhitespaceSetting::Boundary,
                 "selection" => ShowWhitespaceSetting::Selection,
                 "all" => ShowWhitespaceSetting::All,
                 _ => ShowWhitespaceSetting::None,

crates/language/src/syntax_map.rs

@@ -1126,7 +1126,7 @@ impl<'a> SyntaxMapMatches<'a> {
         &self.grammars
     }
 
-    pub fn peek(&self) -> Option<SyntaxMapMatch<'_>> {
+    pub fn peek(&self) -> Option<SyntaxMapMatch> {
         let layer = self.layers.first()?;
 
         if !layer.has_next {
@@ -1550,7 +1550,7 @@ fn insert_newlines_between_ranges(
 
 impl OwnedSyntaxLayer {
     /// Returns the root syntax node for this layer.
-    pub fn node(&self) -> Node<'_> {
+    pub fn node(&self) -> Node {
         self.tree
             .root_node_with_offset(self.offset.0, self.offset.1)
     }

crates/language_model/src/fake_provider.rs

@@ -185,7 +185,6 @@ impl LanguageModel for FakeLanguageModel {
         'static,
         Result<
             BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
-            LanguageModelCompletionError,
         >,
     > {
         let (tx, rx) = mpsc::unbounded();

crates/language_model/src/language_model.rs

@@ -22,7 +22,6 @@ use std::fmt;
 use std::ops::{Add, Sub};
 use std::str::FromStr as _;
 use std::sync::Arc;
-use std::time::Duration;
 use thiserror::Error;
 use util::serde::is_default;
 use zed_llm_client::{
@@ -75,8 +74,6 @@ pub enum LanguageModelCompletionEvent {
 
 #[derive(Error, Debug)]
 pub enum LanguageModelCompletionError {
-    #[error("rate limit exceeded, retry after {0:?}")]
-    RateLimit(Duration),
     #[error("received bad input JSON")]
     BadInputJson {
         id: LanguageModelToolUseId,
@@ -273,7 +270,6 @@ pub trait LanguageModel: Send + Sync {
         'static,
         Result<
             BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
-            LanguageModelCompletionError,
         >,
     >;
 
@@ -281,7 +277,7 @@ pub trait LanguageModel: Send + Sync {
         &self,
         request: LanguageModelRequest,
         cx: &AsyncApp,
-    ) -> BoxFuture<'static, Result<LanguageModelTextStream, LanguageModelCompletionError>> {
+    ) -> BoxFuture<'static, Result<LanguageModelTextStream>> {
         let future = self.stream_completion(request, cx);
 
         async move {

crates/language_model/src/rate_limiter.rs

@@ -1,3 +1,4 @@
+use anyhow::Result;
 use futures::Stream;
 use smol::lock::{Semaphore, SemaphoreGuardArc};
 use std::{
@@ -7,8 +8,6 @@ use std::{
     task::{Context, Poll},
 };
 
-use crate::LanguageModelCompletionError;
-
 #[derive(Clone)]
 pub struct RateLimiter {
     semaphore: Arc<Semaphore>,
@@ -37,12 +36,9 @@ impl RateLimiter {
         }
     }
 
-    pub fn run<'a, Fut, T>(
-        &self,
-        future: Fut,
-    ) -> impl 'a + Future<Output = Result<T, LanguageModelCompletionError>>
+    pub fn run<'a, Fut, T>(&self, future: Fut) -> impl 'a + Future<Output = Result<T>>
     where
-        Fut: 'a + Future<Output = Result<T, LanguageModelCompletionError>>,
+        Fut: 'a + Future<Output = Result<T>>,
     {
         let guard = self.semaphore.acquire_arc();
         async move {
@@ -56,12 +52,9 @@ impl RateLimiter {
     pub fn stream<'a, Fut, T>(
         &self,
         future: Fut,
-    ) -> impl 'a
-    + Future<
-        Output = Result<impl Stream<Item = T::Item> + use<Fut, T>, LanguageModelCompletionError>,
-    >
+    ) -> impl 'a + Future<Output = Result<impl Stream<Item = T::Item> + use<Fut, T>>>
     where
-        Fut: 'a + Future<Output = Result<T, LanguageModelCompletionError>>,
+        Fut: 'a + Future<Output = Result<T>>,
         T: Stream,
     {
         let guard = self.semaphore.acquire_arc();

crates/language_models/src/provider/anthropic.rs

@@ -387,34 +387,22 @@ impl AnthropicModel {
         &self,
         request: anthropic::Request,
         cx: &AsyncApp,
-    ) -> BoxFuture<
-        'static,
-        Result<
-            BoxStream<'static, Result<anthropic::Event, AnthropicError>>,
-            LanguageModelCompletionError,
-        >,
-    > {
+    ) -> BoxFuture<'static, Result<BoxStream<'static, Result<anthropic::Event, AnthropicError>>>>
+    {
         let http_client = self.http_client.clone();
 
         let Ok((api_key, api_url)) = cx.read_entity(&self.state, |state, cx| {
             let settings = &AllLanguageModelSettings::get_global(cx).anthropic;
             (state.api_key.clone(), settings.api_url.clone())
         }) else {
-            return futures::future::ready(Err(anyhow!("App state dropped").into())).boxed();
+            return futures::future::ready(Err(anyhow!("App state dropped"))).boxed();
         };
 
         async move {
             let api_key = api_key.context("Missing Anthropic API Key")?;
             let request =
                 anthropic::stream_completion(http_client.as_ref(), &api_url, &api_key, request);
-            request.await.map_err(|err| match err {
-                AnthropicError::RateLimit(duration) => {
-                    LanguageModelCompletionError::RateLimit(duration)
-                }
-                err @ (AnthropicError::ApiError(..) | AnthropicError::Other(..)) => {
-                    LanguageModelCompletionError::Other(anthropic_err_to_anyhow(err))
-                }
-            })
+            request.await.context("failed to stream completion")
         }
         .boxed()
     }
@@ -485,7 +473,6 @@ impl LanguageModel for AnthropicModel {
         'static,
         Result<
             BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
-            LanguageModelCompletionError,
         >,
     > {
         let request = into_anthropic(
@@ -497,7 +484,12 @@ impl LanguageModel for AnthropicModel {
         );
         let request = self.stream_completion(request, cx);
         let future = self.request_limiter.stream(async move {
-            let response = request.await?;
+            let response = request
+                .await
+                .map_err(|err| match err.downcast::<AnthropicError>() {
+                    Ok(anthropic_err) => anthropic_err_to_anyhow(anthropic_err),
+                    Err(err) => anyhow!(err),
+                })?;
             Ok(AnthropicEventMapper::new().map_stream(response))
         });
         async move { Ok(future.await?.boxed()) }.boxed()

crates/language_models/src/provider/bedrock.rs

@@ -527,7 +527,6 @@ impl LanguageModel for BedrockModel {
         'static,
         Result<
             BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
-            LanguageModelCompletionError,
         >,
     > {
         let Ok(region) = cx.read_entity(&self.state, |state, _cx| {
@@ -540,13 +539,16 @@ impl LanguageModel for BedrockModel {
                 .or(settings_region)
                 .unwrap_or(String::from("us-east-1"))
         }) else {
-            return async move { Err(anyhow::anyhow!("App State Dropped").into()) }.boxed();
+            return async move {
+                anyhow::bail!("App State Dropped");
+            }
+            .boxed();
         };
 
         let model_id = match self.model.cross_region_inference_id(&region) {
             Ok(s) => s,
             Err(e) => {
-                return async move { Err(e.into()) }.boxed();
+                return async move { Err(e) }.boxed();
             }
         };
 
@@ -558,7 +560,7 @@ impl LanguageModel for BedrockModel {
             self.model.mode(),
         ) {
             Ok(request) => request,
-            Err(err) => return futures::future::ready(Err(err.into())).boxed(),
+            Err(err) => return futures::future::ready(Err(err)).boxed(),
         };
 
         let owned_handle = self.handler.clone();

crates/language_models/src/provider/cloud.rs

@@ -807,7 +807,6 @@ impl LanguageModel for CloudLanguageModel {
         'static,
         Result<
             BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
-            LanguageModelCompletionError,
         >,
     > {
         let thread_id = request.thread_id.clone();
@@ -849,8 +848,7 @@ impl LanguageModel for CloudLanguageModel {
                             mode,
                             provider: zed_llm_client::LanguageModelProvider::Anthropic,
                             model: request.model.clone(),
-                            provider_request: serde_json::to_value(&request)
-                                .map_err(|e| anyhow!(e))?,
+                            provider_request: serde_json::to_value(&request)?,
                         },
                     )
                     .await
@@ -886,7 +884,7 @@ impl LanguageModel for CloudLanguageModel {
                 let client = self.client.clone();
                 let model = match open_ai::Model::from_id(&self.model.id.0) {
                     Ok(model) => model,
-                    Err(err) => return async move { Err(anyhow!(err).into()) }.boxed(),
+                    Err(err) => return async move { Err(anyhow!(err)) }.boxed(),
                 };
                 let request = into_open_ai(request, &model, None);
                 let llm_api_token = self.llm_api_token.clone();
@@ -907,8 +905,7 @@ impl LanguageModel for CloudLanguageModel {
                             mode,
                             provider: zed_llm_client::LanguageModelProvider::OpenAi,
                             model: request.model.clone(),
-                            provider_request: serde_json::to_value(&request)
-                                .map_err(|e| anyhow!(e))?,
+                            provider_request: serde_json::to_value(&request)?,
                         },
                     )
                     .await?;
@@ -947,8 +944,7 @@ impl LanguageModel for CloudLanguageModel {
                             mode,
                             provider: zed_llm_client::LanguageModelProvider::Google,
                             model: request.model.model_id.clone(),
-                            provider_request: serde_json::to_value(&request)
-                                .map_err(|e| anyhow!(e))?,
+                            provider_request: serde_json::to_value(&request)?,
                         },
                     )
                     .await?;

crates/language_models/src/provider/copilot_chat.rs

@@ -265,15 +265,13 @@ impl LanguageModel for CopilotChatLanguageModel {
         'static,
         Result<
             BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
-            LanguageModelCompletionError,
         >,
     > {
         if let Some(message) = request.messages.last() {
             if message.contents_empty() {
                 const EMPTY_PROMPT_MSG: &str =
                     "Empty prompts aren't allowed. Please provide a non-empty prompt.";
-                return futures::future::ready(Err(anyhow::anyhow!(EMPTY_PROMPT_MSG).into()))
-                    .boxed();
+                return futures::future::ready(Err(anyhow::anyhow!(EMPTY_PROMPT_MSG))).boxed();
             }
 
             // Copilot Chat has a restriction that the final message must be from the user.
@@ -281,13 +279,13 @@ impl LanguageModel for CopilotChatLanguageModel {
             // and provide a more helpful error message.
             if !matches!(message.role, Role::User) {
                 const USER_ROLE_MSG: &str = "The final message must be from the user. To provide a system prompt, you must provide the system prompt followed by a user prompt.";
-                return futures::future::ready(Err(anyhow::anyhow!(USER_ROLE_MSG).into())).boxed();
+                return futures::future::ready(Err(anyhow::anyhow!(USER_ROLE_MSG))).boxed();
             }
         }
 
         let copilot_request = match into_copilot_chat(&self.model, request) {
             Ok(request) => request,
-            Err(err) => return futures::future::ready(Err(err.into())).boxed(),
+            Err(err) => return futures::future::ready(Err(err)).boxed(),
         };
         let is_streaming = copilot_request.stream;
 
@@ -865,13 +863,6 @@ impl Render for ConfigurationView {
                                         copilot::initiate_sign_in(window, cx)
                                     })),
                             )
-                            .child(
-                                Label::new(
-                                    format!("You can also assign the {} environment variable and restart Zed.", copilot::copilot_chat::COPILOT_OAUTH_ENV_VAR),
-                                )
-                                .size(LabelSize::Small)
-                                .color(Color::Muted),
-                            )
                     }
                 },
                 None => v_flex().gap_6().child(Label::new(ERROR_LABEL)),

crates/language_models/src/provider/deepseek.rs

@@ -348,7 +348,6 @@ impl LanguageModel for DeepSeekLanguageModel {
         'static,
         Result<
             BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
-            LanguageModelCompletionError,
         >,
     > {
         let request = into_deepseek(request, &self.model, self.max_output_tokens());
@@ -373,15 +372,15 @@ pub fn into_deepseek(
     for message in request.messages {
         for content in message.content {
             match content {
-                MessageContent::Text(text) => messages.push(match message.role {
-                    Role::User => deepseek::RequestMessage::User { content: text },
-                    Role::Assistant => deepseek::RequestMessage::Assistant {
-                        content: Some(text),
-                        tool_calls: Vec::new(),
-                    },
-                    Role::System => deepseek::RequestMessage::System { content: text },
-                }),
-                MessageContent::Thinking { .. } => {}
+                MessageContent::Text(text) | MessageContent::Thinking { text, .. } => messages
+                    .push(match message.role {
+                        Role::User => deepseek::RequestMessage::User { content: text },
+                        Role::Assistant => deepseek::RequestMessage::Assistant {
+                            content: Some(text),
+                            tool_calls: Vec::new(),
+                        },
+                        Role::System => deepseek::RequestMessage::System { content: text },
+                    }),
                 MessageContent::RedactedThinking(_) => {}
                 MessageContent::Image(_) => {}
                 MessageContent::ToolUse(tool_use) => {
@@ -486,13 +485,6 @@ impl DeepSeekEventMapper {
             events.push(Ok(LanguageModelCompletionEvent::Text(content)));
         }
 
-        if let Some(reasoning_content) = choice.delta.reasoning_content.clone() {
-            events.push(Ok(LanguageModelCompletionEvent::Thinking {
-                text: reasoning_content,
-                signature: None,
-            }));
-        }
-
         if let Some(tool_calls) = choice.delta.tool_calls.as_ref() {
             for tool_call in tool_calls {
                 let entry = self.tool_calls_by_index.entry(tool_call.index).or_default();

crates/language_models/src/provider/google.rs

@@ -409,7 +409,6 @@ impl LanguageModel for GoogleLanguageModel {
                 'static,
                 Result<LanguageModelCompletionEvent, LanguageModelCompletionError>,
             >,
-            LanguageModelCompletionError,
         >,
     > {
         let request = into_google(

crates/language_models/src/provider/lmstudio.rs

@@ -250,15 +250,15 @@ impl LmStudioLanguageModel {
         for message in request.messages {
             for content in message.content {
                 match content {
-                    MessageContent::Text(text) => messages.push(match message.role {
-                        Role::User => ChatMessage::User { content: text },
-                        Role::Assistant => ChatMessage::Assistant {
-                            content: Some(text),
-                            tool_calls: Vec::new(),
-                        },
-                        Role::System => ChatMessage::System { content: text },
-                    }),
-                    MessageContent::Thinking { .. } => {}
+                    MessageContent::Text(text) | MessageContent::Thinking { text, .. } => messages
+                        .push(match message.role {
+                            Role::User => ChatMessage::User { content: text },
+                            Role::Assistant => ChatMessage::Assistant {
+                                content: Some(text),
+                                tool_calls: Vec::new(),
+                            },
+                            Role::System => ChatMessage::System { content: text },
+                        }),
                     MessageContent::RedactedThinking(_) => {}
                     MessageContent::Image(_) => {}
                     MessageContent::ToolUse(tool_use) => {
@@ -420,7 +420,6 @@ impl LanguageModel for LmStudioLanguageModel {
         'static,
         Result<
             BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
-            LanguageModelCompletionError,
         >,
     > {
         let request = self.to_lmstudio_request(request);
@@ -472,13 +471,6 @@ impl LmStudioEventMapper {
             events.push(Ok(LanguageModelCompletionEvent::Text(content)));
         }
 
-        if let Some(reasoning_content) = choice.delta.reasoning_content {
-            events.push(Ok(LanguageModelCompletionEvent::Thinking {
-                text: reasoning_content,
-                signature: None,
-            }));
-        }
-
         if let Some(tool_calls) = choice.delta.tool_calls {
             for tool_call in tool_calls {
                 let entry = self.tool_calls_by_index.entry(tool_call.index).or_default();

crates/language_models/src/provider/mistral.rs

@@ -18,8 +18,6 @@ use language_model::{
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 use settings::{Settings, SettingsStore};
-use std::collections::HashMap;
-use std::pin::Pin;
 use std::str::FromStr;
 use std::sync::Arc;
 use strum::IntoEnumIterator;
@@ -29,6 +27,9 @@ use util::ResultExt;
 
 use crate::{AllLanguageModelSettings, ui::InstructionListItem};
 
+use std::collections::HashMap;
+use std::pin::Pin;
+
 const PROVIDER_ID: &str = "mistral";
 const PROVIDER_NAME: &str = "Mistral";
 
@@ -47,7 +48,6 @@ pub struct AvailableModel {
     pub max_output_tokens: Option<u32>,
     pub max_completion_tokens: Option<u32>,
     pub supports_tools: Option<bool>,
-    pub supports_images: Option<bool>,
 }
 
 pub struct MistralLanguageModelProvider {
@@ -215,7 +215,6 @@ impl LanguageModelProvider for MistralLanguageModelProvider {
                     max_output_tokens: model.max_output_tokens,
                     max_completion_tokens: model.max_completion_tokens,
                     supports_tools: model.supports_tools,
-                    supports_images: model.supports_images,
                 },
             );
         }
@@ -315,7 +314,7 @@ impl LanguageModel for MistralLanguageModel {
     }
 
     fn supports_images(&self) -> bool {
-        self.model.supports_images()
+        false
     }
 
     fn telemetry_id(&self) -> String {
@@ -364,7 +363,6 @@ impl LanguageModel for MistralLanguageModel {
         'static,
         Result<
             BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
-            LanguageModelCompletionError,
         >,
     > {
         let request = into_mistral(
@@ -391,113 +389,58 @@ pub fn into_mistral(
     let stream = true;
 
     let mut messages = Vec::new();
-    for message in &request.messages {
-        match message.role {
-            Role::User => {
-                let mut message_content = mistral::MessageContent::empty();
-                for content in &message.content {
-                    match content {
-                        MessageContent::Text(text) => {
-                            message_content
-                                .push_part(mistral::MessagePart::Text { text: text.clone() });
-                        }
-                        MessageContent::Image(image_content) => {
-                            message_content.push_part(mistral::MessagePart::ImageUrl {
-                                image_url: image_content.to_base64_url(),
-                            });
-                        }
-                        MessageContent::Thinking { text, .. } => {
-                            message_content
-                                .push_part(mistral::MessagePart::Text { text: text.clone() });
-                        }
-                        MessageContent::RedactedThinking(_) => {}
-                        MessageContent::ToolUse(_) | MessageContent::ToolResult(_) => {
-                            // Tool content is not supported in User messages for Mistral
-                        }
+    for message in request.messages {
+        for content in message.content {
+            match content {
+                MessageContent::Text(text) | MessageContent::Thinking { text, .. } => messages
+                    .push(match message.role {
+                        Role::User => mistral::RequestMessage::User { content: text },
+                        Role::Assistant => mistral::RequestMessage::Assistant {
+                            content: Some(text),
+                            tool_calls: Vec::new(),
+                        },
+                        Role::System => mistral::RequestMessage::System { content: text },
+                    }),
+                MessageContent::RedactedThinking(_) => {}
+                MessageContent::Image(_) => {}
+                MessageContent::ToolUse(tool_use) => {
+                    let tool_call = mistral::ToolCall {
+                        id: tool_use.id.to_string(),
+                        content: mistral::ToolCallContent::Function {
+                            function: mistral::FunctionContent {
+                                name: tool_use.name.to_string(),
+                                arguments: serde_json::to_string(&tool_use.input)
+                                    .unwrap_or_default(),
+                            },
+                        },
+                    };
+
+                    if let Some(mistral::RequestMessage::Assistant { tool_calls, .. }) =
+                        messages.last_mut()
+                    {
+                        tool_calls.push(tool_call);
+                    } else {
+                        messages.push(mistral::RequestMessage::Assistant {
+                            content: None,
+                            tool_calls: vec![tool_call],
+                        });
                     }
                 }
-                if !matches!(message_content, mistral::MessageContent::Plain { ref content } if content.is_empty())
-                {
-                    messages.push(mistral::RequestMessage::User {
-                        content: message_content,
+                MessageContent::ToolResult(tool_result) => {
+                    let content = match &tool_result.content {
+                        LanguageModelToolResultContent::Text(text) => text.to_string(),
+                        LanguageModelToolResultContent::Image(_) => {
+                            // TODO: Mistral image support
+                            "[Tool responded with an image, but Zed doesn't support these in Mistral models yet]".to_string()
+                        }
+                    };
+
+                    messages.push(mistral::RequestMessage::Tool {
+                        content,
+                        tool_call_id: tool_result.tool_use_id.to_string(),
                     });
                 }
             }
-            Role::Assistant => {
-                for content in &message.content {
-                    match content {
-                        MessageContent::Text(text) | MessageContent::Thinking { text, .. } => {
-                            messages.push(mistral::RequestMessage::Assistant {
-                                content: Some(text.clone()),
-                                tool_calls: Vec::new(),
-                            });
-                        }
-                        MessageContent::RedactedThinking(_) => {}
-                        MessageContent::Image(_) => {}
-                        MessageContent::ToolUse(tool_use) => {
-                            let tool_call = mistral::ToolCall {
-                                id: tool_use.id.to_string(),
-                                content: mistral::ToolCallContent::Function {
-                                    function: mistral::FunctionContent {
-                                        name: tool_use.name.to_string(),
-                                        arguments: serde_json::to_string(&tool_use.input)
-                                            .unwrap_or_default(),
-                                    },
-                                },
-                            };
-
-                            if let Some(mistral::RequestMessage::Assistant { tool_calls, .. }) =
-                                messages.last_mut()
-                            {
-                                tool_calls.push(tool_call);
-                            } else {
-                                messages.push(mistral::RequestMessage::Assistant {
-                                    content: None,
-                                    tool_calls: vec![tool_call],
-                                });
-                            }
-                        }
-                        MessageContent::ToolResult(_) => {
-                            // Tool results are not supported in Assistant messages
-                        }
-                    }
-                }
-            }
-            Role::System => {
-                for content in &message.content {
-                    match content {
-                        MessageContent::Text(text) | MessageContent::Thinking { text, .. } => {
-                            messages.push(mistral::RequestMessage::System {
-                                content: text.clone(),
-                            });
-                        }
-                        MessageContent::RedactedThinking(_) => {}
-                        MessageContent::Image(_)
-                        | MessageContent::ToolUse(_)
-                        | MessageContent::ToolResult(_) => {
-                            // Images and tools are not supported in System messages
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    for message in &request.messages {
-        for content in &message.content {
-            if let MessageContent::ToolResult(tool_result) = content {
-                let content = match &tool_result.content {
-                    LanguageModelToolResultContent::Text(text) => text.to_string(),
-                    LanguageModelToolResultContent::Image(_) => {
-                        "[Tool responded with an image, but Zed doesn't support these in Mistral models yet]".to_string()
-                    }
-                };
-
-                messages.push(mistral::RequestMessage::Tool {
-                    content,
-                    tool_call_id: tool_result.tool_use_id.to_string(),
-                });
-            }
         }
     }
 
@@ -876,88 +819,62 @@ impl Render for ConfigurationView {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use language_model::{LanguageModelImage, LanguageModelRequestMessage, MessageContent};
+    use language_model;
 
     #[test]
-    fn test_into_mistral_basic_conversion() {
-        let request = LanguageModelRequest {
+    fn test_into_mistral_conversion() {
+        let request = language_model::LanguageModelRequest {
             messages: vec![
-                LanguageModelRequestMessage {
-                    role: Role::System,
-                    content: vec![MessageContent::Text("System prompt".into())],
+                language_model::LanguageModelRequestMessage {
+                    role: language_model::Role::System,
+                    content: vec![language_model::MessageContent::Text(
+                        "You are a helpful assistant.".to_string(),
+                    )],
                     cache: false,
                 },
-                LanguageModelRequestMessage {
-                    role: Role::User,
-                    content: vec![MessageContent::Text("Hello".into())],
+                language_model::LanguageModelRequestMessage {
+                    role: language_model::Role::User,
+                    content: vec![language_model::MessageContent::Text(
+                        "Hello, how are you?".to_string(),
+                    )],
                     cache: false,
                 },
             ],
-            temperature: Some(0.5),
-            tools: vec![],
+            temperature: Some(0.7),
+            tools: Vec::new(),
             tool_choice: None,
             thread_id: None,
             prompt_id: None,
             intent: None,
             mode: None,
-            stop: vec![],
+            stop: Vec::new(),
         };
 
-        let mistral_request = into_mistral(request, "mistral-small-latest".into(), None);
+        let model_name = "mistral-medium-latest".to_string();
+        let max_output_tokens = Some(1000);
+        let mistral_request = into_mistral(request, model_name, max_output_tokens);
 
-        assert_eq!(mistral_request.model, "mistral-small-latest");
-        assert_eq!(mistral_request.temperature, Some(0.5));
-        assert_eq!(mistral_request.messages.len(), 2);
+        assert_eq!(mistral_request.model, "mistral-medium-latest");
+        assert_eq!(mistral_request.temperature, Some(0.7));
+        assert_eq!(mistral_request.max_tokens, Some(1000));
         assert!(mistral_request.stream);
-    }
+        assert!(mistral_request.tools.is_empty());
+        assert!(mistral_request.tool_choice.is_none());
 
-    #[test]
-    fn test_into_mistral_with_image() {
-        let request = LanguageModelRequest {
-            messages: vec![LanguageModelRequestMessage {
-                role: Role::User,
-                content: vec![
-                    MessageContent::Text("What's in this image?".into()),
-                    MessageContent::Image(LanguageModelImage {
-                        source: "base64data".into(),
-                        size: Default::default(),
-                    }),
-                ],
-                cache: false,
-            }],
-            tools: vec![],
-            tool_choice: None,
-            temperature: None,
-            thread_id: None,
-            prompt_id: None,
-            intent: None,
-            mode: None,
-            stop: vec![],
-        };
+        assert_eq!(mistral_request.messages.len(), 2);
 
-        let mistral_request = into_mistral(request, "pixtral-12b-latest".into(), None);
-
-        assert_eq!(mistral_request.messages.len(), 1);
-        assert!(matches!(
-            &mistral_request.messages[0],
-            mistral::RequestMessage::User {
-                content: mistral::MessageContent::Multipart { .. }
+        match &mistral_request.messages[0] {
+            mistral::RequestMessage::System { content } => {
+                assert_eq!(content, "You are a helpful assistant.");
             }
-        ));
+            _ => panic!("Expected System message"),
+        }
 
-        if let mistral::RequestMessage::User {
-            content: mistral::MessageContent::Multipart { content },
-        } = &mistral_request.messages[0]
-        {
-            assert_eq!(content.len(), 2);
-            assert!(matches!(
-                &content[0],
-                mistral::MessagePart::Text { text } if text == "What's in this image?"
-            ));
-            assert!(matches!(
-                &content[1],
-                mistral::MessagePart::ImageUrl { image_url } if image_url.starts_with("data:image/png;base64,")
-            ));
+        match &mistral_request.messages[1] {
+            mistral::RequestMessage::User { content } => {
+                assert_eq!(content, "Hello, how are you?");
+            }
+            _ => panic!("Expected User message"),
         }
     }
 }

crates/language_models/src/provider/ollama.rs

@@ -406,7 +406,6 @@ impl LanguageModel for OllamaLanguageModel {
         'static,
         Result<
             BoxStream<'static, Result<LanguageModelCompletionEvent, LanguageModelCompletionError>>,
-            LanguageModelCompletionError,
         >,
     > {
         let request = self.to_ollama_request(request);
@@ -416,7 +415,7 @@ impl LanguageModel for OllamaLanguageModel {
             let settings = &AllLanguageModelSettings::get_global(cx).ollama;
             settings.api_url.clone()
         }) else {
-            return futures::future::ready(Err(anyhow!("App state dropped").into())).boxed();
+            return futures::future::ready(Err(anyhow!("App state dropped"))).boxed();
         };
 
         let future = self.request_limiter.stream(async move {

crates/language_models/src/provider/open_ai.rs

@@ -339,7 +339,6 @@ impl LanguageModel for OpenAiLanguageModel {
                 'static,
                 Result<LanguageModelCompletionEvent, LanguageModelCompletionError>,
             >,
-            LanguageModelCompletionError,
         >,
     > {
         let request = into_open_ai(request, &self.model, self.max_output_tokens());

crates/language_models/src/provider/open_router.rs

@@ -367,7 +367,6 @@ impl LanguageModel for OpenRouterLanguageModel {
                 'static,
                 Result<LanguageModelCompletionEvent, LanguageModelCompletionError>,
             >,
-            LanguageModelCompletionError,
         >,
     > {
         let request = into_open_router(request, &self.model, self.max_output_tokens());

crates/languages/src/javascript/outline.scm

@@ -80,21 +80,4 @@
     )
 ) @item
 
-; Add support for parameterized tests
-(
-    (call_expression
-        function: (call_expression
-            function: (member_expression
-                object: [(identifier) @_name (member_expression object: (identifier) @_name)]
-                property: (property_identifier) @_property
-            )
-            (#any-of? @_name "it" "test" "describe" "context" "suite")
-            (#eq? @_property "each")
-        )
-        arguments: (
-            arguments . (string (string_fragment) @name)
-        )
-    )
-) @item
-
 (comment) @annotation

crates/languages/src/javascript/runnables.scm

@@ -19,22 +19,3 @@
 
     (#set! tag js-test)
 )
-
-; Add support for parameterized tests
-(
-    (call_expression
-        function: (call_expression
-            function: (member_expression
-                object: [(identifier) @_name (member_expression object: (identifier) @_name)]
-                property: (property_identifier) @_property
-            )
-            (#any-of? @_name "it" "test" "describe" "context" "suite")
-            (#eq? @_property "each")
-        )
-        arguments: (
-            arguments . (string (string_fragment) @run)
-        )
-    ) @_js-test
-
-    (#set! tag js-test)
-)

crates/languages/src/typescript.rs

@@ -34,15 +34,11 @@ const TYPESCRIPT_RUNNER_VARIABLE: VariableName =
     VariableName::Custom(Cow::Borrowed("TYPESCRIPT_RUNNER"));
 const TYPESCRIPT_JEST_TASK_VARIABLE: VariableName =
     VariableName::Custom(Cow::Borrowed("TYPESCRIPT_JEST"));
-const TYPESCRIPT_JEST_TEST_NAME_VARIABLE: VariableName =
-    VariableName::Custom(Cow::Borrowed("TYPESCRIPT_JEST_TEST_NAME"));
 const TYPESCRIPT_MOCHA_TASK_VARIABLE: VariableName =
     VariableName::Custom(Cow::Borrowed("TYPESCRIPT_MOCHA"));
 
 const TYPESCRIPT_VITEST_TASK_VARIABLE: VariableName =
     VariableName::Custom(Cow::Borrowed("TYPESCRIPT_VITEST"));
-const TYPESCRIPT_VITEST_TEST_NAME_VARIABLE: VariableName =
-    VariableName::Custom(Cow::Borrowed("TYPESCRIPT_VITEST_TEST_NAME"));
 const TYPESCRIPT_JASMINE_TASK_VARIABLE: VariableName =
     VariableName::Custom(Cow::Borrowed("TYPESCRIPT_JASMINE"));
 const TYPESCRIPT_BUILD_SCRIPT_TASK_VARIABLE: VariableName =
@@ -187,10 +183,7 @@ impl ContextProvider for TypeScriptContextProvider {
             args: vec![
                 TYPESCRIPT_JEST_TASK_VARIABLE.template_value(),
                 "--testNamePattern".to_owned(),
-                format!(
-                    "\"{}\"",
-                    TYPESCRIPT_JEST_TEST_NAME_VARIABLE.template_value()
-                ),
+                format!("\"{}\"", VariableName::Symbol.template_value()),
                 VariableName::RelativeFile.template_value(),
             ],
             tags: vec![
@@ -228,7 +221,7 @@ impl ContextProvider for TypeScriptContextProvider {
                 TYPESCRIPT_VITEST_TASK_VARIABLE.template_value(),
                 "run".to_owned(),
                 "--testNamePattern".to_owned(),
-                format!("\"{}\"", TYPESCRIPT_VITEST_TASK_VARIABLE.template_value()),
+                format!("\"{}\"", VariableName::Symbol.template_value()),
                 VariableName::RelativeFile.template_value(),
             ],
             tags: vec![
@@ -351,27 +344,14 @@ impl ContextProvider for TypeScriptContextProvider {
 
     fn build_context(
         &self,
-        current_vars: &task::TaskVariables,
+        _variables: &task::TaskVariables,
         location: ContextLocation<'_>,
         _project_env: Option<HashMap<String, String>>,
         _toolchains: Arc<dyn LanguageToolchainStore>,
         cx: &mut App,
     ) -> Task<Result<task::TaskVariables>> {
-        let mut vars = task::TaskVariables::default();
-
-        if let Some(symbol) = current_vars.get(&VariableName::Symbol) {
-            vars.insert(
-                TYPESCRIPT_JEST_TEST_NAME_VARIABLE,
-                replace_test_name_parameters(symbol),
-            );
-            vars.insert(
-                TYPESCRIPT_VITEST_TEST_NAME_VARIABLE,
-                replace_test_name_parameters(symbol),
-            );
-        }
-
         let Some((fs, worktree_root)) = location.fs.zip(location.worktree_root) else {
-            return Task::ready(Ok(vars));
+            return Task::ready(Ok(task::TaskVariables::default()));
         };
 
         let package_json_contents = self.last_package_json.clone();
@@ -381,10 +361,7 @@ impl ContextProvider for TypeScriptContextProvider {
                 .context("package.json context retrieval")
                 .log_err()
                 .unwrap_or_else(task::TaskVariables::default);
-
-            vars.extend(variables);
-
-            Ok(vars)
+            Ok(variables)
         })
     }
 }
@@ -449,12 +426,6 @@ fn eslint_server_binary_arguments(server_path: &Path) -> Vec<OsString> {
     ]
 }
 
-fn replace_test_name_parameters(test_name: &str) -> String {
-    let pattern = regex::Regex::new(r"(%|\$)[0-9a-zA-Z]+").unwrap();
-
-    pattern.replace_all(test_name, "(.+?)").to_string()
-}
-
 pub struct TypeScriptLspAdapter {
     node: NodeRuntime,
 }

crates/languages/src/typescript/outline.scm

@@ -88,21 +88,4 @@
     )
 ) @item
 
-; Add support for parameterized tests
-(
-    (call_expression
-        function: (call_expression
-            function: (member_expression
-                object: [(identifier) @_name (member_expression object: (identifier) @_name)]
-                property: (property_identifier) @_property
-            )
-            (#any-of? @_name "it" "test" "describe" "context" "suite")
-            (#any-of? @_property "each")
-        )
-        arguments: (
-            arguments . (string (string_fragment) @name)
-        )
-    )
-) @item
-
 (comment) @annotation