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::{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.to_owned(),
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 let range = snapshot.syntax_ancestor(anchor..anchor)?.1;
481 Some(snapshot.anchor_before(range.start)..snapshot.anchor_after(range.end))
482 })
483 .unwrap_or_else(|| anchor..anchor);
484
485 let blocks = hover_result.contents;
486 let language = hover_result.language;
487 let parsed_content =
488 parse_blocks(&blocks, language_registry.as_ref(), language, cx).await;
489 let scroll_handle = ScrollHandle::new();
490 hover_highlights.push(range.clone());
491 let subscription = this
492 .update(cx, |_, cx| {
493 parsed_content.as_ref().map(|parsed_content| {
494 cx.observe(parsed_content, |_, _, cx| cx.notify())
495 })
496 })
497 .ok()
498 .flatten();
499 info_popovers.push(InfoPopover {
500 symbol_range: RangeInEditor::Text(range),
501 parsed_content,
502 scroll_handle,
503 keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
504 anchor: Some(anchor),
505 _subscription: subscription,
506 });
507 }
508
509 this.update_in(cx, |editor, window, cx| {
510 if hover_highlights.is_empty() {
511 editor.clear_background_highlights::<HoverState>(cx);
512 } else {
513 // Highlight the selected symbol using a background highlight
514 editor.highlight_background::<HoverState>(
515 &hover_highlights,
516 |theme| theme.colors().element_hover, // todo update theme
517 cx,
518 );
519 }
520
521 editor.hover_state.info_popovers = info_popovers;
522 cx.notify();
523 window.refresh();
524 })?;
525
526 anyhow::Ok(())
527 }
528 .log_err()
529 .await
530 });
531
532 editor.hover_state.info_task = Some(task);
533 None
534}
535
536fn same_info_hover(editor: &Editor, snapshot: &EditorSnapshot, anchor: Anchor) -> bool {
537 editor
538 .hover_state
539 .info_popovers
540 .iter()
541 .any(|InfoPopover { symbol_range, .. }| {
542 symbol_range
543 .as_text_range()
544 .map(|range| {
545 let hover_range = range.to_offset(&snapshot.buffer_snapshot());
546 let offset = anchor.to_offset(&snapshot.buffer_snapshot());
547 // LSP returns a hover result for the end index of ranges that should be hovered, so we need to
548 // use an inclusive range here to check if we should dismiss the popover
549 (hover_range.start..=hover_range.end).contains(&offset)
550 })
551 .unwrap_or(false)
552 })
553}
554
555fn same_diagnostic_hover(editor: &Editor, snapshot: &EditorSnapshot, anchor: Anchor) -> bool {
556 editor
557 .hover_state
558 .diagnostic_popover
559 .as_ref()
560 .map(|diagnostic| {
561 let hover_range = diagnostic
562 .local_diagnostic
563 .range
564 .to_offset(&snapshot.buffer_snapshot());
565 let offset = anchor.to_offset(&snapshot.buffer_snapshot());
566
567 // Here we do basically the same as in `same_info_hover`, see comment there for an explanation
568 (hover_range.start..=hover_range.end).contains(&offset)
569 })
570 .unwrap_or(false)
571}
572
573async fn parse_blocks(
574 blocks: &[HoverBlock],
575 language_registry: Option<&Arc<LanguageRegistry>>,
576 language: Option<Arc<Language>>,
577 cx: &mut AsyncWindowContext,
578) -> Option<Entity<Markdown>> {
579 let combined_text = blocks
580 .iter()
581 .map(|block| match &block.kind {
582 project::HoverBlockKind::PlainText | project::HoverBlockKind::Markdown => {
583 Cow::Borrowed(block.text.trim())
584 }
585 project::HoverBlockKind::Code { language } => {
586 Cow::Owned(format!("```{}\n{}\n```", language, block.text.trim()))
587 }
588 })
589 .join("\n\n");
590
591 cx.new_window_entity(|_window, cx| {
592 Markdown::new(
593 combined_text.into(),
594 language_registry.cloned(),
595 language.map(|language| language.name()),
596 cx,
597 )
598 })
599 .ok()
600}
601
602pub fn hover_markdown_style(window: &Window, cx: &App) -> MarkdownStyle {
603 let settings = ThemeSettings::get_global(cx);
604 let ui_font_family = settings.ui_font.family.clone();
605 let ui_font_fallbacks = settings.ui_font.fallbacks.clone();
606 let buffer_font_family = settings.buffer_font.family.clone();
607 let buffer_font_fallbacks = settings.buffer_font.fallbacks.clone();
608
609 let mut base_text_style = window.text_style();
610 base_text_style.refine(&TextStyleRefinement {
611 font_family: Some(ui_font_family),
612 font_fallbacks: ui_font_fallbacks,
613 color: Some(cx.theme().colors().editor_foreground),
614 ..Default::default()
615 });
616 MarkdownStyle {
617 base_text_style,
618 code_block: StyleRefinement::default().my(rems(1.)).font_buffer(cx),
619 inline_code: TextStyleRefinement {
620 background_color: Some(cx.theme().colors().background),
621 font_family: Some(buffer_font_family),
622 font_fallbacks: buffer_font_fallbacks,
623 ..Default::default()
624 },
625 rule_color: cx.theme().colors().border,
626 block_quote_border_color: Color::Muted.color(cx),
627 block_quote: TextStyleRefinement {
628 color: Some(Color::Muted.color(cx)),
629 ..Default::default()
630 },
631 link: TextStyleRefinement {
632 color: Some(cx.theme().colors().editor_foreground),
633 underline: Some(gpui::UnderlineStyle {
634 thickness: px(1.),
635 color: Some(cx.theme().colors().editor_foreground),
636 wavy: false,
637 }),
638 ..Default::default()
639 },
640 syntax: cx.theme().syntax().clone(),
641 selection_background_color: cx.theme().colors().element_selection_background,
642 heading: StyleRefinement::default()
643 .font_weight(FontWeight::BOLD)
644 .text_base()
645 .mt(rems(1.))
646 .mb_0(),
647 ..Default::default()
648 }
649}
650
651pub fn diagnostics_markdown_style(window: &Window, cx: &App) -> MarkdownStyle {
652 let settings = ThemeSettings::get_global(cx);
653 let ui_font_family = settings.ui_font.family.clone();
654 let ui_font_fallbacks = settings.ui_font.fallbacks.clone();
655 let buffer_font_family = settings.buffer_font.family.clone();
656 let buffer_font_fallbacks = settings.buffer_font.fallbacks.clone();
657
658 let mut base_text_style = window.text_style();
659 base_text_style.refine(&TextStyleRefinement {
660 font_family: Some(ui_font_family),
661 font_fallbacks: ui_font_fallbacks,
662 color: Some(cx.theme().colors().editor_foreground),
663 ..Default::default()
664 });
665 MarkdownStyle {
666 base_text_style,
667 code_block: StyleRefinement::default().my(rems(1.)).font_buffer(cx),
668 inline_code: TextStyleRefinement {
669 background_color: Some(cx.theme().colors().editor_background.opacity(0.5)),
670 font_family: Some(buffer_font_family),
671 font_fallbacks: buffer_font_fallbacks,
672 ..Default::default()
673 },
674 rule_color: cx.theme().colors().border,
675 block_quote_border_color: Color::Muted.color(cx),
676 block_quote: TextStyleRefinement {
677 color: Some(Color::Muted.color(cx)),
678 ..Default::default()
679 },
680 link: TextStyleRefinement {
681 color: Some(cx.theme().colors().editor_foreground),
682 underline: Some(gpui::UnderlineStyle {
683 thickness: px(1.),
684 color: Some(cx.theme().colors().editor_foreground),
685 wavy: false,
686 }),
687 ..Default::default()
688 },
689 syntax: cx.theme().syntax().clone(),
690 selection_background_color: cx.theme().colors().element_selection_background,
691 height_is_multiple_of_line_height: true,
692 heading: StyleRefinement::default()
693 .font_weight(FontWeight::BOLD)
694 .text_base()
695 .mb_0(),
696 ..Default::default()
697 }
698}
699
700pub fn open_markdown_url(link: SharedString, window: &mut Window, cx: &mut App) {
701 if let Ok(uri) = Url::parse(&link)
702 && uri.scheme() == "file"
703 && let Some(workspace) = window.root::<Workspace>().flatten()
704 {
705 workspace.update(cx, |workspace, cx| {
706 let task = workspace.open_abs_path(
707 PathBuf::from(uri.path()),
708 OpenOptions {
709 visible: Some(OpenVisible::None),
710 ..Default::default()
711 },
712 window,
713 cx,
714 );
715
716 cx.spawn_in(window, async move |_, cx| {
717 let item = task.await?;
718 // Ruby LSP uses URLs with #L1,1-4,4
719 // we'll just take the first number and assume it's a line number
720 let Some(fragment) = uri.fragment() else {
721 return anyhow::Ok(());
722 };
723 let mut accum = 0u32;
724 for c in fragment.chars() {
725 if c >= '0' && c <= '9' && accum < u32::MAX / 2 {
726 accum *= 10;
727 accum += c as u32 - '0' as u32;
728 } else if accum > 0 {
729 break;
730 }
731 }
732 if accum == 0 {
733 return Ok(());
734 }
735 let Some(editor) = cx.update(|_, cx| item.act_as::<Editor>(cx))? else {
736 return Ok(());
737 };
738 editor.update_in(cx, |editor, window, cx| {
739 editor.change_selections(Default::default(), window, cx, |selections| {
740 selections.select_ranges([
741 text::Point::new(accum - 1, 0)..text::Point::new(accum - 1, 0)
742 ]);
743 });
744 })
745 })
746 .detach_and_log_err(cx);
747 });
748 return;
749 }
750 cx.open_url(&link);
751}
752
753#[derive(Default)]
754pub struct HoverState {
755 pub info_popovers: Vec<InfoPopover>,
756 pub diagnostic_popover: Option<DiagnosticPopover>,
757 pub triggered_from: Option<Anchor>,
758 pub info_task: Option<Task<Option<()>>>,
759}
760
761impl HoverState {
762 pub fn visible(&self) -> bool {
763 !self.info_popovers.is_empty() || self.diagnostic_popover.is_some()
764 }
765
766 pub(crate) fn render(
767 &mut self,
768 snapshot: &EditorSnapshot,
769 visible_rows: Range<DisplayRow>,
770 max_size: Size<Pixels>,
771 window: &mut Window,
772 cx: &mut Context<Editor>,
773 ) -> Option<(DisplayPoint, Vec<AnyElement>)> {
774 // If there is a diagnostic, position the popovers based on that.
775 // Otherwise use the start of the hover range
776 let anchor = self
777 .diagnostic_popover
778 .as_ref()
779 .map(|diagnostic_popover| &diagnostic_popover.local_diagnostic.range.start)
780 .or_else(|| {
781 self.info_popovers.iter().find_map(|info_popover| {
782 match &info_popover.symbol_range {
783 RangeInEditor::Text(range) => Some(&range.start),
784 RangeInEditor::Inlay(_) => None,
785 }
786 })
787 })
788 .or_else(|| {
789 self.info_popovers.iter().find_map(|info_popover| {
790 match &info_popover.symbol_range {
791 RangeInEditor::Text(_) => None,
792 RangeInEditor::Inlay(range) => Some(&range.inlay_position),
793 }
794 })
795 })?;
796 let point = anchor.to_display_point(&snapshot.display_snapshot);
797
798 // Don't render if the relevant point isn't on screen
799 if !self.visible() || !visible_rows.contains(&point.row()) {
800 return None;
801 }
802
803 let mut elements = Vec::new();
804
805 if let Some(diagnostic_popover) = self.diagnostic_popover.as_ref() {
806 elements.push(diagnostic_popover.render(max_size, window, cx));
807 }
808 for info_popover in &mut self.info_popovers {
809 elements.push(info_popover.render(max_size, window, cx));
810 }
811
812 Some((point, elements))
813 }
814
815 pub fn focused(&self, window: &mut Window, cx: &mut Context<Editor>) -> bool {
816 let mut hover_popover_is_focused = false;
817 for info_popover in &self.info_popovers {
818 if let Some(markdown_view) = &info_popover.parsed_content
819 && markdown_view.focus_handle(cx).is_focused(window)
820 {
821 hover_popover_is_focused = true;
822 }
823 }
824 if let Some(diagnostic_popover) = &self.diagnostic_popover
825 && diagnostic_popover
826 .markdown
827 .focus_handle(cx)
828 .is_focused(window)
829 {
830 hover_popover_is_focused = true;
831 }
832 hover_popover_is_focused
833 }
834}
835
836pub struct InfoPopover {
837 pub symbol_range: RangeInEditor,
838 pub parsed_content: Option<Entity<Markdown>>,
839 pub scroll_handle: ScrollHandle,
840 pub keyboard_grace: Rc<RefCell<bool>>,
841 pub anchor: Option<Anchor>,
842 _subscription: Option<Subscription>,
843}
844
845impl InfoPopover {
846 pub(crate) fn render(
847 &mut self,
848 max_size: Size<Pixels>,
849 window: &mut Window,
850 cx: &mut Context<Editor>,
851 ) -> AnyElement {
852 let keyboard_grace = Rc::clone(&self.keyboard_grace);
853 div()
854 .id("info_popover")
855 .occlude()
856 .elevation_2(cx)
857 // Prevent a mouse down/move on the popover from being propagated to the editor,
858 // because that would dismiss the popover.
859 .on_mouse_move(|_, _, cx| cx.stop_propagation())
860 .on_mouse_down(MouseButton::Left, move |_, _, cx| {
861 let mut keyboard_grace = keyboard_grace.borrow_mut();
862 *keyboard_grace = false;
863 cx.stop_propagation();
864 })
865 .p_2()
866 .when_some(self.parsed_content.clone(), |this, markdown| {
867 this.child(
868 div()
869 .id("info-md-container")
870 .overflow_y_scroll()
871 .max_w(max_size.width)
872 .max_h(max_size.height)
873 .track_scroll(&self.scroll_handle)
874 .child(
875 MarkdownElement::new(markdown, hover_markdown_style(window, cx))
876 .code_block_renderer(markdown::CodeBlockRenderer::Default {
877 copy_button: false,
878 copy_button_on_hover: false,
879 border: false,
880 })
881 .on_url_click(open_markdown_url),
882 ),
883 )
884 .custom_scrollbars(
885 Scrollbars::for_settings::<EditorSettings>()
886 .tracked_scroll_handle(self.scroll_handle.clone()),
887 window,
888 cx,
889 )
890 })
891 .into_any_element()
892 }
893
894 pub fn scroll(&self, amount: ScrollAmount, window: &mut Window, cx: &mut Context<Editor>) {
895 let mut current = self.scroll_handle.offset();
896 current.y -= amount.pixels(
897 window.line_height(),
898 self.scroll_handle.bounds().size.height - px(16.),
899 ) / 2.0;
900 cx.notify();
901 self.scroll_handle.set_offset(current);
902 }
903}
904
905pub struct DiagnosticPopover {
906 pub(crate) local_diagnostic: DiagnosticEntry<Anchor>,
907 markdown: Entity<Markdown>,
908 border_color: Hsla,
909 background_color: Hsla,
910 pub keyboard_grace: Rc<RefCell<bool>>,
911 pub anchor: Anchor,
912 _subscription: Subscription,
913 pub scroll_handle: ScrollHandle,
914}
915
916impl DiagnosticPopover {
917 pub fn render(
918 &self,
919 max_size: Size<Pixels>,
920 window: &mut Window,
921 cx: &mut Context<Editor>,
922 ) -> AnyElement {
923 let keyboard_grace = Rc::clone(&self.keyboard_grace);
924 let this = cx.entity().downgrade();
925 div()
926 .id("diagnostic")
927 .occlude()
928 .elevation_2_borderless(cx)
929 // Don't draw the background color if the theme
930 // allows transparent surfaces.
931 .when(theme_is_transparent(cx), |this| {
932 this.bg(gpui::transparent_black())
933 })
934 // Prevent a mouse move on the popover from being propagated to the editor,
935 // because that would dismiss the popover.
936 .on_mouse_move(|_, _, cx| cx.stop_propagation())
937 // Prevent a mouse down on the popover from being propagated to the editor,
938 // because that would move the cursor.
939 .on_mouse_down(MouseButton::Left, move |_, _, cx| {
940 let mut keyboard_grace = keyboard_grace.borrow_mut();
941 *keyboard_grace = false;
942 cx.stop_propagation();
943 })
944 .child(
945 div()
946 .py_1()
947 .px_2()
948 .bg(self.background_color)
949 .border_1()
950 .border_color(self.border_color)
951 .rounded_lg()
952 .child(
953 div()
954 .id("diagnostic-content-container")
955 .overflow_y_scroll()
956 .max_w(max_size.width)
957 .max_h(max_size.height)
958 .track_scroll(&self.scroll_handle)
959 .child(
960 MarkdownElement::new(
961 self.markdown.clone(),
962 diagnostics_markdown_style(window, cx),
963 )
964 .on_url_click(
965 move |link, window, cx| {
966 if let Some(renderer) = GlobalDiagnosticRenderer::global(cx)
967 {
968 this.update(cx, |this, cx| {
969 renderer.as_ref().open_link(this, link, window, cx);
970 })
971 .ok();
972 }
973 },
974 ),
975 ),
976 )
977 .custom_scrollbars(
978 Scrollbars::for_settings::<EditorSettings>()
979 .tracked_scroll_handle(self.scroll_handle.clone()),
980 window,
981 cx,
982 ),
983 )
984 .into_any_element()
985 }
986}
987
988#[cfg(test)]
989mod tests {
990 use super::*;
991 use crate::{
992 InlayId, PointForPosition,
993 actions::ConfirmCompletion,
994 editor_tests::{handle_completion_request, init_test},
995 hover_links::update_inlay_link_and_hover_points,
996 inlay_hint_cache::tests::{cached_hint_labels, visible_hint_labels},
997 test::editor_lsp_test_context::EditorLspTestContext,
998 };
999 use collections::BTreeSet;
1000 use gpui::App;
1001 use indoc::indoc;
1002 use markdown::parser::MarkdownEvent;
1003 use settings::InlayHintSettingsContent;
1004 use smol::stream::StreamExt;
1005 use std::sync::atomic;
1006 use std::sync::atomic::AtomicUsize;
1007 use text::Bias;
1008
1009 fn get_hover_popover_delay(cx: &gpui::TestAppContext) -> u64 {
1010 cx.read(|cx: &App| -> u64 { EditorSettings::get_global(cx).hover_popover_delay })
1011 }
1012
1013 impl InfoPopover {
1014 fn get_rendered_text(&self, cx: &gpui::App) -> String {
1015 let mut rendered_text = String::new();
1016 if let Some(parsed_content) = self.parsed_content.clone() {
1017 let markdown = parsed_content.read(cx);
1018 let text = markdown.parsed_markdown().source().to_string();
1019 let data = markdown.parsed_markdown().events();
1020 let slice = data;
1021
1022 for (range, event) in slice.iter() {
1023 match event {
1024 MarkdownEvent::SubstitutedText(parsed) => {
1025 rendered_text.push_str(parsed.as_str())
1026 }
1027 MarkdownEvent::Text | MarkdownEvent::Code => {
1028 rendered_text.push_str(&text[range.clone()])
1029 }
1030 _ => {}
1031 }
1032 }
1033 }
1034 rendered_text
1035 }
1036 }
1037
1038 #[gpui::test]
1039 async fn test_mouse_hover_info_popover_with_autocomplete_popover(
1040 cx: &mut gpui::TestAppContext,
1041 ) {
1042 init_test(cx, |_| {});
1043
1044 let mut cx = EditorLspTestContext::new_rust(
1045 lsp::ServerCapabilities {
1046 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
1047 completion_provider: Some(lsp::CompletionOptions {
1048 trigger_characters: Some(vec![".".to_string(), ":".to_string()]),
1049 resolve_provider: Some(true),
1050 ..Default::default()
1051 }),
1052 ..Default::default()
1053 },
1054 cx,
1055 )
1056 .await;
1057 let counter = Arc::new(AtomicUsize::new(0));
1058 // Basic hover delays and then pops without moving the mouse
1059 cx.set_state(indoc! {"
1060 oneˇ
1061 two
1062 three
1063 fn test() { println!(); }
1064 "});
1065
1066 //prompt autocompletion menu
1067 cx.simulate_keystroke(".");
1068 handle_completion_request(
1069 indoc! {"
1070 one.|<>
1071 two
1072 three
1073 "},
1074 vec!["first_completion", "second_completion"],
1075 true,
1076 counter.clone(),
1077 &mut cx,
1078 )
1079 .await;
1080 cx.condition(|editor, _| editor.context_menu_visible()) // wait until completion menu is visible
1081 .await;
1082 assert_eq!(counter.load(atomic::Ordering::Acquire), 1); // 1 completion request
1083
1084 let hover_point = cx.display_point(indoc! {"
1085 one.
1086 two
1087 three
1088 fn test() { printˇln!(); }
1089 "});
1090 cx.update_editor(|editor, window, cx| {
1091 let snapshot = editor.snapshot(window, cx);
1092 let anchor = snapshot
1093 .buffer_snapshot()
1094 .anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
1095 hover_at(editor, Some(anchor), window, cx)
1096 });
1097 assert!(!cx.editor(|editor, _window, _cx| editor.hover_state.visible()));
1098
1099 // After delay, hover should be visible.
1100 let symbol_range = cx.lsp_range(indoc! {"
1101 one.
1102 two
1103 three
1104 fn test() { «println!»(); }
1105 "});
1106 let mut requests =
1107 cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
1108 Ok(Some(lsp::Hover {
1109 contents: lsp::HoverContents::Markup(lsp::MarkupContent {
1110 kind: lsp::MarkupKind::Markdown,
1111 value: "some basic docs".to_string(),
1112 }),
1113 range: Some(symbol_range),
1114 }))
1115 });
1116 cx.background_executor
1117 .advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
1118 requests.next().await;
1119
1120 cx.editor(|editor, _window, cx| {
1121 assert!(editor.hover_state.visible());
1122 assert_eq!(
1123 editor.hover_state.info_popovers.len(),
1124 1,
1125 "Expected exactly one hover but got: {:?}",
1126 editor.hover_state.info_popovers.len()
1127 );
1128 let rendered_text = editor
1129 .hover_state
1130 .info_popovers
1131 .first()
1132 .unwrap()
1133 .get_rendered_text(cx);
1134 assert_eq!(rendered_text, "some basic docs".to_string())
1135 });
1136
1137 // check that the completion menu is still visible and that there still has only been 1 completion request
1138 cx.editor(|editor, _, _| assert!(editor.context_menu_visible()));
1139 assert_eq!(counter.load(atomic::Ordering::Acquire), 1);
1140
1141 //apply a completion and check it was successfully applied
1142 let _apply_additional_edits = cx.update_editor(|editor, window, cx| {
1143 editor.context_menu_next(&Default::default(), window, cx);
1144 editor
1145 .confirm_completion(&ConfirmCompletion::default(), window, cx)
1146 .unwrap()
1147 });
1148 cx.assert_editor_state(indoc! {"
1149 one.second_completionˇ
1150 two
1151 three
1152 fn test() { println!(); }
1153 "});
1154
1155 // check that the completion menu is no longer visible and that there still has only been 1 completion request
1156 cx.editor(|editor, _, _| assert!(!editor.context_menu_visible()));
1157 assert_eq!(counter.load(atomic::Ordering::Acquire), 1);
1158
1159 //verify the information popover is still visible and unchanged
1160 cx.editor(|editor, _, cx| {
1161 assert!(editor.hover_state.visible());
1162 assert_eq!(
1163 editor.hover_state.info_popovers.len(),
1164 1,
1165 "Expected exactly one hover but got: {:?}",
1166 editor.hover_state.info_popovers.len()
1167 );
1168 let rendered_text = editor
1169 .hover_state
1170 .info_popovers
1171 .first()
1172 .unwrap()
1173 .get_rendered_text(cx);
1174
1175 assert_eq!(rendered_text, "some basic docs".to_string())
1176 });
1177
1178 // Mouse moved with no hover response dismisses
1179 let hover_point = cx.display_point(indoc! {"
1180 one.second_completionˇ
1181 two
1182 three
1183 fn teˇst() { println!(); }
1184 "});
1185 let mut request = cx
1186 .lsp
1187 .set_request_handler::<lsp::request::HoverRequest, _, _>(
1188 |_, _| async move { Ok(None) },
1189 );
1190 cx.update_editor(|editor, window, cx| {
1191 let snapshot = editor.snapshot(window, cx);
1192 let anchor = snapshot
1193 .buffer_snapshot()
1194 .anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
1195 hover_at(editor, Some(anchor), window, cx)
1196 });
1197 cx.background_executor
1198 .advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
1199 request.next().await;
1200
1201 // verify that the information popover is no longer visible
1202 cx.editor(|editor, _, _| {
1203 assert!(!editor.hover_state.visible());
1204 });
1205 }
1206
1207 #[gpui::test]
1208 async fn test_mouse_hover_info_popover(cx: &mut gpui::TestAppContext) {
1209 init_test(cx, |_| {});
1210
1211 let mut cx = EditorLspTestContext::new_rust(
1212 lsp::ServerCapabilities {
1213 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
1214 ..Default::default()
1215 },
1216 cx,
1217 )
1218 .await;
1219
1220 // Basic hover delays and then pops without moving the mouse
1221 cx.set_state(indoc! {"
1222 fn ˇtest() { println!(); }
1223 "});
1224 let hover_point = cx.display_point(indoc! {"
1225 fn test() { printˇln!(); }
1226 "});
1227
1228 cx.update_editor(|editor, window, cx| {
1229 let snapshot = editor.snapshot(window, cx);
1230 let anchor = snapshot
1231 .buffer_snapshot()
1232 .anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
1233 hover_at(editor, Some(anchor), window, cx)
1234 });
1235 assert!(!cx.editor(|editor, _window, _cx| editor.hover_state.visible()));
1236
1237 // After delay, hover should be visible.
1238 let symbol_range = cx.lsp_range(indoc! {"
1239 fn test() { «println!»(); }
1240 "});
1241 let mut requests =
1242 cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
1243 Ok(Some(lsp::Hover {
1244 contents: lsp::HoverContents::Markup(lsp::MarkupContent {
1245 kind: lsp::MarkupKind::Markdown,
1246 value: "some basic docs".to_string(),
1247 }),
1248 range: Some(symbol_range),
1249 }))
1250 });
1251 cx.background_executor
1252 .advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
1253 requests.next().await;
1254
1255 cx.editor(|editor, _, cx| {
1256 assert!(editor.hover_state.visible());
1257 assert_eq!(
1258 editor.hover_state.info_popovers.len(),
1259 1,
1260 "Expected exactly one hover but got: {:?}",
1261 editor.hover_state.info_popovers.len()
1262 );
1263 let rendered_text = editor
1264 .hover_state
1265 .info_popovers
1266 .first()
1267 .unwrap()
1268 .get_rendered_text(cx);
1269
1270 assert_eq!(rendered_text, "some basic docs".to_string())
1271 });
1272
1273 // Mouse moved with no hover response dismisses
1274 let hover_point = cx.display_point(indoc! {"
1275 fn teˇst() { println!(); }
1276 "});
1277 let mut request = cx
1278 .lsp
1279 .set_request_handler::<lsp::request::HoverRequest, _, _>(
1280 |_, _| async move { Ok(None) },
1281 );
1282 cx.update_editor(|editor, window, cx| {
1283 let snapshot = editor.snapshot(window, cx);
1284 let anchor = snapshot
1285 .buffer_snapshot()
1286 .anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
1287 hover_at(editor, Some(anchor), window, cx)
1288 });
1289 cx.background_executor
1290 .advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
1291 request.next().await;
1292 cx.editor(|editor, _, _| {
1293 assert!(!editor.hover_state.visible());
1294 });
1295 }
1296
1297 #[gpui::test]
1298 async fn test_keyboard_hover_info_popover(cx: &mut gpui::TestAppContext) {
1299 init_test(cx, |_| {});
1300
1301 let mut cx = EditorLspTestContext::new_rust(
1302 lsp::ServerCapabilities {
1303 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
1304 ..Default::default()
1305 },
1306 cx,
1307 )
1308 .await;
1309
1310 // Hover with keyboard has no delay
1311 cx.set_state(indoc! {"
1312 fˇn test() { println!(); }
1313 "});
1314 cx.update_editor(|editor, window, cx| hover(editor, &Hover, window, cx));
1315 let symbol_range = cx.lsp_range(indoc! {"
1316 «fn» test() { println!(); }
1317 "});
1318
1319 cx.editor(|editor, _window, _cx| {
1320 assert!(!editor.hover_state.visible());
1321
1322 assert_eq!(
1323 editor.hover_state.info_popovers.len(),
1324 0,
1325 "Expected no hovers but got but got: {:?}",
1326 editor.hover_state.info_popovers.len()
1327 );
1328 });
1329
1330 let mut requests =
1331 cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
1332 Ok(Some(lsp::Hover {
1333 contents: lsp::HoverContents::Markup(lsp::MarkupContent {
1334 kind: lsp::MarkupKind::Markdown,
1335 value: "some other basic docs".to_string(),
1336 }),
1337 range: Some(symbol_range),
1338 }))
1339 });
1340
1341 requests.next().await;
1342 cx.dispatch_action(Hover);
1343
1344 cx.condition(|editor, _| editor.hover_state.visible()).await;
1345 cx.editor(|editor, _, cx| {
1346 assert_eq!(
1347 editor.hover_state.info_popovers.len(),
1348 1,
1349 "Expected exactly one hover but got: {:?}",
1350 editor.hover_state.info_popovers.len()
1351 );
1352
1353 let rendered_text = editor
1354 .hover_state
1355 .info_popovers
1356 .first()
1357 .unwrap()
1358 .get_rendered_text(cx);
1359
1360 assert_eq!(rendered_text, "some other basic docs".to_string())
1361 });
1362 }
1363
1364 #[gpui::test]
1365 async fn test_empty_hovers_filtered(cx: &mut gpui::TestAppContext) {
1366 init_test(cx, |_| {});
1367
1368 let mut cx = EditorLspTestContext::new_rust(
1369 lsp::ServerCapabilities {
1370 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
1371 ..Default::default()
1372 },
1373 cx,
1374 )
1375 .await;
1376
1377 // Hover with keyboard has no delay
1378 cx.set_state(indoc! {"
1379 fˇn test() { println!(); }
1380 "});
1381 cx.update_editor(|editor, window, cx| hover(editor, &Hover, window, cx));
1382 let symbol_range = cx.lsp_range(indoc! {"
1383 «fn» test() { println!(); }
1384 "});
1385 cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
1386 Ok(Some(lsp::Hover {
1387 contents: lsp::HoverContents::Array(vec![
1388 lsp::MarkedString::String("regular text for hover to show".to_string()),
1389 lsp::MarkedString::String("".to_string()),
1390 lsp::MarkedString::LanguageString(lsp::LanguageString {
1391 language: "Rust".to_string(),
1392 value: "".to_string(),
1393 }),
1394 ]),
1395 range: Some(symbol_range),
1396 }))
1397 })
1398 .next()
1399 .await;
1400 cx.dispatch_action(Hover);
1401
1402 cx.condition(|editor, _| editor.hover_state.visible()).await;
1403 cx.editor(|editor, _, cx| {
1404 assert_eq!(
1405 editor.hover_state.info_popovers.len(),
1406 1,
1407 "Expected exactly one hover but got: {:?}",
1408 editor.hover_state.info_popovers.len()
1409 );
1410 let rendered_text = editor
1411 .hover_state
1412 .info_popovers
1413 .first()
1414 .unwrap()
1415 .get_rendered_text(cx);
1416
1417 assert_eq!(
1418 rendered_text,
1419 "regular text for hover to show".to_string(),
1420 "No empty string hovers should be shown"
1421 );
1422 });
1423 }
1424
1425 #[gpui::test]
1426 async fn test_line_ends_trimmed(cx: &mut gpui::TestAppContext) {
1427 init_test(cx, |_| {});
1428
1429 let mut cx = EditorLspTestContext::new_rust(
1430 lsp::ServerCapabilities {
1431 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
1432 ..Default::default()
1433 },
1434 cx,
1435 )
1436 .await;
1437
1438 // Hover with keyboard has no delay
1439 cx.set_state(indoc! {"
1440 fˇn test() { println!(); }
1441 "});
1442 cx.update_editor(|editor, window, cx| hover(editor, &Hover, window, cx));
1443 let symbol_range = cx.lsp_range(indoc! {"
1444 «fn» test() { println!(); }
1445 "});
1446
1447 let code_str = "\nlet hovered_point: Vector2F // size = 8, align = 0x4\n";
1448 let markdown_string = format!("\n```rust\n{code_str}```");
1449
1450 let closure_markdown_string = markdown_string.clone();
1451 cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| {
1452 let future_markdown_string = closure_markdown_string.clone();
1453 async move {
1454 Ok(Some(lsp::Hover {
1455 contents: lsp::HoverContents::Markup(lsp::MarkupContent {
1456 kind: lsp::MarkupKind::Markdown,
1457 value: future_markdown_string,
1458 }),
1459 range: Some(symbol_range),
1460 }))
1461 }
1462 })
1463 .next()
1464 .await;
1465
1466 cx.dispatch_action(Hover);
1467
1468 cx.condition(|editor, _| editor.hover_state.visible()).await;
1469 cx.editor(|editor, _, cx| {
1470 assert_eq!(
1471 editor.hover_state.info_popovers.len(),
1472 1,
1473 "Expected exactly one hover but got: {:?}",
1474 editor.hover_state.info_popovers.len()
1475 );
1476 let rendered_text = editor
1477 .hover_state
1478 .info_popovers
1479 .first()
1480 .unwrap()
1481 .get_rendered_text(cx);
1482
1483 assert_eq!(
1484 rendered_text, code_str,
1485 "Should not have extra line breaks at end of rendered hover"
1486 );
1487 });
1488 }
1489
1490 #[gpui::test]
1491 // https://github.com/zed-industries/zed/issues/15498
1492 async fn test_info_hover_with_hrs(cx: &mut gpui::TestAppContext) {
1493 init_test(cx, |_| {});
1494
1495 let mut cx = EditorLspTestContext::new_rust(
1496 lsp::ServerCapabilities {
1497 hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
1498 ..Default::default()
1499 },
1500 cx,
1501 )
1502 .await;
1503
1504 cx.set_state(indoc! {"
1505 fn fuˇnc(abc def: i32) -> u32 {
1506 }
1507 "});
1508
1509 cx.lsp
1510 .set_request_handler::<lsp::request::HoverRequest, _, _>({
1511 |_, _| async move {
1512 Ok(Some(lsp::Hover {
1513 contents: lsp::HoverContents::Markup(lsp::MarkupContent {
1514 kind: lsp::MarkupKind::Markdown,
1515 value: indoc!(
1516 r#"
1517 ### function `errands_data_read`
1518
1519 ---
1520 → `char *`
1521 Function to read a file into a string
1522
1523 ---
1524 ```cpp
1525 static char *errands_data_read()
1526 ```
1527 "#
1528 )
1529 .to_string(),
1530 }),
1531 range: None,
1532 }))
1533 }
1534 });
1535 cx.update_editor(|editor, window, cx| hover(editor, &Default::default(), window, cx));
1536 cx.run_until_parked();
1537
1538 cx.update_editor(|editor, _, cx| {
1539 let popover = editor.hover_state.info_popovers.first().unwrap();
1540 let content = popover.get_rendered_text(cx);
1541
1542 assert!(content.contains("Function to read a file"));
1543 });
1544 }
1545
1546 #[gpui::test]
1547 async fn test_hover_inlay_label_parts(cx: &mut gpui::TestAppContext) {
1548 init_test(cx, |settings| {
1549 settings.defaults.inlay_hints = Some(InlayHintSettingsContent {
1550 show_value_hints: Some(true),
1551 enabled: Some(true),
1552 edit_debounce_ms: Some(0),
1553 scroll_debounce_ms: Some(0),
1554 show_type_hints: Some(true),
1555 show_parameter_hints: Some(true),
1556 show_other_hints: Some(true),
1557 show_background: Some(false),
1558 toggle_on_modifiers_press: None,
1559 })
1560 });
1561
1562 let mut cx = EditorLspTestContext::new_rust(
1563 lsp::ServerCapabilities {
1564 inlay_hint_provider: Some(lsp::OneOf::Right(
1565 lsp::InlayHintServerCapabilities::Options(lsp::InlayHintOptions {
1566 resolve_provider: Some(true),
1567 ..Default::default()
1568 }),
1569 )),
1570 ..Default::default()
1571 },
1572 cx,
1573 )
1574 .await;
1575
1576 cx.set_state(indoc! {"
1577 struct TestStruct;
1578
1579 // ==================
1580
1581 struct TestNewType<T>(T);
1582
1583 fn main() {
1584 let variableˇ = TestNewType(TestStruct);
1585 }
1586 "});
1587
1588 let hint_start_offset = cx.ranges(indoc! {"
1589 struct TestStruct;
1590
1591 // ==================
1592
1593 struct TestNewType<T>(T);
1594
1595 fn main() {
1596 let variableˇ = TestNewType(TestStruct);
1597 }
1598 "})[0]
1599 .start;
1600 let hint_position = cx.to_lsp(hint_start_offset);
1601 let new_type_target_range = cx.lsp_range(indoc! {"
1602 struct TestStruct;
1603
1604 // ==================
1605
1606 struct «TestNewType»<T>(T);
1607
1608 fn main() {
1609 let variable = TestNewType(TestStruct);
1610 }
1611 "});
1612 let struct_target_range = cx.lsp_range(indoc! {"
1613 struct «TestStruct»;
1614
1615 // ==================
1616
1617 struct TestNewType<T>(T);
1618
1619 fn main() {
1620 let variable = TestNewType(TestStruct);
1621 }
1622 "});
1623
1624 let uri = cx.buffer_lsp_url.clone();
1625 let new_type_label = "TestNewType";
1626 let struct_label = "TestStruct";
1627 let entire_hint_label = ": TestNewType<TestStruct>";
1628 let closure_uri = uri.clone();
1629 cx.lsp
1630 .set_request_handler::<lsp::request::InlayHintRequest, _, _>(move |params, _| {
1631 let task_uri = closure_uri.clone();
1632 async move {
1633 assert_eq!(params.text_document.uri, task_uri);
1634 Ok(Some(vec![lsp::InlayHint {
1635 position: hint_position,
1636 label: lsp::InlayHintLabel::LabelParts(vec![lsp::InlayHintLabelPart {
1637 value: entire_hint_label.to_string(),
1638 ..Default::default()
1639 }]),
1640 kind: Some(lsp::InlayHintKind::TYPE),
1641 text_edits: None,
1642 tooltip: None,
1643 padding_left: Some(false),
1644 padding_right: Some(false),
1645 data: None,
1646 }]))
1647 }
1648 })
1649 .next()
1650 .await;
1651 cx.background_executor.run_until_parked();
1652 cx.update_editor(|editor, _, cx| {
1653 let expected_layers = vec![entire_hint_label.to_string()];
1654 assert_eq!(expected_layers, cached_hint_labels(editor));
1655 assert_eq!(expected_layers, visible_hint_labels(editor, cx));
1656 });
1657
1658 let inlay_range = cx
1659 .ranges(indoc! {"
1660 struct TestStruct;
1661
1662 // ==================
1663
1664 struct TestNewType<T>(T);
1665
1666 fn main() {
1667 let variable« »= TestNewType(TestStruct);
1668 }
1669 "})
1670 .first()
1671 .cloned()
1672 .unwrap();
1673 let new_type_hint_part_hover_position = cx.update_editor(|editor, window, cx| {
1674 let snapshot = editor.snapshot(window, cx);
1675 let previous_valid = inlay_range.start.to_display_point(&snapshot);
1676 let next_valid = inlay_range.end.to_display_point(&snapshot);
1677 assert_eq!(previous_valid.row(), next_valid.row());
1678 assert!(previous_valid.column() < next_valid.column());
1679 let exact_unclipped = DisplayPoint::new(
1680 previous_valid.row(),
1681 previous_valid.column()
1682 + (entire_hint_label.find(new_type_label).unwrap() + new_type_label.len() / 2)
1683 as u32,
1684 );
1685 PointForPosition {
1686 previous_valid,
1687 next_valid,
1688 exact_unclipped,
1689 column_overshoot_after_line_end: 0,
1690 }
1691 });
1692 cx.update_editor(|editor, window, cx| {
1693 update_inlay_link_and_hover_points(
1694 &editor.snapshot(window, cx),
1695 new_type_hint_part_hover_position,
1696 editor,
1697 true,
1698 false,
1699 window,
1700 cx,
1701 );
1702 });
1703
1704 let resolve_closure_uri = uri.clone();
1705 cx.lsp
1706 .set_request_handler::<lsp::request::InlayHintResolveRequest, _, _>(
1707 move |mut hint_to_resolve, _| {
1708 let mut resolved_hint_positions = BTreeSet::new();
1709 let task_uri = resolve_closure_uri.clone();
1710 async move {
1711 let inserted = resolved_hint_positions.insert(hint_to_resolve.position);
1712 assert!(inserted, "Hint {hint_to_resolve:?} was resolved twice");
1713
1714 // `: TestNewType<TestStruct>`
1715 hint_to_resolve.label = lsp::InlayHintLabel::LabelParts(vec![
1716 lsp::InlayHintLabelPart {
1717 value: ": ".to_string(),
1718 ..Default::default()
1719 },
1720 lsp::InlayHintLabelPart {
1721 value: new_type_label.to_string(),
1722 location: Some(lsp::Location {
1723 uri: task_uri.clone(),
1724 range: new_type_target_range,
1725 }),
1726 tooltip: Some(lsp::InlayHintLabelPartTooltip::String(format!(
1727 "A tooltip for `{new_type_label}`"
1728 ))),
1729 ..Default::default()
1730 },
1731 lsp::InlayHintLabelPart {
1732 value: "<".to_string(),
1733 ..Default::default()
1734 },
1735 lsp::InlayHintLabelPart {
1736 value: struct_label.to_string(),
1737 location: Some(lsp::Location {
1738 uri: task_uri,
1739 range: struct_target_range,
1740 }),
1741 tooltip: Some(lsp::InlayHintLabelPartTooltip::MarkupContent(
1742 lsp::MarkupContent {
1743 kind: lsp::MarkupKind::Markdown,
1744 value: format!("A tooltip for `{struct_label}`"),
1745 },
1746 )),
1747 ..Default::default()
1748 },
1749 lsp::InlayHintLabelPart {
1750 value: ">".to_string(),
1751 ..Default::default()
1752 },
1753 ]);
1754
1755 Ok(hint_to_resolve)
1756 }
1757 },
1758 )
1759 .next()
1760 .await;
1761 cx.background_executor.run_until_parked();
1762
1763 cx.update_editor(|editor, window, cx| {
1764 update_inlay_link_and_hover_points(
1765 &editor.snapshot(window, cx),
1766 new_type_hint_part_hover_position,
1767 editor,
1768 true,
1769 false,
1770 window,
1771 cx,
1772 );
1773 });
1774 cx.background_executor
1775 .advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
1776 cx.background_executor.run_until_parked();
1777 cx.update_editor(|editor, _, cx| {
1778 let hover_state = &editor.hover_state;
1779 assert!(
1780 hover_state.diagnostic_popover.is_none() && hover_state.info_popovers.len() == 1
1781 );
1782 let popover = hover_state.info_popovers.first().unwrap();
1783 let buffer_snapshot = editor.buffer().update(cx, |buffer, cx| buffer.snapshot(cx));
1784 assert_eq!(
1785 popover.symbol_range,
1786 RangeInEditor::Inlay(InlayHighlight {
1787 inlay: InlayId::Hint(0),
1788 inlay_position: buffer_snapshot.anchor_after(inlay_range.start),
1789 range: ": ".len()..": ".len() + new_type_label.len(),
1790 }),
1791 "Popover range should match the new type label part"
1792 );
1793 assert_eq!(
1794 popover.get_rendered_text(cx),
1795 format!("A tooltip for {new_type_label}"),
1796 );
1797 });
1798
1799 let struct_hint_part_hover_position = cx.update_editor(|editor, window, cx| {
1800 let snapshot = editor.snapshot(window, cx);
1801 let previous_valid = inlay_range.start.to_display_point(&snapshot);
1802 let next_valid = inlay_range.end.to_display_point(&snapshot);
1803 assert_eq!(previous_valid.row(), next_valid.row());
1804 assert!(previous_valid.column() < next_valid.column());
1805 let exact_unclipped = DisplayPoint::new(
1806 previous_valid.row(),
1807 previous_valid.column()
1808 + (entire_hint_label.find(struct_label).unwrap() + struct_label.len() / 2)
1809 as u32,
1810 );
1811 PointForPosition {
1812 previous_valid,
1813 next_valid,
1814 exact_unclipped,
1815 column_overshoot_after_line_end: 0,
1816 }
1817 });
1818 cx.update_editor(|editor, window, cx| {
1819 update_inlay_link_and_hover_points(
1820 &editor.snapshot(window, cx),
1821 struct_hint_part_hover_position,
1822 editor,
1823 true,
1824 false,
1825 window,
1826 cx,
1827 );
1828 });
1829 cx.background_executor
1830 .advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
1831 cx.background_executor.run_until_parked();
1832 cx.update_editor(|editor, _, cx| {
1833 let hover_state = &editor.hover_state;
1834 assert!(
1835 hover_state.diagnostic_popover.is_none() && hover_state.info_popovers.len() == 1
1836 );
1837 let popover = hover_state.info_popovers.first().unwrap();
1838 let buffer_snapshot = editor.buffer().update(cx, |buffer, cx| buffer.snapshot(cx));
1839 assert_eq!(
1840 popover.symbol_range,
1841 RangeInEditor::Inlay(InlayHighlight {
1842 inlay: InlayId::Hint(0),
1843 inlay_position: buffer_snapshot.anchor_after(inlay_range.start),
1844 range: ": ".len() + new_type_label.len() + "<".len()
1845 ..": ".len() + new_type_label.len() + "<".len() + struct_label.len(),
1846 }),
1847 "Popover range should match the struct label part"
1848 );
1849 assert_eq!(
1850 popover.get_rendered_text(cx),
1851 format!("A tooltip for {struct_label}"),
1852 "Rendered markdown element should remove backticks from text"
1853 );
1854 });
1855 }
1856}