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