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