1use crate::{
2 ActiveDiagnostic, Anchor, AnchorRangeExt, DisplayPoint, DisplayRow, Editor, EditorSettings,
3 EditorSnapshot, Hover,
4 display_map::{InlayOffset, ToDisplayPoint, invisibles::is_invisible},
5 hover_links::{InlayHighlight, RangeInEditor},
6 scroll::{Autoscroll, ScrollAmount},
7};
8use gpui::{
9 AnyElement, AsyncWindowContext, Context, Entity, Focusable as _, FontWeight, Hsla,
10 InteractiveElement, IntoElement, MouseButton, ParentElement, Pixels, ScrollHandle, Size,
11 Stateful, StatefulInteractiveElement, StyleRefinement, Styled, Subscription, Task,
12 TextStyleRefinement, Window, div, px,
13};
14use itertools::Itertools;
15use language::{DiagnosticEntry, Language, LanguageRegistry};
16use lsp::DiagnosticSeverity;
17use markdown::{Markdown, MarkdownElement, MarkdownStyle};
18use multi_buffer::{MultiOrSingleBufferOffsetRange, ToOffset};
19use project::{HoverBlock, HoverBlockKind, InlayHintLabelPart};
20use settings::Settings;
21use std::{borrow::Cow, cell::RefCell};
22use std::{ops::Range, sync::Arc, time::Duration};
23use std::{path::PathBuf, rc::Rc};
24use theme::ThemeSettings;
25use ui::{Scrollbar, ScrollbarState, prelude::*, theme_is_transparent};
26use url::Url;
27use util::TryFutureExt;
28use workspace::{OpenOptions, OpenVisible, Workspace};
29pub const HOVER_REQUEST_DELAY_MILLIS: u64 = 200;
30
31pub const MIN_POPOVER_CHARACTER_WIDTH: f32 = 20.;
32pub const MIN_POPOVER_LINE_HEIGHT: f32 = 4.;
33pub const POPOVER_RIGHT_OFFSET: Pixels = px(8.0);
34pub const HOVER_POPOVER_GAP: Pixels = px(10.);
35
36/// Bindable action which uses the most recent selection head to trigger a hover
37pub fn hover(editor: &mut Editor, _: &Hover, window: &mut Window, cx: &mut Context<Editor>) {
38 let head = editor.selections.newest_anchor().head();
39 show_hover(editor, head, true, window, cx);
40}
41
42/// The internal hover action dispatches between `show_hover` or `hide_hover`
43/// depending on whether a point to hover over is provided.
44pub fn hover_at(
45 editor: &mut Editor,
46 anchor: Option<Anchor>,
47 window: &mut Window,
48 cx: &mut Context<Editor>,
49) {
50 if EditorSettings::get_global(cx).hover_popover_enabled {
51 if show_keyboard_hover(editor, window, cx) {
52 return;
53 }
54 if let Some(anchor) = anchor {
55 show_hover(editor, anchor, false, window, cx);
56 } else {
57 hide_hover(editor, cx);
58 }
59 }
60}
61
62pub fn show_keyboard_hover(
63 editor: &mut Editor,
64 window: &mut Window,
65 cx: &mut Context<Editor>,
66) -> bool {
67 if let Some(anchor) = editor.hover_state.info_popovers.iter().find_map(|p| {
68 if *p.keyboard_grace.borrow() {
69 p.anchor
70 } else {
71 None
72 }
73 }) {
74 show_hover(editor, anchor, false, window, cx);
75 return true;
76 }
77
78 if let Some(anchor) = editor
79 .hover_state
80 .diagnostic_popover
81 .as_ref()
82 .and_then(|d| {
83 if *d.keyboard_grace.borrow() {
84 d.anchor
85 } else {
86 None
87 }
88 })
89 {
90 show_hover(editor, anchor, false, window, cx);
91 return true;
92 }
93
94 false
95}
96
97pub struct InlayHover {
98 pub(crate) range: InlayHighlight,
99 pub tooltip: HoverBlock,
100}
101
102pub fn find_hovered_hint_part(
103 label_parts: Vec<InlayHintLabelPart>,
104 hint_start: InlayOffset,
105 hovered_offset: InlayOffset,
106) -> Option<(InlayHintLabelPart, Range<InlayOffset>)> {
107 if hovered_offset >= hint_start {
108 let mut hovered_character = (hovered_offset - hint_start).0;
109 let mut part_start = hint_start;
110 for part in label_parts {
111 let part_len = part.value.chars().count();
112 if hovered_character > part_len {
113 hovered_character -= part_len;
114 part_start.0 += part_len;
115 } else {
116 let part_end = InlayOffset(part_start.0 + part_len);
117 return Some((part, part_start..part_end));
118 }
119 }
120 }
121 None
122}
123
124pub fn hover_at_inlay(
125 editor: &mut Editor,
126 inlay_hover: InlayHover,
127 window: &mut Window,
128 cx: &mut Context<Editor>,
129) {
130 if EditorSettings::get_global(cx).hover_popover_enabled {
131 if editor.pending_rename.is_some() {
132 return;
133 }
134
135 let Some(project) = editor.project.clone() else {
136 return;
137 };
138
139 if editor
140 .hover_state
141 .info_popovers
142 .iter()
143 .any(|InfoPopover { symbol_range, .. }| {
144 if let RangeInEditor::Inlay(range) = symbol_range {
145 if range == &inlay_hover.range {
146 // Hover triggered from same location as last time. Don't show again.
147 return true;
148 }
149 }
150 false
151 })
152 {
153 hide_hover(editor, cx);
154 }
155
156 let hover_popover_delay = EditorSettings::get_global(cx).hover_popover_delay;
157
158 let task = cx.spawn_in(window, async move |this, cx| {
159 async move {
160 cx.background_executor()
161 .timer(Duration::from_millis(hover_popover_delay))
162 .await;
163 this.update(cx, |this, _| {
164 this.hover_state.diagnostic_popover = None;
165 })?;
166
167 let language_registry = project.update(cx, |p, _| p.languages().clone())?;
168 let blocks = vec![inlay_hover.tooltip];
169 let parsed_content = parse_blocks(&blocks, &language_registry, None, cx).await;
170
171 let scroll_handle = ScrollHandle::new();
172
173 let subscription = this
174 .update(cx, |_, cx| {
175 if let Some(parsed_content) = &parsed_content {
176 Some(cx.observe(parsed_content, |_, _, cx| cx.notify()))
177 } else {
178 None
179 }
180 })
181 .ok()
182 .flatten();
183
184 let hover_popover = InfoPopover {
185 symbol_range: RangeInEditor::Inlay(inlay_hover.range.clone()),
186 parsed_content,
187 scrollbar_state: ScrollbarState::new(scroll_handle.clone()),
188 scroll_handle,
189 keyboard_grace: Rc::new(RefCell::new(false)),
190 anchor: None,
191 _subscription: subscription,
192 };
193
194 this.update(cx, |this, cx| {
195 // TODO: no background highlights happen for inlays currently
196 this.hover_state.info_popovers = vec![hover_popover];
197 cx.notify();
198 })?;
199
200 anyhow::Ok(())
201 }
202 .log_err()
203 .await
204 });
205
206 editor.hover_state.info_task = Some(task);
207 }
208}
209
210/// Hides the type information popup.
211/// Triggered by the `Hover` action when the cursor is not over a symbol or when the
212/// selections changed.
213pub fn hide_hover(editor: &mut Editor, cx: &mut Context<Editor>) -> bool {
214 let info_popovers = editor.hover_state.info_popovers.drain(..);
215 let diagnostics_popover = editor.hover_state.diagnostic_popover.take();
216 let did_hide = info_popovers.count() > 0 || diagnostics_popover.is_some();
217
218 editor.hover_state.info_task = None;
219 editor.hover_state.triggered_from = None;
220
221 editor.clear_background_highlights::<HoverState>(cx);
222
223 if did_hide {
224 cx.notify();
225 }
226
227 did_hide
228}
229
230/// Queries the LSP and shows type info and documentation
231/// about the symbol the mouse is currently hovering over.
232/// Triggered by the `Hover` action when the cursor may be over a symbol.
233fn show_hover(
234 editor: &mut Editor,
235 anchor: Anchor,
236 ignore_timeout: bool,
237 window: &mut Window,
238 cx: &mut Context<Editor>,
239) -> Option<()> {
240 if editor.pending_rename.is_some() {
241 return None;
242 }
243
244 let snapshot = editor.snapshot(window, cx);
245
246 let (buffer, buffer_position) = editor
247 .buffer
248 .read(cx)
249 .text_anchor_for_position(anchor, cx)?;
250
251 let (excerpt_id, _, _) = editor.buffer().read(cx).excerpt_containing(anchor, cx)?;
252
253 let language_registry = editor.project.as_ref()?.read(cx).languages().clone();
254 let provider = editor.semantics_provider.clone()?;
255
256 if !ignore_timeout {
257 if same_info_hover(editor, &snapshot, anchor)
258 || same_diagnostic_hover(editor, &snapshot, anchor)
259 || editor.hover_state.diagnostic_popover.is_some()
260 {
261 // Hover triggered from same location as last time. Don't show again.
262 return None;
263 } else {
264 hide_hover(editor, cx);
265 }
266 }
267
268 // Don't request again if the location is the same as the previous request
269 if let Some(triggered_from) = &editor.hover_state.triggered_from {
270 if triggered_from
271 .cmp(&anchor, &snapshot.buffer_snapshot)
272 .is_eq()
273 {
274 return None;
275 }
276 }
277
278 let hover_popover_delay = EditorSettings::get_global(cx).hover_popover_delay;
279 let all_diagnostics_active = editor.active_diagnostics == ActiveDiagnostic::All;
280 let active_group_id = if let ActiveDiagnostic::Group(group) = &editor.active_diagnostics {
281 Some(group.group_id)
282 } else {
283 None
284 };
285
286 let task = cx.spawn_in(window, async move |this, cx| {
287 async move {
288 // If we need to delay, delay a set amount initially before making the lsp request
289 let delay = if ignore_timeout {
290 None
291 } else {
292 // Construct delay task to wait for later
293 let total_delay = Some(
294 cx.background_executor()
295 .timer(Duration::from_millis(hover_popover_delay)),
296 );
297
298 cx.background_executor()
299 .timer(Duration::from_millis(HOVER_REQUEST_DELAY_MILLIS))
300 .await;
301 total_delay
302 };
303
304 let hover_request = cx.update(|_, cx| provider.hover(&buffer, buffer_position, cx))?;
305
306 if let Some(delay) = delay {
307 delay.await;
308 }
309
310 let offset = anchor.to_offset(&snapshot.buffer_snapshot);
311 let local_diagnostic = if all_diagnostics_active {
312 None
313 } else {
314 snapshot
315 .buffer_snapshot
316 .diagnostics_in_range::<usize>(offset..offset)
317 .filter(|diagnostic| Some(diagnostic.diagnostic.group_id) != active_group_id)
318 // Find the entry with the most specific range
319 .min_by_key(|entry| entry.range.len())
320 };
321
322 let diagnostic_popover = if let Some(local_diagnostic) = local_diagnostic {
323 let text = match local_diagnostic.diagnostic.source {
324 Some(ref source) => {
325 format!("{source}: {}", local_diagnostic.diagnostic.message)
326 }
327 None => local_diagnostic.diagnostic.message.clone(),
328 };
329 let local_diagnostic = DiagnosticEntry {
330 diagnostic: local_diagnostic.diagnostic,
331 range: snapshot
332 .buffer_snapshot
333 .anchor_before(local_diagnostic.range.start)
334 ..snapshot
335 .buffer_snapshot
336 .anchor_after(local_diagnostic.range.end),
337 };
338
339 let (background_color, border_color) = cx.update(|_, cx| {
340 let status_colors = cx.theme().status();
341 match local_diagnostic.diagnostic.severity {
342 DiagnosticSeverity::ERROR => {
343 (status_colors.error_background, status_colors.error_border)
344 }
345 DiagnosticSeverity::WARNING => (
346 status_colors.warning_background,
347 status_colors.warning_border,
348 ),
349 DiagnosticSeverity::INFORMATION => {
350 (status_colors.info_background, status_colors.info_border)
351 }
352 DiagnosticSeverity::HINT => {
353 (status_colors.hint_background, status_colors.hint_border)
354 }
355 _ => (
356 status_colors.ignored_background,
357 status_colors.ignored_border,
358 ),
359 }
360 })?;
361
362 let parsed_content = cx
363 .new(|cx| Markdown::new_text(SharedString::new(text), cx))
364 .ok();
365
366 let subscription = this
367 .update(cx, |_, cx| {
368 if let Some(parsed_content) = &parsed_content {
369 Some(cx.observe(parsed_content, |_, _, cx| cx.notify()))
370 } else {
371 None
372 }
373 })
374 .ok()
375 .flatten();
376
377 Some(DiagnosticPopover {
378 local_diagnostic,
379 parsed_content,
380 border_color,
381 background_color,
382 keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
383 anchor: Some(anchor),
384 _subscription: subscription,
385 })
386 } else {
387 None
388 };
389
390 this.update(cx, |this, _| {
391 this.hover_state.diagnostic_popover = diagnostic_popover;
392 })?;
393
394 let invisible_char = if let Some(invisible) = snapshot
395 .buffer_snapshot
396 .chars_at(anchor)
397 .next()
398 .filter(|&c| is_invisible(c))
399 {
400 let after = snapshot.buffer_snapshot.anchor_after(
401 anchor.to_offset(&snapshot.buffer_snapshot) + invisible.len_utf8(),
402 );
403 Some((invisible, anchor..after))
404 } else if let Some(invisible) = snapshot
405 .buffer_snapshot
406 .reversed_chars_at(anchor)
407 .next()
408 .filter(|&c| is_invisible(c))
409 {
410 let before = snapshot.buffer_snapshot.anchor_before(
411 anchor.to_offset(&snapshot.buffer_snapshot) - invisible.len_utf8(),
412 );
413
414 Some((invisible, before..anchor))
415 } else {
416 None
417 };
418
419 let hovers_response = if let Some(hover_request) = hover_request {
420 hover_request.await
421 } else {
422 Vec::new()
423 };
424 let snapshot = this.update_in(cx, |this, window, cx| this.snapshot(window, cx))?;
425 let mut hover_highlights = Vec::with_capacity(hovers_response.len());
426 let mut info_popovers = Vec::with_capacity(
427 hovers_response.len() + if invisible_char.is_some() { 1 } else { 0 },
428 );
429
430 if let Some((invisible, range)) = invisible_char {
431 let blocks = vec![HoverBlock {
432 text: format!("Unicode character U+{:02X}", invisible as u32),
433 kind: HoverBlockKind::PlainText,
434 }];
435 let parsed_content = parse_blocks(&blocks, &language_registry, None, cx).await;
436 let scroll_handle = ScrollHandle::new();
437 let subscription = this
438 .update(cx, |_, cx| {
439 if let Some(parsed_content) = &parsed_content {
440 Some(cx.observe(parsed_content, |_, _, cx| cx.notify()))
441 } else {
442 None
443 }
444 })
445 .ok()
446 .flatten();
447 info_popovers.push(InfoPopover {
448 symbol_range: RangeInEditor::Text(range),
449 parsed_content,
450 scrollbar_state: ScrollbarState::new(scroll_handle.clone()),
451 scroll_handle,
452 keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
453 anchor: Some(anchor),
454 _subscription: subscription,
455 })
456 }
457
458 for hover_result in hovers_response {
459 // Create symbol range of anchors for highlighting and filtering of future requests.
460 let range = hover_result
461 .range
462 .and_then(|range| {
463 let start = snapshot
464 .buffer_snapshot
465 .anchor_in_excerpt(excerpt_id, range.start)?;
466 let end = snapshot
467 .buffer_snapshot
468 .anchor_in_excerpt(excerpt_id, range.end)?;
469 Some(start..end)
470 })
471 .or_else(|| {
472 let snapshot = &snapshot.buffer_snapshot;
473 match snapshot.syntax_ancestor(anchor..anchor)?.1 {
474 MultiOrSingleBufferOffsetRange::Multi(range) => Some(
475 snapshot.anchor_before(range.start)
476 ..snapshot.anchor_after(range.end),
477 ),
478 MultiOrSingleBufferOffsetRange::Single(_) => None,
479 }
480 })
481 .unwrap_or_else(|| anchor..anchor);
482
483 let blocks = hover_result.contents;
484 let language = hover_result.language;
485 let parsed_content = parse_blocks(&blocks, &language_registry, language, cx).await;
486 let scroll_handle = ScrollHandle::new();
487 hover_highlights.push(range.clone());
488 let subscription = this
489 .update(cx, |_, cx| {
490 if let Some(parsed_content) = &parsed_content {
491 Some(cx.observe(parsed_content, |_, _, cx| cx.notify()))
492 } else {
493 None
494 }
495 })
496 .ok()
497 .flatten();
498 info_popovers.push(InfoPopover {
499 symbol_range: RangeInEditor::Text(range),
500 parsed_content,
501 scrollbar_state: ScrollbarState::new(scroll_handle.clone()),
502 scroll_handle,
503 keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
504 anchor: Some(anchor),
505 _subscription: subscription,
506 });
507 }
508
509 this.update_in(cx, |editor, window, cx| {
510 if hover_highlights.is_empty() {
511 editor.clear_background_highlights::<HoverState>(cx);
512 } else {
513 // Highlight the selected symbol using a background highlight
514 editor.highlight_background::<HoverState>(
515 &hover_highlights,
516 |theme| theme.element_hover, // todo update theme
517 cx,
518 );
519 }
520
521 editor.hover_state.info_popovers = info_popovers;
522 cx.notify();
523 window.refresh();
524 })?;
525
526 anyhow::Ok(())
527 }
528 .log_err()
529 .await
530 });
531
532 editor.hover_state.info_task = Some(task);
533 None
534}
535
536fn same_info_hover(editor: &Editor, snapshot: &EditorSnapshot, anchor: Anchor) -> bool {
537 editor
538 .hover_state
539 .info_popovers
540 .iter()
541 .any(|InfoPopover { symbol_range, .. }| {
542 symbol_range
543 .as_text_range()
544 .map(|range| {
545 let hover_range = range.to_offset(&snapshot.buffer_snapshot);
546 let offset = anchor.to_offset(&snapshot.buffer_snapshot);
547 // LSP returns a hover result for the end index of ranges that should be hovered, so we need to
548 // use an inclusive range here to check if we should dismiss the popover
549 (hover_range.start..=hover_range.end).contains(&offset)
550 })
551 .unwrap_or(false)
552 })
553}
554
555fn same_diagnostic_hover(editor: &Editor, snapshot: &EditorSnapshot, anchor: Anchor) -> bool {
556 editor
557 .hover_state
558 .diagnostic_popover
559 .as_ref()
560 .map(|diagnostic| {
561 let hover_range = diagnostic
562 .local_diagnostic
563 .range
564 .to_offset(&snapshot.buffer_snapshot);
565 let offset = anchor.to_offset(&snapshot.buffer_snapshot);
566
567 // Here we do basically the same as in `same_info_hover`, see comment there for an explanation
568 (hover_range.start..=hover_range.end).contains(&offset)
569 })
570 .unwrap_or(false)
571}
572
573async fn parse_blocks(
574 blocks: &[HoverBlock],
575 language_registry: &Arc<LanguageRegistry>,
576 language: Option<Arc<Language>>,
577 cx: &mut AsyncWindowContext,
578) -> Option<Entity<Markdown>> {
579 let fallback_language_name = if let Some(ref l) = language {
580 let l = Arc::clone(l);
581 Some(l.lsp_id().clone())
582 } else {
583 None
584 };
585
586 let combined_text = blocks
587 .iter()
588 .map(|block| match &block.kind {
589 project::HoverBlockKind::PlainText | project::HoverBlockKind::Markdown => {
590 Cow::Borrowed(block.text.trim())
591 }
592 project::HoverBlockKind::Code { language } => {
593 Cow::Owned(format!("```{}\n{}\n```", language, block.text.trim()))
594 }
595 })
596 .join("\n\n");
597
598 let rendered_block = cx
599 .new_window_entity(|_window, cx| {
600 Markdown::new(
601 combined_text.into(),
602 Some(language_registry.clone()),
603 fallback_language_name,
604 cx,
605 )
606 })
607 .ok();
608
609 rendered_block
610}
611
612pub fn hover_markdown_style(window: &Window, cx: &App) -> MarkdownStyle {
613 let settings = ThemeSettings::get_global(cx);
614 let ui_font_family = settings.ui_font.family.clone();
615 let ui_font_fallbacks = settings.ui_font.fallbacks.clone();
616 let buffer_font_family = settings.buffer_font.family.clone();
617 let buffer_font_fallbacks = settings.buffer_font.fallbacks.clone();
618
619 let mut base_text_style = window.text_style();
620 base_text_style.refine(&TextStyleRefinement {
621 font_family: Some(ui_font_family.clone()),
622 font_fallbacks: ui_font_fallbacks,
623 color: Some(cx.theme().colors().editor_foreground),
624 ..Default::default()
625 });
626 MarkdownStyle {
627 base_text_style,
628 code_block: StyleRefinement::default().my(rems(1.)).font_buffer(cx),
629 inline_code: TextStyleRefinement {
630 background_color: Some(cx.theme().colors().background),
631 font_family: Some(buffer_font_family),
632 font_fallbacks: buffer_font_fallbacks,
633 ..Default::default()
634 },
635 rule_color: cx.theme().colors().border,
636 block_quote_border_color: Color::Muted.color(cx),
637 block_quote: TextStyleRefinement {
638 color: Some(Color::Muted.color(cx)),
639 ..Default::default()
640 },
641 link: TextStyleRefinement {
642 color: Some(cx.theme().colors().editor_foreground),
643 underline: Some(gpui::UnderlineStyle {
644 thickness: px(1.),
645 color: Some(cx.theme().colors().editor_foreground),
646 wavy: false,
647 }),
648 ..Default::default()
649 },
650 syntax: cx.theme().syntax().clone(),
651 selection_background_color: { cx.theme().players().local().selection },
652 height_is_multiple_of_line_height: true,
653 heading: StyleRefinement::default()
654 .font_weight(FontWeight::BOLD)
655 .text_base()
656 .mt(rems(1.))
657 .mb_0(),
658 ..Default::default()
659 }
660}
661
662pub fn open_markdown_url(link: SharedString, window: &mut Window, cx: &mut App) {
663 if let Ok(uri) = Url::parse(&link) {
664 if uri.scheme() == "file" {
665 if let Some(workspace) = window.root::<Workspace>().flatten() {
666 workspace.update(cx, |workspace, cx| {
667 let task = workspace.open_abs_path(
668 PathBuf::from(uri.path()),
669 OpenOptions {
670 visible: Some(OpenVisible::None),
671 ..Default::default()
672 },
673 window,
674 cx,
675 );
676
677 cx.spawn_in(window, async move |_, cx| {
678 let item = task.await?;
679 // Ruby LSP uses URLs with #L1,1-4,4
680 // we'll just take the first number and assume it's a line number
681 let Some(fragment) = uri.fragment() else {
682 return anyhow::Ok(());
683 };
684 let mut accum = 0u32;
685 for c in fragment.chars() {
686 if c >= '0' && c <= '9' && accum < u32::MAX / 2 {
687 accum *= 10;
688 accum += c as u32 - '0' as u32;
689 } else if accum > 0 {
690 break;
691 }
692 }
693 if accum == 0 {
694 return Ok(());
695 }
696 let Some(editor) = cx.update(|_, cx| item.act_as::<Editor>(cx))? else {
697 return Ok(());
698 };
699 editor.update_in(cx, |editor, window, cx| {
700 editor.change_selections(
701 Some(Autoscroll::fit()),
702 window,
703 cx,
704 |selections| {
705 selections.select_ranges([text::Point::new(accum - 1, 0)
706 ..text::Point::new(accum - 1, 0)]);
707 },
708 );
709 })
710 })
711 .detach_and_log_err(cx);
712 });
713 return;
714 }
715 }
716 }
717 cx.open_url(&link);
718}
719
720#[derive(Default)]
721pub struct HoverState {
722 pub(crate) info_popovers: Vec<InfoPopover>,
723 pub diagnostic_popover: Option<DiagnosticPopover>,
724 pub triggered_from: Option<Anchor>,
725 pub info_task: Option<Task<Option<()>>>,
726}
727
728impl HoverState {
729 pub fn visible(&self) -> bool {
730 !self.info_popovers.is_empty() || self.diagnostic_popover.is_some()
731 }
732
733 pub(crate) fn render(
734 &mut self,
735 snapshot: &EditorSnapshot,
736 visible_rows: Range<DisplayRow>,
737 max_size: Size<Pixels>,
738 window: &mut Window,
739 cx: &mut Context<Editor>,
740 ) -> Option<(DisplayPoint, Vec<AnyElement>)> {
741 // If there is a diagnostic, position the popovers based on that.
742 // Otherwise use the start of the hover range
743 let anchor = self
744 .diagnostic_popover
745 .as_ref()
746 .map(|diagnostic_popover| &diagnostic_popover.local_diagnostic.range.start)
747 .or_else(|| {
748 self.info_popovers.iter().find_map(|info_popover| {
749 match &info_popover.symbol_range {
750 RangeInEditor::Text(range) => Some(&range.start),
751 RangeInEditor::Inlay(_) => None,
752 }
753 })
754 })
755 .or_else(|| {
756 self.info_popovers.iter().find_map(|info_popover| {
757 match &info_popover.symbol_range {
758 RangeInEditor::Text(_) => None,
759 RangeInEditor::Inlay(range) => Some(&range.inlay_position),
760 }
761 })
762 })?;
763 let point = anchor.to_display_point(&snapshot.display_snapshot);
764
765 // Don't render if the relevant point isn't on screen
766 if !self.visible() || !visible_rows.contains(&point.row()) {
767 return None;
768 }
769
770 let mut elements = Vec::new();
771
772 if let Some(diagnostic_popover) = self.diagnostic_popover.as_ref() {
773 elements.push(diagnostic_popover.render(max_size, window, cx));
774 }
775 for info_popover in &mut self.info_popovers {
776 elements.push(info_popover.render(max_size, window, cx));
777 }
778
779 Some((point, elements))
780 }
781
782 pub fn focused(&self, window: &mut Window, cx: &mut Context<Editor>) -> bool {
783 let mut hover_popover_is_focused = false;
784 for info_popover in &self.info_popovers {
785 if let Some(markdown_view) = &info_popover.parsed_content {
786 if markdown_view.focus_handle(cx).is_focused(window) {
787 hover_popover_is_focused = true;
788 }
789 }
790 }
791 if let Some(diagnostic_popover) = &self.diagnostic_popover {
792 if let Some(markdown_view) = &diagnostic_popover.parsed_content {
793 if markdown_view.focus_handle(cx).is_focused(window) {
794 hover_popover_is_focused = true;
795 }
796 }
797 }
798 hover_popover_is_focused
799 }
800}
801
802pub(crate) struct InfoPopover {
803 pub(crate) symbol_range: RangeInEditor,
804 pub(crate) parsed_content: Option<Entity<Markdown>>,
805 pub(crate) scroll_handle: ScrollHandle,
806 pub(crate) scrollbar_state: ScrollbarState,
807 pub(crate) keyboard_grace: Rc<RefCell<bool>>,
808 pub(crate) anchor: Option<Anchor>,
809 _subscription: Option<Subscription>,
810}
811
812impl InfoPopover {
813 pub(crate) fn render(
814 &mut self,
815 max_size: Size<Pixels>,
816 window: &mut Window,
817 cx: &mut Context<Editor>,
818 ) -> AnyElement {
819 let keyboard_grace = Rc::clone(&self.keyboard_grace);
820 div()
821 .id("info_popover")
822 .elevation_2(cx)
823 // Prevent a mouse down/move on the popover from being propagated to the editor,
824 // because that would dismiss the popover.
825 .on_mouse_move(|_, _, cx| cx.stop_propagation())
826 .on_mouse_down(MouseButton::Left, move |_, _, cx| {
827 let mut keyboard_grace = keyboard_grace.borrow_mut();
828 *keyboard_grace = false;
829 cx.stop_propagation();
830 })
831 .when_some(self.parsed_content.clone(), |this, markdown| {
832 this.child(
833 div()
834 .id("info-md-container")
835 .overflow_y_scroll()
836 .max_w(max_size.width)
837 .max_h(max_size.height)
838 .p_2()
839 .track_scroll(&self.scroll_handle)
840 .child(
841 MarkdownElement::new(markdown, hover_markdown_style(window, cx))
842 .code_block_renderer(markdown::CodeBlockRenderer::Default {
843 copy_button: false,
844 border: false,
845 })
846 .on_url_click(open_markdown_url),
847 ),
848 )
849 .child(self.render_vertical_scrollbar(cx))
850 })
851 .into_any_element()
852 }
853
854 pub fn scroll(&self, amount: &ScrollAmount, window: &mut Window, cx: &mut Context<Editor>) {
855 let mut current = self.scroll_handle.offset();
856 current.y -= amount.pixels(
857 window.line_height(),
858 self.scroll_handle.bounds().size.height - px(16.),
859 ) / 2.0;
860 cx.notify();
861 self.scroll_handle.set_offset(current);
862 }
863
864 fn render_vertical_scrollbar(&self, cx: &mut Context<Editor>) -> Stateful<Div> {
865 div()
866 .occlude()
867 .id("info-popover-vertical-scroll")
868 .on_mouse_move(cx.listener(|_, _, _, cx| {
869 cx.notify();
870 cx.stop_propagation()
871 }))
872 .on_hover(|_, _, cx| {
873 cx.stop_propagation();
874 })
875 .on_any_mouse_down(|_, _, cx| {
876 cx.stop_propagation();
877 })
878 .on_mouse_up(
879 MouseButton::Left,
880 cx.listener(|_, _, _, cx| {
881 cx.stop_propagation();
882 }),
883 )
884 .on_scroll_wheel(cx.listener(|_, _, _, cx| {
885 cx.notify();
886 }))
887 .h_full()
888 .absolute()
889 .right_1()
890 .top_1()
891 .bottom_0()
892 .w(px(12.))
893 .cursor_default()
894 .children(Scrollbar::vertical(self.scrollbar_state.clone()))
895 }
896}
897
898pub struct DiagnosticPopover {
899 pub(crate) local_diagnostic: DiagnosticEntry<Anchor>,
900 parsed_content: Option<Entity<Markdown>>,
901 border_color: Hsla,
902 background_color: Hsla,
903 pub keyboard_grace: Rc<RefCell<bool>>,
904 pub anchor: Option<Anchor>,
905 _subscription: Option<Subscription>,
906}
907
908impl DiagnosticPopover {
909 pub fn render(
910 &self,
911 max_size: Size<Pixels>,
912 window: &mut Window,
913 cx: &mut Context<Editor>,
914 ) -> AnyElement {
915 let keyboard_grace = Rc::clone(&self.keyboard_grace);
916 div()
917 .id("diagnostic")
918 .block()
919 .max_h(max_size.height)
920 .overflow_y_scroll()
921 .max_w(max_size.width)
922 .elevation_2_borderless(cx)
923 // Don't draw the background color if the theme
924 // allows transparent surfaces.
925 .when(theme_is_transparent(cx), |this| {
926 this.bg(gpui::transparent_black())
927 })
928 // Prevent a mouse move on the popover from being propagated to the editor,
929 // because that would dismiss the popover.
930 .on_mouse_move(|_, _, cx| cx.stop_propagation())
931 // Prevent a mouse down on the popover from being propagated to the editor,
932 // because that would move the cursor.
933 .on_mouse_down(MouseButton::Left, move |_, _, cx| {
934 let mut keyboard_grace = keyboard_grace.borrow_mut();
935 *keyboard_grace = false;
936 cx.stop_propagation();
937 })
938 .when_some(self.parsed_content.clone(), |this, markdown| {
939 this.child(
940 div()
941 .py_1()
942 .px_2()
943 .child(
944 MarkdownElement::new(markdown, {
945 let settings = ThemeSettings::get_global(cx);
946 let mut base_text_style = window.text_style();
947 base_text_style.refine(&TextStyleRefinement {
948 font_family: Some(settings.ui_font.family.clone()),
949 font_fallbacks: settings.ui_font.fallbacks.clone(),
950 font_size: Some(settings.ui_font_size(cx).into()),
951 color: Some(cx.theme().colors().editor_foreground),
952 background_color: Some(gpui::transparent_black()),
953 ..Default::default()
954 });
955 MarkdownStyle {
956 base_text_style,
957 selection_background_color: {
958 cx.theme().players().local().selection
959 },
960 link: TextStyleRefinement {
961 underline: Some(gpui::UnderlineStyle {
962 thickness: px(1.),
963 color: Some(cx.theme().colors().editor_foreground),
964 wavy: false,
965 }),
966 ..Default::default()
967 },
968 ..Default::default()
969 }
970 })
971 .code_block_renderer(markdown::CodeBlockRenderer::Default {
972 copy_button: false,
973 border: false,
974 })
975 .on_url_click(open_markdown_url),
976 )
977 .bg(self.background_color)
978 .border_1()
979 .border_color(self.border_color)
980 .rounded_lg(),
981 )
982 })
983 .into_any_element()
984 }
985}
986
987#[cfg(test)]
988mod tests {
989 use super::*;
990 use crate::{
991 InlayId, PointForPosition,
992 actions::ConfirmCompletion,
993 editor_tests::{handle_completion_request, init_test},
994 hover_links::update_inlay_link_and_hover_points,
995 inlay_hint_cache::tests::{cached_hint_labels, visible_hint_labels},
996 test::editor_lsp_test_context::EditorLspTestContext,
997 };
998 use collections::BTreeSet;
999 use gpui::App;
1000 use indoc::indoc;
1001 use language::{Diagnostic, DiagnosticSet, language_settings::InlayHintSettings};
1002 use lsp::LanguageServerId;
1003 use markdown::parser::MarkdownEvent;
1004 use smol::stream::StreamExt;
1005 use std::sync::atomic;
1006 use std::sync::atomic::AtomicUsize;
1007 use text::Bias;
1008
1009 fn get_hover_popover_delay(cx: &gpui::TestAppContext) -> u64 {
1010 cx.read(|cx: &App| -> u64 { EditorSettings::get_global(cx).hover_popover_delay })
1011 }
1012
1013 impl InfoPopover {
1014 fn get_rendered_text(&self, cx: &gpui::App) -> String {
1015 let mut rendered_text = String::new();
1016 if let Some(parsed_content) = self.parsed_content.clone() {
1017 let markdown = parsed_content.read(cx);
1018 let text = markdown.parsed_markdown().source().to_string();
1019 let data = markdown.parsed_markdown().events();
1020 let slice = data;
1021
1022 for (range, event) in slice.iter() {
1023 match event {
1024 MarkdownEvent::SubstitutedText(parsed) => rendered_text.push_str(parsed),
1025 MarkdownEvent::Text | MarkdownEvent::Code => {
1026 rendered_text.push_str(&text[range.clone()])
1027 }
1028 _ => {}
1029 }
1030 }
1031 }
1032 rendered_text
1033 }
1034 }
1035
1036 #[gpui::test]
1037 async fn test_mouse_hover_info_popover_with_autocomplete_popover(
1038 cx: &mut gpui::TestAppContext,
1039 ) {
1040 init_test(cx, |_| {});
1041
1042 let mut cx = EditorLspTestContext::new_rust(
1043 lsp::ServerCapabilities {
1044 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
1045 completion_provider: Some(lsp::CompletionOptions {
1046 trigger_characters: Some(vec![".".to_string(), ":".to_string()]),
1047 resolve_provider: Some(true),
1048 ..Default::default()
1049 }),
1050 ..Default::default()
1051 },
1052 cx,
1053 )
1054 .await;
1055 let counter = Arc::new(AtomicUsize::new(0));
1056 // Basic hover delays and then pops without moving the mouse
1057 cx.set_state(indoc! {"
1058 oneˇ
1059 two
1060 three
1061 fn test() { println!(); }
1062 "});
1063
1064 //prompt autocompletion menu
1065 cx.simulate_keystroke(".");
1066 handle_completion_request(
1067 &mut cx,
1068 indoc! {"
1069 one.|<>
1070 two
1071 three
1072 "},
1073 vec!["first_completion", "second_completion"],
1074 counter.clone(),
1075 )
1076 .await;
1077 cx.condition(|editor, _| editor.context_menu_visible()) // wait until completion menu is visible
1078 .await;
1079 assert_eq!(counter.load(atomic::Ordering::Acquire), 1); // 1 completion request
1080
1081 let hover_point = cx.display_point(indoc! {"
1082 one.
1083 two
1084 three
1085 fn test() { printˇln!(); }
1086 "});
1087 cx.update_editor(|editor, window, cx| {
1088 let snapshot = editor.snapshot(window, cx);
1089 let anchor = snapshot
1090 .buffer_snapshot
1091 .anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
1092 hover_at(editor, Some(anchor), window, cx)
1093 });
1094 assert!(!cx.editor(|editor, _window, _cx| editor.hover_state.visible()));
1095
1096 // After delay, hover should be visible.
1097 let symbol_range = cx.lsp_range(indoc! {"
1098 one.
1099 two
1100 three
1101 fn test() { «println!»(); }
1102 "});
1103 let mut requests =
1104 cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
1105 Ok(Some(lsp::Hover {
1106 contents: lsp::HoverContents::Markup(lsp::MarkupContent {
1107 kind: lsp::MarkupKind::Markdown,
1108 value: "some basic docs".to_string(),
1109 }),
1110 range: Some(symbol_range),
1111 }))
1112 });
1113 cx.background_executor
1114 .advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
1115 requests.next().await;
1116
1117 cx.editor(|editor, _window, cx| {
1118 assert!(editor.hover_state.visible());
1119 assert_eq!(
1120 editor.hover_state.info_popovers.len(),
1121 1,
1122 "Expected exactly one hover but got: {:?}",
1123 editor.hover_state.info_popovers.len()
1124 );
1125 let rendered_text = editor
1126 .hover_state
1127 .info_popovers
1128 .first()
1129 .unwrap()
1130 .get_rendered_text(cx);
1131 assert_eq!(rendered_text, "some basic docs".to_string())
1132 });
1133
1134 // check that the completion menu is still visible and that there still has only been 1 completion request
1135 cx.editor(|editor, _, _| assert!(editor.context_menu_visible()));
1136 assert_eq!(counter.load(atomic::Ordering::Acquire), 1);
1137
1138 //apply a completion and check it was successfully applied
1139 let _apply_additional_edits = cx.update_editor(|editor, window, cx| {
1140 editor.context_menu_next(&Default::default(), window, cx);
1141 editor
1142 .confirm_completion(&ConfirmCompletion::default(), window, cx)
1143 .unwrap()
1144 });
1145 cx.assert_editor_state(indoc! {"
1146 one.second_completionˇ
1147 two
1148 three
1149 fn test() { println!(); }
1150 "});
1151
1152 // check that the completion menu is no longer visible and that there still has only been 1 completion request
1153 cx.editor(|editor, _, _| assert!(!editor.context_menu_visible()));
1154 assert_eq!(counter.load(atomic::Ordering::Acquire), 1);
1155
1156 //verify the information popover is still visible and unchanged
1157 cx.editor(|editor, _, cx| {
1158 assert!(editor.hover_state.visible());
1159 assert_eq!(
1160 editor.hover_state.info_popovers.len(),
1161 1,
1162 "Expected exactly one hover but got: {:?}",
1163 editor.hover_state.info_popovers.len()
1164 );
1165 let rendered_text = editor
1166 .hover_state
1167 .info_popovers
1168 .first()
1169 .unwrap()
1170 .get_rendered_text(cx);
1171
1172 assert_eq!(rendered_text, "some basic docs".to_string())
1173 });
1174
1175 // Mouse moved with no hover response dismisses
1176 let hover_point = cx.display_point(indoc! {"
1177 one.second_completionˇ
1178 two
1179 three
1180 fn teˇst() { println!(); }
1181 "});
1182 let mut request = cx
1183 .lsp
1184 .set_request_handler::<lsp::request::HoverRequest, _, _>(
1185 |_, _| async move { Ok(None) },
1186 );
1187 cx.update_editor(|editor, window, cx| {
1188 let snapshot = editor.snapshot(window, cx);
1189 let anchor = snapshot
1190 .buffer_snapshot
1191 .anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
1192 hover_at(editor, Some(anchor), window, cx)
1193 });
1194 cx.background_executor
1195 .advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
1196 request.next().await;
1197
1198 // verify that the information popover is no longer visible
1199 cx.editor(|editor, _, _| {
1200 assert!(!editor.hover_state.visible());
1201 });
1202 }
1203
1204 #[gpui::test]
1205 async fn test_mouse_hover_info_popover(cx: &mut gpui::TestAppContext) {
1206 init_test(cx, |_| {});
1207
1208 let mut cx = EditorLspTestContext::new_rust(
1209 lsp::ServerCapabilities {
1210 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
1211 ..Default::default()
1212 },
1213 cx,
1214 )
1215 .await;
1216
1217 // Basic hover delays and then pops without moving the mouse
1218 cx.set_state(indoc! {"
1219 fn ˇtest() { println!(); }
1220 "});
1221 let hover_point = cx.display_point(indoc! {"
1222 fn test() { printˇln!(); }
1223 "});
1224
1225 cx.update_editor(|editor, window, cx| {
1226 let snapshot = editor.snapshot(window, cx);
1227 let anchor = snapshot
1228 .buffer_snapshot
1229 .anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
1230 hover_at(editor, Some(anchor), window, cx)
1231 });
1232 assert!(!cx.editor(|editor, _window, _cx| editor.hover_state.visible()));
1233
1234 // After delay, hover should be visible.
1235 let symbol_range = cx.lsp_range(indoc! {"
1236 fn test() { «println!»(); }
1237 "});
1238 let mut requests =
1239 cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
1240 Ok(Some(lsp::Hover {
1241 contents: lsp::HoverContents::Markup(lsp::MarkupContent {
1242 kind: lsp::MarkupKind::Markdown,
1243 value: "some basic docs".to_string(),
1244 }),
1245 range: Some(symbol_range),
1246 }))
1247 });
1248 cx.background_executor
1249 .advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
1250 requests.next().await;
1251
1252 cx.editor(|editor, _, cx| {
1253 assert!(editor.hover_state.visible());
1254 assert_eq!(
1255 editor.hover_state.info_popovers.len(),
1256 1,
1257 "Expected exactly one hover but got: {:?}",
1258 editor.hover_state.info_popovers.len()
1259 );
1260 let rendered_text = editor
1261 .hover_state
1262 .info_popovers
1263 .first()
1264 .unwrap()
1265 .get_rendered_text(cx);
1266
1267 assert_eq!(rendered_text, "some basic docs".to_string())
1268 });
1269
1270 // Mouse moved with no hover response dismisses
1271 let hover_point = cx.display_point(indoc! {"
1272 fn teˇst() { println!(); }
1273 "});
1274 let mut request = cx
1275 .lsp
1276 .set_request_handler::<lsp::request::HoverRequest, _, _>(
1277 |_, _| async move { Ok(None) },
1278 );
1279 cx.update_editor(|editor, window, cx| {
1280 let snapshot = editor.snapshot(window, cx);
1281 let anchor = snapshot
1282 .buffer_snapshot
1283 .anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
1284 hover_at(editor, Some(anchor), window, cx)
1285 });
1286 cx.background_executor
1287 .advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
1288 request.next().await;
1289 cx.editor(|editor, _, _| {
1290 assert!(!editor.hover_state.visible());
1291 });
1292 }
1293
1294 #[gpui::test]
1295 async fn test_keyboard_hover_info_popover(cx: &mut gpui::TestAppContext) {
1296 init_test(cx, |_| {});
1297
1298 let mut cx = EditorLspTestContext::new_rust(
1299 lsp::ServerCapabilities {
1300 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
1301 ..Default::default()
1302 },
1303 cx,
1304 )
1305 .await;
1306
1307 // Hover with keyboard has no delay
1308 cx.set_state(indoc! {"
1309 fˇn test() { println!(); }
1310 "});
1311 cx.update_editor(|editor, window, cx| hover(editor, &Hover, window, cx));
1312 let symbol_range = cx.lsp_range(indoc! {"
1313 «fn» test() { println!(); }
1314 "});
1315
1316 cx.editor(|editor, _window, _cx| {
1317 assert!(!editor.hover_state.visible());
1318
1319 assert_eq!(
1320 editor.hover_state.info_popovers.len(),
1321 0,
1322 "Expected no hovers but got but got: {:?}",
1323 editor.hover_state.info_popovers.len()
1324 );
1325 });
1326
1327 let mut requests =
1328 cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
1329 Ok(Some(lsp::Hover {
1330 contents: lsp::HoverContents::Markup(lsp::MarkupContent {
1331 kind: lsp::MarkupKind::Markdown,
1332 value: "some other basic docs".to_string(),
1333 }),
1334 range: Some(symbol_range),
1335 }))
1336 });
1337
1338 requests.next().await;
1339 cx.dispatch_action(Hover);
1340
1341 cx.condition(|editor, _| editor.hover_state.visible()).await;
1342 cx.editor(|editor, _, cx| {
1343 assert_eq!(
1344 editor.hover_state.info_popovers.len(),
1345 1,
1346 "Expected exactly one hover but got: {:?}",
1347 editor.hover_state.info_popovers.len()
1348 );
1349
1350 let rendered_text = editor
1351 .hover_state
1352 .info_popovers
1353 .first()
1354 .unwrap()
1355 .get_rendered_text(cx);
1356
1357 assert_eq!(rendered_text, "some other basic docs".to_string())
1358 });
1359 }
1360
1361 #[gpui::test]
1362 async fn test_empty_hovers_filtered(cx: &mut gpui::TestAppContext) {
1363 init_test(cx, |_| {});
1364
1365 let mut cx = EditorLspTestContext::new_rust(
1366 lsp::ServerCapabilities {
1367 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
1368 ..Default::default()
1369 },
1370 cx,
1371 )
1372 .await;
1373
1374 // Hover with keyboard has no delay
1375 cx.set_state(indoc! {"
1376 fˇn test() { println!(); }
1377 "});
1378 cx.update_editor(|editor, window, cx| hover(editor, &Hover, window, cx));
1379 let symbol_range = cx.lsp_range(indoc! {"
1380 «fn» test() { println!(); }
1381 "});
1382 cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
1383 Ok(Some(lsp::Hover {
1384 contents: lsp::HoverContents::Array(vec![
1385 lsp::MarkedString::String("regular text for hover to show".to_string()),
1386 lsp::MarkedString::String("".to_string()),
1387 lsp::MarkedString::LanguageString(lsp::LanguageString {
1388 language: "Rust".to_string(),
1389 value: "".to_string(),
1390 }),
1391 ]),
1392 range: Some(symbol_range),
1393 }))
1394 })
1395 .next()
1396 .await;
1397 cx.dispatch_action(Hover);
1398
1399 cx.condition(|editor, _| editor.hover_state.visible()).await;
1400 cx.editor(|editor, _, cx| {
1401 assert_eq!(
1402 editor.hover_state.info_popovers.len(),
1403 1,
1404 "Expected exactly one hover but got: {:?}",
1405 editor.hover_state.info_popovers.len()
1406 );
1407 let rendered_text = editor
1408 .hover_state
1409 .info_popovers
1410 .first()
1411 .unwrap()
1412 .get_rendered_text(cx);
1413
1414 assert_eq!(
1415 rendered_text,
1416 "regular text for hover to show".to_string(),
1417 "No empty string hovers should be shown"
1418 );
1419 });
1420 }
1421
1422 #[gpui::test]
1423 async fn test_line_ends_trimmed(cx: &mut gpui::TestAppContext) {
1424 init_test(cx, |_| {});
1425
1426 let mut cx = EditorLspTestContext::new_rust(
1427 lsp::ServerCapabilities {
1428 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
1429 ..Default::default()
1430 },
1431 cx,
1432 )
1433 .await;
1434
1435 // Hover with keyboard has no delay
1436 cx.set_state(indoc! {"
1437 fˇn test() { println!(); }
1438 "});
1439 cx.update_editor(|editor, window, cx| hover(editor, &Hover, window, cx));
1440 let symbol_range = cx.lsp_range(indoc! {"
1441 «fn» test() { println!(); }
1442 "});
1443
1444 let code_str = "\nlet hovered_point: Vector2F // size = 8, align = 0x4\n";
1445 let markdown_string = format!("\n```rust\n{code_str}```");
1446
1447 let closure_markdown_string = markdown_string.clone();
1448 cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| {
1449 let future_markdown_string = closure_markdown_string.clone();
1450 async move {
1451 Ok(Some(lsp::Hover {
1452 contents: lsp::HoverContents::Markup(lsp::MarkupContent {
1453 kind: lsp::MarkupKind::Markdown,
1454 value: future_markdown_string,
1455 }),
1456 range: Some(symbol_range),
1457 }))
1458 }
1459 })
1460 .next()
1461 .await;
1462
1463 cx.dispatch_action(Hover);
1464
1465 cx.condition(|editor, _| editor.hover_state.visible()).await;
1466 cx.editor(|editor, _, cx| {
1467 assert_eq!(
1468 editor.hover_state.info_popovers.len(),
1469 1,
1470 "Expected exactly one hover but got: {:?}",
1471 editor.hover_state.info_popovers.len()
1472 );
1473 let rendered_text = editor
1474 .hover_state
1475 .info_popovers
1476 .first()
1477 .unwrap()
1478 .get_rendered_text(cx);
1479
1480 assert_eq!(
1481 rendered_text, code_str,
1482 "Should not have extra line breaks at end of rendered hover"
1483 );
1484 });
1485 }
1486
1487 #[gpui::test]
1488 async fn test_hover_diagnostic_and_info_popovers(cx: &mut gpui::TestAppContext) {
1489 init_test(cx, |_| {});
1490
1491 let mut cx = EditorLspTestContext::new_rust(
1492 lsp::ServerCapabilities {
1493 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
1494 ..Default::default()
1495 },
1496 cx,
1497 )
1498 .await;
1499
1500 // Hover with just diagnostic, pops DiagnosticPopover immediately and then
1501 // info popover once request completes
1502 cx.set_state(indoc! {"
1503 fn teˇst() { println!(); }
1504 "});
1505
1506 // Send diagnostic to client
1507 let range = cx.text_anchor_range(indoc! {"
1508 fn «test»() { println!(); }
1509 "});
1510 cx.update_buffer(|buffer, cx| {
1511 let snapshot = buffer.text_snapshot();
1512 let set = DiagnosticSet::from_sorted_entries(
1513 vec![DiagnosticEntry {
1514 range,
1515 diagnostic: Diagnostic {
1516 message: "A test diagnostic message.".to_string(),
1517 ..Default::default()
1518 },
1519 }],
1520 &snapshot,
1521 );
1522 buffer.update_diagnostics(LanguageServerId(0), set, cx);
1523 });
1524
1525 // Hover pops diagnostic immediately
1526 cx.update_editor(|editor, window, cx| hover(editor, &Hover, window, cx));
1527 cx.background_executor.run_until_parked();
1528
1529 cx.editor(|Editor { hover_state, .. }, _, _| {
1530 assert!(
1531 hover_state.diagnostic_popover.is_some() && hover_state.info_popovers.is_empty()
1532 )
1533 });
1534
1535 // Info Popover shows after request responded to
1536 let range = cx.lsp_range(indoc! {"
1537 fn «test»() { println!(); }
1538 "});
1539 cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
1540 Ok(Some(lsp::Hover {
1541 contents: lsp::HoverContents::Markup(lsp::MarkupContent {
1542 kind: lsp::MarkupKind::Markdown,
1543 value: "some new docs".to_string(),
1544 }),
1545 range: Some(range),
1546 }))
1547 });
1548 cx.background_executor
1549 .advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
1550
1551 cx.background_executor.run_until_parked();
1552 cx.editor(|Editor { hover_state, .. }, _, _| {
1553 hover_state.diagnostic_popover.is_some() && hover_state.info_task.is_some()
1554 });
1555 }
1556
1557 #[gpui::test]
1558 // https://github.com/zed-industries/zed/issues/15498
1559 async fn test_info_hover_with_hrs(cx: &mut gpui::TestAppContext) {
1560 init_test(cx, |_| {});
1561
1562 let mut cx = EditorLspTestContext::new_rust(
1563 lsp::ServerCapabilities {
1564 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
1565 ..Default::default()
1566 },
1567 cx,
1568 )
1569 .await;
1570
1571 cx.set_state(indoc! {"
1572 fn fuˇnc(abc def: i32) -> u32 {
1573 }
1574 "});
1575
1576 cx.lsp
1577 .set_request_handler::<lsp::request::HoverRequest, _, _>({
1578 |_, _| async move {
1579 Ok(Some(lsp::Hover {
1580 contents: lsp::HoverContents::Markup(lsp::MarkupContent {
1581 kind: lsp::MarkupKind::Markdown,
1582 value: indoc!(
1583 r#"
1584 ### function `errands_data_read`
1585
1586 ---
1587 → `char *`
1588 Function to read a file into a string
1589
1590 ---
1591 ```cpp
1592 static char *errands_data_read()
1593 ```
1594 "#
1595 )
1596 .to_string(),
1597 }),
1598 range: None,
1599 }))
1600 }
1601 });
1602 cx.update_editor(|editor, window, cx| hover(editor, &Default::default(), window, cx));
1603 cx.run_until_parked();
1604
1605 cx.update_editor(|editor, _, cx| {
1606 let popover = editor.hover_state.info_popovers.first().unwrap();
1607 let content = popover.get_rendered_text(cx);
1608
1609 assert!(content.contains("Function to read a file"));
1610 });
1611 }
1612
1613 #[gpui::test]
1614 async fn test_hover_inlay_label_parts(cx: &mut gpui::TestAppContext) {
1615 init_test(cx, |settings| {
1616 settings.defaults.inlay_hints = Some(InlayHintSettings {
1617 show_value_hints: true,
1618 enabled: true,
1619 edit_debounce_ms: 0,
1620 scroll_debounce_ms: 0,
1621 show_type_hints: true,
1622 show_parameter_hints: true,
1623 show_other_hints: true,
1624 show_background: false,
1625 toggle_on_modifiers_press: None,
1626 })
1627 });
1628
1629 let mut cx = EditorLspTestContext::new_rust(
1630 lsp::ServerCapabilities {
1631 inlay_hint_provider: Some(lsp::OneOf::Right(
1632 lsp::InlayHintServerCapabilities::Options(lsp::InlayHintOptions {
1633 resolve_provider: Some(true),
1634 ..Default::default()
1635 }),
1636 )),
1637 ..Default::default()
1638 },
1639 cx,
1640 )
1641 .await;
1642
1643 cx.set_state(indoc! {"
1644 struct TestStruct;
1645
1646 // ==================
1647
1648 struct TestNewType<T>(T);
1649
1650 fn main() {
1651 let variableˇ = TestNewType(TestStruct);
1652 }
1653 "});
1654
1655 let hint_start_offset = cx.ranges(indoc! {"
1656 struct TestStruct;
1657
1658 // ==================
1659
1660 struct TestNewType<T>(T);
1661
1662 fn main() {
1663 let variableˇ = TestNewType(TestStruct);
1664 }
1665 "})[0]
1666 .start;
1667 let hint_position = cx.to_lsp(hint_start_offset);
1668 let new_type_target_range = cx.lsp_range(indoc! {"
1669 struct TestStruct;
1670
1671 // ==================
1672
1673 struct «TestNewType»<T>(T);
1674
1675 fn main() {
1676 let variable = TestNewType(TestStruct);
1677 }
1678 "});
1679 let struct_target_range = cx.lsp_range(indoc! {"
1680 struct «TestStruct»;
1681
1682 // ==================
1683
1684 struct TestNewType<T>(T);
1685
1686 fn main() {
1687 let variable = TestNewType(TestStruct);
1688 }
1689 "});
1690
1691 let uri = cx.buffer_lsp_url.clone();
1692 let new_type_label = "TestNewType";
1693 let struct_label = "TestStruct";
1694 let entire_hint_label = ": TestNewType<TestStruct>";
1695 let closure_uri = uri.clone();
1696 cx.lsp
1697 .set_request_handler::<lsp::request::InlayHintRequest, _, _>(move |params, _| {
1698 let task_uri = closure_uri.clone();
1699 async move {
1700 assert_eq!(params.text_document.uri, task_uri);
1701 Ok(Some(vec![lsp::InlayHint {
1702 position: hint_position,
1703 label: lsp::InlayHintLabel::LabelParts(vec![lsp::InlayHintLabelPart {
1704 value: entire_hint_label.to_string(),
1705 ..Default::default()
1706 }]),
1707 kind: Some(lsp::InlayHintKind::TYPE),
1708 text_edits: None,
1709 tooltip: None,
1710 padding_left: Some(false),
1711 padding_right: Some(false),
1712 data: None,
1713 }]))
1714 }
1715 })
1716 .next()
1717 .await;
1718 cx.background_executor.run_until_parked();
1719 cx.update_editor(|editor, _, cx| {
1720 let expected_layers = vec![entire_hint_label.to_string()];
1721 assert_eq!(expected_layers, cached_hint_labels(editor));
1722 assert_eq!(expected_layers, visible_hint_labels(editor, cx));
1723 });
1724
1725 let inlay_range = cx
1726 .ranges(indoc! {"
1727 struct TestStruct;
1728
1729 // ==================
1730
1731 struct TestNewType<T>(T);
1732
1733 fn main() {
1734 let variable« »= TestNewType(TestStruct);
1735 }
1736 "})
1737 .first()
1738 .cloned()
1739 .unwrap();
1740 let new_type_hint_part_hover_position = cx.update_editor(|editor, window, cx| {
1741 let snapshot = editor.snapshot(window, cx);
1742 let previous_valid = inlay_range.start.to_display_point(&snapshot);
1743 let next_valid = inlay_range.end.to_display_point(&snapshot);
1744 assert_eq!(previous_valid.row(), next_valid.row());
1745 assert!(previous_valid.column() < next_valid.column());
1746 let exact_unclipped = DisplayPoint::new(
1747 previous_valid.row(),
1748 previous_valid.column()
1749 + (entire_hint_label.find(new_type_label).unwrap() + new_type_label.len() / 2)
1750 as u32,
1751 );
1752 PointForPosition {
1753 previous_valid,
1754 next_valid,
1755 exact_unclipped,
1756 column_overshoot_after_line_end: 0,
1757 }
1758 });
1759 cx.update_editor(|editor, window, cx| {
1760 update_inlay_link_and_hover_points(
1761 &editor.snapshot(window, cx),
1762 new_type_hint_part_hover_position,
1763 editor,
1764 true,
1765 false,
1766 window,
1767 cx,
1768 );
1769 });
1770
1771 let resolve_closure_uri = uri.clone();
1772 cx.lsp
1773 .set_request_handler::<lsp::request::InlayHintResolveRequest, _, _>(
1774 move |mut hint_to_resolve, _| {
1775 let mut resolved_hint_positions = BTreeSet::new();
1776 let task_uri = resolve_closure_uri.clone();
1777 async move {
1778 let inserted = resolved_hint_positions.insert(hint_to_resolve.position);
1779 assert!(inserted, "Hint {hint_to_resolve:?} was resolved twice");
1780
1781 // `: TestNewType<TestStruct>`
1782 hint_to_resolve.label = lsp::InlayHintLabel::LabelParts(vec![
1783 lsp::InlayHintLabelPart {
1784 value: ": ".to_string(),
1785 ..Default::default()
1786 },
1787 lsp::InlayHintLabelPart {
1788 value: new_type_label.to_string(),
1789 location: Some(lsp::Location {
1790 uri: task_uri.clone(),
1791 range: new_type_target_range,
1792 }),
1793 tooltip: Some(lsp::InlayHintLabelPartTooltip::String(format!(
1794 "A tooltip for `{new_type_label}`"
1795 ))),
1796 ..Default::default()
1797 },
1798 lsp::InlayHintLabelPart {
1799 value: "<".to_string(),
1800 ..Default::default()
1801 },
1802 lsp::InlayHintLabelPart {
1803 value: struct_label.to_string(),
1804 location: Some(lsp::Location {
1805 uri: task_uri,
1806 range: struct_target_range,
1807 }),
1808 tooltip: Some(lsp::InlayHintLabelPartTooltip::MarkupContent(
1809 lsp::MarkupContent {
1810 kind: lsp::MarkupKind::Markdown,
1811 value: format!("A tooltip for `{struct_label}`"),
1812 },
1813 )),
1814 ..Default::default()
1815 },
1816 lsp::InlayHintLabelPart {
1817 value: ">".to_string(),
1818 ..Default::default()
1819 },
1820 ]);
1821
1822 Ok(hint_to_resolve)
1823 }
1824 },
1825 )
1826 .next()
1827 .await;
1828 cx.background_executor.run_until_parked();
1829
1830 cx.update_editor(|editor, window, cx| {
1831 update_inlay_link_and_hover_points(
1832 &editor.snapshot(window, cx),
1833 new_type_hint_part_hover_position,
1834 editor,
1835 true,
1836 false,
1837 window,
1838 cx,
1839 );
1840 });
1841 cx.background_executor
1842 .advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
1843 cx.background_executor.run_until_parked();
1844 cx.update_editor(|editor, _, cx| {
1845 let hover_state = &editor.hover_state;
1846 assert!(
1847 hover_state.diagnostic_popover.is_none() && hover_state.info_popovers.len() == 1
1848 );
1849 let popover = hover_state.info_popovers.first().unwrap();
1850 let buffer_snapshot = editor.buffer().update(cx, |buffer, cx| buffer.snapshot(cx));
1851 assert_eq!(
1852 popover.symbol_range,
1853 RangeInEditor::Inlay(InlayHighlight {
1854 inlay: InlayId::Hint(0),
1855 inlay_position: buffer_snapshot.anchor_at(inlay_range.start, Bias::Right),
1856 range: ": ".len()..": ".len() + new_type_label.len(),
1857 }),
1858 "Popover range should match the new type label part"
1859 );
1860 assert_eq!(
1861 popover.get_rendered_text(cx),
1862 format!("A tooltip for {new_type_label}"),
1863 );
1864 });
1865
1866 let struct_hint_part_hover_position = cx.update_editor(|editor, window, cx| {
1867 let snapshot = editor.snapshot(window, cx);
1868 let previous_valid = inlay_range.start.to_display_point(&snapshot);
1869 let next_valid = inlay_range.end.to_display_point(&snapshot);
1870 assert_eq!(previous_valid.row(), next_valid.row());
1871 assert!(previous_valid.column() < next_valid.column());
1872 let exact_unclipped = DisplayPoint::new(
1873 previous_valid.row(),
1874 previous_valid.column()
1875 + (entire_hint_label.find(struct_label).unwrap() + struct_label.len() / 2)
1876 as u32,
1877 );
1878 PointForPosition {
1879 previous_valid,
1880 next_valid,
1881 exact_unclipped,
1882 column_overshoot_after_line_end: 0,
1883 }
1884 });
1885 cx.update_editor(|editor, window, cx| {
1886 update_inlay_link_and_hover_points(
1887 &editor.snapshot(window, cx),
1888 struct_hint_part_hover_position,
1889 editor,
1890 true,
1891 false,
1892 window,
1893 cx,
1894 );
1895 });
1896 cx.background_executor
1897 .advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
1898 cx.background_executor.run_until_parked();
1899 cx.update_editor(|editor, _, cx| {
1900 let hover_state = &editor.hover_state;
1901 assert!(
1902 hover_state.diagnostic_popover.is_none() && hover_state.info_popovers.len() == 1
1903 );
1904 let popover = hover_state.info_popovers.first().unwrap();
1905 let buffer_snapshot = editor.buffer().update(cx, |buffer, cx| buffer.snapshot(cx));
1906 assert_eq!(
1907 popover.symbol_range,
1908 RangeInEditor::Inlay(InlayHighlight {
1909 inlay: InlayId::Hint(0),
1910 inlay_position: buffer_snapshot.anchor_at(inlay_range.start, Bias::Right),
1911 range: ": ".len() + new_type_label.len() + "<".len()
1912 ..": ".len() + new_type_label.len() + "<".len() + struct_label.len(),
1913 }),
1914 "Popover range should match the struct label part"
1915 );
1916 assert_eq!(
1917 popover.get_rendered_text(cx),
1918 format!("A tooltip for {struct_label}"),
1919 "Rendered markdown element should remove backticks from text"
1920 );
1921 });
1922 }
1923}