Yehowshua/ZIm
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

debugger: Add breakpoint list (#28496)

Browse source 
![image](https://github.com/user-attachments/assets/2cbe60cc-bf04-4233-a7bc-32affff8eef5)
Release Notes:

- N/A

---------

Co-authored-by: Anthony Eid <hello@anthonyeid.me>
This commit is contained in:
Piotr Osiewicz 2025-04-10 20:18:58 +02:00 • committed by GitHub
parent 3abf95216c
commit 26f4705198
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
13 changed files with 711 additions and 18 deletions
Download patch file Download diff file Expand all files Collapse all files

1
assets/icons/binary.svg Normal file
View file

@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-binary-icon lucide-binary"><rect x="14" y="14" width="4" height="6" rx="2"/><rect x="6" y="4" width="4" height="6" rx="2"/><path d="M6 20h4"/><path d="M14 10h4"/><path d="M6 14h2v6"/><path d="M14 4h2v6"/></svg>
Side by side

After

Width:  |  Height:  |  Size: 413 B

1
assets/icons/flame.svg Normal file
View file

@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-flame-icon lucide-flame"><path d="M8.5 14.5A2.5 2.5 0 0 0 11 12c0-1.38-.5-2-1-3-1.072-2.143-.224-4.054 2-6 .5 2.5 2 4.9 4 6.5 2 1.6 3 3.5 3 5.5a7 7 0 1 1-14 0c0-1.153.433-2.294 1-3a2.5 2.5 0 0 0 2.5 2.5z"/></svg>
Side by side

After

Width:  |  Height:  |  Size: 415 B

1
assets/icons/function.svg Normal file
View file

@ -0,0 +1 @@
<svg xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" class="lucide lucide-square-function-icon lucide-square-function"><rect width="18" height="18" x="3" y="3" rx="2" ry="2"/><path d="M9 17c2 0 2.8-1 2.8-2.8V10c0-2 1-3.3 3.2-3"/><path d="M9 11.2h5.7"/></svg>
Side by side

After

Width:  |  Height:  |  Size: 387 B

8
crates/dap_adapters/src/codelldb.rs
View file

@ -105,6 +105,12 @@ impl DebugAdapter for CodeLldbDebugAdapter {
Ok(DebugAdapterBinary {
command,
cwd: Some(adapter_dir),
arguments: Some(vec![
"--settings".into(),
json!({"sourceLanguages": ["cpp", "rust"]})
.to_string()
.into(),
]),
..Default::default()
})
}
@ -117,6 +123,8 @@ impl DebugAdapter for CodeLldbDebugAdapter {
},
});
let map = args.as_object_mut().unwrap();
// CodeLLDB uses `name` for a terminal label.
map.insert("name".into(), Value::String(config.label.clone()));
match &config.request {
DebugRequestType::Attach(attach) => {
map.insert("pid".into(), attach.process_id.into());

21
crates/debugger_ui/src/debugger_panel.rs
View file

@ -417,7 +417,8 @@ impl DebugPanel {
DropdownMenu::new_with_element(
"debugger-session-list",
label,
ContextMenu::build(window, cx, move |mut this, _, _| {
ContextMenu::build(window, cx, move |mut this, _, cx| {
let context_menu = cx.weak_entity();
for session in sessions.into_iter() {
let weak_session = session.downgrade();
let weak_session_id = weak_session.entity_id();
@ -425,11 +426,17 @@ impl DebugPanel {
this = this.custom_entry(
{
let weak = weak.clone();
let context_menu = context_menu.clone();
move |_, cx| {
weak_session
.read_with(cx, |session, cx| {
let context_menu = context_menu.clone();
let id: SharedString =
format!("debug-session-{}", session.session_id(cx).0)
.into();
h_flex()
.w_full()
.group(id.clone())
.justify_between()
.child(session.label_element(cx))
.child(
@ -437,15 +444,25 @@ impl DebugPanel {
"close-debug-session",
IconName::Close,
)
.visible_on_hover(id.clone())
.icon_size(IconSize::Small)
.on_click({
let weak = weak.clone();
move |_, _, cx| {
move |_, window, cx| {
weak.update(cx, |panel, cx| {
panel
.close_session(weak_session_id, cx);
})
.ok();
context_menu
.update(cx, |this, cx| {
this.cancel(
&Default::default(),
window,
cx,
);
})
.ok();
}
}),
)

17
crates/debugger_ui/src/session/running.rs
View file

@ -1,3 +1,4 @@
mod breakpoint_list;
mod console;
mod loaded_source_list;
mod module_list;
@ -7,6 +8,7 @@ pub mod variable_list;
use std::{any::Any, ops::ControlFlow, sync::Arc};
use super::DebugPanelItemEvent;
use breakpoint_list::BreakpointList;
use collections::HashMap;
use console::Console;
use dap::{Capabilities, Thread, client::SessionId, debugger_settings::DebuggerSettings};
@ -321,6 +323,21 @@ impl RunningState {
window,
cx,
);
let breakpoints = BreakpointList::new(session.clone(), workspace.clone(), &project, cx);
this.add_item(
Box::new(SubView::new(
breakpoints.focus_handle(cx),
breakpoints.into(),
SharedString::new_static("Breakpoints"),
cx,
)),
true,
false,
None,
window,
cx,
);
this.activate_item(0, false, false, window, cx);
});
let center_pane = new_debugger_pane(workspace.clone(), project.clone(), window, cx);
center_pane.update(cx, |this, cx| {

482
crates/debugger_ui/src/session/running/breakpoint_list.rs Normal file
View file

@ -0,0 +1,482 @@
use std::{
path::{Path, PathBuf},
time::Duration,
};
use dap::ExceptionBreakpointsFilter;
use editor::Editor;
use gpui::{
AppContext, Entity, FocusHandle, Focusable, ListState, MouseButton, Stateful, Task, WeakEntity,
list,
};
use language::Point;
use project::{
Project,
debugger::{
breakpoint_store::{BreakpointEditAction, BreakpointStore, SourceBreakpoint},
session::Session,
},
worktree_store::WorktreeStore,
};
use ui::{
App, Clickable, Color, Context, Div, Icon, IconButton, IconName, Indicator, InteractiveElement,
IntoElement, Label, LabelCommon, LabelSize, ListItem, ParentElement, Render, RenderOnce,
Scrollbar, ScrollbarState, SharedString, StatefulInteractiveElement, Styled, Window, div,
h_flex, px, v_flex,
};
use util::{ResultExt, maybe};
use workspace::Workspace;
pub(super) struct BreakpointList {
workspace: WeakEntity<Workspace>,
breakpoint_store: Entity<BreakpointStore>,
worktree_store: Entity<WorktreeStore>,
list_state: ListState,
scrollbar_state: ScrollbarState,
breakpoints: Vec<BreakpointEntry>,
session: Entity<Session>,
hide_scrollbar_task: Option<Task<()>>,
show_scrollbar: bool,
focus_handle: FocusHandle,
}
impl Focusable for BreakpointList {
fn focus_handle(&self, _: &App) -> gpui::FocusHandle {
self.focus_handle.clone()
}
}
impl BreakpointList {
pub(super) fn new(
session: Entity<Session>,
workspace: WeakEntity<Workspace>,
project: &Entity<Project>,
cx: &mut App,
) -> Entity<Self> {
let project = project.read(cx);
let breakpoint_store = project.breakpoint_store();
let worktree_store = project.worktree_store();
cx.new(|cx| {
let weak: gpui::WeakEntity<Self> = cx.weak_entity();
let list_state = ListState::new(
0,
gpui::ListAlignment::Top,
px(1000.),
move |ix, window, cx| {
let Ok(Some(breakpoint)) =
weak.update(cx, |this, _| this.breakpoints.get(ix).cloned())
else {
return div().into_any_element();
};
breakpoint.render(window, cx).into_any_element()
},
);
Self {
breakpoint_store,
worktree_store,
scrollbar_state: ScrollbarState::new(list_state.clone()),
list_state,
breakpoints: Default::default(),
hide_scrollbar_task: None,
show_scrollbar: false,
workspace,
session,
focus_handle: cx.focus_handle(),
}
})
}
fn hide_scrollbar(&mut self, window: &mut Window, cx: &mut Context<Self>) {
const SCROLLBAR_SHOW_INTERVAL: Duration = Duration::from_secs(1);
self.hide_scrollbar_task = Some(cx.spawn_in(window, async move |panel, cx| {
cx.background_executor()
.timer(SCROLLBAR_SHOW_INTERVAL)
.await;
panel
.update(cx, |panel, cx| {
panel.show_scrollbar = false;
cx.notify();
})
.log_err();
}))
}
fn render_vertical_scrollbar(&self, cx: &mut Context<Self>) -> Option<Stateful<Div>> {
if !(self.show_scrollbar || self.scrollbar_state.is_dragging()) {
return None;
}
Some(
div()
.occlude()
.id("breakpoint-list-vertical-scrollbar")
.on_mouse_move(cx.listener(|_, _, _, cx| {
cx.notify();
cx.stop_propagation()
}))
.on_hover(|_, _, cx| {
cx.stop_propagation();
})
.on_any_mouse_down(|_, _, cx| {
cx.stop_propagation();
})
.on_mouse_up(
MouseButton::Left,
cx.listener(|_, _, _, cx| {
cx.stop_propagation();
}),
)
.on_scroll_wheel(cx.listener(|_, _, _, cx| {
cx.notify();
}))
.h_full()
.absolute()
.right_1()
.top_1()
.bottom_0()
.w(px(12.))
.cursor_default()
.children(Scrollbar::vertical(self.scrollbar_state.clone())),
)
}
}
impl Render for BreakpointList {
fn render(
&mut self,
_window: &mut ui::Window,
cx: &mut ui::Context<Self>,
) -> impl ui::IntoElement {
let old_len = self.breakpoints.len();
let breakpoints = self.breakpoint_store.read(cx).all_breakpoints(cx);
self.breakpoints.clear();
let weak = cx.weak_entity();
let breakpoints = breakpoints.into_iter().flat_map(|(path, mut breakpoints)| {
let relative_worktree_path = self
.worktree_store
.read(cx)
.find_worktree(&path, cx)
.and_then(|(worktree, relative_path)| {
worktree
.read(cx)
.is_visible()
.then(|| Path::new(worktree.read(cx).root_name()).join(relative_path))
});
breakpoints.sort_by_key(|breakpoint| breakpoint.row);
let weak = weak.clone();
breakpoints.into_iter().filter_map(move |breakpoint| {
debug_assert_eq!(&path, &breakpoint.path);
let file_name = breakpoint.path.file_name()?;
let dir = relative_worktree_path
.clone()
.unwrap_or_else(|| PathBuf::from(&*breakpoint.path))
.parent()
.and_then(|parent| {
parent
.to_str()
.map(ToOwned::to_owned)
.map(SharedString::from)
});
let name = file_name
.to_str()
.map(ToOwned::to_owned)
.map(SharedString::from)?;
let weak = weak.clone();
let line = format!("Line {}", breakpoint.row + 1).into();
Some(BreakpointEntry {
kind: BreakpointEntryKind::LineBreakpoint(LineBreakpoint {
name,
dir,
line,
breakpoint,
}),
weak,
})
})
});
let exception_breakpoints =
self.session
.read(cx)
.exception_breakpoints()
.map(|(data, is_enabled)| BreakpointEntry {
kind: BreakpointEntryKind::ExceptionBreakpoint(ExceptionBreakpoint {
id: data.filter.clone(),
data: data.clone(),
is_enabled: *is_enabled,
}),
weak: weak.clone(),
});
self.breakpoints
.extend(breakpoints.chain(exception_breakpoints));
if self.breakpoints.len() != old_len {
self.list_state.reset(self.breakpoints.len());
}
v_flex()
.id("breakpoint-list")
.on_hover(cx.listener(|this, hovered, window, cx| {
if *hovered {
this.show_scrollbar = true;
this.hide_scrollbar_task.take();
cx.notify();
} else if !this.focus_handle.contains_focused(window, cx) {
this.hide_scrollbar(window, cx);
}
}))
.size_full()
.m_0p5()
.child(list(self.list_state.clone()).flex_grow())
.children(self.render_vertical_scrollbar(cx))
}
}
#[derive(Clone, Debug)]
struct LineBreakpoint {
name: SharedString,
dir: Option<SharedString>,
line: SharedString,
breakpoint: SourceBreakpoint,
}
impl LineBreakpoint {
fn render(self, weak: WeakEntity<BreakpointList>) -> ListItem {
let LineBreakpoint {
name,
dir,
line,
breakpoint,
} = self;
let icon_name = if breakpoint.state.is_enabled() {
IconName::DebugBreakpoint
} else {
IconName::DebugDisabledBreakpoint
};
let path = breakpoint.path;
let row = breakpoint.row;
let indicator = div()
.id(SharedString::from(format!(
"breakpoint-ui-toggle-{:?}/{}:{}",
dir, name, line
)))
.cursor_pointer()
.on_click({
let weak = weak.clone();
let path = path.clone();
move |_, _, cx| {
weak.update(cx, |this, cx| {
this.breakpoint_store.update(cx, |this, cx| {
if let Some((buffer, breakpoint)) =
this.breakpoint_at_row(&path, row, cx)
{
this.toggle_breakpoint(
buffer,
breakpoint,
BreakpointEditAction::InvertState,
cx,
);
} else {
log::error!("Couldn't find breakpoint at row event though it exists: row {row}")
}
})
})
.ok();
}
})
.child(Indicator::icon(Icon::new(icon_name)).color(Color::Debugger))
.on_mouse_down(MouseButton::Left, move |_, _, _| {});
ListItem::new(SharedString::from(format!(
"breakpoint-ui-item-{:?}/{}:{}",
dir, name, line
)))
.start_slot(indicator)
.rounded()
.end_hover_slot(
IconButton::new(
SharedString::from(format!(
"breakpoint-ui-on-click-go-to-line-{:?}/{}:{}",
dir, name, line
)),
IconName::Close,
)
.on_click({
let weak = weak.clone();
let path = path.clone();
move |_, _, cx| {
weak.update(cx, |this, cx| {
this.breakpoint_store.update(cx, |this, cx| {
if let Some((buffer, breakpoint)) =
this.breakpoint_at_row(&path, row, cx)
{
this.toggle_breakpoint(
buffer,
breakpoint,
BreakpointEditAction::Toggle,
cx,
);
} else {
log::error!("Couldn't find breakpoint at row event though it exists: row {row}")
}
})
})
.ok();
}
})
.icon_size(ui::IconSize::XSmall),
)
.child(
v_flex()
.id(SharedString::from(format!(
"breakpoint-ui-on-click-go-to-line-{:?}/{}:{}",
dir, name, line
)))
.on_click(move |_, window, cx| {
let path = path.clone();
let weak = weak.clone();
let row = breakpoint.row;
maybe!({
let task = weak
.update(cx, |this, cx| {
this.worktree_store.update(cx, |this, cx| {
this.find_or_create_worktree(path, false, cx)
})
})
.ok()?;
window
.spawn(cx, async move |cx| {
let (worktree, relative_path) = task.await?;
let worktree_id = worktree.update(cx, |this, _| this.id())?;
let item = weak
.update_in(cx, |this, window, cx| {
this.workspace.update(cx, |this, cx| {
this.open_path(
(worktree_id, relative_path),
None,
true,
window,
cx,
)
})
})??
.await?;
if let Some(editor) = item.downcast::<Editor>() {
editor
.update_in(cx, |this, window, cx| {
this.go_to_singleton_buffer_point(
Point { row, column: 0 },
window,
cx,
);
})
.ok();
}
Result::<_, anyhow::Error>::Ok(())
})
.detach();
Some(())
});
})
.cursor_pointer()
.py_1()
.items_center()
.child(
h_flex()
.gap_1()
.child(
Label::new(name)
.size(LabelSize::Small)
.line_height_style(ui::LineHeightStyle::UiLabel),
)
.children(dir.map(|dir| {
Label::new(dir)
.color(Color::Muted)
.size(LabelSize::Small)
.line_height_style(ui::LineHeightStyle::UiLabel)
})),
)
.child(
Label::new(line)
.size(LabelSize::XSmall)
.color(Color::Muted)
.line_height_style(ui::LineHeightStyle::UiLabel),
),
)
}
}
#[derive(Clone, Debug)]
struct ExceptionBreakpoint {
id: String,
data: ExceptionBreakpointsFilter,
is_enabled: bool,
}
impl ExceptionBreakpoint {
fn render(self, list: WeakEntity<BreakpointList>) -> ListItem {
let color = if self.is_enabled {
Color::Debugger
} else {
Color::Muted
};
let id = SharedString::from(&self.id);
ListItem::new(SharedString::from(format!(
"exception-breakpoint-ui-item-{}",
self.id
)))
.rounded()
.start_slot(
div()
.id(SharedString::from(format!(
"exception-breakpoint-ui-item-{}-click-handler",
self.id
)))
.on_click(move |_, _, cx| {
list.update(cx, |this, cx| {
this.session.update(cx, |this, cx| {
this.toggle_exception_breakpoint(&id, cx);
});
cx.notify();
})
.ok();
})
.cursor_pointer()
.child(Indicator::icon(Icon::new(IconName::Flame)).color(color)),
)
.child(
div()
.py_1()
.gap_1()
.child(
Label::new(self.data.label)
.size(LabelSize::Small)
.line_height_style(ui::LineHeightStyle::UiLabel),
)
.children(self.data.description.map(|description| {
Label::new(description)
.size(LabelSize::XSmall)
.line_height_style(ui::LineHeightStyle::UiLabel)
.color(Color::Muted)
})),
)
}
}
#[derive(Clone, Debug)]
enum BreakpointEntryKind {
LineBreakpoint(LineBreakpoint),
ExceptionBreakpoint(ExceptionBreakpoint),
}
#[derive(Clone, Debug)]
struct BreakpointEntry {
kind: BreakpointEntryKind,
weak: WeakEntity<BreakpointList>,
}
impl RenderOnce for BreakpointEntry {
fn render(self, _: &mut ui::Window, _: &mut App) -> impl ui::IntoElement {
match self.kind {
BreakpointEntryKind::LineBreakpoint(line_breakpoint) => {
line_breakpoint.render(self.weak)
}
BreakpointEntryKind::ExceptionBreakpoint(exception_breakpoint) => {
exception_breakpoint.render(self.weak)
}
}
}
}

5
crates/debugger_ui/src/session/running/console.rs
View file

@ -17,7 +17,7 @@ use project::{
use settings::Settings;
use std::{cell::RefCell, rc::Rc, usize};
use theme::ThemeSettings;
use ui::prelude::*;
use ui::{Divider, prelude::*};
pub struct Console {
console: Entity<Editor>,
@ -229,7 +229,8 @@ impl Render for Console {
.size_full()
.child(self.render_console(cx))
.when(self.is_local(cx), |this| {
this.child(self.render_query_bar(cx))
this.child(Divider::horizontal())
.child(self.render_query_bar(cx))
.pt(DynamicSpacing::Base04.rems(cx))
})
.border_2()

3
crates/icons/src/icons.rs
View file

@ -39,6 +39,7 @@ pub enum IconName {
BellDot,
BellOff,
BellRing,
Binary,
Blocks,
Bolt,
Book,
@ -119,6 +120,7 @@ pub enum IconName {
FileToml,
FileTree,
Filter,
Flame,
Folder,
FolderOpen,
FolderX,
@ -126,6 +128,7 @@ pub enum IconName {
FontSize,
FontWeight,
ForwardArrow,
Function,
GenericClose,
GenericMaximize,
GenericMinimize,

19
crates/project/src/debugger/breakpoint_store.rs
View file

@ -12,7 +12,7 @@ use rpc::{
proto::{self},
};
use std::{hash::Hash, ops::Range, path::Path, sync::Arc};
use text::PointUtf16;
use text::{Point, PointUtf16};
use crate::{Project, ProjectPath, buffer_store::BufferStore, worktree_store::WorktreeStore};
@ -464,6 +464,23 @@ impl BreakpointStore {
cx.notify();
}
pub fn breakpoint_at_row(
&self,
path: &Path,
row: u32,
cx: &App,
) -> Option<(Entity<Buffer>, (text::Anchor, Breakpoint))> {
self.breakpoints.get(path).and_then(|breakpoints| {
let snapshot = breakpoints.buffer.read(cx).text_snapshot();
breakpoints
.breakpoints
.iter()
.find(|(anchor, _)| anchor.summary::<Point>(&snapshot).row == row)
.map(|breakpoint| (breakpoints.buffer.clone(), breakpoint.clone()))
})
}
pub fn breakpoints_from_path(&self, path: &Arc<Path>, cx: &App) -> Vec<SourceBreakpoint> {
self.breakpoints
.get(path)

40
crates/project/src/debugger/dap_command.rs
View file

@ -2,7 +2,7 @@ use std::sync::Arc;
use anyhow::{Ok, Result, anyhow};
use dap::{
Capabilities, ContinueArguments, InitializeRequestArguments,
Capabilities, ContinueArguments, ExceptionFilterOptions, InitializeRequestArguments,
InitializeRequestArgumentsPathFormat, NextArguments, SetVariableResponse, SourceBreakpoint,
StepInArguments, StepOutArguments, SteppingGranularity, ValueFormat, Variable,
VariablesArgumentsFilter,
@ -1665,6 +1665,44 @@ impl LocalDapCommand for SetBreakpoints {
Ok(message.breakpoints)
}
}
#[derive(Clone, Debug, Hash, PartialEq)]
pub(super) enum SetExceptionBreakpoints {
Plain {
filters: Vec<String>,
},
WithOptions {
filters: Vec<ExceptionFilterOptions>,
},
}
impl LocalDapCommand for SetExceptionBreakpoints {
type Response = Vec<dap::Breakpoint>;
type DapRequest = dap::requests::SetExceptionBreakpoints;
fn to_dap(&self) -> <Self::DapRequest as dap::requests::Request>::Arguments {
match self {
SetExceptionBreakpoints::Plain { filters } => dap::SetExceptionBreakpointsArguments {
filters: filters.clone(),
exception_options: None,
filter_options: None,
},
SetExceptionBreakpoints::WithOptions { filters } => {
dap::SetExceptionBreakpointsArguments {
filters: vec![],
filter_options: Some(filters.clone()),
exception_options: None,
}
}
}
}
fn response_from_dap(
&self,
message: <Self::DapRequest as dap::requests::Request>::Response,
) -> Result<Self::Response> {
Ok(message.breakpoints.unwrap_or_default())
}
}
#[derive(Clone, Debug, Hash, PartialEq, Eq)]
pub(super) struct LocationsCommand {

6
crates/project/src/debugger/dap_store.rs
View file

@ -852,8 +852,7 @@ fn create_new_session(
cx.emit(DapStoreEvent::DebugClientStarted(session_id));
cx.notify();
})?;
match {
let seq_result = {
session
.update(cx, |session, cx| session.request_initialize(cx))?
.await?;
@ -863,7 +862,8 @@ fn create_new_session(
session.initialize_sequence(initialized_rx, cx)
})?
.await
} {
};
match seq_result {
Ok(_) => {}
Err(error) => {
this.update(cx, |this, cx| {

125
crates/project/src/debugger/session.rs
View file

@ -7,9 +7,9 @@ use super::dap_command::{
self, Attach, ConfigurationDone, ContinueCommand, DapCommand, DisconnectCommand,
EvaluateCommand, Initialize, Launch, LoadedSourcesCommand, LocalDapCommand, LocationsCommand,
ModulesCommand, NextCommand, PauseCommand, RestartCommand, RestartStackFrameCommand,
ScopesCommand, SetVariableValueCommand, StackTraceCommand, StepBackCommand, StepCommand,
StepInCommand, StepOutCommand, TerminateCommand, TerminateThreadsCommand, ThreadsCommand,
VariablesCommand,
ScopesCommand, SetExceptionBreakpoints, SetVariableValueCommand, StackTraceCommand,
StepBackCommand, StepCommand, StepInCommand, StepOutCommand, TerminateCommand,
TerminateThreadsCommand, ThreadsCommand, VariablesCommand,
};
use super::dap_store::DapAdapterDelegate;
use anyhow::{Context as _, Result, anyhow};
@ -23,7 +23,10 @@ use dap::{
client::{DebugAdapterClient, SessionId},
messages::{Events, Message},
};
use dap::{DapRegistry, DebugRequestType, OutputEventCategory};
use dap::{
DapRegistry, DebugRequestType, ExceptionBreakpointsFilter, ExceptionFilterOptions,
OutputEventCategory,
};
use futures::channel::oneshot;
use futures::{FutureExt, future::Shared};
use gpui::{
@ -34,6 +37,7 @@ use serde_json::{Value, json};
use settings::Settings;
use smol::stream::StreamExt;
use std::any::TypeId;
use std::collections::BTreeMap;
use std::path::PathBuf;
use std::u64;
use std::{
@ -324,6 +328,13 @@ impl LocalMode {
}
}
session
.client
.on_request::<dap::requests::SetExceptionBreakpoints, _>(move |_, _| {
Ok(dap::SetExceptionBreakpointsResponse { breakpoints: None })
})
.await;
session
.client
.on_request::<dap::requests::Disconnect, _>(move |_, _| Ok(()))
@ -456,7 +467,31 @@ impl LocalMode {
})
}
fn send_all_breakpoints(&self, ignore_breakpoints: bool, cx: &App) -> Task<()> {
fn send_exception_breakpoints(
&self,
filters: Vec<ExceptionBreakpointsFilter>,
supports_filter_options: bool,
cx: &App,
) -> Task<Result<Vec<dap::Breakpoint>>> {
let arg = if supports_filter_options {
SetExceptionBreakpoints::WithOptions {
filters: filters
.into_iter()
.map(|filter| ExceptionFilterOptions {
filter_id: filter.filter,
condition: None,
mode: None,
})
.collect(),
}
} else {
SetExceptionBreakpoints::Plain {
filters: filters.into_iter().map(|filter| filter.filter).collect(),
}
};
self.request(arg, cx.background_executor().clone())
}
fn send_source_breakpoints(&self, ignore_breakpoints: bool, cx: &App) -> Task<()> {
let mut breakpoint_tasks = Vec::new();
let breakpoints = self
.breakpoint_store
@ -588,15 +623,37 @@ impl LocalMode {
};
let configuration_done_supported = ConfigurationDone::is_supported(capabilities);
let exception_filters = capabilities
.exception_breakpoint_filters
.as_ref()
.map(|exception_filters| {
exception_filters
.iter()
.filter(|filter| filter.default == Some(true))
.cloned()
.collect::<Vec<_>>()
})
.unwrap_or_default();
let supports_exception_filters = capabilities
.supports_exception_filter_options
.unwrap_or_default();
let configuration_sequence = cx.spawn({
let this = self.clone();
async move |cx| {
initialized_rx.await?;
// todo(debugger) figure out if we want to handle a breakpoint response error
// This will probably consist of letting a user know that breakpoints failed to be set
cx.update(|cx| this.send_all_breakpoints(false, cx))?.await;
cx.update(|cx| this.send_source_breakpoints(false, cx))?
.await;
cx.update(|cx| {
this.send_exception_breakpoints(
exception_filters,
supports_exception_filters,
cx,
)
})?
.await
.ok();
if configuration_done_supported {
this.request(ConfigurationDone {}, cx.background_executor().clone())
} else {
@ -727,6 +784,8 @@ impl ThreadStates {
}
const MAX_TRACKED_OUTPUT_EVENTS: usize = 5000;
type IsEnabled = bool;
#[derive(Copy, Clone, Default, Debug, PartialEq, PartialOrd, Eq, Ord)]
pub struct OutputToken(pub usize);
/// Represents a current state of a single debug adapter and provides ways to mutate it.
@ -748,6 +807,7 @@ pub struct Session {
locations: HashMap<u64, dap::LocationsResponse>,
is_session_terminated: bool,
requests: HashMap<TypeId, HashMap<RequestSlot, Shared<Task<Option<()>>>>>,
exception_breakpoints: BTreeMap<String, (ExceptionBreakpointsFilter, IsEnabled)>,
_background_tasks: Vec<Task<()>>,
}
@ -956,6 +1016,7 @@ impl Session {
_background_tasks: Vec::default(),
locations: Default::default(),
is_session_terminated: false,
exception_breakpoints: Default::default(),
}
}
@ -1022,6 +1083,18 @@ impl Session {
let capabilities = capabilities.await?;
this.update(cx, |session, _| {
session.capabilities = capabilities;
let filters = session
.capabilities
.exception_breakpoint_filters
.clone()
.unwrap_or_default();
for filter in filters {
let default = filter.default.unwrap_or_default();
session
.exception_breakpoints
.entry(filter.filter.clone())
.or_insert_with(|| (filter, default));
}
})?;
Ok(())
})
@ -1464,13 +1537,46 @@ impl Session {
self.ignore_breakpoints = ignore;
if let Some(local) = self.as_local() {
local.send_all_breakpoints(ignore, cx)
local.send_source_breakpoints(ignore, cx)
} else {
// todo(debugger): We need to propagate this change to downstream sessions and send a message to upstream sessions
unimplemented!()
}
}
pub fn exception_breakpoints(
&self,
) -> impl Iterator<Item = &(ExceptionBreakpointsFilter, IsEnabled)> {
self.exception_breakpoints.values()
}
pub fn toggle_exception_breakpoint(&mut self, id: &str, cx: &App) {
if let Some((_, is_enabled)) = self.exception_breakpoints.get_mut(id) {
*is_enabled = !*is_enabled;
self.send_exception_breakpoints(cx);
}
}
fn send_exception_breakpoints(&mut self, cx: &App) {
if let Some(local) = self.as_local() {
let exception_filters = self
.exception_breakpoints
.values()
.filter_map(|(filter, is_enabled)| is_enabled.then(|| filter.clone()))
.collect();
let supports_exception_filters = self
.capabilities
.supports_exception_filter_options
.unwrap_or_default();
local
.send_exception_breakpoints(exception_filters, supports_exception_filters, cx)
.detach_and_log_err(cx);
} else {
debug_assert!(false, "Not implemented");
}
}
pub fn breakpoints_enabled(&self) -> bool {
self.ignore_breakpoints
}
@ -2084,6 +2190,7 @@ fn create_local_session(
threads: IndexMap::default(),
stack_frames: IndexMap::default(),
locations: Default::default(),
exception_breakpoints: Default::default(),
_background_tasks,
is_session_terminated: false,
}