Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

debugger: Add hover tree UI (#53198)

Tortesafff3d26164b
diff --git a/assets/keymaps/default-linux.json b/assets/keymaps/default-linux.json
index 5d7aa8f5833..d436da468d3 100644
--- a/assets/keymaps/default-linux.json
+++ b/assets/keymaps/default-linux.json
@@ -908,6 +908,27 @@
"down": "editor::SignatureHelpNext",
},
},
+ {
+ "context": "Editor && DebuggerHover",
+ "bindings": {
+ "escape": "editor::Cancel",
+ "left": "editor::DebuggerHoverCollapseSelected",
+ "down": "editor::DebuggerHoverSelectNext",
+ "up": "editor::DebuggerHoverSelectPrevious",
+ "right": "editor::DebuggerHoverExpandSelected",
+ },
+ },
+ {
+ "context": "DebuggerHoverMenu",
+ "bindings": {
+ "enter": "menu::Confirm",
+ "escape": "menu::Cancel",
+ "up": "menu::SelectPrevious",
+ "down": "menu::SelectNext",
+ "home": "menu::SelectFirst",
+ "end": "menu::SelectLast",
+ },
+ },
// Custom bindings
{
"bindings": {
diff --git a/assets/keymaps/default-macos.json b/assets/keymaps/default-macos.json
index f084301b614..e4d0fe51ed0 100644
--- a/assets/keymaps/default-macos.json
+++ b/assets/keymaps/default-macos.json
@@ -961,6 +961,27 @@
"down": "editor::SignatureHelpNext",
},
},
+ {
+ "context": "Editor && DebuggerHover",
+ "bindings": {
+ "escape": "editor::Cancel",
+ "left": "editor::DebuggerHoverCollapseSelected",
+ "down": "editor::DebuggerHoverSelectNext",
+ "up": "editor::DebuggerHoverSelectPrevious",
+ "right": "editor::DebuggerHoverExpandSelected",
+ },
+ },
+ {
+ "context": "DebuggerHoverMenu",
+ "bindings": {
+ "enter": "menu::Confirm",
+ "escape": "menu::Cancel",
+ "up": "menu::SelectPrevious",
+ "down": "menu::SelectNext",
+ "home": "menu::SelectFirst",
+ "end": "menu::SelectLast",
+ },
+ },
// Custom bindings
{
"use_key_equivalents": true,
diff --git a/assets/keymaps/default-windows.json b/assets/keymaps/default-windows.json
index 0f2a06b6cee..66327800a73 100644
--- a/assets/keymaps/default-windows.json
+++ b/assets/keymaps/default-windows.json
@@ -906,6 +906,27 @@
"down": "editor::SignatureHelpNext",
},
},
+ {
+ "context": "Editor && DebuggerHover",
+ "bindings": {
+ "escape": "editor::Cancel",
+ "left": "editor::DebuggerHoverCollapseSelected",
+ "down": "editor::DebuggerHoverSelectNext",
+ "up": "editor::DebuggerHoverSelectPrevious",
+ "right": "editor::DebuggerHoverExpandSelected",
+ },
+ },
+ {
+ "context": "DebuggerHoverMenu",
+ "bindings": {
+ "enter": "menu::Confirm",
+ "escape": "menu::Cancel",
+ "up": "menu::SelectPrevious",
+ "down": "menu::SelectNext",
+ "home": "menu::SelectFirst",
+ "end": "menu::SelectLast",
+ },
+ },
// Custom bindings
{
"use_key_equivalents": true,
diff --git a/assets/keymaps/vim.json b/assets/keymaps/vim.json
index b8152333bde..9c765b2aa92 100644
--- a/assets/keymaps/vim.json
+++ b/assets/keymaps/vim.json
@@ -1008,6 +1008,20 @@
"space w q": "pane::CloseActiveItem",
},
},
+ {
+ "context": "Editor && DebuggerHover && VimControl && (vim_mode == normal || vim_mode == helix_normal)",
+ "bindings": {
+ "escape": "editor::Cancel",
+ "h": "editor::DebuggerHoverCollapseSelected",
+ "j": "editor::DebuggerHoverSelectNext",
+ "k": "editor::DebuggerHoverSelectPrevious",
+ "l": "editor::DebuggerHoverExpandSelected",
+ "left": "editor::DebuggerHoverCollapseSelected",
+ "down": "editor::DebuggerHoverSelectNext",
+ "up": "editor::DebuggerHoverSelectPrevious",
+ "right": "editor::DebuggerHoverExpandSelected"
+ }
+ },
{
// netrw compatibility
"context": "ProjectPanel && not_editing",
diff --git a/crates/debugger_ui/src/tests.rs b/crates/debugger_ui/src/tests.rs
index 4b4cebb2931..71e83c4749a 100644
--- a/crates/debugger_ui/src/tests.rs
+++ b/crates/debugger_ui/src/tests.rs
@@ -21,6 +21,8 @@ mod dap_logger;
#[cfg(test)]
mod debugger_panel;
#[cfg(test)]
+mod hover_values;
+#[cfg(test)]
mod inline_values;
#[cfg(test)]
mod module_list;
diff --git a/crates/debugger_ui/src/tests/hover_values.rs b/crates/debugger_ui/src/tests/hover_values.rs
new file mode 100644
index 00000000000..0401e407c93
--- /dev/null
+++ b/crates/debugger_ui/src/tests/hover_values.rs
@@ -0,0 +1,1012 @@
+#![expect(clippy::result_large_err)]
+
+use dap::{
+ StackFrame, Variable,
+ requests::{Evaluate, Scopes, StackTrace, Threads, Variables},
+};
+use editor::{
+ Editor, EditorMode, MultiBuffer, MultiBufferOffset, SelectionEffects,
+ actions::{
+ Cancel as CancelAction, DebuggerHoverExpandSelected, DebuggerHoverSelectNext,
+ Hover as HoverAction,
+ },
+};
+use gpui::{BackgroundExecutor, Focusable as _, Modifiers, TestAppContext, VisualTestContext};
+use language::rust_lang;
+use project::{FakeFs, Project};
+use serde_json::json;
+use std::sync::{
+ Arc,
+ atomic::{AtomicUsize, Ordering},
+};
+use util::path;
+
+use crate::{
+ debugger_panel::DebugPanel,
+ tests::{init_test, init_test_workspace, start_debug_session},
+};
+
+const SOURCE: &str =
+ "fn main() {\n let value = 42;\n let x = value + 1;\n println!(\"{}\", x);\n}\n";
+
+#[gpui::test]
+async fn test_hover_horizontal_scrollbar_drag_is_stable(
+ executor: BackgroundExecutor,
+ cx: &mut TestAppContext,
+) {
+ const SOURCE: &str = "fn main() {\n let a = 0;\n let b = vec![\"heyy\"];\n println!(\"{a} {b:?}\");\n}\n";
+ const VECTOR_TYPE: &str = "alloc::vec::Vec<&str, alloc::alloc::Global>";
+ init_test(cx);
+ let fs = FakeFs::new(executor);
+ fs.insert_tree(path!("/project"), json!({ "main.rs": SOURCE }))
+ .await;
+ let project = Project::test(fs, [path!("/project").as_ref()], cx).await;
+ let workspace = init_test_workspace(&project, cx).await;
+ workspace
+ .update(cx, |workspace, window, cx| {
+ workspace.focus_panel::<DebugPanel>(window, cx);
+ })
+ .unwrap();
+ let session = start_debug_session(&workspace, cx, |_| {}).unwrap();
+ let client = session.update(cx, |session, _| session.adapter_client().unwrap());
+ client.on_request::<Threads, _>(|_, _| {
+ Ok(
+ serde_json::from_value(json!({"threads": [{"id": 1, "name": "main"}]}))
+ .expect("threads fixture"),
+ )
+ });
+ client.on_request::<StackTrace, _>(|_, _| {
+ Ok(serde_json::from_value(json!({
+ "stackFrames": [{"id": 1, "name": "main", "line": 4, "column": 1,
+ "source": {"name": "main.rs", "path": path!("/project/main.rs")}}]
+ }))
+ .expect("stack fixture"))
+ });
+ client.on_request::<Scopes, _>(|_, _| Ok(dap::ScopesResponse { scopes: vec![] }));
+ client.on_request::<Evaluate, _>(|_, args| {
+ assert_eq!(args.expression, "b");
+ Ok(serde_json::from_value(json!({
+ "result": "size=1", "type": VECTOR_TYPE, "variablesReference": 1
+ }))
+ .expect("evaluate fixture"))
+ });
+ client.on_request::<Variables, _>(|_, args| {
+ let variables = match args.variables_reference {
+ 1 => json!([
+ {"name": "[0]", "value": "\"heyy\"", "variablesReference": 2},
+ {"name": "[raw]", "value": VECTOR_TYPE, "variablesReference": 3}
+ ]),
+ 3 => json!([
+ {"name": "buf", "value": "{inner:{ptr:{pointer:\"\\xd0c\\U00000003\"}, _marker:{}}, cap:{0:1}, alloc:{}}", "variablesReference": 4},
+ {"name": "len", "value": "1", "variablesReference": 0}
+ ]),
+ reference => panic!("unexpected variables reference {reference}"),
+ };
+ Ok(serde_json::from_value(json!({"variables": variables})).expect("variables fixture"))
+ });
+ let buffer = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer(path!("/project/main.rs"), cx)
+ })
+ .await
+ .unwrap();
+ buffer.update(cx, |buffer, cx| buffer.set_language(Some(rust_lang()), cx));
+ let (editor, editor_cx) = cx.add_window_view(|window, cx| {
+ Editor::new(
+ EditorMode::full(),
+ MultiBuffer::build_from_buffer(buffer, cx),
+ Some(project),
+ window,
+ cx,
+ )
+ });
+ editor_cx.simulate_resize(gpui::size(gpui::px(900.), gpui::px(582.)));
+ focus_editor(&editor, editor_cx);
+ client
+ .fake_event(dap::messages::Events::Stopped(
+ serde_json::from_value(json!({
+ "reason": "breakpoint", "threadId": 1, "allThreadsStopped": true
+ }))
+ .unwrap(),
+ ))
+ .await;
+ editor_cx.run_until_parked();
+ trigger_hover(&editor, editor_cx, SOURCE.find("b =").unwrap());
+ editor_cx.run_until_parked();
+ let toggle = editor_cx
+ .debug_bounds("debugger-hover-toggle-1")
+ .expect("raw disclosure");
+ editor_cx.simulate_click(toggle.center(), Modifiers::none());
+ editor_cx.run_until_parked();
+ assert!(editor_cx.debug_bounds("debugger-hover-node-1-0").is_some());
+ let handle = editor.read_with(editor_cx, |editor, _| {
+ editor.hover_state.info_popovers[0].scroll_handle.clone()
+ });
+ let viewport = handle.bounds();
+ let max_offset = handle.max_offset();
+ assert!(max_offset.x > gpui::px(100.));
+ let start = gpui::point(
+ viewport.left() + gpui::px(40.),
+ viewport.bottom() - gpui::px(7.),
+ );
+ editor_cx.simulate_mouse_move(start, None, Modifiers::none());
+ editor_cx.simulate_mouse_down(start, gpui::MouseButton::Left, Modifiers::none());
+ let mut position = start + gpui::point(gpui::px(60.), gpui::px(0.));
+ editor_cx.simulate_mouse_move(position, Some(gpui::MouseButton::Left), Modifiers::none());
+ let mut previous_offset = handle.offset();
+ assert!(previous_offset.x < gpui::px(0.));
+ let pixels_per_pointer_pixel = -previous_offset.x / gpui::px(60.);
+ for step in 0..20 {
+ position.x += gpui::px(1.);
+ editor_cx.simulate_mouse_move(position, Some(gpui::MouseButton::Left), Modifiers::none());
+ let offset = handle.offset();
+ assert_eq!(handle.bounds(), viewport);
+ assert_eq!(handle.max_offset(), max_offset);
+ assert!(
+ (offset.x - previous_offset.x + gpui::px(pixels_per_pointer_pixel)).abs()
+ < gpui::px(0.1),
+ "drag step {step}: a one-pixel pointer move must not jump the content: {previous_offset:?} -> {offset:?}, expected {} pixels",
+ pixels_per_pointer_pixel
+ );
+ previous_offset = offset;
+ }
+ editor_cx.simulate_mouse_up(position, gpui::MouseButton::Left, Modifiers::none());
+ handle.set_offset(gpui::point(-max_offset.x, gpui::px(0.)));
+ editor_cx.update(|window, cx| window.draw(cx).clear(cx));
+ let value_bounds = editor_cx
+ .debug_bounds("debugger-hover-node-1-0-value-container")
+ .expect("expanded buffer value");
+ assert!(
+ value_bounds.right() <= viewport.right(),
+ "the full value must be reachable at the horizontal scroll limit: {value_bounds:?}, viewport {viewport:?}"
+ );
+}
+
+fn open_variable_menu(editor_cx: &mut VisualTestContext, selector: &'static str) {
+ let bounds = editor_cx
+ .debug_bounds(selector)
+ .expect("expected variable row");
+ editor_cx.simulate_mouse_down(bounds.center(), gpui::MouseButton::Right, Modifiers::none());
+ editor_cx.simulate_mouse_up(bounds.center(), gpui::MouseButton::Right, Modifiers::none());
+ for _ in 0..3 {
+ editor_cx.refresh().unwrap();
+ editor_cx.update(|window, cx| {
+ window.simulate_next_frame(cx);
+ });
+ editor_cx.run_until_parked();
+ }
+ assert!(
+ editor_cx.debug_bounds("MENU_ITEM-Copy Value").is_some(),
+ "expected visible variable menu"
+ );
+}
+
+fn trigger_hover(editor: &gpui::Entity<Editor>, cx: &mut VisualTestContext, offset: usize) {
+ editor.update_in(cx, |editor, window, cx| {
+ editor.change_selections(SelectionEffects::no_scroll(), window, cx, |selection| {
+ selection.select_ranges([MultiBufferOffset(offset)..MultiBufferOffset(offset)])
+ });
+ editor::hover_popover::hover(editor, &HoverAction, window, cx);
+ });
+}
+
+fn focus_editor(editor: &gpui::Entity<Editor>, cx: &mut VisualTestContext) {
+ editor.update_in(cx, |editor, window, cx| {
+ window.focus(&editor.focus_handle(cx), cx);
+ });
+}
+
+fn editor_has_focus(editor: &gpui::Entity<Editor>, cx: &mut VisualTestContext) -> bool {
+ cx.update(|window, app| {
+ editor.read_with(app, |editor, cx| editor.focus_handle(cx).is_focused(window))
+ })
+}
+
+fn hover_uses_keyboard_grace<C: gpui::AppContext>(editor: &gpui::Entity<Editor>, cx: &C) -> bool {
+ editor.read_with(cx, |editor, _| {
+ editor
+ .hover_state
+ .info_popovers
+ .first()
+ .is_some_and(|popover| *popover.keyboard_grace.borrow())
+ })
+}
+
+fn hover_is_visible<C: gpui::AppContext>(editor: &gpui::Entity<Editor>, cx: &C) -> bool {
+ editor.read_with(cx, |editor, _| editor.hover_state.visible())
+}
+
+fn hover_has_markdown_content<C: gpui::AppContext>(editor: &gpui::Entity<Editor>, cx: &C) -> bool {
+ editor.read_with(cx, |editor, _| {
+ editor
+ .hover_state
+ .info_popovers
+ .first()
+ .is_some_and(|popover| popover.parsed_content.is_some())
+ })
+}
+
+#[gpui::test]
+async fn test_hover_values_after_debugger_stop_when_hover_is_retriggered(
+ executor: BackgroundExecutor,
+ cx: &mut TestAppContext,
+) {
+ const VALUE: &str = "first line\nsecond line\nthird line with a long value that must remain fully readable and copyable without truncation";
+ let watch_requests = Arc::new(AtomicUsize::new(0));
+ init_test(cx);
+ let fs = FakeFs::new(executor);
+ fs.insert_tree(path!("/project"), json!({ "main.rs": SOURCE }))
+ .await;
+ let project = Project::test(fs, [path!("/project").as_ref()], cx).await;
+ let workspace = init_test_workspace(&project, cx).await;
+ workspace
+ .update(cx, |workspace, window, cx| {
+ workspace.focus_panel::<DebugPanel>(window, cx)
+ })
+ .unwrap();
+ let cx = &mut VisualTestContext::from_window(*workspace, cx);
+
+ let session = start_debug_session(&workspace, cx, |_| {}).unwrap();
+ let client = session.update(cx, |session, _| session.adapter_client().unwrap());
+ client.on_request::<Threads, _>(move |_, _| {
+ Ok(dap::ThreadsResponse {
+ threads: vec![dap::Thread {
+ id: 1,
+ name: "Thread 1".into(),
+ }],
+ })
+ });
+ client.on_request::<StackTrace, _>(move |_, _| {
+ Ok(dap::StackTraceResponse {
+ stack_frames: vec![StackFrame {
+ id: 1,
+ name: "Stack Frame 1".into(),
+ source: Some(dap::Source {
+ name: Some("main.rs".into()),
+ path: Some(path!("/project/main.rs").into()),
+ source_reference: None,
+ presentation_hint: None,
+ origin: None,
+ sources: None,
+ adapter_data: None,
+ checksums: None,
+ }),
+ line: 3,
+ column: 1,
+ end_line: None,
+ end_column: None,
+ can_restart: None,
+ instruction_pointer_reference: None,
+ module_id: None,
+ presentation_hint: None,
+ }],
+ total_frames: None,
+ })
+ });
+ client.on_request::<Scopes, _>(move |_, _| Ok(dap::ScopesResponse { scopes: vec![] }));
+ client.on_request::<Evaluate, _>({
+ let watch_requests = watch_requests.clone();
+ move |_, args| {
+ assert_eq!(args.expression, "value");
+ if args.context == Some(dap::EvaluateArgumentsContext::Watch) {
+ watch_requests.fetch_add(1, Ordering::SeqCst);
+ } else {
+ assert_eq!(args.context, Some(dap::EvaluateArgumentsContext::Hover));
+ }
+ Ok(dap::EvaluateResponse {
+ result: VALUE.into(),
+ type_: Some("i32".into()),
+ presentation_hint: None,
+ variables_reference: 0,
+ named_variables: None,
+ indexed_variables: None,
+ memory_reference: None,
+ value_location_reference: None,
+ })
+ }
+ });
+
+ let buffer = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer(path!("/project/main.rs"), cx)
+ })
+ .await
+ .unwrap();
+ buffer.update(cx, |buffer, cx| buffer.set_language(Some(rust_lang()), cx));
+ cx.run_until_parked();
+
+ let (editor, editor_cx) = cx.add_window_view(|window, cx| {
+ Editor::new(
+ EditorMode::full(),
+ MultiBuffer::build_from_buffer(buffer.clone(), cx),
+ Some(project.clone()),
+ window,
+ cx,
+ )
+ });
+ editor_cx.run_until_parked();
+
+ let hover_offset = SOURCE.find("value + 1").unwrap();
+ trigger_hover(&editor, editor_cx, hover_offset);
+ editor_cx.run_until_parked();
+ assert!(editor_cx.debug_bounds("debugger-hover-node-root").is_none());
+
+ client
+ .fake_event(dap::messages::Events::Stopped(dap::StoppedEvent {
+ reason: dap::StoppedEventReason::Pause,
+ description: None,
+ thread_id: Some(1),
+ preserve_focus_hint: None,
+ text: None,
+ all_threads_stopped: None,
+ hit_breakpoint_ids: None,
+ }))
+ .await;
+
+ editor_cx.run_until_parked();
+ trigger_hover(&editor, editor_cx, hover_offset);
+ editor_cx.run_until_parked();
+
+ assert!(
+ editor_cx.debug_bounds("debugger-hover-node-root").is_some(),
+ "expected visible debugger hover tree after stop"
+ );
+ assert!(
+ editor_cx
+ .debug_bounds("debugger-hover-toggle-root")
+ .is_none(),
+ "expected scalar hover to render without a disclosure toggle"
+ );
+ assert!(
+ !hover_has_markdown_content(&editor, editor_cx),
+ "expected debugger hover to render without the old markdown value block"
+ );
+ let root_bounds = editor_cx
+ .debug_bounds("debugger-hover-node-root")
+ .expect("expected debugger hover root bounds");
+ assert!(
+ root_bounds.size.width >= gpui::px(280.),
+ "expected a readable hover width after reserving its scrollbar track, got {:?}",
+ root_bounds.size.width
+ );
+ let value_bounds = editor_cx
+ .debug_bounds("debugger-hover-node-root-value-container")
+ .expect("expected debugger hover value bounds");
+ assert!(
+ value_bounds.size.width >= gpui::px(48.),
+ "expected debugger hover to keep short values visible"
+ );
+ assert!(
+ root_bounds.size.height > gpui::px(40.),
+ "multiline values must not be flattened to one line"
+ );
+ focus_editor(&editor, editor_cx);
+ editor_cx.update(|_, cx| {
+ let bindings = settings::KeymapFile::load_asset_allow_partial_failure(
+ settings::DEFAULT_KEYMAP_PATH,
+ cx,
+ )
+ .unwrap();
+ cx.bind_keys(bindings);
+ });
+
+ open_variable_menu(editor_cx, "debugger-hover-node-root");
+ assert!(
+ hover_is_visible(&editor, editor_cx),
+ "focusing the menu must preserve the hover"
+ );
+ assert!(
+ !editor_has_focus(&editor, editor_cx),
+ "menu must receive keyboard focus"
+ );
+ editor_cx.simulate_keystrokes("enter");
+ editor_cx.run_until_parked();
+ assert_eq!(
+ editor_cx.read_from_clipboard().unwrap().text().as_deref(),
+ Some(VALUE)
+ );
+
+ open_variable_menu(editor_cx, "debugger-hover-node-root");
+ editor_cx.simulate_keystrokes("down enter");
+ editor_cx.run_until_parked();
+ assert_eq!(
+ editor_cx.read_from_clipboard().unwrap().text().as_deref(),
+ Some("value")
+ );
+
+ open_variable_menu(editor_cx, "debugger-hover-node-root");
+ editor_cx.simulate_keystrokes("down down enter");
+ editor_cx.run_until_parked();
+ assert_eq!(watch_requests.load(Ordering::SeqCst), 1);
+ session.read_with(editor_cx, |session, _| {
+ assert_eq!(
+ session.watchers().get("value").unwrap().value.as_ref(),
+ VALUE
+ );
+ });
+}
+
+#[gpui::test]
+async fn test_hover_values_load_children_on_expand(
+ executor: BackgroundExecutor,
+ cx: &mut TestAppContext,
+) {
+ init_test(cx);
+ let fs = FakeFs::new(executor);
+ let source = format!(
+ "fn main() {{\n{}{indent}let value = 42;\n{indent}let x = value + 1;\n}}\n",
+ "\n".repeat(20),
+ indent = " "
+ );
+ fs.insert_tree(path!("/project"), json!({ "main.rs": source }))
+ .await;
+ let project = Project::test(fs, [path!("/project").as_ref()], cx).await;
+ let workspace = init_test_workspace(&project, cx).await;
+ workspace
+ .update(cx, |workspace, window, cx| {
+ workspace.focus_panel::<DebugPanel>(window, cx)
+ })
+ .unwrap();
+ let cx = &mut VisualTestContext::from_window(*workspace, cx);
+
+ let session = start_debug_session(&workspace, cx, |_| {}).unwrap();
+ let client = session.update(cx, |session, _| session.adapter_client().unwrap());
+ client.on_request::<Threads, _>(move |_, _| {
+ Ok(dap::ThreadsResponse {
+ threads: vec![dap::Thread {
+ id: 1,
+ name: "Thread 1".into(),
+ }],
+ })
+ });
+ client.on_request::<StackTrace, _>(move |_, _| {
+ Ok(dap::StackTraceResponse {
+ stack_frames: vec![StackFrame {
+ id: 1,
+ name: "Stack Frame 1".into(),
+ source: Some(dap::Source {
+ name: Some("main.rs".into()),
+ path: Some(path!("/project/main.rs").into()),
+ source_reference: None,
+ presentation_hint: None,
+ origin: None,
+ sources: None,
+ adapter_data: None,
+ checksums: None,
+ }),
+ line: 3,
+ column: 1,
+ end_line: None,
+ end_column: None,
+ can_restart: None,
+ instruction_pointer_reference: None,
+ module_id: None,
+ presentation_hint: None,
+ }],
+ total_frames: None,
+ })
+ });
+ client.on_request::<Scopes, _>(move |_, _| Ok(dap::ScopesResponse { scopes: vec![] }));
+ client.on_request::<Evaluate, _>(move |_, args| {
+ assert_eq!(args.expression, "value");
+ assert_eq!(args.context, Some(dap::EvaluateArgumentsContext::Hover));
+ Ok(dap::EvaluateResponse {
+ result: "Point { x: 42 }".into(),
+ type_: Some("Point".into()),
+ presentation_hint: None,
+ variables_reference: 1,
+ named_variables: Some(1),
+ indexed_variables: None,
+ memory_reference: None,
+ value_location_reference: None,
+ })
+ });
+
+ let variables_request_count = Arc::new(AtomicUsize::new(0));
+ client.on_request::<Variables, _>({
+ let variables_request_count = variables_request_count.clone();
+ move |_, args| {
+ variables_request_count.fetch_add(1, Ordering::SeqCst);
+ assert!(matches!(args.variables_reference, 1 | 2));
+ Ok(dap::VariablesResponse {
+ variables: vec![Variable {
+ name: if args.variables_reference == 1 {
+ "x"
+ } else {
+ "y"
+ }
+ .into(),
+ value: "42".into(),
+ type_: Some("i32".into()),
+ presentation_hint: None,
+ evaluate_name: None,
+ variables_reference: if args.variables_reference == 1 { 2 } else { 0 },
+ named_variables: None,
+ indexed_variables: None,
+ memory_reference: None,
+ declaration_location_reference: None,
+ value_location_reference: None,
+ }],
+ })
+ }
+ });
+
+ let buffer = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer(path!("/project/main.rs"), cx)
+ })
+ .await
+ .unwrap();
+ buffer.update(cx, |buffer, cx| buffer.set_language(Some(rust_lang()), cx));
+ cx.run_until_parked();
+
+ let (editor, editor_cx) = cx.add_window_view(|window, cx| {
+ Editor::new(
+ EditorMode::full(),
+ MultiBuffer::build_from_buffer(buffer.clone(), cx),
+ Some(project.clone()),
+ window,
+ cx,
+ )
+ });
+ editor_cx.run_until_parked();
+ focus_editor(&editor, editor_cx);
+
+ client
+ .fake_event(dap::messages::Events::Stopped(dap::StoppedEvent {
+ reason: dap::StoppedEventReason::Pause,
+ description: None,
+ thread_id: Some(1),
+ preserve_focus_hint: None,
+ text: None,
+ all_threads_stopped: None,
+ hit_breakpoint_ids: None,
+ }))
+ .await;
+
+ editor_cx.run_until_parked();
+ editor_cx.simulate_resize(gpui::size(gpui::px(320.), gpui::px(110.)));
+
+ let hover_offset = source.find("value + 1").unwrap();
+ trigger_hover(&editor, editor_cx, hover_offset);
+ editor_cx.run_until_parked();
+
+ assert!(editor_cx.debug_bounds("debugger-hover-node-root").is_some());
+ assert!(editor_cx.debug_bounds("debugger-hover-node-0").is_some());
+ assert_eq!(variables_request_count.load(Ordering::SeqCst), 1);
+ assert!(editor_has_focus(&editor, editor_cx));
+ assert!(hover_uses_keyboard_grace(&editor, editor_cx));
+
+ let root_bounds = editor_cx
+ .debug_bounds("debugger-hover-node-root")
+ .expect("expected root hover row bounds");
+ editor_cx.simulate_click(root_bounds.center(), Modifiers::none());
+ editor_cx.refresh().unwrap();
+ editor_cx.run_until_parked();
+ assert!(editor_cx.debug_bounds("debugger-hover-node-0").is_none());
+ let collapsed_bounds = editor_cx.debug_bounds("debugger-hover-node-root").unwrap();
+ editor_cx.simulate_click(collapsed_bounds.center(), Modifiers::none());
+ editor_cx.refresh().unwrap();
+ editor_cx.run_until_parked();
+
+ let expanded_root_bounds = editor_cx
+ .debug_bounds("debugger-hover-node-root")
+ .expect("expected root hover row bounds after expanding");
+
+ assert_eq!(variables_request_count.load(Ordering::SeqCst), 1);
+ assert!(editor_cx.debug_bounds("debugger-hover-node-0").is_some());
+ assert_eq!(
+ root_bounds.origin, expanded_root_bounds.origin,
+ "expected debugger hover root row to stay in place when expanding"
+ );
+ assert!(editor_has_focus(&editor, editor_cx));
+ assert!(!hover_uses_keyboard_grace(&editor, editor_cx));
+
+ assert!(editor_cx.debug_bounds("debugger-hover-node-0-0").is_none());
+ let toggle = editor_cx.debug_bounds("debugger-hover-toggle-0").unwrap();
+ editor_cx.simulate_click(toggle.center(), Modifiers::none());
+ editor_cx.run_until_parked();
+ assert!(editor_cx.debug_bounds("debugger-hover-node-0-0").is_some());
+ assert_eq!(
+ variables_request_count.load(Ordering::SeqCst),
+ 2,
+ "only the first layer should load automatically"
+ );
+
+ editor.update_in(editor_cx, |editor, window, cx| {
+ editor.cancel(&CancelAction, window, cx);
+ });
+ editor_cx.refresh().unwrap();
+ editor_cx.run_until_parked();
+
+ assert!(!hover_is_visible(&editor, editor_cx));
+}
+
+#[gpui::test]
+async fn test_hover_values_default_keymaps(executor: BackgroundExecutor, cx: &mut TestAppContext) {
+ init_test(cx);
+ let fs = FakeFs::new(executor);
+ fs.insert_tree(path!("/project"), json!({ "main.rs": SOURCE }))
+ .await;
+ let project = Project::test(fs, [path!("/project").as_ref()], cx).await;
+ let workspace = init_test_workspace(&project, cx).await;
+ workspace
+ .update(cx, |workspace, window, cx| {
+ workspace.focus_panel::<DebugPanel>(window, cx)
+ })
+ .unwrap();
+ let cx = &mut VisualTestContext::from_window(*workspace, cx);
+
+ let session = start_debug_session(&workspace, cx, |_| {}).unwrap();
+ let client = session.update(cx, |session, _| session.adapter_client().unwrap());
+ client.on_request::<Threads, _>(move |_, _| {
+ Ok(dap::ThreadsResponse {
+ threads: vec![dap::Thread {
+ id: 1,
+ name: "Thread 1".into(),
+ }],
+ })
+ });
+ client.on_request::<StackTrace, _>(move |_, _| {
+ Ok(dap::StackTraceResponse {
+ stack_frames: vec![StackFrame {
+ id: 1,
+ name: "Stack Frame 1".into(),
+ source: Some(dap::Source {
+ name: Some("main.rs".into()),
+ path: Some(path!("/project/main.rs").into()),
+ source_reference: None,
+ presentation_hint: None,
+ origin: None,
+ sources: None,
+ adapter_data: None,
+ checksums: None,
+ }),
+ line: 3,
+ column: 1,
+ end_line: None,
+ end_column: None,
+ can_restart: None,
+ instruction_pointer_reference: None,
+ module_id: None,
+ presentation_hint: None,
+ }],
+ total_frames: None,
+ })
+ });
+ client.on_request::<Scopes, _>(move |_, _| Ok(dap::ScopesResponse { scopes: vec![] }));
+ client.on_request::<Evaluate, _>(move |_, args| {
+ assert_eq!(args.expression, "value");
+ assert_eq!(args.context, Some(dap::EvaluateArgumentsContext::Hover));
+ Ok(dap::EvaluateResponse {
+ result: "Point { x: 42 }".into(),
+ type_: Some("Point".into()),
+ presentation_hint: None,
+ variables_reference: 1,
+ named_variables: Some(1),
+ indexed_variables: None,
+ memory_reference: None,
+ value_location_reference: None,
+ })
+ });
+ client.on_request::<Variables, _>(move |_, args| {
+ assert_eq!(args.variables_reference, 1);
+ Ok(dap::VariablesResponse {
+ variables: vec![Variable {
+ name: "x".into(),
+ value: "42".into(),
+ type_: Some("i32".into()),
+ presentation_hint: None,
+ evaluate_name: None,
+ variables_reference: 0,
+ named_variables: None,
+ indexed_variables: None,
+ memory_reference: None,
+ declaration_location_reference: None,
+ value_location_reference: None,
+ }],
+ })
+ });
+
+ let buffer = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer(path!("/project/main.rs"), cx)
+ })
+ .await
+ .unwrap();
+ buffer.update(cx, |buffer, cx| buffer.set_language(Some(rust_lang()), cx));
+ cx.run_until_parked();
+
+ let (editor, editor_cx) = cx.add_window_view(|window, cx| {
+ Editor::new(
+ EditorMode::full(),
+ MultiBuffer::build_from_buffer(buffer.clone(), cx),
+ Some(project.clone()),
+ window,
+ cx,
+ )
+ });
+ editor_cx.run_until_parked();
+ focus_editor(&editor, editor_cx);
+
+ client
+ .fake_event(dap::messages::Events::Stopped(dap::StoppedEvent {
+ reason: dap::StoppedEventReason::Pause,
+ description: None,
+ thread_id: Some(1),
+ preserve_focus_hint: None,
+ text: None,
+ all_threads_stopped: None,
+ hit_breakpoint_ids: None,
+ }))
+ .await;
+
+ editor_cx.run_until_parked();
+ let hover_offset = SOURCE.find("value + 1").unwrap();
+ for keymap in [
+ "keymaps/default-macos.json",
+ "keymaps/default-linux.json",
+ "keymaps/default-windows.json",
+ ] {
+ editor_cx.update(|_, cx| {
+ cx.clear_key_bindings();
+ let bindings = settings::KeymapFile::load_asset_allow_partial_failure(keymap, cx)
+ .expect("expected default keymap");
+ cx.bind_keys(bindings);
+ });
+ trigger_hover(&editor, editor_cx, hover_offset);
+ editor_cx.run_until_parked();
+ let selection_head = editor.read_with(editor_cx, |editor, _| {
+ editor.selections.newest_anchor().head()
+ });
+
+ assert!(hover_uses_keyboard_grace(&editor, editor_cx));
+ assert!(editor_cx.debug_bounds("debugger-hover-node-0").is_some());
+ editor_cx.simulate_keystrokes("left");
+ editor_cx.run_until_parked();
+ assert!(editor_cx.debug_bounds("debugger-hover-node-0").is_none());
+
+ editor_cx.simulate_keystrokes("right");
+ editor_cx.run_until_parked();
+ assert!(
+ editor_cx.debug_bounds("debugger-hover-node-0").is_some(),
+ "right should expand the hover with {keymap}"
+ );
+
+ editor_cx.simulate_keystrokes("down left left");
+ editor_cx.run_until_parked();
+ assert!(editor_cx.debug_bounds("debugger-hover-node-0").is_none());
+
+ editor_cx.simulate_keystrokes("right down up left");
+ editor_cx.run_until_parked();
+ assert!(editor_cx.debug_bounds("debugger-hover-node-0").is_none());
+ editor.read_with(editor_cx, |editor, _| {
+ assert_eq!(
+ editor.selections.newest_anchor().head(),
+ selection_head,
+ "hover navigation must not move the editor cursor"
+ );
+ });
+
+ editor_cx.simulate_keystrokes("escape");
+ editor_cx.run_until_parked();
+ assert!(!hover_is_visible(&editor, editor_cx));
+ assert!(editor_has_focus(&editor, editor_cx));
+ editor_cx.simulate_keystrokes("right");
+ editor.read_with(editor_cx, |editor, _| {
+ assert_ne!(
+ editor.selections.newest_anchor().head(),
+ selection_head,
+ "closing the hover must restore normal cursor navigation"
+ );
+ });
+ }
+}
+
+#[gpui::test]
+async fn test_hover_values_keyboard_selection_scrolls_into_view(
+ executor: BackgroundExecutor,
+ cx: &mut TestAppContext,
+) {
+ init_test(cx);
+ let fs = FakeFs::new(executor);
+ fs.insert_tree(path!("/project"), json!({ "main.rs": SOURCE }))
+ .await;
+ let project = Project::test(fs, [path!("/project").as_ref()], cx).await;
+ let workspace = init_test_workspace(&project, cx).await;
+ workspace
+ .update(cx, |workspace, window, cx| {
+ workspace.focus_panel::<DebugPanel>(window, cx)
+ })
+ .unwrap();
+ let cx = &mut VisualTestContext::from_window(*workspace, cx);
+
+ let session = start_debug_session(&workspace, cx, |_| {}).unwrap();
+ let client = session.update(cx, |session, _| session.adapter_client().unwrap());
+ client.on_request::<Threads, _>(move |_, _| {
+ Ok(dap::ThreadsResponse {
+ threads: vec![dap::Thread {
+ id: 1,
+ name: "Thread 1".into(),
+ }],
+ })
+ });
+ client.on_request::<StackTrace, _>(move |_, _| {
+ Ok(dap::StackTraceResponse {
+ stack_frames: vec![StackFrame {
+ id: 1,
+ name: "Stack Frame 1".into(),
+ source: Some(dap::Source {
+ name: Some("main.rs".into()),
+ path: Some(path!("/project/main.rs").into()),
+ source_reference: None,
+ presentation_hint: None,
+ origin: None,
+ sources: None,
+ adapter_data: None,
+ checksums: None,
+ }),
+ line: 3,
+ column: 1,
+ end_line: None,
+ end_column: None,
+ can_restart: None,
+ instruction_pointer_reference: None,
+ module_id: None,
+ presentation_hint: None,
+ }],
+ total_frames: None,
+ })
+ });
+ client.on_request::<Scopes, _>(move |_, _| Ok(dap::ScopesResponse { scopes: vec![] }));
+ client.on_request::<Evaluate, _>(move |_, args| {
+ assert_eq!(args.expression, "value");
+ assert_eq!(args.context, Some(dap::EvaluateArgumentsContext::Hover));
+ Ok(dap::EvaluateResponse {
+ result: "Point { x: 42 }".into(),
+ type_: Some("Point".into()),
+ presentation_hint: None,
+ variables_reference: 1,
+ named_variables: Some(10),
+ indexed_variables: None,
+ memory_reference: None,
+ value_location_reference: None,
+ })
+ });
+ client.on_request::<Variables, _>(move |_, args| {
+ assert_eq!(args.variables_reference, 1);
+ Ok(dap::VariablesResponse {
+ variables: (0..10)
+ .map(|index| Variable {
+ name: format!("field_{index}"),
+ value: format!("{index}: {}", "long value ".repeat(30)),
+ type_: Some("i32".into()),
+ presentation_hint: None,
+ evaluate_name: None,
+ variables_reference: 0,
+ named_variables: None,
+ indexed_variables: None,
+ memory_reference: None,
+ declaration_location_reference: None,
+ value_location_reference: None,
+ })
+ .collect(),
+ })
+ });
+
+ let buffer = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer(path!("/project/main.rs"), cx)
+ })
+ .await
+ .unwrap();
+ buffer.update(cx, |buffer, cx| buffer.set_language(Some(rust_lang()), cx));
+ cx.run_until_parked();
+
+ let (editor, editor_cx) = cx.add_window_view(|window, cx| {
+ Editor::new(
+ EditorMode::full(),
+ MultiBuffer::build_from_buffer(buffer.clone(), cx),
+ Some(project.clone()),
+ window,
+ cx,
+ )
+ });
+ editor_cx.run_until_parked();
+ focus_editor(&editor, editor_cx);
+ editor_cx.simulate_resize(gpui::size(gpui::px(320.), gpui::px(110.)));
+
+ client
+ .fake_event(dap::messages::Events::Stopped(dap::StoppedEvent {
+ reason: dap::StoppedEventReason::Pause,
+ description: None,
+ thread_id: Some(1),
+ preserve_focus_hint: None,
+ text: None,
+ all_threads_stopped: None,
+ hit_breakpoint_ids: None,
+ }))
+ .await;
+
+ editor_cx.run_until_parked();
+ let hover_offset = SOURCE.find("value + 1").unwrap();
+ trigger_hover(&editor, editor_cx, hover_offset);
+ editor_cx.run_until_parked();
+ editor_cx.dispatch_action(DebuggerHoverExpandSelected);
+ editor_cx.run_until_parked();
+
+ for viewport_size in [
+ gpui::size(gpui::px(320.), gpui::px(110.)),
+ gpui::size(gpui::px(180.), gpui::px(90.)),
+ ] {
+ editor_cx.simulate_resize(viewport_size);
+ editor_cx.run_until_parked();
+ editor.read_with(editor_cx, |editor, _| {
+ let bounds = editor.hover_state.info_popovers[0]
+ .last_bounds
+ .get()
+ .expect("expected hover bounds");
+ assert!(
+ bounds.is_contained_within(&gpui::Bounds::new(
+ gpui::point(gpui::px(0.), gpui::px(0.)),
+ viewport_size
+ )),
+ "expanded hover {bounds:?} must fit inside {viewport_size:?}"
+ );
+ });
+ }
+
+ let scroll_handle = editor.read_with(editor_cx, |editor, _| {
+ editor.hover_state.info_popovers[0].scroll_handle.clone()
+ });
+ let viewport = scroll_handle.bounds();
+ let max_offset = scroll_handle.max_offset();
+ let position = viewport.center();
+ for delta in [
+ gpui::point(gpui::px(-30.), gpui::px(0.)),
+ gpui::point(gpui::px(0.), gpui::px(-15.)),
+ gpui::point(gpui::px(20.), gpui::px(0.)),
+ gpui::point(gpui::px(0.), gpui::px(10.)),
+ ] {
+ let before = scroll_handle.offset();
+ editor_cx.simulate_event(gpui::ScrollWheelEvent {
+ position,
+ delta: gpui::ScrollDelta::Pixels(delta),
+ modifiers: Modifiers::none(),
+ touch_phase: gpui::TouchPhase::Moved,
+ });
+ editor_cx.run_until_parked();
+ assert_eq!(scroll_handle.bounds(), viewport);
+ assert_eq!(scroll_handle.max_offset(), max_offset);
+ assert_eq!(scroll_handle.offset(), before + delta);
+ }
+ scroll_handle.set_offset(gpui::Point::default());
+ editor_cx.refresh().unwrap();
+ editor_cx.run_until_parked();
+
+ let initial_scroll_offset = editor.update(editor_cx, |editor, _| {
+ assert!(
+ editor.hover_state.info_popovers[0]
+ .scroll_handle
+ .max_offset()
+ .x
+ > gpui::px(0.),
+ "long child values must be available through horizontal scrolling"
+ );
+ editor.hover_state.info_popovers[0].scroll_handle.offset()
+ });
+
+ for _ in 0..8 {
+ editor_cx.dispatch_action(DebuggerHoverSelectNext);
+ editor_cx.run_until_parked();
+ }
+
+ let final_scroll_offset = editor.update(editor_cx, |editor, _| {
+ editor.hover_state.info_popovers[0].scroll_handle.offset()
+ });
+
+ assert!(
+ final_scroll_offset.y < initial_scroll_offset.y,
+ "expected debugger hover to scroll downward as selection moves out of view"
+ );
+}
diff --git a/crates/editor/src/actions.rs b/crates/editor/src/actions.rs
index 635f74ddaf2..6afc5a406ef 100644
--- a/crates/editor/src/actions.rs
+++ b/crates/editor/src/actions.rs
@@ -636,6 +636,14 @@ actions!(
HalfPageUp,
/// Shows hover information for the symbol at cursor.
Hover,
+ /// Expands the selected debugger hover entry.
+ DebuggerHoverExpandSelected,
+ /// Collapses the selected debugger hover entry.
+ DebuggerHoverCollapseSelected,
+ /// Selects the next debugger hover entry.
+ DebuggerHoverSelectNext,
+ /// Selects the previous debugger hover entry.
+ DebuggerHoverSelectPrevious,
/// Increases indentation of selected lines.
Indent,
/// Inserts a UUID v4 at cursor position.
diff --git a/crates/editor/src/debugger_hover.rs b/crates/editor/src/debugger_hover.rs
new file mode 100644
index 00000000000..02b0a2ac758
--- /dev/null
+++ b/crates/editor/src/debugger_hover.rs
@@ -0,0 +1,826 @@
+use anyhow::anyhow;
+use dap::client::SessionId;
+use gpui::{
+ AnyElement, App, AsyncWindowContext, Bounds, Context, Entity, Focusable as _, Hsla,
+ InteractiveElement, IntoElement, MouseButton, MouseDownEvent, ParentElement, Pixels, Render,
+ Subscription, Task, WeakEntity, Window, canvas, div, px,
+};
+use itertools::Itertools;
+use project::{DebuggerHoverData, DebuggerHoverVariable, Project};
+use settings::Settings;
+use std::{cell::RefCell, collections::HashMap, rc::Rc};
+use theme_settings::ThemeSettings;
+use ui::{ContextMenu, Disclosure, IconButtonShape, Tooltip, prelude::*};
+use util::ResultExt;
+
+pub(crate) fn build_debugger_hover_view(
+ debugger_value: Option<DebuggerHoverData>,
+ project: Option<WeakEntity<Project>>,
+ cx: &mut AsyncWindowContext,
+) -> Option<Entity<DebuggerHoverView>> {
+ let debugger_value = debugger_value?;
+
+ Some(cx.new(|cx| {
+ let mut view = DebuggerHoverView::new(debugger_value, project);
+ if view.root.has_children() {
+ view.toggle_node(Vec::new(), cx);
+ }
+ view
+ }))
+}
+
+enum DebuggerHoverChildren {
+ Unsupported,
+ Unloaded,
+ Loading,
+ Loaded(Vec<DebuggerHoverNode>),
+ Failed(String),
+}
+
+struct DebuggerHoverNode {
+ variable: DebuggerHoverVariable,
+ is_expanded: bool,
+ children: DebuggerHoverChildren,
+ load_task: Option<Task<()>>,
+}
+
+impl DebuggerHoverNode {
+ fn new(variable: DebuggerHoverVariable) -> Self {
+ let children = if variable.has_children() {
+ DebuggerHoverChildren::Unloaded
+ } else {
+ DebuggerHoverChildren::Unsupported
+ };
+
+ Self {
+ variable,
+ is_expanded: false,
+ children,
+ load_task: None,
+ }
+ }
+
+ fn has_children(&self) -> bool {
+ self.variable.has_children()
+ }
+}
+
+pub(crate) struct DebuggerHoverView {
+ project: Option<WeakEntity<Project>>,
+ session_id: SessionId,
+ session_name: SharedString,
+ root: DebuggerHoverNode,
+ selected_path: Vec<usize>,
+ row_bounds: Rc<RefCell<HashMap<Vec<usize>, Bounds<Pixels>>>>,
+ context_menu: Option<Entity<ContextMenu>>,
+ menu_position: gpui::Point<Pixels>,
+ menu_subscription: Option<Subscription>,
+ operation_error: Option<String>,
+}
+
+pub(crate) struct DebuggerHoverVariableColors {
+ pub(crate) name: Option<Hsla>,
+ pub(crate) value: Option<Hsla>,
+ pub(crate) type_name: Option<Hsla>,
+}
+
+pub(crate) const DEBUGGER_HOVER_MIN_WIDTH: Pixels = px(320.0);
+
+impl DebuggerHoverView {
+ pub(crate) fn render_header(&self, cx: &mut Context<Self>) -> impl IntoElement {
+ let variable = self.root.variable.clone();
+ let value = variable.value.clone();
+ h_flex()
+ .w_full()
+ .min_w_0()
+ .h_6()
+ .px_1()
+ .gap_1()
+ .child(
+ Icon::new(IconName::Debug)
+ .size(IconSize::Small)
+ .color(Color::Muted),
+ )
+ .child(
+ div().min_w_0().flex_1().child(
+ Label::new(self.session_name.clone())
+ .size(LabelSize::XSmall)
+ .color(Color::Muted)
+ .single_line()
+ .truncate(),
+ ),
+ )
+ .child(
+ h_flex()
+ .ml_auto()
+ .flex_none()
+ .gap_1()
+ .child(
+ IconButton::new("copy-debug-value", IconName::Copy)
+ .shape(IconButtonShape::Square)
+ .icon_size(IconSize::Small)
+ .icon_color(Color::Muted)
+ .aria_label("Copy Value")
+ .tooltip(Tooltip::text("Copy Value"))
+ .on_click(move |_, _, cx| {
+ cx.write_to_clipboard(gpui::ClipboardItem::new_string(
+ value.clone(),
+ ));
+ }),
+ )
+ .when_some(variable.evaluate_name.clone(), |this, expression| {
+ this.child(
+ IconButton::new("watch-debug-value", IconName::Eye)
+ .shape(IconButtonShape::Square)
+ .icon_size(IconSize::Small)
+ .icon_color(Color::Muted)
+ .aria_label("Add to Watch")
+ .tooltip(Tooltip::text("Add to Watch"))
+ .on_click(cx.listener(move |view, _, _, cx| {
+ view.add_watch(expression.clone(), cx);
+ })),
+ )
+ })
+ .child(
+ IconButton::new("debug-value-actions", IconName::Ellipsis)
+ .shape(IconButtonShape::Square)
+ .icon_size(IconSize::Small)
+ .icon_color(Color::Muted)
+ .aria_label("Value Actions")
+ .tooltip(Tooltip::text("Value Actions"))
+ .on_click(cx.listener(move |view, _, window, cx| {
+ view.variable_menu(variable.clone(), window, cx);
+ })),
+ ),
+ )
+ }
+
+ pub(crate) fn has_menu(&self) -> bool {
+ self.context_menu.is_some()
+ }
+
+ pub(crate) fn context_menu(&self) -> Option<&Entity<ContextMenu>> {
+ self.context_menu.as_ref()
+ }
+
+ fn new(debugger_value: DebuggerHoverData, project: Option<WeakEntity<Project>>) -> Self {
+ Self {
+ project,
+ session_id: debugger_value.session_id,
+ session_name: debugger_value.session_name,
+ root: DebuggerHoverNode::new(debugger_value.root),
+ selected_path: Vec::new(),
+ row_bounds: Rc::new(RefCell::new(HashMap::default())),
+ context_menu: None,
+ menu_position: Default::default(),
+ menu_subscription: None,
+ operation_error: None,
+ }
+ }
+
+ fn node_mut(&mut self, path: &[usize]) -> Option<&mut DebuggerHoverNode> {
+ let mut node = &mut self.root;
+ for index in path {
+ match &mut node.children {
+ DebuggerHoverChildren::Loaded(children) => node = children.get_mut(*index)?,
+ DebuggerHoverChildren::Unsupported
+ | DebuggerHoverChildren::Unloaded
+ | DebuggerHoverChildren::Loading
+ | DebuggerHoverChildren::Failed(_) => return None,
+ }
+ }
+
+ Some(node)
+ }
+
+ pub(crate) fn toggle_node(&mut self, path: Vec<usize>, cx: &mut Context<Self>) {
+ let Some(node) = self.node_mut(&path) else {
+ return;
+ };
+
+ if !node.has_children() {
+ return;
+ }
+
+ node.is_expanded = !node.is_expanded;
+ let should_load = node.is_expanded
+ && matches!(
+ node.children,
+ DebuggerHoverChildren::Unloaded | DebuggerHoverChildren::Failed(_)
+ );
+ let variables_reference = node.variable.variables_reference;
+ if should_load {
+ node.children = DebuggerHoverChildren::Loading;
+ }
+
+ cx.notify();
+
+ if should_load {
+ self.load_children(path, variables_reference, cx);
+ }
+ }
+
+ fn load_children(
+ &mut self,
+ path: Vec<usize>,
+ variables_reference: u64,
+ cx: &mut Context<Self>,
+ ) {
+ let project = self.project.clone();
+ let session_id = self.session_id;
+ let Some(node) = self.node_mut(&path) else {
+ return;
+ };
+
+ node.load_task = Some(cx.spawn(async move |this, cx| {
+ let result = match project {
+ Some(project) => match project.update(cx, |project, cx| {
+ project.load_debugger_hover_children(session_id, variables_reference, cx)
+ }) {
+ Ok(task) => task.await.map_err(|error| error.to_string()),
+ Err(error) => Err(error.to_string()),
+ },
+ None => Err(anyhow!("project is no longer available").to_string()),
+ };
+
+ this.update(cx, |this, cx| {
+ let Some(node) = this.node_mut(&path) else {
+ return;
+ };
+
+ node.load_task.take();
+ node.children = match result {
+ Ok(children) => DebuggerHoverChildren::Loaded(
+ children.into_iter().map(DebuggerHoverNode::new).collect(),
+ ),
+ Err(error) => DebuggerHoverChildren::Failed(error),
+ };
+ cx.notify();
+ })
+ .ok();
+ }));
+ }
+
+ fn visible_paths(&self) -> Vec<Vec<usize>> {
+ fn collect(node: &DebuggerHoverNode, path: &mut Vec<usize>, out: &mut Vec<Vec<usize>>) {
+ out.push(path.clone());
+
+ if !node.is_expanded {
+ return;
+ }
+
+ if let DebuggerHoverChildren::Loaded(children) = &node.children {
+ for (index, child) in children.iter().enumerate() {
+ path.push(index);
+ collect(child, path, out);
+ path.pop();
+ }
+ }
+ }
+
+ let mut out = Vec::new();
+ collect(&self.root, &mut Vec::new(), &mut out);
+ out
+ }
+
+ fn variable_menu(
+ &mut self,
+ variable: DebuggerHoverVariable,
+ window: &mut Window,
+ cx: &mut Context<Self>,
+ ) -> Entity<ContextMenu> {
+ let view = cx.entity().downgrade();
+ let menu = ContextMenu::build(window, cx, |menu, _, _| {
+ menu.key_context("menu DebuggerHoverMenu")
+ .entry("Copy Value", None, move |_, cx| {
+ cx.write_to_clipboard(gpui::ClipboardItem::new_string(variable.value.clone()));
+ })
+ .when_some(variable.evaluate_name, |menu, expression| {
+ let watch_expression = expression.clone();
+ menu.entry("Copy as Expression", None, move |_, cx| {
+ cx.write_to_clipboard(gpui::ClipboardItem::new_string(expression.clone()));
+ })
+ .entry("Add to Watch", None, move |_, cx| {
+ view.update(cx, |view, cx| view.add_watch(watch_expression.clone(), cx))
+ .log_err();
+ })
+ })
+ });
+ menu.update(cx, |menu, cx| menu.select_toggled_or_first(window, cx));
+ let previous_focus = window.focused(cx);
+ self.menu_subscription = Some(cx.subscribe_in(
+ &menu,
+ window,
+ move |view, menu, _: &gpui::DismissEvent, window, cx| {
+ if menu.focus_handle(cx).contains_focused(window, cx)
+ && let Some(focus) = &previous_focus
+ {
+ window.focus(focus, cx);
+ }
+ view.context_menu = None;
+ cx.notify();
+ },
+ ));
+ self.context_menu = Some(menu.clone());
+ self.menu_position = window.mouse_position();
+ let focus = menu.focus_handle(cx);
+ window.on_next_frame(move |window, _| {
+ window.on_next_frame(move |window, cx| window.focus(&focus, cx));
+ });
+ cx.notify();
+ menu
+ }
+
+ fn add_watch(&mut self, expression: String, cx: &mut Context<Self>) {
+ let session_id = self.session_id;
+ let task = self.project.as_ref().and_then(|project| {
+ project
+ .update(cx, |project, cx| {
+ let (session, frame) = project.active_debug_session(cx)?;
+ if session.read(cx).session_id() != session_id {
+ return None;
+ }
+ Some(session.update(cx, |session, cx| {
+ session.add_watcher(expression.into(), frame.stack_frame_id, cx)
+ }))
+ })
+ .ok()
+ .flatten()
+ });
+ let Some(task) = task else {
+ self.operation_error = Some("The debug session is no longer paused here".into());
+ cx.notify();
+ return;
+ };
+ self.operation_error = None;
+ cx.spawn(async move |view, cx| {
+ let result = task.await;
+ view.update(cx, |view, cx| {
+ view.operation_error = result
+ .err()
+ .map(|error| format!("Could not add watch: {error}"));
+ cx.notify();
+ })
+ .log_err();
+ })
+ .detach();
+ }
+
+ fn select_path(&mut self, path: Vec<usize>, cx: &mut Context<Self>) {
+ self.selected_path = path;
+ cx.notify();
+ }
+
+ pub(crate) fn select_next(&mut self, cx: &mut Context<Self>) {
+ let visible_paths = self.visible_paths();
+ let Some(index) = visible_paths
+ .iter()
+ .position(|path| path == &self.selected_path)
+ else {
+ self.selected_path = Vec::new();
+ cx.notify();
+ return;
+ };
+
+ if let Some(path) = visible_paths.get(index + 1) {
+ self.selected_path = path.clone();
+ cx.notify();
+ }
+ }
+
+ pub(crate) fn select_previous(&mut self, cx: &mut Context<Self>) {
+ let visible_paths = self.visible_paths();
+ let Some(index) = visible_paths
+ .iter()
+ .position(|path| path == &self.selected_path)
+ else {
+ self.selected_path = Vec::new();
+ cx.notify();
+ return;
+ };
+
+ if let Some(path) = index
+ .checked_sub(1)
+ .and_then(|previous_index| visible_paths.get(previous_index))
+ {
+ self.selected_path = path.clone();
+ cx.notify();
+ }
+ }
+
+ pub(crate) fn expand_selected(&mut self, cx: &mut Context<Self>) {
+ let path = self.selected_path.clone();
+ let Some(node) = self.node_mut(&path) else {
+ return;
+ };
+
+ if !node.has_children() {
+ return;
+ }
+
+ if !node.is_expanded {
+ self.toggle_node(path, cx);
+ return;
+ }
+
+ if let DebuggerHoverChildren::Loaded(children) = &node.children
+ && !children.is_empty()
+ {
+ let mut child_path = path;
+ child_path.push(0);
+ self.selected_path = child_path;
+ cx.notify();
+ }
+ }
+
+ pub(crate) fn collapse_selected(&mut self, cx: &mut Context<Self>) {
+ let path = self.selected_path.clone();
+ let Some(node) = self.node_mut(&path) else {
+ return;
+ };
+
+ if node.is_expanded {
+ self.toggle_node(path, cx);
+ return;
+ }
+
+ if !self.selected_path.is_empty() {
+ self.selected_path.pop();
+ cx.notify();
+ }
+ }
+
+ pub(crate) fn selected_row_bounds(&self) -> Option<Bounds<Pixels>> {
+ self.row_bounds.borrow().get(&self.selected_path).copied()
+ }
+
+ fn render_entries(
+ &self,
+ node: &DebuggerHoverNode,
+ depth: usize,
+ path: &[usize],
+ cx: &mut Context<Self>,
+ ) -> Vec<AnyElement> {
+ let mut entries = vec![self.render_node(node, depth, path, cx)];
+
+ if node.is_expanded {
+ match &node.children {
+ DebuggerHoverChildren::Loaded(children) => {
+ for (index, child) in children.iter().enumerate() {
+ let mut child_path = path.to_vec();
+ child_path.push(index);
+ entries.extend(self.render_entries(child, depth + 1, &child_path, cx));
+ }
+ }
+ DebuggerHoverChildren::Loading => {
+ entries.push(self.render_status_row("Loading…", depth + 1, cx));
+ }
+ DebuggerHoverChildren::Failed(error) => {
+ entries.push(self.render_status_row(error, depth + 1, cx));
+ }
+ DebuggerHoverChildren::Unsupported | DebuggerHoverChildren::Unloaded => {}
+ }
+ }
+
+ entries
+ }
+
+ fn render_status_row(&self, message: &str, depth: usize, cx: &mut Context<Self>) -> AnyElement {
+ div()
+ .w_full()
+ .min_h_5()
+ .pl(px(depth as f32 * 14.0 + 18.0))
+ .pr_1()
+ .flex()
+ .items_center()
+ .text_ui_sm(cx)
+ .font_buffer(cx)
+ .child(
+ Label::new(message.to_string())
+ .single_line()
+ .truncate()
+ .color(Color::Muted),
+ )
+ .into_any_element()
+ }
+
+ fn render_node(
+ &self,
+ node: &DebuggerHoverNode,
+ depth: usize,
+ path: &[usize],
+ cx: &mut Context<Self>,
+ ) -> AnyElement {
+ let path = path.to_vec();
+ let row_selector = debugger_hover_row_selector(&path);
+ let toggle_selector = debugger_hover_toggle_selector(&path);
+ let value_container_selector = format!("{row_selector}-value-container");
+ let is_expandable = node.has_children();
+ let is_selected = self.selected_path == path;
+ let variable_colors = debugger_hover_variable_colors(cx);
+ let row_bounds = self.row_bounds.clone();
+ let row_bounds_path = path.clone();
+ let variable = node.variable.clone();
+
+ if depth == 0 && !is_expandable {
+ let text = format!("{} = {}", variable.name, variable.value);
+ let name_end = variable.name.len();
+ let value_start = name_end + " = ".len();
+ let text_length = text.len();
+ let scalar = div()
+ .debug_selector(|| row_selector.clone())
+ .w_full()
+ .min_w_0()
+ .text_ui_sm(cx)
+ .font_buffer(cx)
+ .whitespace_normal()
+ .child(
+ div()
+ .debug_selector(move || value_container_selector)
+ .w_full()
+ .child(gpui::StyledText::new(text).with_highlights([
+ (
+ 0..name_end,
+ gpui::HighlightStyle {
+ color: variable_colors.name,
+ ..Default::default()
+ },
+ ),
+ (
+ name_end..value_start,
+ gpui::HighlightStyle {
+ color: Some(Color::Muted.color(cx)),
+ ..Default::default()
+ },
+ ),
+ (
+ value_start..text_length,
+ gpui::HighlightStyle {
+ color: variable_colors.value,
+ ..Default::default()
+ },
+ ),
+ ])),
+ );
+ return scalar
+ .on_mouse_down(
+ MouseButton::Right,
+ cx.listener(move |view, _, window, cx| {
+ window.prevent_default();
+ cx.stop_propagation();
+ view.variable_menu(variable.clone(), window, cx);
+ }),
+ )
+ .into_any_element();
+ }
+
+ let row = div()
+ .min_w(gpui::relative(1.))
+ .flex_none()
+ .debug_selector(|| row_selector.clone())
+ .rounded_sm()
+ .child(
+ canvas(
+ move |bounds, _window, _cx| {
+ row_bounds
+ .borrow_mut()
+ .insert(row_bounds_path.clone(), bounds);
+ },
+ |_, _, _, _| {},
+ )
+ .absolute()
+ .size_full(),
+ )
+ .when(!is_expandable, |this| {
+ this.on_mouse_down(
+ MouseButton::Left,
+ cx.listener({
+ let path = path.clone();
+ move |this, _: &MouseDownEvent, _window, cx| {
+ this.select_path(path.clone(), cx);
+ }
+ }),
+ )
+ })
+ .when(is_expandable, |this| {
+ this.cursor_pointer().on_mouse_down(
+ MouseButton::Left,
+ cx.listener({
+ let path = path.clone();
+ move |this, _: &MouseDownEvent, window, cx| {
+ window.prevent_default();
+ this.select_path(path.clone(), cx);
+ this.toggle_node(path.clone(), cx)
+ }
+ }),
+ )
+ })
+ .child(
+ h_flex()
+ .min_w(gpui::relative(1.))
+ .min_h_5()
+ .items_center()
+ .gap_1()
+ .rounded_sm()
+ .px_1()
+ .when(is_selected, |this| {
+ this.bg(cx.theme().colors().ghost_element_selected)
+ })
+ .hover(|style| style.bg(cx.theme().colors().ghost_element_hover))
+ .pl(px(depth as f32 * 14.0))
+ .child(if is_expandable {
+ div()
+ .debug_selector(|| toggle_selector.clone())
+ .on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
+ .child(Disclosure::new(toggle_selector, node.is_expanded).on_click(
+ cx.listener(move |this, _, window, cx| {
+ window.prevent_default();
+ this.toggle_node(path.clone(), cx)
+ }),
+ ))
+ .into_any_element()
+ } else {
+ div().w_4().flex_none().into_any_element()
+ })
+ .child(
+ h_flex()
+ .flex_none()
+ .gap_0p5()
+ .text_ui_sm(cx)
+ .font_buffer(cx)
+ .child(
+ div()
+ .id(format!("{row_selector}-name"))
+ .flex_none()
+ .tooltip(Tooltip::text(node.variable.name.clone()))
+ .child(
+ Label::new(node.variable.name.clone())
+ .single_line()
+ .when_some(variable_colors.name, |this, color| {
+ this.color(Color::from(color))
+ }),
+ ),
+ )
+ .child(
+ h_flex()
+ .debug_selector(move || value_container_selector)
+ .flex_none()
+ .gap_0p5()
+ .child(Label::new("=").single_line().color(Color::Muted))
+ .child(
+ div()
+ .id(format!("{row_selector}-value"))
+ .flex_none()
+ .tooltip(Tooltip::text(node.variable.value.clone()))
+ .child(
+ Label::new(node.variable.value.clone())
+ .single_line()
+ .color(Color::Muted)
+ .when_some(
+ variable_colors.value,
+ |this, color| {
+ this.color(Color::from(color))
+ },
+ ),
+ ),
+ ),
+ )
+ .children(
+ debugger_hover_type_suffix(
+ depth,
+ node.variable.type_name.as_deref(),
+ )
+ .map(|type_name| {
+ div().flex_none().child(
+ Label::new(type_name)
+ .single_line()
+ .color(Color::Muted)
+ .when_some(variable_colors.type_name, |this, color| {
+ this.color(Color::from(color))
+ }),
+ )
+ }),
+ ),
+ ),
+ )
+ .on_mouse_down(
+ MouseButton::Right,
+ cx.listener(move |view, _, window, cx| {
+ window.prevent_default();
+ cx.stop_propagation();
+ view.variable_menu(variable.clone(), window, cx);
+ }),
+ )
+ .into_any_element();
+ row
+ }
+}
+
+pub(crate) fn debugger_hover_variable_colors(cx: &App) -> DebuggerHoverVariableColors {
+ let syntax = cx.theme().syntax();
+ let colors = cx.theme().colors();
+ let syntax_color_for = |name| syntax.style_for_name(name).and_then(|style| style.color);
+
+ DebuggerHoverVariableColors {
+ name: syntax_color_for("variable").or(Some(colors.text)),
+ value: syntax_color_for("variable.special").or(Some(colors.text_accent)),
+ type_name: syntax_color_for("type").or(Some(colors.text_muted)),
+ }
+}
+
+pub(crate) fn debugger_hover_type_suffix(depth: usize, type_name: Option<&str>) -> Option<String> {
+ if depth > 0 {
+ return None;
+ }
+
+ type_name
+ .filter(|type_name| !type_name.is_empty())
+ .map(|type_name| format!(": {type_name}"))
+}
+
+impl DebuggerHoverView {
+ pub(crate) fn content_width(&self, window: &Window, cx: &App) -> Option<Pixels> {
+ self.root.has_children().then(|| {
+ let mut width = Pixels::ZERO;
+ let mut nodes = vec![(&self.root, 0)];
+ let font = ThemeSettings::get_global(cx).buffer_font.clone();
+ // Labels override the row's text size with their own default size.
+ let font_size = ui::TextSize::Default.rems(cx).to_pixels(window.rem_size());
+ while let Some((node, depth)) = nodes.pop() {
+ let text = ui::utils::replace_control_characters(&format!(
+ "{} = {}{}",
+ node.variable.name,
+ node.variable.value,
+ debugger_hover_type_suffix(depth, node.variable.type_name.as_deref())
+ .unwrap_or_default(),
+ ))
+ .into_owned();
+ let line = window.text_system().shape_line(
+ text.clone().into(),
+ font_size,
+ &[gpui::TextRun {
+ len: text.len(),
+ font: font.clone(),
+ ..Default::default()
+ }],
+ None,
+ );
+ width = width.max(line.width + px(depth as f32 * 14.) + window.rem_size() * 3.);
+ if node.is_expanded
+ && let DebuggerHoverChildren::Loaded(children) = &node.children
+ {
+ nodes.extend(children.iter().map(|child| (child, depth + 1)));
+ }
+ }
+ width
+ })
+ }
+}
+
+impl Render for DebuggerHoverView {
+ fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
+ self.row_bounds.borrow_mut().clear();
+ let rows = self.render_entries(&self.root, 0, &[], cx);
+ v_flex()
+ .id("debugger-hover-view")
+ .w_full()
+ .flex_none()
+ .gap_0()
+ .children(rows)
+ .children(self.context_menu.as_ref().map(|menu| {
+ gpui::deferred(
+ gpui::anchored()
+ .position(self.menu_position)
+ .snap_to_window_with_margin(px(8.))
+ .child(menu.clone()),
+ )
+ // The editor draws hover popovers at priority 2.
+ .with_priority(3)
+ }))
+ .when_some(self.operation_error.as_ref(), |this, error| {
+ this.child(self.render_status_row(error, 0, cx))
+ })
+ }
+}
+
+fn debugger_hover_row_selector(path: &[usize]) -> String {
+ if path.is_empty() {
+ "debugger-hover-node-root".to_string()
+ } else {
+ format!(
+ "debugger-hover-node-{}",
+ path.iter().map(|index| index.to_string()).join("-")
+ )
+ }
+}
+
+fn debugger_hover_toggle_selector(path: &[usize]) -> String {
+ if path.is_empty() {
+ "debugger-hover-toggle-root".to_string()
+ } else {
+ format!(
+ "debugger-hover-toggle-{}",
+ path.iter().map(|index| index.to_string()).join("-")
+ )
+ }
+}
diff --git a/crates/editor/src/editor.rs b/crates/editor/src/editor.rs
index 4fddce235a0..cb8f7e13f11 100644
--- a/crates/editor/src/editor.rs
+++ b/crates/editor/src/editor.rs
@@ -17,6 +17,7 @@ mod bracket_colorization;
mod clangd_ext;
pub mod code_context_menus;
mod code_lens;
+mod debugger_hover;
pub mod display_map;
mod document_colors;
mod document_links;
@@ -2839,6 +2840,10 @@ impl Editor {
key_context.add("showing_signature_help");
}
+ if self.hover_state.keyboard_debugger_hover_active() {
+ key_context.add("DebuggerHover");
+ }
+
// Disable vim contexts when a sub-editor (e.g. rename/inline assistant) is focused.
if !self.focus_handle(cx).contains_focused(window, cx)
|| (self.is_focused(window) || self.mouse_menu_is_focused(window, cx))
@@ -11864,6 +11869,15 @@ pub trait SemanticsProvider {
cx: &mut App,
) -> Option<Task<Option<Vec<project::Hover>>>>;
+ fn debugger_hover(
+ &self,
+ _buffer: &Entity<Buffer>,
+ _position: text::Anchor,
+ _cx: &mut App,
+ ) -> Option<Task<Option<project::DebuggerHover>>> {
+ None
+ }
+
fn inline_values(
&self,
buffer_handle: Entity<Buffer>,
@@ -11942,6 +11956,18 @@ impl SemanticsProvider for WeakEntity<Project> {
.ok()
}
+ fn debugger_hover(
+ &self,
+ buffer: &Entity<Buffer>,
+ position: text::Anchor,
+ cx: &mut App,
+ ) -> Option<Task<Option<project::DebuggerHover>>> {
+ self.update(cx, |project, cx| {
+ project.debugger_hover(buffer, position, cx)
+ })
+ .ok()
+ }
+
fn document_highlights(
&self,
buffer: &Entity<Buffer>,
diff --git a/crates/editor/src/element.rs b/crates/editor/src/element.rs
index 77aa1dbe9fe..be3f7cb64f0 100644
--- a/crates/editor/src/element.rs
+++ b/crates/editor/src/element.rs
@@ -409,6 +409,10 @@ impl EditorElement {
register_action(editor, window, Editor::select_page_up);
register_action(editor, window, Editor::cancel);
register_action(editor, window, Editor::blame_hover);
+ register_action(editor, window, Editor::debugger_hover_expand_selected);
+ register_action(editor, window, Editor::debugger_hover_collapse_selected);
+ register_action(editor, window, Editor::debugger_hover_select_next);
+ register_action(editor, window, Editor::debugger_hover_select_previous);
register_action(editor, window, Editor::next_snippet_tabstop);
register_action(editor, window, Editor::previous_snippet_tabstop);
register_action(editor, window, Editor::copy);
@@ -4455,7 +4459,7 @@ impl EditorElement {
horizontal_offset: Pixels,
}
- let max_size = size(
+ let mut max_size = size(
(120. * em_width) // Default size
.min(hitbox.size.width / 2.) // Shrink to half of the editor width
.max(MIN_POPOVER_CHARACTER_WIDTH * em_width), // Apply minimum width of 20 characters
@@ -4464,6 +4468,31 @@ impl EditorElement {
.max(MIN_POPOVER_LINE_HEIGHT * line_height), // Apply minimum height of 4 lines
);
+ let (is_single_debugger_hover, stable_debugger_hover_origin) = {
+ let editor = self.editor.read(cx);
+ (
+ editor.hover_state.is_single_debugger_hover(),
+ editor.hover_state.stable_debugger_hover_origin(),
+ )
+ };
+ if is_single_debugger_hover {
+ let available_height = stable_debugger_hover_origin
+ .map(|origin| {
+ // Prefer scrolling below the existing origin to moving a row under the mouse.
+ // After a resize, leave enough room for at least one row and its padding.
+ (hitbox.bottom() - origin.y).max(line_height + px(10.))
+ })
+ .unwrap_or(hitbox.size.height)
+ .min(hitbox.size.height);
+ // The content container's limits exclude the popover's one-pixel border.
+ max_size.width = max_size
+ .width
+ .min((hitbox.size.width - px(2.)).max(Pixels::ZERO));
+ max_size.height = max_size
+ .height
+ .min((available_height - px(2.)).max(Pixels::ZERO));
+ }
+
// Don't show hover popovers when context menu is open to avoid overlap
let has_context_menu = self.editor.read(cx).mouse_context_menu.is_some();
if has_context_menu {
@@ -4501,7 +4530,7 @@ impl EditorElement {
let mut overall_height = Pixels::ZERO;
- let measured_hover_popovers = hover_popovers
+ let mut measured_hover_popovers = hover_popovers
.into_iter()
.with_position()
.map(|(position, mut hover_popover)| {
@@ -4605,9 +4634,9 @@ impl EditorElement {
})
};
- let can_place_below = || {
+ let can_place_below = |popovers: &[MeasuredHoverPopover]| {
let mut current_y = hovered_point.y + line_height;
- measured_hover_popovers.iter().all(|popover| {
+ popovers.iter().all(|popover| {
let size = popover.size;
let popover_origin = point(hovered_point.x + popover.horizontal_offset, current_y);
let bounds = Bounds::new(popover_origin, size);
@@ -4616,10 +4645,45 @@ impl EditorElement {
})
};
+ if is_single_debugger_hover
+ && measured_hover_popovers.len() == 1
+ && let Some(popover) = measured_hover_popovers.pop()
+ {
+ let mut popover_origin = stable_debugger_hover_origin.unwrap_or_else(|| {
+ if can_place_below(std::slice::from_ref(&popover)) {
+ point(
+ hovered_point.x + popover.horizontal_offset,
+ hovered_point.y + line_height,
+ )
+ } else {
+ point(
+ hovered_point.x + popover.horizontal_offset,
+ hovered_point.y - popover.size.height,
+ )
+ }
+ });
+
+ // Preserve the origin while it fits, but keep expanded or resized hovers reachable.
+ popover_origin.x = popover_origin.x.clamp(
+ hitbox.left(),
+ (hitbox.right() - popover.size.width).max(hitbox.left()),
+ );
+ popover_origin.y = popover_origin.y.clamp(
+ hitbox.top(),
+ (hitbox.bottom() - popover.size.height).max(hitbox.top()),
+ );
+
+ window.defer_draw(popover.element, popover_origin, 2, None);
+ self.editor.update(cx, |editor, _| {
+ editor.hover_state.stable_debugger_hover_origin = Some(popover_origin);
+ });
+ return;
+ }
+
if can_place_above {
// try placing above hovered point
place_popovers_above(hovered_point, measured_hover_popovers, window, cx);
- } else if can_place_below() {
+ } else if can_place_below(&measured_hover_popovers) {
// try placing below hovered point
place_popovers_below(
hovered_point,
diff --git a/crates/editor/src/hover_popover.rs b/crates/editor/src/hover_popover.rs
index a006d8049fa..7b3c9975aff 100644
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -32,11 +32,16 @@ use url::Url;
use util::TryFutureExt;
use workspace::{OpenOptions, OpenVisible, Workspace};
+use crate::debugger_hover::{
+ DEBUGGER_HOVER_MIN_WIDTH, DebuggerHoverView, build_debugger_hover_view,
+};
+
pub const MIN_POPOVER_CHARACTER_WIDTH: f32 = 20.;
pub const MIN_POPOVER_LINE_HEIGHT: f32 = 4.;
pub const POPOVER_RIGHT_OFFSET: Pixels = px(8.0);
pub const HOVER_POPOVER_GAP: Pixels = px(10.);
const MAX_HOVER_BYTES: usize = 100_000;
+const DEBUGGER_HOVER_HEADER_HEIGHT: Pixels = px(24.);
/// Bindable action which uses the most recent selection head to trigger a hover
pub fn hover(editor: &mut Editor, _: &Hover, window: &mut Window, cx: &mut Context<Editor>) {
@@ -55,6 +60,10 @@ pub fn hover_at(
) {
editor.hover_state.hint_hover_task = None;
if EditorSettings::get_global(cx).hover_popover_enabled {
+ if editor.hover_state.debugger_menu_open(cx) {
+ editor.hover_state.hiding_delay_task = None;
+ return;
+ }
if show_keyboard_hover(editor, window, cx) {
return;
}
@@ -87,7 +96,9 @@ pub fn hover_at(
let task = cx.spawn(async move |this, cx| {
cx.background_executor().timer(delay).await;
this.update(cx, |editor, cx| {
- hide_popovers(editor, cx);
+ if !editor.hover_state.debugger_menu_open(cx) {
+ hide_popovers(editor, cx);
+ }
})
.ok();
});
@@ -193,15 +204,17 @@ pub fn hover_at_inlay(
.as_ref()
.map(|parsed_content| cx.observe(parsed_content, |_, _, cx| cx.notify()));
editor.hover_state.diagnostic_popover = None;
+ editor.hover_state.stable_debugger_hover_origin = None;
editor.hover_state.info_popovers = vec![InfoPopover {
symbol_range,
fallback_state: None,
parsed_content,
+ debugger_hover: None,
scroll_handle: ScrollHandle::new(),
keyboard_grace: Rc::new(RefCell::new(false)),
anchor: None,
last_bounds: Rc::new(Cell::new(None)),
- _subscription: subscription,
+ _subscriptions: subscription.into_iter().collect(),
}];
cx.notify();
})
@@ -244,6 +257,7 @@ fn show_hover(
let language_registry = editor
.project()
.map(|project| project.read(cx).languages().clone());
+ let debugger_project = editor.project().map(|project| project.downgrade());
let provider = editor.semantics_provider.clone()?;
editor.hover_state.hiding_delay_task = None;
@@ -287,7 +301,10 @@ fn show_hover(
total_delay
};
- let hover_request = cx.update(|_, cx| provider.hover(&buffer, buffer_position, cx))?;
+ let mut hover_request =
+ cx.update(|_, cx| provider.hover(&buffer, buffer_position, cx))?;
+ let debugger_request =
+ cx.update(|_, cx| provider.debugger_hover(&buffer, buffer_position, cx))?;
if let Some(delay) = delay {
delay.await;
@@ -416,10 +433,18 @@ fn show_hover(
None
};
- let hovers_response = if let Some(hover_request) = hover_request {
- hover_request.await.unwrap_or_default()
- } else {
+ let debugger_response = match debugger_request {
+ Some(request) => request.await,
+ None => None,
+ };
+ let show_debugger_hover_only = debugger_response.is_some();
+ let hovers_response = if show_debugger_hover_only {
Vec::new()
+ } else {
+ match hover_request.take() {
+ Some(request) => request.await.unwrap_or_default(),
+ None => Vec::new(),
+ }
};
let snapshot = this.update_in(cx, |this, window, cx| this.snapshot(window, cx))?;
let mut hover_highlights = Vec::with_capacity(hovers_response.len());
@@ -427,39 +452,46 @@ fn show_hover(
hovers_response.len() + if invisible_char.is_some() { 1 } else { 0 },
);
- if let Some((invisible, range)) = invisible_char {
+ if !show_debugger_hover_only && let Some((invisible, range)) = invisible_char {
let blocks = vec![HoverBlock {
text: format!("Unicode character U+{:02X}", invisible as u32),
kind: HoverBlockKind::PlainText,
}];
let parsed_content = parse_blocks(&blocks, language_registry.as_ref(), None, cx);
let scroll_handle = ScrollHandle::new();
- let subscription = this
+ let subscriptions = this
.update(cx, |_, cx| {
- parsed_content.as_ref().map(|parsed_content| {
- cx.observe(parsed_content, |_, _, cx| cx.notify())
- })
+ parsed_content
+ .as_ref()
+ .map(|parsed_content| {
+ vec![cx.observe(parsed_content, |_, _, cx| cx.notify())]
+ })
+ .unwrap_or_default()
})
.ok()
- .flatten();
+ .unwrap_or_default();
info_popovers.push(InfoPopover {
symbol_range: RangeInEditor::Text(range),
fallback_state: None,
parsed_content,
+ debugger_hover: None,
scroll_handle,
keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
anchor: Some(anchor),
last_bounds: Rc::new(Cell::new(None)),
- _subscription: subscription,
+ _subscriptions: subscriptions,
})
}
- let doc_link_task = this
- .update(cx, |editor, cx| {
+ let doc_link_task = if show_debugger_hover_only {
+ None
+ } else {
+ this.update(cx, |editor, cx| {
editor.document_links_at(buffer.clone(), buffer_position, cx)
})
.ok()
- .flatten();
+ .flatten()
+ };
let doc_link_tooltips = match doc_link_task {
Some(task) => task
.await
@@ -476,10 +508,45 @@ fn show_hover(
};
let buffer_snapshot = snapshot.buffer_snapshot();
+ let mut debugger_view = None;
+ if let Some(debugger_response) = debugger_response {
+ let range = snapshot
+ .buffer_snapshot()
+ .buffer_anchor_range_to_anchor_range(debugger_response.range)
+ .unwrap_or_else(|| anchor..anchor);
+ let debugger_hover = build_debugger_hover_view(
+ Some(debugger_response.data),
+ debugger_project.clone(),
+ cx,
+ );
+ if let Some(view) = debugger_hover {
+ debugger_view = Some(view.entity_id());
+ hover_highlights.push(range.clone());
+ let subscription =
+ this.update(cx, |_, cx| cx.observe(&view, |_, _, cx| cx.notify()))?;
+ info_popovers.push(InfoPopover {
+ symbol_range: RangeInEditor::Text(range),
+ fallback_state: None,
+ parsed_content: None,
+ debugger_hover: Some(view),
+ scroll_handle: ScrollHandle::new(),
+ keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
+ anchor: Some(anchor),
+ last_bounds: Rc::new(Cell::new(None)),
+ _subscriptions: vec![subscription],
+ });
+ }
+ }
+
for hover_result in hovers_response {
+ let project::Hover {
+ contents: blocks,
+ range: hover_range,
+ language,
+ } = hover_result;
+
// Create symbol range of anchors for highlighting and filtering of future requests.
- let (range, fallback_state) = hover_result
- .range
+ let (range, fallback_state) = hover_range
.and_then(|range| buffer_snapshot.buffer_anchor_range_to_anchor_range(range))
.filter(|range| !range.to_offset(buffer_snapshot).is_empty())
.map(|range| (range, None))
@@ -489,57 +556,65 @@ fn show_hover(
(range, Some(fallback_state))
});
- let blocks = hover_result.contents;
- let language = hover_result.language;
let parsed_content =
parse_blocks(&blocks, language_registry.as_ref(), language, cx);
+ if parsed_content.is_none() {
+ continue;
+ }
let scroll_handle = ScrollHandle::new();
hover_highlights.push(range.clone());
- let subscription = this
+ let subscriptions = this
.update(cx, |_, cx| {
- parsed_content.as_ref().map(|parsed_content| {
- cx.observe(parsed_content, |_, _, cx| cx.notify())
- })
+ let mut subscriptions = Vec::new();
+ if let Some(parsed_content) = parsed_content.as_ref() {
+ subscriptions.push(cx.observe(parsed_content, |_, _, cx| cx.notify()));
+ }
+ subscriptions
})
.ok()
- .flatten();
+ .unwrap_or_default();
info_popovers.push(InfoPopover {
symbol_range: RangeInEditor::Text(range),
fallback_state,
parsed_content,
+ debugger_hover: None,
scroll_handle,
keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
anchor: Some(anchor),
last_bounds: Rc::new(Cell::new(None)),
- _subscription: subscription,
+ _subscriptions: subscriptions,
});
}
- for (multi_buffer_range, tooltip) in doc_link_tooltips {
- let blocks = vec![HoverBlock {
- text: tooltip.to_string(),
- kind: HoverBlockKind::Markdown,
- }];
- let parsed_content = parse_blocks(&blocks, language_registry.as_ref(), None, cx);
- let scroll_handle = ScrollHandle::new();
- let subscription = this
- .update(cx, |_, cx| {
- parsed_content.as_ref().map(|parsed_content| {
- cx.observe(parsed_content, |_, _, cx| cx.notify())
+ if !show_debugger_hover_only {
+ for (multi_buffer_range, tooltip) in doc_link_tooltips {
+ let blocks = vec![HoverBlock {
+ text: tooltip.to_string(),
+ kind: HoverBlockKind::Markdown,
+ }];
+ let parsed_content =
+ parse_blocks(&blocks, language_registry.as_ref(), None, cx);
+ let scroll_handle = ScrollHandle::new();
+ let subscription = this
+ .update(cx, |_, cx| {
+ parsed_content.as_ref().map(|parsed_content| {
+ cx.observe(parsed_content, |_, _, cx| cx.notify())
+ })
})
- })
- .ok()
- .flatten();
- info_popovers.push(InfoPopover {
- symbol_range: RangeInEditor::Text(multi_buffer_range),
- fallback_state: None,
- parsed_content,
- scroll_handle,
- keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
- anchor: Some(anchor),
- last_bounds: Rc::new(Cell::new(None)),
- _subscription: subscription,
- });
+ .ok()
+ .flatten();
+ info_popovers.push(InfoPopover {
+ symbol_range: RangeInEditor::Text(multi_buffer_range),
+ fallback_state: None,
+ parsed_content,
+ debugger_hover: None,
+ scroll_handle,
+ keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
+ anchor: Some(anchor),
+ last_bounds: Rc::new(Cell::new(None)),
+ _subscriptions: subscription.into_iter().collect(),
+ });
+ }
}
this.update_in(cx, |editor, window, cx| {
@@ -555,11 +630,56 @@ fn show_hover(
);
}
+ if show_debugger_hover_only {
+ editor.hover_state.diagnostic_popover = None;
+ }
+ editor.hover_state.stable_debugger_hover_origin = None;
editor.hover_state.info_popovers = info_popovers;
cx.notify();
window.refresh();
})?;
+ if let (Some(view_id), Some(request)) = (debugger_view, hover_request) {
+ let lsp_hovers = request.await.unwrap_or_default();
+ let language = lsp_hovers.iter().find_map(|hover| hover.language.clone());
+ let blocks = lsp_hovers
+ .into_iter()
+ .flat_map(|hover| hover.contents)
+ .collect::<Vec<_>>();
+ if let Some(markdown) =
+ parse_blocks(&blocks, language_registry.as_ref(), language, cx)
+ {
+ this.update_in(cx, |editor, window, cx| {
+ if let Some(popover) =
+ editor.hover_state.info_popovers.iter().find(|popover| {
+ popover
+ .debugger_hover
+ .as_ref()
+ .is_some_and(|view| view.entity_id() == view_id)
+ })
+ {
+ let symbol_range = popover.symbol_range.clone();
+ let keyboard_grace = popover.keyboard_grace.clone();
+ let anchor = popover.anchor;
+ let subscription = cx.observe(&markdown, |_, _, cx| cx.notify());
+ editor.hover_state.info_popovers.push(InfoPopover {
+ symbol_range,
+ parsed_content: Some(markdown),
+ debugger_hover: None,
+ scroll_handle: ScrollHandle::new(),
+ keyboard_grace,
+ anchor,
+ last_bounds: Rc::new(Cell::new(None)),
+ fallback_state: None,
+ _subscriptions: vec![subscription],
+ });
+ cx.notify();
+ window.refresh();
+ }
+ })?;
+ }
+ }
+
anyhow::Ok(())
}
.log_err()
@@ -674,6 +794,11 @@ fn parse_blocks(
cx: &mut AsyncWindowContext,
) -> Option<Entity<Markdown>> {
let combined_text = combine_hover_blocks(blocks);
+
+ if combined_text.trim().is_empty() {
+ return None;
+ }
+
cx.new_window_entity(|_window, cx| {
Markdown::new(
combined_text.into(),
@@ -1100,14 +1225,49 @@ pub struct HoverState {
pub info_task: Option<Task<Option<()>>>,
pub closest_mouse_distance: Option<Pixels>,
pub hiding_delay_task: Option<Task<()>>,
+ pub stable_debugger_hover_origin: Option<gpui::Point<Pixels>>,
pub(crate) hint_hover_task: Option<Task<()>>,
}
impl HoverState {
+ fn debugger_menu_open(&self, cx: &App) -> bool {
+ self.info_popovers.iter().any(|popover| {
+ popover
+ .debugger_hover
+ .as_ref()
+ .is_some_and(|view| view.read(cx).has_menu())
+ })
+ }
pub fn visible(&self) -> bool {
!self.info_popovers.is_empty() || self.diagnostic_popover.is_some()
}
+ pub fn is_single_debugger_hover(&self) -> bool {
+ let [info_popover] = self.info_popovers.as_slice() else {
+ return false;
+ };
+
+ self.diagnostic_popover.is_none() && info_popover.debugger_hover.is_some()
+ }
+
+ pub fn stable_debugger_hover_origin(&self) -> Option<gpui::Point<Pixels>> {
+ self.is_single_debugger_hover()
+ .then_some(self.stable_debugger_hover_origin)
+ .flatten()
+ }
+
+ fn keyboard_debugger_hover(&self) -> Option<Entity<DebuggerHoverView>> {
+ self.info_popovers.iter().find_map(|info_popover| {
+ (*info_popover.keyboard_grace.borrow())
+ .then(|| info_popover.debugger_hover.clone())
+ .flatten()
+ })
+ }
+
+ pub fn keyboard_debugger_hover_active(&self) -> bool {
+ self.keyboard_debugger_hover().is_some()
+ }
+
pub fn is_mouse_getting_closer(&mut self, mouse_position: gpui::Point<Pixels>) -> bool {
if !self.visible() {
return false;
@@ -1240,6 +1400,12 @@ impl HoverState {
pub fn focused(&self, window: &mut Window, cx: &mut Context<Editor>) -> bool {
let mut hover_popover_is_focused = false;
for info_popover in &self.info_popovers {
+ if let Some(view) = &info_popover.debugger_hover
+ && let Some(menu) = view.read(cx).context_menu()
+ && menu.focus_handle(cx).contains_focused(window, cx)
+ {
+ hover_popover_is_focused = true;
+ }
if let Some(markdown_view) = &info_popover.parsed_content
&& markdown_view.focus_handle(cx).is_focused(window)
{
@@ -1258,15 +1424,104 @@ impl HoverState {
}
}
+impl Editor {
+ fn ensure_debugger_hover_selection_visible(&mut self, cx: &mut Context<Self>) {
+ let Some((debugger_hover, scroll_handle)) =
+ self.hover_state
+ .info_popovers
+ .iter()
+ .find_map(|info_popover| {
+ if !*info_popover.keyboard_grace.borrow() {
+ return None;
+ }
+
+ info_popover
+ .debugger_hover
+ .clone()
+ .map(|debugger_hover| (debugger_hover, info_popover.scroll_handle.clone()))
+ })
+ else {
+ return;
+ };
+
+ let Some(selected_bounds) = debugger_hover.read(cx).selected_row_bounds() else {
+ return;
+ };
+ let viewport_bounds = scroll_handle.bounds();
+ let mut scroll_offset = scroll_handle.offset();
+ let initial_offset = scroll_offset;
+
+ if selected_bounds.top() < viewport_bounds.top() {
+ scroll_offset.y += viewport_bounds.top() - selected_bounds.top();
+ } else if selected_bounds.bottom() > viewport_bounds.bottom() {
+ scroll_offset.y += viewport_bounds.bottom() - selected_bounds.bottom();
+ }
+
+ if scroll_offset != initial_offset {
+ scroll_handle.set_offset(scroll_offset);
+ cx.notify();
+ }
+ }
+
+ pub fn debugger_hover_expand_selected(
+ &mut self,
+ _: &crate::actions::DebuggerHoverExpandSelected,
+ _window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ if let Some(debugger_hover) = self.hover_state.keyboard_debugger_hover() {
+ debugger_hover.update(cx, |debugger_hover, cx| debugger_hover.expand_selected(cx));
+ }
+ }
+
+ pub fn debugger_hover_collapse_selected(
+ &mut self,
+ _: &crate::actions::DebuggerHoverCollapseSelected,
+ _window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ if let Some(debugger_hover) = self.hover_state.keyboard_debugger_hover() {
+ debugger_hover.update(cx, |debugger_hover, cx| {
+ debugger_hover.collapse_selected(cx)
+ });
+ }
+ }
+
+ pub fn debugger_hover_select_next(
+ &mut self,
+ _: &crate::actions::DebuggerHoverSelectNext,
+ _window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ if let Some(debugger_hover) = self.hover_state.keyboard_debugger_hover() {
+ debugger_hover.update(cx, |debugger_hover, cx| debugger_hover.select_next(cx));
+ self.ensure_debugger_hover_selection_visible(cx);
+ }
+ }
+
+ pub fn debugger_hover_select_previous(
+ &mut self,
+ _: &crate::actions::DebuggerHoverSelectPrevious,
+ _window: &mut Window,
+ cx: &mut Context<Self>,
+ ) {
+ if let Some(debugger_hover) = self.hover_state.keyboard_debugger_hover() {
+ debugger_hover.update(cx, |debugger_hover, cx| debugger_hover.select_previous(cx));
+ self.ensure_debugger_hover_selection_visible(cx);
+ }
+ }
+}
+
pub struct InfoPopover {
pub symbol_range: RangeInEditor,
pub parsed_content: Option<Entity<Markdown>>,
+ debugger_hover: Option<Entity<DebuggerHoverView>>,
pub scroll_handle: ScrollHandle,
pub keyboard_grace: Rc<RefCell<bool>>,
pub anchor: Option<Anchor>,
pub last_bounds: Rc<Cell<Option<Bounds<Pixels>>>>,
fallback_state: Option<FallbackHoverState>,
- _subscription: Option<Subscription>,
+ _subscriptions: Vec<Subscription>,
}
struct FallbackHoverState {
@@ -1300,10 +1555,29 @@ impl InfoPopover {
let this = cx.entity().downgrade();
let this2 = this.clone();
let bounds_cell = self.last_bounds.clone();
+ let parsed_content = self.parsed_content.clone();
+ let debugger_hover = self.debugger_hover.clone();
+ let debugger_hover_only = debugger_hover.is_some();
+ let debugger_content_width = debugger_hover
+ .as_ref()
+ .and_then(|view| view.read(cx).content_width(window, cx));
+ let scrollbars = if let Some(view_id) = debugger_hover.as_ref().map(Entity::entity_id) {
+ Scrollbars::always_visible(ui::ScrollAxes::Both)
+ .id(("debugger-hover-scrollbar", view_id))
+ .with_stable_track_along(
+ ui::ScrollAxes::Vertical,
+ cx.theme().colors().elevated_surface_background,
+ )
+ .tracked_scroll_handle(&self.scroll_handle)
+ } else {
+ Scrollbars::for_settings::<EditorSettingsScrollbarProxy>()
+ .tracked_scroll_handle(&self.scroll_handle)
+ };
div()
.id("info_popover")
.occlude()
.elevation_2(cx)
+ .when(debugger_hover_only, |this| this.flex().flex_col())
.child(
canvas(
{
@@ -1334,43 +1608,80 @@ impl InfoPopover {
*keyboard_grace = false;
cx.stop_propagation();
})
- .when_some(self.parsed_content.clone(), |this, markdown| {
- this.child(
- div()
- .id("info-md-container")
- .overflow_y_scroll()
- .max_w(max_size.width)
- .max_h(max_size.height)
- .track_scroll(&self.scroll_handle)
- .child(
- MarkdownElement::new(markdown, hover_markdown_style(window, cx))
- .scroll_handle(self.scroll_handle.clone())
- .code_block_renderer(markdown::CodeBlockRenderer::Default {
- copy_button_visibility: CopyButtonVisibility::Hidden,
- wrap_button_visibility: markdown::WrapButtonVisibility::Hidden,
- border: false,
- })
- .on_url_click(move |link, window, cx| {
- open_markdown_url(
- this2
- .read_with(cx, |editor, _| editor.workspace())
- .ok()
- .flatten(),
- link,
- window,
- cx,
- )
- })
- .p_2(),
- ),
- )
- .custom_scrollbars(
- Scrollbars::for_settings::<EditorSettingsScrollbarProxy>()
- .tracked_scroll_handle(&self.scroll_handle),
- window,
- cx,
- )
+ .when_some(debugger_hover.as_ref(), |this, view| {
+ this.child(view.update(cx, |view, cx| view.render_header(cx).into_any_element()))
})
+ .when(
+ parsed_content.is_some() || debugger_hover.is_some(),
+ |this| {
+ this.child(
+ div()
+ .id("info-content-container")
+ .overflow_y_scroll()
+ .when(debugger_hover_only, |this| this.overflow_x_scroll())
+ .max_w(max_size.width)
+ .max_h(if debugger_hover_only {
+ (max_size.height - DEBUGGER_HOVER_HEADER_HEIGHT).max(Pixels::ZERO)
+ } else {
+ max_size.height
+ })
+ .when(debugger_hover_only, |this| {
+ this.min_w(DEBUGGER_HOVER_MIN_WIDTH.min(max_size.width))
+ })
+ .track_scroll(&self.scroll_handle)
+ .child(
+ v_flex()
+ .when(!debugger_hover_only, |this| this.w_full())
+ .when_some(debugger_content_width, |this, width| this.w(width))
+ .flex_none()
+ .when(debugger_hover_only, |this| this.gap_0().p_1())
+ .when(!debugger_hover_only, |this| this.gap_2().p_2())
+ .when_some(debugger_hover, |this, debugger_hover| {
+ this.child(debugger_hover)
+ })
+ .when_some(parsed_content, |this, markdown| {
+ this.child(
+ div().child(
+ MarkdownElement::new(
+ markdown,
+ hover_markdown_style(window, cx),
+ )
+ .scroll_handle(self.scroll_handle.clone())
+ .code_block_renderer(
+ markdown::CodeBlockRenderer::Default {
+ copy_button_visibility:
+ CopyButtonVisibility::Hidden,
+ wrap_button_visibility:
+ markdown::WrapButtonVisibility::Hidden,
+ border: false,
+ },
+ )
+ .on_url_click(move |link, window, cx| {
+ open_markdown_url(
+ this2
+ .read_with(cx, |editor, _| {
+ editor.workspace()
+ })
+ .ok()
+ .flatten(),
+ link,
+ window,
+ cx,
+ )
+ }),
+ ),
+ )
+ }),
+ )
+ .map(|content| {
+ div()
+ .relative()
+ .child(content)
+ .custom_scrollbars(scrollbars, window, cx)
+ }),
+ )
+ },
+ )
.into_any_element()
}
@@ -1517,6 +1828,7 @@ fn hide_popovers(editor: &mut Editor, cx: &mut Context<Editor>) -> bool {
editor.hover_state.info_task = None;
editor.hover_state.hiding_delay_task = None;
editor.hover_state.closest_mouse_distance = None;
+ editor.hover_state.stable_debugger_hover_origin = None;
editor.clear_background_highlights(HighlightKey::HoverState, cx);
@@ -1530,26 +1842,39 @@ fn hide_popovers(editor: &mut Editor, cx: &mut Context<Editor>) -> bool {
#[cfg(test)]
mod tests {
use super::*;
+ use crate::debugger_hover::{debugger_hover_type_suffix, debugger_hover_variable_colors};
use crate::{
+ RenameTarget,
actions::{Cancel, ConfirmCompletion},
editor_tests::{handle_completion_request, init_test},
inlays::inlay_hints::tests::{cached_hint_labels, visible_hint_labels},
- test::editor_lsp_test_context::EditorLspTestContext,
+ test::{
+ editor_lsp_test_context::EditorLspTestContext, editor_test_context::EditorTestContext,
+ },
};
- use collections::BTreeSet;
- use futures::{channel::oneshot, stream::StreamExt};
+ use collections::{BTreeSet, HashMap, HashSet};
+ use dap::client::SessionId;
+ use futures::channel::oneshot;
+ use futures::future::Shared;
+ use futures::stream::StreamExt;
use gpui::{App, Modifiers};
use indoc::indoc;
- use language::{FakeLspAdapter, rust_lang};
+ use language::{Buffer, BufferRow, FakeLspAdapter, LanguageServerId, rust_lang};
use markdown::parser::MarkdownEvent;
use multi_buffer::MultiBuffer;
use parking_lot::Mutex;
- use project::InlayId;
+ use project::{
+ DebuggerHoverData, DebuggerHoverVariable, DocumentHighlight, Hover as ProjectHover,
+ InlayHint, InlayId, InvalidationStrategy, LocationLink, ProjectTransaction,
+ lsp_store::{BufferSemanticTokens, CacheInlayHints},
+ };
use settings::InlayHintSettingsContent;
use settings::{DelayMs, SettingsStore};
use std::sync::atomic;
use std::sync::atomic::AtomicUsize;
+ use std::{ops::Range, rc::Rc, sync::Arc};
use text::Bias;
+ use text::BufferId;
fn get_hover_popover_delay(cx: &gpui::TestAppContext) -> u64 {
cx.read(|cx: &App| -> u64 { EditorSettings::get_global(cx).hover_popover_delay.0 })
@@ -1605,6 +1930,150 @@ mod tests {
assert_eq!(lines, ["first line", "second line", "third line"]);
}
+ #[derive(Clone)]
+ struct TestHoverSemanticsProvider {
+ hover_response: Vec<ProjectHover>,
+ debugger_response: Option<project::DebuggerHover>,
+ lsp_gate: Option<Rc<RefCell<Option<oneshot::Receiver<()>>>>>,
+ }
+
+ fn test_debugger_hover(editor: &Editor, cx: &App) -> project::DebuggerHover {
+ let buffer = editor.buffer.read(cx).as_singleton().unwrap();
+ let snapshot = buffer.read(cx).snapshot();
+ project::DebuggerHover {
+ range: snapshot.anchor_before(12)..snapshot.anchor_after(17),
+ data: DebuggerHoverData {
+ session_id: SessionId(1),
+ session_name: "Debug application".into(),
+ root: DebuggerHoverVariable {
+ name: "point".to_string(),
+ evaluate_name: Some("point".to_string()),
+ value: "Point { x: 42 }".to_string(),
+ type_name: Some("Point".to_string()),
+ variables_reference: 0,
+ },
+ },
+ }
+ }
+
+ impl crate::SemanticsProvider for TestHoverSemanticsProvider {
+ fn hover(
+ &self,
+ _buffer: &Entity<Buffer>,
+ _position: text::Anchor,
+ cx: &mut App,
+ ) -> Option<Task<Option<Vec<ProjectHover>>>> {
+ if let Some(gate) = &self.lsp_gate {
+ let receiver = gate.borrow_mut().take()?;
+ let response = self.hover_response.clone();
+ Some(cx.background_spawn(async move {
+ receiver.await.ok()?;
+ Some(response)
+ }))
+ } else {
+ Some(Task::ready(Some(self.hover_response.clone())))
+ }
+ }
+
+ fn debugger_hover(
+ &self,
+ _buffer: &Entity<Buffer>,
+ _position: text::Anchor,
+ _cx: &mut App,
+ ) -> Option<Task<Option<project::DebuggerHover>>> {
+ self.debugger_response
+ .clone()
+ .map(|response| Task::ready(Some(response)))
+ }
+
+ fn inline_values(
+ &self,
+ _buffer_handle: Entity<Buffer>,
+ _range: Range<text::Anchor>,
+ _cx: &mut App,
+ ) -> Option<Task<anyhow::Result<Vec<InlayHint>>>> {
+ None
+ }
+
+ fn applicable_inlay_chunks(
+ &self,
+ _buffer: &Entity<Buffer>,
+ _ranges: &[Range<text::Anchor>],
+ _cx: &mut App,
+ ) -> Vec<Range<BufferRow>> {
+ Vec::new()
+ }
+
+ fn invalidate_inlay_hints(&self, _for_buffers: &HashSet<BufferId>, _cx: &mut App) {}
+
+ fn inlay_hints(
+ &self,
+ _invalidate: InvalidationStrategy,
+ _buffer: Entity<Buffer>,
+ _ranges: Vec<Range<text::Anchor>>,
+ _known_chunks: Option<(clock::Global, HashSet<Range<BufferRow>>)>,
+ _cx: &mut App,
+ ) -> Option<HashMap<Range<BufferRow>, Task<anyhow::Result<CacheInlayHints>>>> {
+ None
+ }
+
+ fn semantic_tokens(
+ &self,
+ _buffer: Entity<Buffer>,
+ _cx: &mut App,
+ ) -> Option<Shared<Task<std::result::Result<BufferSemanticTokens, Arc<anyhow::Error>>>>>
+ {
+ None
+ }
+
+ fn supports_inlay_hints(&self, _buffer: &Entity<Buffer>, _cx: &mut App) -> bool {
+ false
+ }
+
+ fn supports_semantic_tokens(&self, _buffer: &Entity<Buffer>, _cx: &mut App) -> bool {
+ false
+ }
+
+ fn document_highlights(
+ &self,
+ _buffer: &Entity<Buffer>,
+ _position: text::Anchor,
+ _cx: &mut App,
+ ) -> Option<Task<anyhow::Result<Vec<DocumentHighlight>>>> {
+ None
+ }
+
+ fn definitions(
+ &self,
+ _buffer: &Entity<Buffer>,
+ _position: text::Anchor,
+ _kind: crate::GotoDefinitionKind,
+ _cx: &mut App,
+ ) -> Option<Task<anyhow::Result<Option<Vec<LocationLink>>>>> {
+ None
+ }
+
+ fn range_for_rename(
+ &self,
+ _buffer: &Entity<Buffer>,
+ _position: text::Anchor,
+ _cx: &mut App,
+ ) -> Task<anyhow::Result<Option<RenameTarget>>> {
+ Task::ready(Ok(None))
+ }
+
+ fn perform_rename(
+ &self,
+ _buffer: &Entity<Buffer>,
+ _position: text::Anchor,
+ _new_name: String,
+ _language_server_id: Option<LanguageServerId>,
+ _cx: &mut App,
+ ) -> Option<Task<anyhow::Result<ProjectTransaction>>> {
+ None
+ }
+ }
+
impl InfoPopover {
fn get_rendered_text(&self, cx: &gpui::App) -> String {
let mut rendered_text = String::new();
@@ -1799,6 +2268,158 @@ mod tests {
});
}
+ #[gpui::test]
+ async fn test_debugger_hover_separates_lsp_markdown_content(cx: &mut gpui::TestAppContext) {
+ init_test(cx, |_| {});
+
+ let mut editor_cx = EditorTestContext::new(cx).await;
+ editor_cx.set_state("let value = ˇpoint.x;\n");
+
+ editor_cx.update_editor(|editor, _, cx| {
+ let mut debugger_response = test_debugger_hover(editor, cx);
+ debugger_response.data.root.value = "Point { x: 42 }\n".repeat(40);
+ editor.set_semantics_provider(Some(Rc::new(TestHoverSemanticsProvider {
+ hover_response: vec![ProjectHover {
+ contents: vec![HoverBlock {
+ text: "Documentation for point\n\n".repeat(40),
+ kind: HoverBlockKind::Markdown,
+ }],
+ range: None,
+ language: None,
+ }],
+ debugger_response: Some(debugger_response),
+ lsp_gate: None,
+ })));
+ });
+
+ editor_cx.update_editor(|editor, window, cx| hover(editor, &Hover, window, cx));
+ editor_cx.run_until_parked();
+
+ editor_cx.update_editor(|editor, _, cx| {
+ assert_eq!(editor.hover_state.info_popovers.len(), 2);
+ let popover = editor
+ .hover_state
+ .info_popovers
+ .first()
+ .expect("expected debugger hover popover");
+
+ assert!(popover.debugger_hover.is_some());
+ assert!(popover.parsed_content.is_none());
+ let documentation = editor.hover_state.info_popovers.last().unwrap();
+ assert!(documentation.debugger_hover.is_none());
+ assert!(
+ documentation
+ .get_rendered_text(cx)
+ .contains("Documentation for point")
+ );
+ });
+
+ let handles = editor_cx.update_editor(|editor, _, _| {
+ editor
+ .hover_state
+ .info_popovers
+ .iter()
+ .map(|popover| popover.scroll_handle.clone())
+ .collect::<Vec<_>>()
+ });
+ for (index, handle) in handles.iter().enumerate() {
+ let viewport = handle.bounds();
+ let max_offset = handle.max_offset();
+ assert!(max_offset.y > px(20.));
+ let other_offset = handles[1 - index].offset();
+ let before = handle.offset();
+ editor_cx.simulate_event(gpui::ScrollWheelEvent {
+ position: viewport.center(),
+ delta: gpui::ScrollDelta::Pixels(gpui::point(px(0.), px(-20.))),
+ modifiers: Modifiers::none(),
+ touch_phase: gpui::TouchPhase::Moved,
+ });
+ editor_cx.run_until_parked();
+ assert_eq!(handle.offset(), before + gpui::point(px(0.), px(-20.)));
+ assert_eq!(handle.bounds(), viewport);
+ assert_eq!(handle.max_offset(), max_offset);
+ assert_eq!(handles[1 - index].offset(), other_offset);
+ }
+ }
+
+ #[gpui::test]
+ async fn test_debugger_hover_keeps_tree_when_lsp_documentation_arrives_late(
+ cx: &mut gpui::TestAppContext,
+ ) {
+ init_test(cx, |_| {});
+ let mut editor_cx = EditorTestContext::new(cx).await;
+ editor_cx.set_state("let value = ˇpoint.x;\n");
+ let (send_lsp, receive_lsp) = oneshot::channel();
+ editor_cx.update_editor(|editor, _, cx| {
+ editor.set_semantics_provider(Some(Rc::new(TestHoverSemanticsProvider {
+ hover_response: vec![
+ ProjectHover {
+ contents: vec![HoverBlock {
+ text: "Point is documented here".to_string(),
+ kind: HoverBlockKind::Markdown,
+ }],
+ range: None,
+ language: None,
+ },
+ ProjectHover {
+ contents: vec![HoverBlock {
+ text: "Additional type documentation".to_string(),
+ kind: HoverBlockKind::Markdown,
+ }],
+ range: None,
+ language: None,
+ },
+ ],
+ debugger_response: Some(test_debugger_hover(editor, cx)),
+ lsp_gate: Some(Rc::new(RefCell::new(Some(receive_lsp)))),
+ })));
+ });
+
+ editor_cx.update_editor(|editor, window, cx| hover(editor, &Hover, window, cx));
+ editor_cx.run_until_parked();
+ let tree = editor_cx.update_editor(|editor, _, _cx| {
+ let popover = editor.hover_state.info_popovers.first().unwrap();
+ assert!(popover.parsed_content.is_none());
+ assert!(editor.hover_state.is_single_debugger_hover());
+ popover.debugger_hover.as_ref().unwrap().entity_id()
+ });
+
+ send_lsp.send(()).unwrap();
+ editor_cx.run_until_parked();
+ editor_cx.update_editor(|editor, _, cx| {
+ assert_eq!(editor.hover_state.info_popovers.len(), 2);
+ let popover = editor.hover_state.info_popovers.first().unwrap();
+ assert_eq!(popover.debugger_hover.as_ref().unwrap().entity_id(), tree);
+ assert!(popover.parsed_content.is_none());
+ let documentation = editor.hover_state.info_popovers.last().unwrap();
+ assert!(documentation.debugger_hover.is_none());
+ let rendered = documentation.get_rendered_text(cx);
+ assert!(rendered.contains("Point is documented here"));
+ assert!(rendered.contains("Additional type documentation"));
+ });
+ }
+
+ #[test]
+ fn test_debugger_hover_type_suffix_is_inline() {
+ assert_eq!(debugger_hover_type_suffix(0, None), None);
+ assert_eq!(
+ debugger_hover_type_suffix(0, Some("Point")),
+ Some(": Point".to_string())
+ );
+ assert_eq!(debugger_hover_type_suffix(1, Some("Point")), None);
+ }
+
+ #[gpui::test]
+ fn test_debugger_hover_variable_colors_use_theme_syntax(cx: &mut gpui::TestAppContext) {
+ init_test(cx, |_| {});
+
+ let colors = cx.read(|cx: &App| debugger_hover_variable_colors(cx));
+
+ assert!(colors.name.is_some());
+ assert!(colors.value.is_some());
+ assert!(colors.type_name.is_some());
+ }
+
#[gpui::test]
async fn test_mouse_hover_info_popover(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
diff --git a/crates/project/src/debugger/session.rs b/crates/project/src/debugger/session.rs
index 6e972ca4cf0..536b02eb584 100644
--- a/crates/project/src/debugger/session.rs
+++ b/crates/project/src/debugger/session.rs
@@ -2677,6 +2677,117 @@ impl Session {
})
}
+ pub fn evaluate_hover_expression(
+ &self,
+ stack_frame_id: StackFrameId,
+ expression: String,
+ cx: &mut Context<Self>,
+ ) -> Task<Option<dap::EvaluateResponse>> {
+ cx.spawn(async move |session, cx| {
+ let hover_eval_task = session.read_with(cx, |session, _| {
+ session.state.request_dap(EvaluateCommand {
+ expression: expression.clone(),
+ frame_id: Some(stack_frame_id),
+ source: None,
+ context: Some(EvaluateArgumentsContext::Hover),
+ })
+ }).ok()?;
+
+ match hover_eval_task.await {
+ Ok(response) => Some(response),
+ Err(error) => {
+ log::debug!(
+ "Falling back to EvaluateArgumentsContext::Variables after hover evaluation failed: {error:#}"
+ );
+
+ let variables_eval_task = session.read_with(cx, |session, _| {
+ session.state.request_dap(EvaluateCommand {
+ expression,
+ frame_id: Some(stack_frame_id),
+ source: None,
+ context: Some(EvaluateArgumentsContext::Variables),
+ })
+ }).ok()?;
+
+ variables_eval_task.await.log_err()
+ }
+ }
+ })
+ }
+
+ pub fn load_hover_children(
+ &self,
+ variables_reference: VariableReference,
+ cx: &mut Context<Self>,
+ ) -> Task<Result<Vec<dap::Variable>>> {
+ if let Some(cached_variables) = self
+ .session_state()
+ .variables
+ .get(&variables_reference)
+ .cloned()
+ {
+ return Task::ready(Ok(cached_variables));
+ }
+
+ cx.spawn(async move |session, cx| {
+ let request = session.read_with(cx, |session, _| {
+ session.state.request_dap(VariablesCommand {
+ variables_reference,
+ filter: None,
+ start: None,
+ count: None,
+ format: None,
+ })
+ })?;
+
+ let mut variables = request.await?;
+
+ session.update(cx, |session, cx| {
+ session.normalize_variables(&mut variables);
+ session
+ .active_snapshot
+ .variables
+ .insert(variables_reference, variables.clone());
+ cx.emit(SessionEvent::Variables);
+ cx.emit(SessionEvent::InvalidateInlineValue);
+ })?;
+
+ Ok(variables)
+ })
+ }
+
+ fn normalize_variables(&self, variables: &mut [dap::Variable]) {
+ if self.adapter.0.as_ref() == "Debugpy" {
+ for variable in variables.iter_mut() {
+ if variable.type_ == Some("str".into()) {
+ // Debugpy returns Python repr() escaping for string variables.
+ let mut unescaped = String::with_capacity(variable.value.len());
+ let mut chars = variable.value.chars();
+ while let Some(character) = chars.next() {
+ if character != '\\' {
+ unescaped.push(character);
+ } else {
+ match chars.next() {
+ Some('\\') => unescaped.push('\\'),
+ Some('n') => unescaped.push('\n'),
+ Some('t') => unescaped.push('\t'),
+ Some('r') => unescaped.push('\r'),
+ Some('\'') => unescaped.push('\''),
+ Some('"') => unescaped.push('"'),
+ Some(character) => {
+ unescaped.push('\\');
+ unescaped.push(character);
+ }
+ None => {}
+ }
+ }
+ }
+ variable.value = unescaped;
+ }
+ }
+ }
+ }
+
pub fn refresh_watchers(&mut self, frame_id: u64, cx: &mut Context<Self>) {
let watches = self.watchers.clone();
for (_, watch) in watches.into_iter() {
@@ -2709,35 +2820,7 @@ impl Session {
return;
};
- if this.adapter.0.as_ref() == "Debugpy" {
- for variable in variables.iter_mut() {
- if variable.type_ == Some("str".into()) {
- // reverse Python repr() escaping
- let mut unescaped = String::with_capacity(variable.value.len());
- let mut chars = variable.value.chars();
- while let Some(c) = chars.next() {
- if c != '\\' {
- unescaped.push(c);
- } else {
- match chars.next() {
- Some('\\') => unescaped.push('\\'),
- Some('n') => unescaped.push('\n'),
- Some('t') => unescaped.push('\t'),
- Some('r') => unescaped.push('\r'),
- Some('\'') => unescaped.push('\''),
- Some('"') => unescaped.push('"'),
- Some(c) => {
- unescaped.push('\\');
- unescaped.push(c);
- }
- None => {}
- }
- }
- }
- variable.value = unescaped;
- }
- }
- }
+ this.normalize_variables(&mut variables);
this.active_snapshot
.variables
diff --git a/crates/project/src/project.rs b/crates/project/src/project.rs
index c3a979e269d..f53d8faa570 100644
--- a/crates/project/src/project.rs
+++ b/crates/project/src/project.rs
@@ -63,7 +63,10 @@ use client::{
};
use clock::ReplicaId;
-use dap::client::DebugAdapterClient;
+use dap::{
+ VariableReference,
+ client::{DebugAdapterClient, SessionId},
+};
use collections::{BTreeSet, HashMap, HashSet, IndexSet};
use debounced_delay::DebouncedDelay;
@@ -949,6 +952,57 @@ pub enum HoverBlockKind {
Code { language: String },
}
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct DebuggerHoverVariable {
+ pub name: String,
+ pub evaluate_name: Option<String>,
+ pub value: String,
+ pub type_name: Option<String>,
+ pub variables_reference: VariableReference,
+}
+
+impl DebuggerHoverVariable {
+ fn from_evaluate_response(expression: String, response: &dap::EvaluateResponse) -> Self {
+ Self {
+ evaluate_name: Some(expression.clone()),
+ name: expression,
+ value: response.result.clone(),
+ type_name: response
+ .type_
+ .clone()
+ .filter(|type_name| !type_name.is_empty()),
+ variables_reference: response.variables_reference,
+ }
+ }
+
+ fn from_dap_variable(variable: dap::Variable) -> Self {
+ Self {
+ evaluate_name: variable.evaluate_name.filter(|name| !name.is_empty()),
+ name: variable.name,
+ value: variable.value,
+ type_name: variable.type_.filter(|type_name| !type_name.is_empty()),
+ variables_reference: variable.variables_reference,
+ }
+ }
+
+ pub fn has_children(&self) -> bool {
+ self.variables_reference != 0
+ }
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct DebuggerHoverData {
+ pub session_id: SessionId,
+ pub session_name: SharedString,
+ pub root: DebuggerHoverVariable,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct DebuggerHover {
+ pub range: Range<language::Anchor>,
+ pub data: DebuggerHoverData,
+}
+
#[derive(Debug, Clone)]
pub struct Hover {
pub contents: Vec<HoverBlock>,
@@ -4662,6 +4716,75 @@ impl Project {
.update(cx, |lsp_store, cx| lsp_store.hover(buffer, position, cx))
}
+ pub fn debugger_hover<T: ToPointUtf16>(
+ &self,
+ buffer: &Entity<Buffer>,
+ position: T,
+ cx: &mut Context<Self>,
+ ) -> Task<Option<DebuggerHover>> {
+ let Some((session, active_stack_frame)) = self.active_debug_session(cx) else {
+ return Task::ready(None);
+ };
+ // The frame's source has already been resolved to a buffer. Its reported path
+ // may differ from the local path, for example when debugging a relocated build.
+ if buffer.read(cx).remote_id() != active_stack_frame.position.buffer_id {
+ return Task::ready(None);
+ }
+
+ let snapshot = buffer.read(cx).snapshot();
+ let position = position.to_point_utf16(buffer.read(cx));
+ let Some((expression, range)) = hovered_debug_expression(&snapshot, position) else {
+ return Task::ready(None);
+ };
+ let session_id = session.read(cx).session_id();
+ let session_name = session
+ .read(cx)
+ .label()
+ .unwrap_or_else(|| session.read(cx).adapter().0);
+ let evaluate = session.update(cx, |session, cx| {
+ session.evaluate_hover_expression(
+ active_stack_frame.stack_frame_id,
+ expression.clone(),
+ cx,
+ )
+ });
+
+ cx.background_spawn(async move {
+ let response = evaluate.await?;
+ Some(DebuggerHover {
+ range,
+ data: DebuggerHoverData {
+ session_id,
+ session_name,
+ root: DebuggerHoverVariable::from_evaluate_response(expression, &response),
+ },
+ })
+ })
+ }
+
+ pub fn load_debugger_hover_children(
+ &self,
+ session_id: SessionId,
+ variables_reference: VariableReference,
+ cx: &mut Context<Self>,
+ ) -> Task<Result<Vec<DebuggerHoverVariable>>> {
+ let Some(session) = self.dap_store.read(cx).session_by_id(session_id) else {
+ return Task::ready(Err(anyhow!("debug session is no longer available")));
+ };
+
+ let task = session.update(cx, |session, cx| {
+ session.load_hover_children(variables_reference, cx)
+ });
+
+ cx.spawn(async move |_, _| {
+ let variables = task.await?;
+ Ok(variables
+ .into_iter()
+ .map(DebuggerHoverVariable::from_dap_variable)
+ .collect())
+ })
+ }
+
pub fn linked_edits(
&self,
buffer: &Entity<Buffer>,
@@ -7146,6 +7269,115 @@ fn proto_to_prompt(level: proto::language_server_prompt_request::Level) -> gpui:
}
}
+fn hovered_debug_expression(
+ snapshot: &language::BufferSnapshot,
+ position: PointUtf16,
+) -> Option<(String, Range<Anchor>)> {
+ hovered_debug_variable_expression(snapshot, position)
+ .or_else(|| hovered_debug_member_expression(snapshot, position))
+ .or_else(|| hovered_debug_identifier_expression(snapshot, position))
+}
+
+fn hovered_debug_identifier_expression(
+ snapshot: &language::BufferSnapshot,
+ position: PointUtf16,
+) -> Option<(String, Range<Anchor>)> {
+ let offset = snapshot.point_utf16_to_offset(position);
+ let (range, _) = snapshot.surrounding_word(offset, None);
+ if range.is_empty() || !(range.start..range.end).contains(&offset) {
+ return None;
+ }
+ let node = snapshot.syntax_ancestor(offset..offset)?;
+ if node.kind() != "identifier" || node.byte_range() != range {
+ return None;
+ }
+ let expression = snapshot.text_for_range(range.clone()).collect::<String>();
+ if !expression
+ .chars()
+ .next()
+ .is_some_and(|character| character.is_alphabetic() || character == '_')
+ || !expression
+ .chars()
+ .all(|character| character.is_alphanumeric() || character == '_')
+ {
+ return None;
+ }
+ Some((
+ expression,
+ snapshot.anchor_before(range.start)..snapshot.anchor_after(range.end),
+ ))
+}
+
+fn hovered_debug_variable_expression(
+ snapshot: &language::BufferSnapshot,
+ position: PointUtf16,
+) -> Option<(String, Range<Anchor>)> {
+ let offset = snapshot.point_utf16_to_offset(position);
+
+ snapshot
+ .debug_variables_query(offset..offset)
+ .filter_map(|(range, capture_kind)| {
+ (capture_kind == language::DebuggerTextObject::Variable
+ && range.start <= offset
+ && offset <= range.end)
+ .then(|| {
+ let expression = snapshot.text_for_range(range.clone()).collect::<String>();
+ let anchor_range =
+ snapshot.anchor_before(range.start)..snapshot.anchor_after(range.end);
+ (expression, anchor_range, range.end - range.start)
+ })
+ })
+ .min_by_key(|(_, _, len)| *len)
+ .map(|(expression, range, _)| (expression, range))
+}
+
+fn hovered_debug_member_expression(
+ snapshot: &language::BufferSnapshot,
+ position: PointUtf16,
+) -> Option<(String, Range<Anchor>)> {
+ let offset = snapshot.point_utf16_to_offset(position);
+ let mut node = snapshot.syntax_ancestor(offset..offset)?;
+ let mut best_match = None;
+
+ loop {
+ let byte_range = node.byte_range();
+ if byte_range.start > offset || offset > byte_range.end {
+ break;
+ }
+
+ let expression = snapshot
+ .text_for_range(byte_range.clone())
+ .collect::<String>();
+ if looks_like_debug_hover_member_expression(&expression) {
+ best_match = Some((
+ expression,
+ snapshot.anchor_before(byte_range.start)..snapshot.anchor_after(byte_range.end),
+ ));
+ }
+
+ let Some(parent) = node.parent() else {
+ break;
+ };
+ node = parent;
+ }
+
+ best_match
+}
+
+fn looks_like_debug_hover_member_expression(expression: &str) -> bool {
+ !expression.is_empty()
+ && expression.len() <= 128
+ && !expression.contains(char::is_whitespace)
+ && (expression.contains('.') || expression.contains('[') || expression.contains("->"))
+ && expression.chars().all(|char| {
+ char.is_alphanumeric()
+ || matches!(
+ char,
+ '_' | '.' | '[' | ']' | '(' | ')' | '"' | '\'' | '-' | '>'
+ )
+ })
+}
+
fn provide_inline_values(
captures: impl Iterator<Item = (Range<usize>, language::DebuggerTextObject)>,
snapshot: &language::BufferSnapshot,
diff --git a/crates/project/tests/integration/debugger.rs b/crates/project/tests/integration/debugger.rs
index d6d3816a10b..2d814cb4527 100644
--- a/crates/project/tests/integration/debugger.rs
+++ b/crates/project/tests/integration/debugger.rs
@@ -299,6 +299,525 @@ mod python_locator {
}
}
+mod hover {
+ #![expect(clippy::result_large_err)]
+
+ use std::{path::Path, sync::Arc};
+
+ use dap::{
+ DapRegistry, EvaluateArgumentsContext, Variable,
+ adapters::{DebugAdapterName, DebugTaskDefinition},
+ client::DebugAdapterClient,
+ requests::{Evaluate, Variables},
+ };
+ use fs::FakeFs;
+ use futures::StreamExt as _;
+ use gpui::{AppContext as _, BackgroundExecutor, Entity, TestAppContext};
+ use language::{Buffer, FakeLspAdapter, ToPointUtf16, rust_lang};
+ use parking_lot::Mutex;
+ use project::{
+ Project,
+ debugger::{
+ breakpoint_store::ActiveStackFrame,
+ session::{Session, SessionQuirks, ThreadId},
+ },
+ };
+ use serde_json::json;
+ use std::sync::atomic::{AtomicUsize, Ordering};
+ use task::SharedTaskContext;
+ use util::path;
+
+ use crate::init_test;
+
+ const SOURCE: &str = "fn main() {
+ let value = 42;
+ let x = value + 1;
+ let a = 7;
+ let c = a;
+ // a here is not an expression
+ println!(\"{}\", x);
+}
+";
+
+ async fn init_project(
+ executor: BackgroundExecutor,
+ cx: &mut TestAppContext,
+ ) -> Entity<Project> {
+ init_test(cx);
+ cx.executor().allow_parking();
+ cx.update(|cx| DapRegistry::global(cx).add_adapter(Arc::new(dap::FakeAdapter::new())));
+ let fs = FakeFs::new(executor);
+ fs.insert_tree(path!("/project"), json!({ "main.rs": SOURCE }))
+ .await;
+ let project = Project::test(fs, [path!("/project").as_ref()], cx).await;
+ project
+ .read_with(cx, |project, _| project.languages().clone())
+ .add(rust_lang());
+ project
+ }
+
+ async fn boot_session<T: Fn(&Arc<DebugAdapterClient>) + 'static>(
+ project: &Entity<Project>,
+ configure: T,
+ cx: &mut TestAppContext,
+ ) -> Entity<Session> {
+ let worktree = project.update(cx, |project, cx| {
+ project
+ .worktrees(cx)
+ .next()
+ .expect("test project should have one worktree")
+ });
+ let _subscription = project::debugger::test::intercept_debug_sessions(cx, configure);
+ let dap_store = project.read_with(cx, |project, _| project.dap_store());
+ let (session, boot_task) = dap_store.update(cx, |dap_store, cx| {
+ let session = dap_store.new_session(
+ None,
+ DebugAdapterName(dap::FakeAdapter::ADAPTER_NAME.into()),
+ SharedTaskContext::default(),
+ None,
+ SessionQuirks::default(),
+ cx,
+ );
+ let boot_task = dap_store.boot_session(
+ session.clone(),
+ DebugTaskDefinition {
+ adapter: dap::FakeAdapter::ADAPTER_NAME.into(),
+ label: "test".into(),
+ config: json!({ "request": "launch" }),
+ tcp_connection: None,
+ },
+ worktree,
+ cx,
+ );
+ (session, boot_task)
+ });
+ boot_task.await.expect("session should boot");
+ cx.run_until_parked();
+ session
+ }
+
+ fn set_active_stack_frame(
+ project: &Entity<Project>,
+ session: &Entity<Session>,
+ buffer: &Entity<Buffer>,
+ cx: &mut TestAppContext,
+ ) {
+ let session_id = session.read_with(cx, |session, _| session.session_id());
+ let position = buffer.read_with(cx, |buffer, _| buffer.snapshot().anchor_before(0));
+ project.update(cx, |project, cx| {
+ project.breakpoint_store().update(cx, |store, cx| {
+ store.set_active_position(
+ ActiveStackFrame {
+ session_id,
+ thread_id: ThreadId(1),
+ stack_frame_id: 1,
+ path: Arc::<Path>::from(Path::new(path!("/project/main.rs"))),
+ position,
+ },
+ cx,
+ );
+ });
+ });
+ }
+
+ #[gpui::test]
+ async fn test_hover_debug_value_does_not_wait_for_lsp(
+ executor: BackgroundExecutor,
+ cx: &mut TestAppContext,
+ ) {
+ let project = init_project(executor, cx).await;
+ let evaluation_contexts = Arc::new(Mutex::new(Vec::new()));
+ let evaluation_succeeds = Arc::new(std::sync::atomic::AtomicBool::new(true));
+ let languages = project.read_with(cx, |project, _| project.languages().clone());
+ let mut fake_servers = languages.register_fake_lsp(
+ "Rust",
+ FakeLspAdapter {
+ capabilities: lsp::ServerCapabilities {
+ hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
+ ..lsp::ServerCapabilities::default()
+ },
+ ..FakeLspAdapter::default()
+ },
+ );
+ let session = boot_session(
+ &project,
+ {
+ let evaluation_contexts = evaluation_contexts.clone();
+ let evaluation_succeeds = evaluation_succeeds.clone();
+ move |client| {
+ let evaluation_contexts = evaluation_contexts.clone();
+ let evaluation_succeeds = evaluation_succeeds.clone();
+ client.on_request::<Evaluate, _>(move |_, args| {
+ evaluation_contexts
+ .lock()
+ .push((args.expression, args.context.clone()));
+
+ match args.context {
+ Some(EvaluateArgumentsContext::Hover) => Err(dap::ErrorResponse {
+ error: Some(dap::Message {
+ id: 1,
+ format: "hover unsupported".into(),
+ variables: None,
+ send_telemetry: None,
+ show_user: None,
+ url: None,
+ url_label: None,
+ }),
+ }),
+ Some(EvaluateArgumentsContext::Variables) => {
+ if !evaluation_succeeds.load(Ordering::SeqCst) {
+ return Err(dap::ErrorResponse { error: None });
+ }
+ Ok(dap::EvaluateResponse {
+ result: "42".into(),
+ type_: Some("i32".into()),
+ presentation_hint: None,
+ variables_reference: 0,
+ named_variables: None,
+ indexed_variables: None,
+ memory_reference: None,
+ value_location_reference: None,
+ })
+ }
+ other => panic!("unexpected evaluate context: {other:?}"),
+ }
+ });
+ }
+ },
+ cx,
+ )
+ .await;
+
+ let (buffer, _handle) = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer_with_lsp(path!("/project/main.rs"), cx)
+ })
+ .await
+ .unwrap();
+ cx.run_until_parked();
+ let (release_lsp, wait_for_release) = async_channel::unbounded::<()>();
+ fake_servers
+ .next()
+ .await
+ .expect("failed to get language server")
+ .set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _| {
+ let wait_for_release = wait_for_release.clone();
+ async move {
+ wait_for_release.recv().await.unwrap();
+ Ok(Some(lsp::Hover {
+ contents: lsp::HoverContents::Scalar(lsp::MarkedString::String(
+ "lsp hover".to_string(),
+ )),
+ range: None,
+ }))
+ }
+ });
+
+ set_active_stack_frame(&project, &session, &buffer, cx);
+ let hover_offset = SOURCE.find("value + 1").unwrap();
+ let hover_position = buffer.read_with(cx, |buffer, _| hover_offset.to_point_utf16(buffer));
+ let lsp_hover =
+ project.update(cx, |project, cx| project.hover(&buffer, hover_position, cx));
+ let debugger_hover = project.update(cx, |project, cx| {
+ project.debugger_hover(&buffer, hover_position, cx)
+ });
+ cx.run_until_parked();
+ let debugger_hover = futures::FutureExt::now_or_never(debugger_hover)
+ .expect("debug hover must complete while the LSP request is blocked")
+ .expect("expected debugger hover payload");
+ let debugger_value = debugger_hover.data;
+
+ release_lsp.send(()).await.unwrap();
+ let lsp_hover = lsp_hover
+ .await
+ .and_then(|mut hovers| hovers.pop())
+ .expect("expected independent LSP hover");
+ assert_eq!(lsp_hover.contents[0].text, "lsp hover");
+ assert_eq!(debugger_value.root.name, "value");
+ assert_eq!(debugger_value.root.evaluate_name.as_deref(), Some("value"));
+ assert_eq!(debugger_value.root.value, "42");
+ assert_eq!(debugger_value.root.type_name.as_deref(), Some("i32"));
+ assert_eq!(debugger_value.root.variables_reference, 0);
+ assert_eq!(
+ *evaluation_contexts.lock(),
+ vec![
+ ("value".to_string(), Some(EvaluateArgumentsContext::Hover),),
+ (
+ "value".to_string(),
+ Some(EvaluateArgumentsContext::Variables),
+ ),
+ ]
+ );
+ evaluation_succeeds.store(false, Ordering::SeqCst);
+ let fallback = project
+ .update(cx, |project, cx| {
+ project.debugger_hover(&buffer, hover_position, cx)
+ })
+ .await;
+ assert!(fallback.is_none());
+ }
+
+ #[gpui::test]
+ async fn test_hover_children_are_loaded_on_demand_and_cached(
+ executor: BackgroundExecutor,
+ cx: &mut TestAppContext,
+ ) {
+ let project = init_project(executor, cx).await;
+ let variables_request_count = Arc::new(AtomicUsize::new(0));
+ let session = boot_session(
+ &project,
+ {
+ let variables_request_count = variables_request_count.clone();
+ move |client| {
+ client.on_request::<Evaluate, _>(move |_, args| {
+ assert_eq!(args.expression, "value");
+ assert_eq!(args.context, Some(EvaluateArgumentsContext::Hover));
+ Ok(dap::EvaluateResponse {
+ result: "Point { x: 42 }".into(),
+ type_: Some("Point".into()),
+ presentation_hint: None,
+ variables_reference: 1,
+ named_variables: Some(1),
+ indexed_variables: None,
+ memory_reference: None,
+ value_location_reference: None,
+ })
+ });
+
+ let variables_request_count = variables_request_count.clone();
+ client.on_request::<Variables, _>(move |_, args| {
+ variables_request_count.fetch_add(1, Ordering::SeqCst);
+ assert_eq!(args.variables_reference, 1);
+ Ok(dap::VariablesResponse {
+ variables: vec![Variable {
+ name: "x".into(),
+ value: "42".into(),
+ type_: Some("i32".into()),
+ presentation_hint: None,
+ evaluate_name: Some("value.x".into()),
+ variables_reference: 0,
+ named_variables: None,
+ indexed_variables: None,
+ memory_reference: None,
+ declaration_location_reference: None,
+ value_location_reference: None,
+ }],
+ })
+ });
+ }
+ },
+ cx,
+ )
+ .await;
+
+ let buffer = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer(path!("/project/main.rs"), cx)
+ })
+ .await
+ .unwrap();
+ buffer.update(cx, |buffer, cx| buffer.set_language(Some(rust_lang()), cx));
+
+ set_active_stack_frame(&project, &session, &buffer, cx);
+ let hover_offset = SOURCE.find("value + 1").unwrap();
+ let hover_position = buffer.read_with(cx, |buffer, _| hover_offset.to_point_utf16(buffer));
+ let debugger_value = project
+ .update(cx, |project, cx| {
+ project.debugger_hover(&buffer, hover_position, cx)
+ })
+ .await
+ .map(|hover| hover.data)
+ .expect("expected debugger hover payload");
+
+ let children = project
+ .update(cx, |project, cx| {
+ project.load_debugger_hover_children(
+ debugger_value.session_id,
+ debugger_value.root.variables_reference,
+ cx,
+ )
+ })
+ .await
+ .expect("expected first child load to succeed");
+ assert_eq!(variables_request_count.load(Ordering::SeqCst), 1);
+ assert_eq!(children.len(), 1);
+ assert_eq!(children[0].name, "x");
+ assert_eq!(children[0].evaluate_name.as_deref(), Some("value.x"));
+ assert_eq!(children[0].value, "42");
+ assert_eq!(children[0].type_name.as_deref(), Some("i32"));
+ assert_eq!(children[0].variables_reference, 0);
+
+ let cached_children = project
+ .update(cx, |project, cx| {
+ project.load_debugger_hover_children(
+ debugger_value.session_id,
+ debugger_value.root.variables_reference,
+ cx,
+ )
+ })
+ .await
+ .expect("expected cached child load to succeed");
+ assert_eq!(variables_request_count.load(Ordering::SeqCst), 1);
+ assert_eq!(cached_children, children);
+ }
+
+ #[gpui::test]
+ async fn test_hover_identifier_on_assignment_rhs(
+ executor: BackgroundExecutor,
+ cx: &mut TestAppContext,
+ ) {
+ let project = init_project(executor, cx).await;
+ let session = boot_session(
+ &project,
+ |client| {
+ client.on_request::<Evaluate, _>(|_, args| {
+ assert_eq!(args.expression, "a");
+ assert_eq!(args.context, Some(EvaluateArgumentsContext::Hover));
+ Ok(dap::EvaluateResponse {
+ result: "7".into(),
+ type_: Some("i32".into()),
+ presentation_hint: None,
+ variables_reference: 0,
+ named_variables: None,
+ indexed_variables: None,
+ memory_reference: None,
+ value_location_reference: None,
+ })
+ });
+ },
+ cx,
+ )
+ .await;
+ let buffer = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer(path!("/project/main.rs"), cx)
+ })
+ .await
+ .unwrap();
+ buffer.update(cx, |buffer, cx| buffer.set_language(Some(rust_lang()), cx));
+ set_active_stack_frame(&project, &session, &buffer, cx);
+
+ let offset = SOURCE.find("c = a;").unwrap() + 4;
+ let position = buffer.read_with(cx, |buffer, _| offset.to_point_utf16(buffer));
+ let hover = project
+ .update(cx, |project, cx| {
+ project.debugger_hover(&buffer, position, cx)
+ })
+ .await
+ .expect("hovering the right-hand identifier should evaluate it");
+ assert_eq!(hover.data.root.name, "a");
+ assert_eq!(hover.data.root.value, "7");
+
+ let comment_offset = SOURCE.find("a here is not").unwrap();
+ let comment_position =
+ buffer.read_with(cx, |buffer, _| comment_offset.to_point_utf16(buffer));
+ assert!(
+ project
+ .update(cx, |project, cx| {
+ project.debugger_hover(&buffer, comment_position, cx)
+ })
+ .await
+ .is_none(),
+ "comment text is not an evaluatable identifier"
+ );
+ }
+
+ #[gpui::test]
+ async fn test_hover_uses_resolved_stack_frame_buffer(
+ executor: BackgroundExecutor,
+ cx: &mut TestAppContext,
+ ) {
+ let project = init_project(executor, cx).await;
+ let evaluation_count = Arc::new(AtomicUsize::new(0));
+ let session = boot_session(
+ &project,
+ {
+ let evaluation_count = evaluation_count.clone();
+ move |client| {
+ let evaluation_count = evaluation_count.clone();
+ client.on_request::<Evaluate, _>(move |_, args| {
+ assert_eq!(args.expression, "a");
+ assert_eq!(args.frame_id, Some(1));
+ assert_eq!(args.context, Some(EvaluateArgumentsContext::Hover));
+ evaluation_count.fetch_add(1, Ordering::SeqCst);
+ Ok(dap::EvaluateResponse {
+ result: "7".into(),
+ type_: Some("i32".into()),
+ presentation_hint: None,
+ variables_reference: 0,
+ named_variables: None,
+ indexed_variables: None,
+ memory_reference: None,
+ value_location_reference: None,
+ })
+ });
+ }
+ },
+ cx,
+ )
+ .await;
+ let buffer = project
+ .update(cx, |project, cx| {
+ project.open_local_buffer(path!("/project/main.rs"), cx)
+ })
+ .await
+ .unwrap();
+ buffer.update(cx, |buffer, cx| buffer.set_language(Some(rust_lang()), cx));
+ let offset = SOURCE.find("c = a;").unwrap() + 4;
+ let position = buffer.read_with(cx, |buffer, _| offset.to_point_utf16(buffer));
+
+ assert!(
+ project
+ .update(cx, |project, cx| project
+ .debugger_hover(&buffer, position, cx))
+ .await
+ .is_none(),
+ "hover must not evaluate without an active stack frame"
+ );
+ set_active_stack_frame(&project, &session, &buffer, cx);
+ project.update(cx, |project, cx| {
+ project.breakpoint_store().update(cx, |store, cx| {
+ let mut frame = store.active_position().unwrap().clone();
+ frame.path = Path::new(path!("/build/workspace/main.rs")).into();
+ store.set_active_position(frame, cx);
+ });
+ });
+
+ let hover = project
+ .update(cx, |project, cx| {
+ project.debugger_hover(&buffer, position, cx)
+ })
+ .await
+ .expect("the resolved source buffer must work even when the frame path differs");
+ assert_eq!(hover.data.root.name, "a");
+ assert_eq!(hover.data.root.value, "7");
+ assert_eq!(
+ hover.range.start.buffer_id,
+ buffer.read_with(cx, |buffer, _| buffer.remote_id())
+ );
+ assert_eq!(evaluation_count.load(Ordering::SeqCst), 1);
+
+ let other_buffer = cx.new(|cx| Buffer::local(SOURCE, cx));
+ project.update(cx, |project, cx| {
+ project.breakpoint_store().update(cx, |store, cx| {
+ let mut frame = store.active_position().unwrap().clone();
+ frame.path = Path::new(path!("/project/main.rs")).into();
+ frame.position = other_buffer.read(cx).snapshot().anchor_before(0);
+ store.set_active_position(frame, cx);
+ });
+ });
+ assert!(
+ project
+ .update(cx, |project, cx| project
+ .debugger_hover(&buffer, position, cx))
+ .await
+ .is_none(),
+ "a matching path must not evaluate identifiers from another source buffer"
+ );
+ assert_eq!(evaluation_count.load(Ordering::SeqCst), 1);
+ }
+}
+
mod memory {
use project::debugger::{
MemoryCell,