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