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.jsonindex 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.jsonindex 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.jsonindex 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.jsonindex 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsnew file mode 100644index 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.rsindex 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.rsindex 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 overlaplet 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 pointplace_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 pointplace_popovers_below(hovered_point,diff --git a/crates/editor/src/hover_popover.rs b/crates/editor/src/hover_popover.rsindex 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 hoverpub 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.rsindex 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.variablesdiff --git a/crates/project/src/project.rs b/crates/project/src/project.rsindex 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.rsindex 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,