Breakpoints

.zed/tasks.json

@@ -3,5 +3,10 @@
     "label": "clippy",
     "command": "./script/clippy",
     "args": []
+  },
+  {
+    "label": "Run Zed Tests",
+    "command": "cargo nextest run --workspace --no-fail-fast",
+    "args": []
   }
 ]

crates/dap/Cargo.toml

@@ -14,6 +14,8 @@ async-std = "1.12.0"
 dap-types = { git = "https://github.com/zed-industries/dap-types" }
 futures.workspace = true
 gpui.workspace = true
+multi_buffer.workspace = true
+language.workspace = true
 log.workspace = true
 parking_lot.workspace = true
 postage.workspace = true
@@ -24,4 +26,5 @@ serde_json.workspace = true
 serde_json_lenient.workspace = true
 smol.workspace = true
 task.workspace = true
+text.workspace = true
 util.workspace = true

crates/dap/src/client.rs

@@ -15,6 +15,7 @@ use dap_types::{
 };
 use futures::{AsyncBufRead, AsyncReadExt, AsyncWrite};
 use gpui::{AppContext, AsyncAppContext};
+use language::Buffer;
 use parking_lot::{Mutex, MutexGuard};
 use serde_json::Value;
 use smol::{
@@ -35,6 +36,7 @@ use std::{
     time::Duration,
 };
 use task::{DebugAdapterConfig, DebugConnectionType, DebugRequestType, TCPHost};
+use text::Point;
 use util::ResultExt;
 
 #[derive(Copy, Clone, Default, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -331,7 +333,9 @@ impl DebugAdapterClient {
     {
         while let Ok(payload) = client_rx.recv().await {
             match payload {
-                Payload::Event(event) => cx.update(|cx| event_handler(*event, cx))?,
+                Payload::Event(event) => cx
+                    .update(|cx| event_handler(*event, cx))
+                    .context("Event handler failed")?,
                 Payload::Request(request) => {
                     if RunInTerminal::COMMAND == request.command {
                         Self::handle_run_in_terminal_request(request, &server_tx).await?;
@@ -395,8 +399,7 @@ impl DebugAdapterClient {
         request: crate::transport::Request,
         cx: &mut AsyncAppContext,
     ) -> Result<()> {
-        dbg!(&request);
-        let arguments: StartDebuggingRequestArguments =
+        let _arguments: StartDebuggingRequestArguments =
             serde_json::from_value(request.arguments.clone().unwrap_or_default())?;
 
         let sub_client = DebugAdapterClient::new(
@@ -416,10 +419,7 @@ impl DebugAdapterClient {
         )
         .await?;
 
-        dbg!(&arguments);
-
-        let res = sub_client.launch(request.arguments).await?;
-        dbg!(res);
+        let _res = sub_client.launch(request.arguments).await?;
 
         *this.sub_client.lock() = Some(sub_client);
 
@@ -455,6 +455,7 @@ impl DebugAdapterClient {
         self.server_tx.send(Payload::Request(request)).await?;
 
         let response = callback_rx.recv().await??;
+        let _ = self.next_sequence_id();
 
         match response.success {
             true => Ok(serde_json::from_value(response.body.unwrap_or_default())?),
@@ -644,3 +645,24 @@ impl DebugAdapterClient {
             .await
     }
 }
+
+#[derive(Clone, Debug, Hash, PartialEq, Eq)]
+pub struct Breakpoint {
+    pub position: multi_buffer::Anchor,
+}
+
+impl Breakpoint {
+    pub fn to_source_breakpoint(&self, buffer: &Buffer) -> SourceBreakpoint {
+        SourceBreakpoint {
+            line: (buffer
+                .summary_for_anchor::<Point>(&self.position.text_anchor)
+                .row
+                + 1) as u64,
+            condition: None,
+            hit_condition: None,
+            log_message: None,
+            column: None,
+            mode: None,
+        }
+    }
+}

crates/debugger_ui/src/debugger_panel.rs

@@ -133,6 +133,9 @@ impl DebugPanel {
         event: &Events,
         cx: &mut ViewContext<Self>,
     ) {
+        // Increment the sequence id because an event is being processed
+        let _ = client.next_sequence_id();
+
         match event {
             Events::Initialized(event) => Self::handle_initialized_event(client, event, cx),
             Events::Stopped(event) => Self::handle_stopped_event(client, event, cx),

crates/editor/Cargo.toml

@@ -37,6 +37,7 @@ clock.workspace = true
 collections.workspace = true
 convert_case = "0.6.0"
 db.workspace = true
+dap.workspace = true
 emojis.workspace = true
 file_icons.workspace = true
 futures.workspace = true

crates/editor/src/editor.rs

@@ -97,6 +97,7 @@ use language::{point_to_lsp, BufferRow, Runnable, RunnableRange};
 use linked_editing_ranges::refresh_linked_ranges;
 use task::{ResolvedTask, TaskTemplate, TaskVariables};
 
+use dap::client::Breakpoint;
 use hover_links::{HoverLink, HoveredLinkState, InlayHighlight};
 pub use lsp::CompletionContext;
 use lsp::{
@@ -450,12 +451,6 @@ struct ResolvedTasks {
     position: Anchor,
 }
 
-#[derive(Clone, Debug)]
-struct Breakpoint {
-    row: MultiBufferRow,
-    _line: BufferRow,
-}
-
 #[derive(Copy, Clone, Debug)]
 struct MultiBufferOffset(usize);
 #[derive(Copy, Clone, Debug, PartialEq, PartialOrd)]
@@ -575,7 +570,13 @@ pub struct Editor {
     expect_bounds_change: Option<Bounds<Pixels>>,
     tasks: BTreeMap<(BufferId, BufferRow), RunnableTasks>,
     tasks_update_task: Option<Task<()>>,
-    breakpoints: BTreeMap<(BufferId, BufferRow), Breakpoint>,
+    /// All the breakpoints that are active within a project
+    /// Is shared with editor's active project
+    breakpoints: Option<Arc<RwLock<BTreeMap<BufferId, HashSet<Breakpoint>>>>>,
+    /// Allow's a user to create a breakpoint by selecting this indicator
+    /// It should be None while a user is not hovering over the gutter
+    /// Otherwise it represents the point that the breakpoint will be shown
+    pub gutter_breakpoint_indicator: Option<DisplayPoint>,
     previous_search_ranges: Option<Arc<[Range<Anchor>]>>,
     file_header_size: u8,
     breadcrumb_header: Option<String>,
@@ -1789,6 +1790,12 @@ impl Editor {
             None
         };
 
+        let breakpoints = if let Some(project) = project.as_ref() {
+            Some(project.update(cx, |project, _cx| project.breakpoints.clone()))
+        } else {
+            None
+        };
+
         let mut this = Self {
             focus_handle,
             show_cursor_when_unfocused: false,
@@ -1891,7 +1898,8 @@ impl Editor {
             blame_subscription: None,
             file_header_size,
             tasks: Default::default(),
-            breakpoints: Default::default(),
+            breakpoints,
+            gutter_breakpoint_indicator: None,
             _subscriptions: vec![
                 cx.observe(&buffer, Self::on_buffer_changed),
                 cx.subscribe(&buffer, Self::on_buffer_event),
@@ -5141,14 +5149,19 @@ impl Editor {
         }
     }
 
-    fn render_breakpoint(&self, row: DisplayRow, cx: &mut ViewContext<Self>) -> IconButton {
+    fn render_breakpoint(
+        &self,
+        position: Anchor,
+        row: DisplayRow,
+        cx: &mut ViewContext<Self>,
+    ) -> IconButton {
         IconButton::new(("breakpoint_indicator", row.0 as usize), ui::IconName::Play)
             .icon_size(IconSize::XSmall)
             .size(ui::ButtonSize::None)
             .icon_color(Color::Error)
             .on_click(cx.listener(move |editor, _e, cx| {
                 editor.focus(cx);
-                editor.toggle_breakpoint_at_row(row.0, cx) //TODO handle folded
+                editor.toggle_breakpoint_at_row(position, cx) //TODO handle folded
             }))
     }
 
@@ -5972,33 +5985,58 @@ impl Editor {
 
     pub fn toggle_breakpoint(&mut self, _: &ToggleBreakpoint, cx: &mut ViewContext<Self>) {
         let cursor_position: Point = self.selections.newest(cx).head();
-        self.toggle_breakpoint_at_row(cursor_position.row, cx);
+
+        let breakpoint_position = self
+            .snapshot(cx)
+            .display_snapshot
+            .buffer_snapshot
+            .anchor_before(cursor_position);
+
+        self.toggle_breakpoint_at_row(breakpoint_position, cx);
     }
 
-    pub fn toggle_breakpoint_at_row(&mut self, row: u32, cx: &mut ViewContext<Self>) {
+    pub fn toggle_breakpoint_at_row(
+        &mut self,
+        breakpoint_position: Anchor,
+        cx: &mut ViewContext<Self>,
+    ) {
         let Some(project) = &self.project else {
             return;
         };
+
+        let Some(breakpoints) = &self.breakpoints else {
+            return;
+        };
+
         let Some(buffer) = self.buffer.read(cx).as_singleton() else {
             return;
         };
 
         let buffer_id = buffer.read(cx).remote_id();
-        let key = (buffer_id, row);
-
-        if self.breakpoints.remove(&key).is_none() {
-            self.breakpoints.insert(
-                key,
-                Breakpoint {
-                    row: MultiBufferRow(row),
-                    _line: row,
-                },
-            );
+
+        let breakpoint = Breakpoint {
+            position: breakpoint_position,
+        };
+
+        // Putting the write guard within it's own scope so it's dropped
+        // before project updates it's breakpoints. This is done to prevent
+        // a data race condition where project waits to get a read lock
+        {
+            let mut write_guard = breakpoints.write();
+
+            let breakpoint_set = write_guard.entry(buffer_id).or_default();
+
+            if !breakpoint_set.remove(&breakpoint) {
+                breakpoint_set.insert(breakpoint);
+            }
         }
 
         project.update(cx, |project, cx| {
-            project.update_breakpoint(buffer, row + 1, cx);
+            if project.has_active_debugger() {
+                project.update_file_breakpoints(buffer_id, cx);
+            }
         });
+
         cx.notify();
     }