Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
use crate::{
Anchor, AnchorRangeExt, DisplayPoint, DisplayRow, Editor, EditorSettings, EditorSnapshot,
GlobalDiagnosticRenderer, HighlightKey, Hover,
display_map::{ToDisplayPoint, is_invisible},
editor_settings::EditorSettingsScrollbarProxy,
hover_links::{InlayHighlight, RangeInEditor},
movement::TextLayoutDetails,
scroll::ScrollAmount,
};
use anyhow::Context as _;
use gpui::{
AnyElement, App, AsyncWindowContext, Bounds, Context, Entity, Focusable as _, FontWeight, Hsla,
InteractiveElement, IntoElement, MouseButton, ParentElement, Pixels, ScrollHandle, Size,
StatefulInteractiveElement, StyleRefinement, Styled, Subscription, Task, TaskExt,
TextStyleRefinement, Window, canvas, div, px,
};
use language::{CharKind, DiagnosticEntry, Language, LanguageRegistry};
use lsp::DiagnosticSeverity;
use markdown::{CopyButtonVisibility, Markdown, MarkdownElement, MarkdownStyle};
use multi_buffer::{MultiBufferOffset, MultiBufferSnapshot, ToOffset, ToPoint};
use project::{HoverBlock, HoverBlockKind, InlayHintLabelPart};
use settings::Settings;
use std::{
borrow::Cow,
cell::{Cell, RefCell},
};
use std::{ops::Range, sync::Arc, time::Duration};
use std::{path::PathBuf, rc::Rc};
use theme_settings::ThemeSettings;
use ui::{CopyButton, Scrollbars, WithScrollbar, prelude::*, theme_is_transparent};
use url::Url;
use util::TryFutureExt;
use workspace::{OpenOptions, OpenVisible, Workspace};
use crate::debugger_hover::{
DEBUGGER_HOVER_MIN_WIDTH, DebuggerHoverView, build_debugger_hover_view,
};
pub const MIN_POPOVER_CHARACTER_WIDTH: f32 = 20.;
pub const MIN_POPOVER_LINE_HEIGHT: f32 = 4.;
pub const POPOVER_RIGHT_OFFSET: Pixels = px(8.0);
pub const HOVER_POPOVER_GAP: Pixels = px(10.);
const MAX_HOVER_BYTES: usize = 100_000;
const DEBUGGER_HOVER_HEADER_HEIGHT: Pixels = px(24.);
/// Bindable action which uses the most recent selection head to trigger a hover
pub fn hover(editor: &mut Editor, _: &Hover, window: &mut Window, cx: &mut Context<Editor>) {
let head = editor.selections.newest_anchor().head();
show_hover(editor, head, true, window, cx);
}
/// The internal hover action dispatches between `show_hover` or `hide_hover`
/// depending on whether a point to hover over is provided.
pub fn hover_at(
editor: &mut Editor,
anchor: Option<Anchor>,
mouse_position: Option<gpui::Point<Pixels>>,
window: &mut Window,
cx: &mut Context<Editor>,
) {
editor.hover_state.hint_hover_task = None;
if EditorSettings::get_global(cx).hover_popover_enabled {
if editor.hover_state.debugger_menu_open(cx) {
editor.hover_state.hiding_delay_task = None;
return;
}
if show_keyboard_hover(editor, window, cx) {
return;
}
if let Some(anchor) = anchor {
editor.hover_state.hiding_delay_task = None;
editor.hover_state.closest_mouse_distance = None;
show_hover(editor, anchor, false, window, cx);
} else if !editor.hover_state.visible() {
editor.hover_state.info_task = None;
} else {
let settings = EditorSettings::get_global(cx);
if !settings.hover_popover_sticky {
hide_hover(editor, cx);
return;
}
let mut getting_closer = false;
if let Some(mouse_position) = mouse_position {
getting_closer = editor.hover_state.is_mouse_getting_closer(mouse_position);
}
// If we are moving away and a timer is already running, just let it count down.
if !getting_closer && editor.hover_state.hiding_delay_task.is_some() {
return;
}
// If we are moving closer, or if no timer is running at all, start/restart the timer.
let delay = Duration::from_millis(settings.hover_popover_hiding_delay.0);
let task = cx.spawn(async move |this, cx| {
cx.background_executor().timer(delay).await;
this.update(cx, |editor, cx| {
if !editor.hover_state.debugger_menu_open(cx) {
hide_popovers(editor, cx);
}
})
.ok();
});
editor.hover_state.hiding_delay_task = Some(task);
}
}
}
pub fn show_keyboard_hover(
editor: &mut Editor,
window: &mut Window,
cx: &mut Context<Editor>,
) -> bool {
if let Some(anchor) = editor.hover_state.info_popovers.iter().find_map(|p| {
if *p.keyboard_grace.borrow() {
p.anchor
} else {
None
}
}) {
show_hover(editor, anchor, false, window, cx);
return true;
}
if let Some(anchor) = editor
.hover_state
.diagnostic_popover
.as_ref()
.and_then(|d| {
if *d.keyboard_grace.borrow() {
Some(d.anchor)
} else {
None
}
})
{
show_hover(editor, anchor, false, window, cx);
return true;
}
false
}
pub struct InlayHover {
pub(crate) range: InlayHighlight,
pub tooltip: HoverBlock,
}
pub fn find_hovered_hint_part(
label_parts: Vec<InlayHintLabelPart>,
offset_in_label: usize,
) -> Option<(InlayHintLabelPart, Range<usize>)> {
let mut part_start = 0;
for part in label_parts {
let part_end = part_start + part.value.len();
if (part_start..part_end).contains(&offset_in_label) {
return Some((part, part_start..part_end));
}
part_start = part_end;
}
None
}
pub fn hover_at_inlay(
editor: &mut Editor,
inlay_hover: InlayHover,
window: &mut Window,
cx: &mut Context<Editor>,
) -> Option<Task<()>> {
if !EditorSettings::get_global(cx).hover_popover_enabled || editor.pending_rename.is_some() {
return None;
}
let project = editor.project.clone()?;
let symbol_range = RangeInEditor::Inlay(inlay_hover.range);
if editor
.hover_state
.info_popovers
.iter()
.any(|popover| popover.symbol_range == symbol_range)
{
editor.hover_state.hiding_delay_task = None;
return Some(Task::ready(()));
}
let hover_popover_delay = EditorSettings::get_global(cx).hover_popover_delay.0;
editor.hover_state.info_task = None;
editor.hover_state.hiding_delay_task = None;
editor.hover_state.closest_mouse_distance = None;
Some(cx.spawn_in(window, async move |editor, cx| {
cx.background_executor()
.timer(Duration::from_millis(hover_popover_delay))
.await;
let language_registry = project.read_with(cx, |project, _| project.languages().clone());
let parsed_content =
parse_blocks(&[inlay_hover.tooltip], Some(&language_registry), None, cx);
editor
.update(cx, |editor, cx| {
let subscription = parsed_content
.as_ref()
.map(|parsed_content| cx.observe(parsed_content, |_, _, cx| cx.notify()));
editor.hover_state.diagnostic_popover = None;
editor.hover_state.stable_debugger_hover_origin = None;
editor.hover_state.info_popovers = vec![InfoPopover {
symbol_range,
fallback_state: None,
parsed_content,
debugger_hover: None,
scroll_handle: ScrollHandle::new(),
keyboard_grace: Rc::new(RefCell::new(false)),
anchor: None,
last_bounds: Rc::new(Cell::new(None)),
_subscriptions: subscription.into_iter().collect(),
}];
cx.notify();
})
.ok();
}))
}
/// Hides the type information popup.
/// Triggered by the `Hover` action when the cursor is not over a symbol or when the
/// selections changed.
pub fn hide_hover(editor: &mut Editor, cx: &mut Context<Editor>) -> bool {
editor.hover_state.hint_hover_task = None;
hide_popovers(editor, cx)
}
/// Queries the LSP and shows type info and documentation
/// about the symbol the mouse is currently hovering over.
/// Triggered by the `Hover` action when the cursor may be over a symbol.
fn show_hover(
editor: &mut Editor,
anchor: Anchor,
ignore_timeout: bool,
window: &mut Window,
cx: &mut Context<Editor>,
) -> Option<()> {
editor.hover_state.hint_hover_task = None;
if editor.pending_rename.is_some() {
return None;
}
let snapshot = editor.snapshot(window, cx);
let (buffer_position, _) = editor
.buffer
.read(cx)
.snapshot(cx)
.anchor_to_buffer_anchor(anchor)?;
let buffer = editor.buffer.read(cx).buffer(buffer_position.buffer_id)?;
let language_registry = editor
.project()
.map(|project| project.read(cx).languages().clone());
let debugger_project = editor.project().map(|project| project.downgrade());
let provider = editor.semantics_provider.clone()?;
editor.hover_state.hiding_delay_task = None;
editor.hover_state.closest_mouse_distance = None;
if !ignore_timeout {
if same_info_hover(editor, &snapshot, anchor)
|| same_diagnostic_hover(editor, &snapshot, anchor)
|| editor.hover_state.diagnostic_popover.is_some()
{
// Hover triggered from same location as last time. Don't show again.
return None;
} else {
hide_hover(editor, cx);
}
}
let hover_popover_delay = EditorSettings::get_global(cx).hover_popover_delay.0;
let all_diagnostics_active = editor.all_diagnostics_active();
let active_group_id = editor.active_diagnostic_group_id();
let renderer = GlobalDiagnosticRenderer::global(cx);
let task = cx.spawn_in(window, async move |this, cx| {
async move {
// If we need to delay, delay a set amount initially before making the lsp request
let delay = if ignore_timeout {
None
} else {
let lsp_request_early = hover_popover_delay / 2;
cx.background_executor()
.timer(Duration::from_millis(
hover_popover_delay - lsp_request_early,
))
.await;
// Construct delay task to wait for later
let total_delay = Some(
cx.background_executor()
.timer(Duration::from_millis(lsp_request_early)),
);
total_delay
};
let mut hover_request =
cx.update(|_, cx| provider.hover(&buffer, buffer_position, cx))?;
let debugger_request =
cx.update(|_, cx| provider.debugger_hover(&buffer, buffer_position, cx))?;
if let Some(delay) = delay {
delay.await;
}
let offset = anchor.to_offset(&snapshot.buffer_snapshot());
let local_diagnostic = if all_diagnostics_active {
None
} else {
snapshot
.buffer_snapshot()
.diagnostics_with_buffer_ids_in_range::<MultiBufferOffset>(offset..offset)
.filter(|(_, diagnostic)| {
Some(diagnostic.diagnostic.group_id) != active_group_id
})
// Find the entry with the most specific range
.min_by_key(|(_, entry)| entry.range.end - entry.range.start)
};
let diagnostic_popover = if let Some((buffer_id, local_diagnostic)) = local_diagnostic {
let group = snapshot
.buffer_snapshot()
.diagnostic_group(buffer_id, local_diagnostic.diagnostic.group_id)
.collect::<Vec<_>>();
let point_range = local_diagnostic
.range
.start
.to_point(&snapshot.buffer_snapshot())
..local_diagnostic
.range
.end
.to_point(&snapshot.buffer_snapshot());
let markdown = cx.update(|_, cx| {
renderer
.as_ref()
.and_then(|renderer| {
renderer.render_hover(
group,
point_range,
buffer_id,
language_registry.clone(),
cx,
)
})
.context("no rendered diagnostic")
})??;
let (background_color, border_color) = cx.update(|_, cx| {
let status_colors = cx.theme().status();
match local_diagnostic.diagnostic.severity {
DiagnosticSeverity::ERROR => {
(status_colors.error_background, status_colors.error_border)
}
DiagnosticSeverity::WARNING => (
status_colors.warning_background,
status_colors.warning_border,
),
DiagnosticSeverity::INFORMATION => {
(status_colors.info_background, status_colors.info_border)
}
DiagnosticSeverity::HINT => {
(status_colors.hint_background, status_colors.hint_border)
}
_ => (
status_colors.ignored_background,
status_colors.ignored_border,
),
}
})?;
let subscription =
this.update(cx, |_, cx| cx.observe(&markdown, |_, _, cx| cx.notify()))?;
let local_diagnostic = DiagnosticEntry::new(
snapshot
.buffer_snapshot()
.anchor_before(local_diagnostic.range.start)
..snapshot
.buffer_snapshot()
.anchor_after(local_diagnostic.range.end),
local_diagnostic.diagnostic.to_owned(),
);
let scroll_handle = ScrollHandle::new();
Some(DiagnosticPopover {
local_diagnostic,
markdown,
border_color,
scroll_handle,
background_color,
keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
anchor,
last_bounds: Rc::new(Cell::new(None)),
_subscription: subscription,
})
} else {
None
};
this.update(cx, |this, _| {
this.hover_state.diagnostic_popover = diagnostic_popover;
})?;
let invisible_char = if let Some(invisible) = snapshot
.buffer_snapshot()
.chars_at(anchor)
.next()
.filter(|&c| is_invisible(c))
{
let after = snapshot.buffer_snapshot().anchor_after(
anchor.to_offset(&snapshot.buffer_snapshot()) + invisible.len_utf8(),
);
Some((invisible, anchor..after))
} else if let Some(invisible) = snapshot
.buffer_snapshot()
.reversed_chars_at(anchor)
.next()
.filter(|&c| is_invisible(c))
{
let before = snapshot.buffer_snapshot().anchor_before(
anchor.to_offset(&snapshot.buffer_snapshot()) - invisible.len_utf8(),
);
Some((invisible, before..anchor))
} else {
None
};
let debugger_response = match debugger_request {
Some(request) => request.await,
None => None,
};
let show_debugger_hover_only = debugger_response.is_some();
let hovers_response = if show_debugger_hover_only {
Vec::new()
} else {
match hover_request.take() {
Some(request) => request.await.unwrap_or_default(),
None => Vec::new(),
}
};
let snapshot = this.update_in(cx, |this, window, cx| this.snapshot(window, cx))?;
let mut hover_highlights = Vec::with_capacity(hovers_response.len());
let mut info_popovers = Vec::with_capacity(
hovers_response.len() + if invisible_char.is_some() { 1 } else { 0 },
);
if !show_debugger_hover_only && let Some((invisible, range)) = invisible_char {
let blocks = vec![HoverBlock {
text: format!("Unicode character U+{:02X}", invisible as u32),
kind: HoverBlockKind::PlainText,
}];
let parsed_content = parse_blocks(&blocks, language_registry.as_ref(), None, cx);
let scroll_handle = ScrollHandle::new();
let subscriptions = this
.update(cx, |_, cx| {
parsed_content
.as_ref()
.map(|parsed_content| {
vec![cx.observe(parsed_content, |_, _, cx| cx.notify())]
})
.unwrap_or_default()
})
.ok()
.unwrap_or_default();
info_popovers.push(InfoPopover {
symbol_range: RangeInEditor::Text(range),
fallback_state: None,
parsed_content,
debugger_hover: None,
scroll_handle,
keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
anchor: Some(anchor),
last_bounds: Rc::new(Cell::new(None)),
_subscriptions: subscriptions,
})
}
let doc_link_task = if show_debugger_hover_only {
None
} else {
this.update(cx, |editor, cx| {
editor.document_links_at(buffer.clone(), buffer_position, cx)
})
.ok()
.flatten()
};
let doc_link_tooltips = match doc_link_task {
Some(task) => task
.await
.into_iter()
.filter_map(|(_, link)| {
let multi_buffer_range = snapshot
.buffer_snapshot()
.buffer_anchor_range_to_anchor_range(link.range.clone())?;
let tooltip = link.tooltip?;
Some((multi_buffer_range, tooltip))
})
.collect::<Vec<_>>(),
None => Vec::new(),
};
let buffer_snapshot = snapshot.buffer_snapshot();
let mut debugger_view = None;
if let Some(debugger_response) = debugger_response {
let range = snapshot
.buffer_snapshot()
.buffer_anchor_range_to_anchor_range(debugger_response.range)
.unwrap_or_else(|| anchor..anchor);
let debugger_hover = build_debugger_hover_view(
Some(debugger_response.data),
debugger_project.clone(),
cx,
);
if let Some(view) = debugger_hover {
debugger_view = Some(view.entity_id());
hover_highlights.push(range.clone());
let subscription =
this.update(cx, |_, cx| cx.observe(&view, |_, _, cx| cx.notify()))?;
info_popovers.push(InfoPopover {
symbol_range: RangeInEditor::Text(range),
fallback_state: None,
parsed_content: None,
debugger_hover: Some(view),
scroll_handle: ScrollHandle::new(),
keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
anchor: Some(anchor),
last_bounds: Rc::new(Cell::new(None)),
_subscriptions: vec![subscription],
});
}
}
for hover_result in hovers_response {
let project::Hover {
contents: blocks,
range: hover_range,
language,
} = hover_result;
// Create symbol range of anchors for highlighting and filtering of future requests.
let (range, fallback_state) = hover_range
.and_then(|range| buffer_snapshot.buffer_anchor_range_to_anchor_range(range))
.filter(|range| !range.to_offset(buffer_snapshot).is_empty())
.map(|range| (range, None))
.unwrap_or_else(|| {
let range = fallback_hover_range(buffer_snapshot, anchor);
let fallback_state = FallbackHoverState::new(buffer_snapshot, &range);
(range, Some(fallback_state))
});
let parsed_content =
parse_blocks(&blocks, language_registry.as_ref(), language, cx);
if parsed_content.is_none() {
continue;
}
let scroll_handle = ScrollHandle::new();
hover_highlights.push(range.clone());
let subscriptions = this
.update(cx, |_, cx| {
let mut subscriptions = Vec::new();
if let Some(parsed_content) = parsed_content.as_ref() {
subscriptions.push(cx.observe(parsed_content, |_, _, cx| cx.notify()));
}
subscriptions
})
.ok()
.unwrap_or_default();
info_popovers.push(InfoPopover {
symbol_range: RangeInEditor::Text(range),
fallback_state,
parsed_content,
debugger_hover: None,
scroll_handle,
keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
anchor: Some(anchor),
last_bounds: Rc::new(Cell::new(None)),
_subscriptions: subscriptions,
});
}
if !show_debugger_hover_only {
for (multi_buffer_range, tooltip) in doc_link_tooltips {
let blocks = vec![HoverBlock {
text: tooltip.to_string(),
kind: HoverBlockKind::Markdown,
}];
let parsed_content =
parse_blocks(&blocks, language_registry.as_ref(), None, cx);
let scroll_handle = ScrollHandle::new();
let subscription = this
.update(cx, |_, cx| {
parsed_content.as_ref().map(|parsed_content| {
cx.observe(parsed_content, |_, _, cx| cx.notify())
})
})
.ok()
.flatten();
info_popovers.push(InfoPopover {
symbol_range: RangeInEditor::Text(multi_buffer_range),
fallback_state: None,
parsed_content,
debugger_hover: None,
scroll_handle,
keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
anchor: Some(anchor),
last_bounds: Rc::new(Cell::new(None)),
_subscriptions: subscription.into_iter().collect(),
});
}
}
this.update_in(cx, |editor, window, cx| {
if hover_highlights.is_empty() {
editor.clear_background_highlights(HighlightKey::HoverState, cx);
} else {
// Highlight the selected symbol using a background highlight
editor.highlight_background(
HighlightKey::HoverState,
&hover_highlights,
|_, theme| theme.colors().element_hover, // todo update theme
cx,
);
}
if show_debugger_hover_only {
editor.hover_state.diagnostic_popover = None;
}
editor.hover_state.stable_debugger_hover_origin = None;
editor.hover_state.info_popovers = info_popovers;
cx.notify();
window.refresh();
})?;
if let (Some(view_id), Some(request)) = (debugger_view, hover_request) {
let lsp_hovers = request.await.unwrap_or_default();
let language = lsp_hovers.iter().find_map(|hover| hover.language.clone());
let blocks = lsp_hovers
.into_iter()
.flat_map(|hover| hover.contents)
.collect::<Vec<_>>();
if let Some(markdown) =
parse_blocks(&blocks, language_registry.as_ref(), language, cx)
{
this.update_in(cx, |editor, window, cx| {
if let Some(popover) =
editor.hover_state.info_popovers.iter().find(|popover| {
popover
.debugger_hover
.as_ref()
.is_some_and(|view| view.entity_id() == view_id)
})
{
let symbol_range = popover.symbol_range.clone();
let keyboard_grace = popover.keyboard_grace.clone();
let anchor = popover.anchor;
let subscription = cx.observe(&markdown, |_, _, cx| cx.notify());
editor.hover_state.info_popovers.push(InfoPopover {
symbol_range,
parsed_content: Some(markdown),
debugger_hover: None,
scroll_handle: ScrollHandle::new(),
keyboard_grace,
anchor,
last_bounds: Rc::new(Cell::new(None)),
fallback_state: None,
_subscriptions: vec![subscription],
});
cx.notify();
window.refresh();
}
})?;
}
}
anyhow::Ok(())
}
.log_err()
.await
});
editor.hover_state.info_task = Some(task);
None
}
/// The range to use for a hover result whose language server reported no usable range.
fn fallback_hover_range(buffer_snapshot: &MultiBufferSnapshot, anchor: Anchor) -> Range<Anchor> {
let offset = anchor.to_offset(buffer_snapshot);
let syntax_offset = if offset == buffer_snapshot.len()
|| buffer_snapshot
.chars_at(offset)
.next()
.is_some_and(char::is_whitespace)
{
match buffer_snapshot.reversed_chars_at(offset).next() {
Some(character) if !character.is_whitespace() => offset - character.len_utf8(),
_ if offset == buffer_snapshot.len() => return anchor..anchor,
_ => offset,
}
} else {
offset
};
if buffer_snapshot
.chars_at(syntax_offset)
.next()
.is_some_and(|character| !character.is_whitespace())
&& let Some((_, range)) = buffer_snapshot.syntax_ancestor(syntax_offset..syntax_offset)
&& !range.is_empty()
&& (syntax_offset == offset || range.end == offset)
{
return buffer_snapshot.anchor_after(range.start)..buffer_snapshot.anchor_before(range.end);
}
let classifier = buffer_snapshot.char_classifier_at(offset);
if buffer_snapshot
.chars_at(offset)
.next()
.is_some_and(|character| classifier.kind(character) == CharKind::Punctuation)
{
return anchor..anchor;
}
let (range, kind) = buffer_snapshot.surrounding_word(offset, None);
if kind != Some(CharKind::Word) {
return anchor..anchor;
}
buffer_snapshot.anchor_after(range.start)..buffer_snapshot.anchor_before(range.end)
}
fn same_info_hover(editor: &mut Editor, snapshot: &EditorSnapshot, anchor: Anchor) -> bool {
editor.hover_state.info_popovers.iter_mut().any(
|InfoPopover {
symbol_range,
fallback_state,
..
}| {
symbol_range
.as_text_range()
.map(|range| {
let buffer_snapshot = snapshot.buffer_snapshot();
let hover_range = range.to_offset(buffer_snapshot);
let offset = anchor.to_offset(buffer_snapshot);
if let Some(fallback_state) = fallback_state {
if fallback_state.edit_count != buffer_snapshot.edit_count() {
return false;
}
if offset == hover_range.end {
if fallback_state.non_text_state_update_count
!= buffer_snapshot.non_text_state_update_count()
{
*fallback_state = FallbackHoverState::new(buffer_snapshot, &range);
}
return fallback_state.includes_end;
}
}
// LSP returns a hover result for the end index of ranges that should be hovered, so we need to
// use an inclusive range here to check if we should dismiss the popover
(hover_range.start..=hover_range.end).contains(&offset)
})
.unwrap_or(false)
},
)
}
fn same_diagnostic_hover(editor: &Editor, snapshot: &EditorSnapshot, anchor: Anchor) -> bool {
editor
.hover_state
.diagnostic_popover
.as_ref()
.map(|diagnostic| {
let hover_range = diagnostic
.local_diagnostic
.range
.to_offset(&snapshot.buffer_snapshot());
let offset = anchor.to_offset(&snapshot.buffer_snapshot());
// Here we do basically the same as in `same_info_hover`, see comment there for an explanation
(hover_range.start..=hover_range.end).contains(&offset)
})
.unwrap_or(false)
}
fn parse_blocks(
blocks: &[HoverBlock],
language_registry: Option<&Arc<LanguageRegistry>>,
language: Option<Arc<Language>>,
cx: &mut AsyncWindowContext,
) -> Option<Entity<Markdown>> {
let combined_text = combine_hover_blocks(blocks);
if combined_text.trim().is_empty() {
return None;
}
cx.new_window_entity(|_window, cx| {
Markdown::new(
combined_text.into(),
language_registry.cloned(),
language.map(|language| language.name()),
cx,
)
})
.ok()
}
fn combine_hover_blocks(blocks: &[HoverBlock]) -> String {
let mut combined = String::new();
let mut budget = MAX_HOVER_BYTES;
let mut dropped_blocks = false;
let last_block_index = blocks
.iter()
.rposition(|block| !block.text.trim().is_empty());
for (index, block) in blocks.iter().enumerate() {
let text = block.text.trim();
if text.is_empty() {
continue;
}
let separator = if combined.is_empty() { "" } else { "\n\n" };
let is_last_block = Some(index) == last_block_index;
let reserved_for_dropped_marker = if is_last_block { 0 } else { "\n\n…".len() };
let mut truncated_inline = false;
let piece = match &block.kind {
project::HoverBlockKind::PlainText | project::HoverBlockKind::Markdown => {
let Some(block_budget) =
budget.checked_sub(separator.len() + reserved_for_dropped_marker)
else {
dropped_blocks = true;
break;
};
match fit_in_budget(text.len(), block_budget) {
BudgetFit::Fits => Cow::Borrowed(text),
BudgetFit::TooSmall => {
dropped_blocks = true;
break;
}
BudgetFit::NeedsTruncation => {
truncated_inline = true;
Cow::Owned(truncate_hover_markdown(text, block_budget))
}
}
}
project::HoverBlockKind::Code { language } => {
let language = language.replace(['`', '\r', '\n'], "");
let fence = wrapping_code_fence(text);
let overhead = separator.len()
+ reserved_for_dropped_marker
+ fence.len() * 2
+ language.len()
+ "\n\n".len();
let Some(block_budget) = budget.checked_sub(overhead) else {
dropped_blocks = true;
break;
};
let text = match fit_in_budget(text.len(), block_budget) {
BudgetFit::Fits => Cow::Borrowed(text),
BudgetFit::TooSmall => {
dropped_blocks = true;
break;
}
BudgetFit::NeedsTruncation => {
truncated_inline = true;
Cow::Owned(format!(
"{}…",
truncated_to_byte_budget(text, block_budget.saturating_sub("…".len()))
))
}
};
Cow::Owned(format!("{fence}{language}\n{text}\n{fence}"))
}
};
budget = budget.saturating_sub(separator.len() + piece.len());
combined.push_str(separator);
combined.push_str(&piece);
if truncated_inline {
dropped_blocks = !is_last_block;
break;
}
}
if dropped_blocks {
if !combined.is_empty() {
combined.push_str("\n\n");
}
combined.push('…');
}
combined
}
enum BudgetFit {
Fits,
NeedsTruncation,
TooSmall,
}
fn fit_in_budget(len: usize, budget: usize) -> BudgetFit {
if len <= budget {
BudgetFit::Fits
} else if budget <= "…".len() {
BudgetFit::TooSmall
} else {
BudgetFit::NeedsTruncation
}
}
fn truncated_to_byte_budget(text: &str, budget: usize) -> &str {
let mut end = budget.min(text.len());
while !text.is_char_boundary(end) {
end -= 1;
}
&text[..end]
}
fn wrapping_code_fence(text: &str) -> String {
let mut longest_run = 0;
let mut current_run = 0;
for byte in text.bytes() {
if byte == b'`' {
current_run += 1;
longest_run = longest_run.max(current_run);
} else {
current_run = 0;
}
}
"`".repeat((longest_run + 1).max(3))
}
fn truncate_hover_markdown(text: &str, max_len: usize) -> String {
let mut cut = max_len.saturating_sub("…".len()).min(text.len());
loop {
let mut truncated = truncated_to_byte_budget(text, cut);
if let Some(&split_byte) = text.as_bytes().get(truncated.len())
&& (split_byte == b'`' || split_byte == b'~')
{
let mut end = truncated.len();
while end > 0 && text.as_bytes()[end - 1] == split_byte {
end -= 1;
}
truncated = &text[..end];
}
if let Some(&next_byte) = text.as_bytes().get(truncated.len())
&& next_byte != b'\n'
&& !truncated.ends_with('\n')
&& ends_with_code_fence_line(truncated)
{
let line_start = truncated.rfind('\n').map_or(0, |index| index + 1);
truncated = &text[..line_start];
}
let ellipsis = if ends_with_code_fence_line(truncated) {
"\n…"
} else {
"…"
};
let closing_fence = unclosed_code_fence(truncated);
let total_len = truncated.len()
+ ellipsis.len()
+ closing_fence
.as_ref()
.map_or(0, |fence| "\n".len() + fence.len());
if total_len <= max_len || truncated.is_empty() {
return match closing_fence {
Some(fence) => format!("{truncated}{ellipsis}\n{fence}"),
None => format!("{truncated}{ellipsis}"),
};
}
cut = truncated.len().saturating_sub(total_len - max_len);
}
}
fn ends_with_code_fence_line(text: &str) -> bool {
text.lines()
.next_back()
.is_some_and(|line| parse_code_fence(line).is_some())
}
struct CodeFence {
fence_char: char,
len: usize,
has_info: bool,
}
fn parse_code_fence(line: &str) -> Option<CodeFence> {
let trimmed = line.trim_start_matches(' ');
if line.len() - trimmed.len() > 3 {
return None;
}
let first_char @ ('`' | '~') = trimmed.chars().next()? else {
return None;
};
let len = trimmed.chars().take_while(|&c| c == first_char).count();
if len < 3 {
return None;
}
let info = trimmed[len..].trim();
if first_char == '`' && info.contains('`') {
return None;
}
Some(CodeFence {
fence_char: first_char,
len,
has_info: !info.is_empty(),
})
}
fn unclosed_code_fence(markdown: &str) -> Option<String> {
let mut open_fence: Option<CodeFence> = None;
for line in markdown.lines() {
let Some(fence) = parse_code_fence(line) else {
continue;
};
match &open_fence {
None => open_fence = Some(fence),
Some(open) => {
if fence.fence_char == open.fence_char && fence.len >= open.len && !fence.has_info {
open_fence = None;
}
}
}
}
open_fence.map(|fence| fence.fence_char.to_string().repeat(fence.len))
}
pub fn hover_markdown_style(window: &Window, cx: &App) -> MarkdownStyle {
let settings = ThemeSettings::get_global(cx);
let ui_font_family = settings.ui_font.family.clone();
let ui_font_features = settings.ui_font.features.clone();
let ui_font_fallbacks = settings.ui_font.fallbacks.clone();
let buffer_font_family = settings.buffer_font.family.clone();
let buffer_font_features = settings.buffer_font.features.clone();
let buffer_font_fallbacks = settings.buffer_font.fallbacks.clone();
let buffer_font_weight = settings.buffer_font.weight;
let mut base_text_style = window.text_style();
base_text_style.refine(&TextStyleRefinement {
font_family: Some(ui_font_family),
font_features: Some(ui_font_features),
font_fallbacks: ui_font_fallbacks,
color: Some(cx.theme().colors().editor_foreground),
..Default::default()
});
MarkdownStyle {
base_text_style,
code_block: StyleRefinement::default()
.my(rems(1.))
.font_buffer(cx)
.font_features(buffer_font_features.clone())
.font_weight(buffer_font_weight),
inline_code: TextStyleRefinement {
background_color: Some(cx.theme().colors().background),
font_family: Some(buffer_font_family),
font_features: Some(buffer_font_features),
font_fallbacks: buffer_font_fallbacks,
font_weight: Some(buffer_font_weight),
..Default::default()
},
rule_color: cx.theme().colors().border,
block_quote_border_color: Color::Muted.color(cx),
block_quote: TextStyleRefinement {
color: Some(Color::Muted.color(cx)),
..Default::default()
},
link: TextStyleRefinement {
color: Some(cx.theme().colors().editor_foreground),
underline: Some(gpui::UnderlineStyle {
thickness: px(1.),
color: Some(cx.theme().colors().editor_foreground),
wavy: false,
}),
..Default::default()
},
syntax: cx.theme().syntax().clone(),
selection_background_color: cx.theme().colors().element_selection_background,
heading: StyleRefinement::default()
.font_weight(FontWeight::BOLD)
.text_base()
.mt(rems(1.))
.mb_0(),
table_columns_min_size: true,
..Default::default()
}
}
pub fn diagnostics_markdown_style(window: &Window, cx: &App) -> MarkdownStyle {
let settings = ThemeSettings::get_global(cx);
let ui_font_family = settings.ui_font.family.clone();
let ui_font_fallbacks = settings.ui_font.fallbacks.clone();
let ui_font_features = settings.ui_font.features.clone();
let buffer_font_family = settings.buffer_font.family.clone();
let buffer_font_features = settings.buffer_font.features.clone();
let buffer_font_fallbacks = settings.buffer_font.fallbacks.clone();
let mut base_text_style = window.text_style();
base_text_style.refine(&TextStyleRefinement {
font_family: Some(ui_font_family),
font_features: Some(ui_font_features),
font_fallbacks: ui_font_fallbacks,
color: Some(cx.theme().colors().editor_foreground),
..Default::default()
});
MarkdownStyle {
base_text_style,
code_block: StyleRefinement::default().my(rems(1.)).font_buffer(cx),
inline_code: TextStyleRefinement {
background_color: Some(cx.theme().colors().editor_background.opacity(0.5)),
font_family: Some(buffer_font_family),
font_features: Some(buffer_font_features),
font_fallbacks: buffer_font_fallbacks,
..Default::default()
},
rule_color: cx.theme().colors().border,
block_quote_border_color: Color::Muted.color(cx),
block_quote: TextStyleRefinement {
color: Some(Color::Muted.color(cx)),
..Default::default()
},
link: TextStyleRefinement {
color: Some(cx.theme().colors().editor_foreground),
underline: Some(gpui::UnderlineStyle {
thickness: px(1.),
color: Some(cx.theme().colors().editor_foreground),
wavy: false,
}),
..Default::default()
},
syntax: cx.theme().syntax().clone(),
selection_background_color: cx.theme().colors().element_selection_background,
height_is_multiple_of_line_height: true,
heading: StyleRefinement::default()
.font_weight(FontWeight::BOLD)
.text_base()
.mb_0(),
table_columns_min_size: true,
..Default::default()
}
}
fn parse_file_link(link: &str) -> Option<(PathBuf, Option<String>)> {
let uri = Url::parse(link).ok().filter(|uri| uri.scheme() == "file")?;
let fragment = uri.fragment().map(ToOwned::to_owned);
let path = uri.to_file_path().unwrap_or_else(|_| {
let encoded = uri.path();
urlencoding::decode(encoded)
.map(Cow::into_owned)
.map(PathBuf::from)
.unwrap_or_else(|_| PathBuf::from(encoded))
});
Some((path, fragment))
}
pub fn open_markdown_url(
workspace: Option<Entity<Workspace>>,
link: SharedString,
window: &mut Window,
cx: &mut App,
) {
if let Some((path, fragment)) = parse_file_link(&link)
&& let Some(workspace) = workspace
{
workspace.update(cx, |workspace, cx| {
let task = workspace.open_abs_path(
path,
OpenOptions {
visible: Some(OpenVisible::None),
..Default::default()
},
window,
cx,
);
cx.spawn_in(window, async move |_, cx| {
let item = task.await?;
// Ruby LSP uses URLs with #L1,1-4,4
// we'll just take the first number and assume it's a line number
let Some(fragment) = fragment else {
return anyhow::Ok(());
};
let mut accum = 0u32;
for c in fragment.chars() {
if c >= '0' && c <= '9' && accum < u32::MAX / 2 {
accum *= 10;
accum += c as u32 - '0' as u32;
} else if accum > 0 {
break;
}
}
if accum == 0 {
return Ok(());
}
let Some(editor) = cx.update(|_, cx| item.act_as::<Editor>(cx))? else {
return Ok(());
};
editor.update_in(cx, |editor, window, cx| {
editor.change_selections(Default::default(), window, cx, |selections| {
selections.select_ranges([
text::Point::new(accum - 1, 0)..text::Point::new(accum - 1, 0)
]);
});
})
})
.detach_and_log_err(cx);
});
return;
}
if let Some(workspace) = workspace {
workspace.update(cx, |workspace, cx| {
workspace.open_url_or_file(&link, None, window, cx);
});
} else {
cx.open_url(&link);
}
}
#[derive(Default)]
pub struct HoverState {
pub info_popovers: Vec<InfoPopover>,
pub diagnostic_popover: Option<DiagnosticPopover>,
pub info_task: Option<Task<Option<()>>>,
pub closest_mouse_distance: Option<Pixels>,
pub hiding_delay_task: Option<Task<()>>,
pub stable_debugger_hover_origin: Option<gpui::Point<Pixels>>,
pub(crate) hint_hover_task: Option<Task<()>>,
}
impl HoverState {
fn debugger_menu_open(&self, cx: &App) -> bool {
self.info_popovers.iter().any(|popover| {
popover
.debugger_hover
.as_ref()
.is_some_and(|view| view.read(cx).has_menu())
})
}
pub fn visible(&self) -> bool {
!self.info_popovers.is_empty() || self.diagnostic_popover.is_some()
}
pub fn is_single_debugger_hover(&self) -> bool {
let [info_popover] = self.info_popovers.as_slice() else {
return false;
};
self.diagnostic_popover.is_none() && info_popover.debugger_hover.is_some()
}
pub fn stable_debugger_hover_origin(&self) -> Option<gpui::Point<Pixels>> {
self.is_single_debugger_hover()
.then_some(self.stable_debugger_hover_origin)
.flatten()
}
fn keyboard_debugger_hover(&self) -> Option<Entity<DebuggerHoverView>> {
self.info_popovers.iter().find_map(|info_popover| {
(*info_popover.keyboard_grace.borrow())
.then(|| info_popover.debugger_hover.clone())
.flatten()
})
}
pub fn keyboard_debugger_hover_active(&self) -> bool {
self.keyboard_debugger_hover().is_some()
}
pub fn is_mouse_getting_closer(&mut self, mouse_position: gpui::Point<Pixels>) -> bool {
if !self.visible() {
return false;
}
let mut popover_bounds = Vec::new();
for info_popover in &self.info_popovers {
if let Some(bounds) = info_popover.last_bounds.get() {
popover_bounds.push(bounds);
}
}
if let Some(diagnostic_popover) = &self.diagnostic_popover {
if let Some(bounds) = diagnostic_popover.last_bounds.get() {
popover_bounds.push(bounds);
}
}
if popover_bounds.is_empty() {
return false;
}
let distance = popover_bounds
.iter()
.map(|bounds| self.distance_from_point_to_bounds(mouse_position, *bounds))
.min_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal))
.unwrap_or(px(f32::MAX));
if let Some(closest_distance) = self.closest_mouse_distance {
if distance > closest_distance + px(4.0) {
return false;
}
}
self.closest_mouse_distance =
Some(distance.min(self.closest_mouse_distance.unwrap_or(distance)));
true
}
fn distance_from_point_to_bounds(
&self,
point: gpui::Point<Pixels>,
bounds: Bounds<Pixels>,
) -> Pixels {
let center_x = bounds.origin.x + bounds.size.width / 2.;
let center_y = bounds.origin.y + bounds.size.height / 2.;
let dx: f32 = ((point.x - center_x).abs() - bounds.size.width / 2.)
.max(px(0.0))
.into();
let dy: f32 = ((point.y - center_y).abs() - bounds.size.height / 2.)
.max(px(0.0))
.into();
px((dx.powi(2) + dy.powi(2)).sqrt())
}
pub(crate) fn render(
&mut self,
snapshot: &EditorSnapshot,
visible_rows: Range<DisplayRow>,
max_size: Size<Pixels>,
text_layout_details: &TextLayoutDetails,
window: &mut Window,
cx: &mut Context<Editor>,
) -> Option<(DisplayPoint, Vec<AnyElement>)> {
if !self.visible() {
return None;
}
// If there is a diagnostic, position the popovers based on that.
// Otherwise use the start of the hover range
let anchor = self
.diagnostic_popover
.as_ref()
.map(|diagnostic_popover| &diagnostic_popover.local_diagnostic.range.start)
.or_else(|| {
self.info_popovers.iter().find_map(|info_popover| {
match &info_popover.symbol_range {
RangeInEditor::Text(range) => Some(&range.start),
RangeInEditor::Inlay(_) => None,
}
})
})
.or_else(|| {
self.info_popovers.iter().find_map(|info_popover| {
match &info_popover.symbol_range {
RangeInEditor::Text(_) => None,
RangeInEditor::Inlay(range) => Some(&range.inlay_position),
}
})
})?;
let mut point = anchor.to_display_point(&snapshot.display_snapshot);
// Clamp the point within the visible rows in case the popup source spans multiple lines
if visible_rows.end <= point.row() {
point = crate::movement::up_by_rows(
&snapshot.display_snapshot,
point,
1 + (point.row() - visible_rows.end).0,
text::SelectionGoal::None,
true,
text_layout_details,
)
.0;
} else if point.row() < visible_rows.start {
point = crate::movement::down_by_rows(
&snapshot.display_snapshot,
point,
(visible_rows.start - point.row()).0,
text::SelectionGoal::None,
true,
text_layout_details,
)
.0;
}
if !visible_rows.contains(&point.row()) {
log::error!("Hover popover point out of bounds after moving");
return None;
}
let mut elements = Vec::new();
if let Some(diagnostic_popover) = self.diagnostic_popover.as_ref() {
elements.push(diagnostic_popover.render(max_size, window, cx));
}
for info_popover in &mut self.info_popovers {
elements.push(info_popover.render(max_size, window, cx));
}
Some((point, elements))
}
pub fn focused(&self, window: &mut Window, cx: &mut Context<Editor>) -> bool {
let mut hover_popover_is_focused = false;
for info_popover in &self.info_popovers {
if let Some(view) = &info_popover.debugger_hover
&& let Some(menu) = view.read(cx).context_menu()
&& menu.focus_handle(cx).contains_focused(window, cx)
{
hover_popover_is_focused = true;
}
if let Some(markdown_view) = &info_popover.parsed_content
&& markdown_view.focus_handle(cx).is_focused(window)
{
hover_popover_is_focused = true;
}
}
if let Some(diagnostic_popover) = &self.diagnostic_popover
&& diagnostic_popover
.markdown
.focus_handle(cx)
.is_focused(window)
{
hover_popover_is_focused = true;
}
hover_popover_is_focused
}
}
impl Editor {
fn ensure_debugger_hover_selection_visible(&mut self, cx: &mut Context<Self>) {
let Some((debugger_hover, scroll_handle)) =
self.hover_state
.info_popovers
.iter()
.find_map(|info_popover| {
if !*info_popover.keyboard_grace.borrow() {
return None;
}
info_popover
.debugger_hover
.clone()
.map(|debugger_hover| (debugger_hover, info_popover.scroll_handle.clone()))
})
else {
return;
};
let Some(selected_bounds) = debugger_hover.read(cx).selected_row_bounds() else {
return;
};
let viewport_bounds = scroll_handle.bounds();
let mut scroll_offset = scroll_handle.offset();
let initial_offset = scroll_offset;
if selected_bounds.top() < viewport_bounds.top() {
scroll_offset.y += viewport_bounds.top() - selected_bounds.top();
} else if selected_bounds.bottom() > viewport_bounds.bottom() {
scroll_offset.y += viewport_bounds.bottom() - selected_bounds.bottom();
}
if scroll_offset != initial_offset {
scroll_handle.set_offset(scroll_offset);
cx.notify();
}
}
pub fn debugger_hover_expand_selected(
&mut self,
_: &crate::actions::DebuggerHoverExpandSelected,
_window: &mut Window,
cx: &mut Context<Self>,
) {
if let Some(debugger_hover) = self.hover_state.keyboard_debugger_hover() {
debugger_hover.update(cx, |debugger_hover, cx| debugger_hover.expand_selected(cx));
}
}
pub fn debugger_hover_collapse_selected(
&mut self,
_: &crate::actions::DebuggerHoverCollapseSelected,
_window: &mut Window,
cx: &mut Context<Self>,
) {
if let Some(debugger_hover) = self.hover_state.keyboard_debugger_hover() {
debugger_hover.update(cx, |debugger_hover, cx| {
debugger_hover.collapse_selected(cx)
});
}
}
pub fn debugger_hover_select_next(
&mut self,
_: &crate::actions::DebuggerHoverSelectNext,
_window: &mut Window,
cx: &mut Context<Self>,
) {
if let Some(debugger_hover) = self.hover_state.keyboard_debugger_hover() {
debugger_hover.update(cx, |debugger_hover, cx| debugger_hover.select_next(cx));
self.ensure_debugger_hover_selection_visible(cx);
}
}
pub fn debugger_hover_select_previous(
&mut self,
_: &crate::actions::DebuggerHoverSelectPrevious,
_window: &mut Window,
cx: &mut Context<Self>,
) {
if let Some(debugger_hover) = self.hover_state.keyboard_debugger_hover() {
debugger_hover.update(cx, |debugger_hover, cx| debugger_hover.select_previous(cx));
self.ensure_debugger_hover_selection_visible(cx);
}
}
}
pub struct InfoPopover {
pub symbol_range: RangeInEditor,
pub parsed_content: Option<Entity<Markdown>>,
debugger_hover: Option<Entity<DebuggerHoverView>>,
pub scroll_handle: ScrollHandle,
pub keyboard_grace: Rc<RefCell<bool>>,
pub anchor: Option<Anchor>,
pub last_bounds: Rc<Cell<Option<Bounds<Pixels>>>>,
fallback_state: Option<FallbackHoverState>,
_subscriptions: Vec<Subscription>,
}
struct FallbackHoverState {
edit_count: usize,
non_text_state_update_count: usize,
includes_end: bool,
}
impl FallbackHoverState {
fn new(buffer_snapshot: &MultiBufferSnapshot, range: &Range<Anchor>) -> Self {
let offsets = range.to_offset(buffer_snapshot);
let includes_end = offsets.end == buffer_snapshot.len()
|| fallback_hover_range(buffer_snapshot, range.end).to_offset(buffer_snapshot)
== offsets;
Self {
edit_count: buffer_snapshot.edit_count(),
non_text_state_update_count: buffer_snapshot.non_text_state_update_count(),
includes_end,
}
}
}
impl InfoPopover {
pub(crate) fn render(
&mut self,
max_size: Size<Pixels>,
window: &mut Window,
cx: &mut Context<Editor>,
) -> AnyElement {
let keyboard_grace = Rc::clone(&self.keyboard_grace);
let this = cx.entity().downgrade();
let this2 = this.clone();
let bounds_cell = self.last_bounds.clone();
let parsed_content = self.parsed_content.clone();
let debugger_hover = self.debugger_hover.clone();
let debugger_hover_only = debugger_hover.is_some();
let debugger_content_width = debugger_hover
.as_ref()
.and_then(|view| view.read(cx).content_width(window, cx));
let scrollbars = if let Some(view_id) = debugger_hover.as_ref().map(Entity::entity_id) {
Scrollbars::always_visible(ui::ScrollAxes::Both)
.id(("debugger-hover-scrollbar", view_id))
.with_stable_track_along(
ui::ScrollAxes::Vertical,
cx.theme().colors().elevated_surface_background,
)
.tracked_scroll_handle(&self.scroll_handle)
} else {
Scrollbars::for_settings::<EditorSettingsScrollbarProxy>()
.tracked_scroll_handle(&self.scroll_handle)
};
div()
.id("info_popover")
.occlude()
.elevation_2(cx)
.when(debugger_hover_only, |this| this.flex().flex_col())
.child(
canvas(
{
move |bounds, _window, _cx| {
bounds_cell.set(Some(bounds));
}
},
|_, _, _, _| {},
)
.absolute()
.size_full(),
)
// Prevent a mouse down/move on the popover from being propagated to the editor,
// because that would dismiss the popover.
.on_mouse_move({
move |_, _, cx: &mut App| {
this.update(cx, |editor, _| {
editor.hover_state.closest_mouse_distance = Some(px(0.0));
editor.hover_state.hiding_delay_task = None;
editor.hover_state.hint_hover_task = None;
})
.ok();
cx.stop_propagation()
}
})
.on_mouse_down(MouseButton::Left, move |_, _, cx| {
let mut keyboard_grace = keyboard_grace.borrow_mut();
*keyboard_grace = false;
cx.stop_propagation();
})
.when_some(debugger_hover.as_ref(), |this, view| {
this.child(view.update(cx, |view, cx| view.render_header(cx).into_any_element()))
})
.when(
parsed_content.is_some() || debugger_hover.is_some(),
|this| {
this.child(
div()
.id("info-content-container")
.overflow_y_scroll()
.when(debugger_hover_only, |this| this.overflow_x_scroll())
.max_w(max_size.width)
.max_h(if debugger_hover_only {
(max_size.height - DEBUGGER_HOVER_HEADER_HEIGHT).max(Pixels::ZERO)
} else {
max_size.height
})
.when(debugger_hover_only, |this| {
this.min_w(DEBUGGER_HOVER_MIN_WIDTH.min(max_size.width))
})
.track_scroll(&self.scroll_handle)
.child(
v_flex()
.when(!debugger_hover_only, |this| this.w_full())
.when_some(debugger_content_width, |this, width| this.w(width))
.flex_none()
.when(debugger_hover_only, |this| this.gap_0().p_1())
.when(!debugger_hover_only, |this| this.gap_2().p_2())
.when_some(debugger_hover, |this, debugger_hover| {
this.child(debugger_hover)
})
.when_some(parsed_content, |this, markdown| {
this.child(
div().child(
MarkdownElement::new(
markdown,
hover_markdown_style(window, cx),
)
.scroll_handle(self.scroll_handle.clone())
.code_block_renderer(
markdown::CodeBlockRenderer::Default {
copy_button_visibility:
CopyButtonVisibility::Hidden,
wrap_button_visibility:
markdown::WrapButtonVisibility::Hidden,
border: false,
},
)
.on_url_click(move |link, window, cx| {
open_markdown_url(
this2
.read_with(cx, |editor, _| {
editor.workspace()
})
.ok()
.flatten(),
link,
window,
cx,
)
}),
),
)
}),
)
.map(|content| {
div()
.relative()
.child(content)
.custom_scrollbars(scrollbars, window, cx)
}),
)
},
)
.into_any_element()
}
pub fn scroll(&self, amount: ScrollAmount, window: &mut Window, cx: &mut Context<Editor>) {
let mut current = self.scroll_handle.offset();
current.y -= amount.pixels(
window.line_height(),
self.scroll_handle.bounds().size.height - px(16.),
) / 2.0;
cx.notify();
self.scroll_handle.set_offset(current);
}
}
pub struct DiagnosticPopover {
pub(crate) local_diagnostic: DiagnosticEntry<Anchor>,
markdown: Entity<Markdown>,
border_color: Hsla,
background_color: Hsla,
pub keyboard_grace: Rc<RefCell<bool>>,
pub anchor: Anchor,
pub last_bounds: Rc<Cell<Option<Bounds<Pixels>>>>,
_subscription: Subscription,
pub scroll_handle: ScrollHandle,
}
impl DiagnosticPopover {
pub fn render(
&self,
max_size: Size<Pixels>,
window: &mut Window,
cx: &mut Context<Editor>,
) -> AnyElement {
let keyboard_grace = Rc::clone(&self.keyboard_grace);
let this = cx.entity().downgrade();
let bounds_cell = self.last_bounds.clone();
div()
.id("diagnostic")
.occlude()
.elevation_2_borderless(cx)
.child(
canvas(
{
move |bounds, _window, _cx| {
bounds_cell.set(Some(bounds));
}
},
|_, _, _, _| {},
)
.absolute()
.size_full(),
)
// Don't draw the background color if the theme
// allows transparent surfaces.
.when(theme_is_transparent(cx), |this| {
this.bg(gpui::transparent_black())
})
// Prevent a mouse move on the popover from being propagated to the editor,
// because that would dismiss the popover.
.on_mouse_move({
let this = this.clone();
move |_, _, cx: &mut App| {
this.update(cx, |editor, _| {
editor.hover_state.closest_mouse_distance = Some(px(0.0));
editor.hover_state.hiding_delay_task = None;
editor.hover_state.hint_hover_task = None;
})
.ok();
cx.stop_propagation()
}
})
// Prevent a mouse down on the popover from being propagated to the editor,
// because that would move the cursor.
.on_mouse_down(MouseButton::Left, move |_, _, cx| {
let mut keyboard_grace = keyboard_grace.borrow_mut();
*keyboard_grace = false;
cx.stop_propagation();
})
.child(
div()
.relative()
.py_1()
.pl_2()
.pr_8()
.bg(self.background_color)
.border_1()
.border_color(self.border_color)
.rounded_lg()
.child(
div()
.id("diagnostic-content-container")
.max_w(max_size.width)
.max_h(max_size.height)
.overflow_y_scroll()
.track_scroll(&self.scroll_handle)
.child(
MarkdownElement::new(
self.markdown.clone(),
diagnostics_markdown_style(window, cx),
)
.code_block_renderer(markdown::CodeBlockRenderer::Default {
copy_button_visibility: CopyButtonVisibility::Hidden,
wrap_button_visibility: markdown::WrapButtonVisibility::Hidden,
border: false,
})
.on_url_click(
move |link, window, cx| {
if let Some(renderer) = GlobalDiagnosticRenderer::global(cx)
{
this.update(cx, |this, cx| {
renderer.as_ref().open_link(this, link, window, cx);
})
.ok();
}
},
),
),
)
.child(div().absolute().top_1().right_1().child({
let message = self
.local_diagnostic
.diagnostic
.message
.as_shared_string()
.clone();
CopyButton::new("copy-diagnostic", message).tooltip_label("Copy Diagnostic")
}))
.custom_scrollbars(
Scrollbars::for_settings::<EditorSettingsScrollbarProxy>()
.tracked_scroll_handle(&self.scroll_handle),
window,
cx,
),
)
.into_any_element()
}
}
fn hide_popovers(editor: &mut Editor, cx: &mut Context<Editor>) -> bool {
let info_popovers = editor.hover_state.info_popovers.drain(..);
let diagnostics_popover = editor.hover_state.diagnostic_popover.take();
let did_hide = info_popovers.count() > 0 || diagnostics_popover.is_some();
editor.hover_state.info_task = None;
editor.hover_state.hiding_delay_task = None;
editor.hover_state.closest_mouse_distance = None;
editor.hover_state.stable_debugger_hover_origin = None;
editor.clear_background_highlights(HighlightKey::HoverState, cx);
if did_hide {
cx.notify();
}
did_hide
}
#[cfg(test)]
mod tests {
use super::*;
use crate::debugger_hover::{debugger_hover_type_suffix, debugger_hover_variable_colors};
use crate::{
RenameTarget,
actions::{Cancel, ConfirmCompletion},
editor_tests::{handle_completion_request, init_test},
inlays::inlay_hints::tests::{cached_hint_labels, visible_hint_labels},
test::{
editor_lsp_test_context::EditorLspTestContext, editor_test_context::EditorTestContext,
},
};
use collections::{BTreeSet, HashMap, HashSet};
use dap::client::SessionId;
use futures::channel::oneshot;
use futures::future::Shared;
use futures::stream::StreamExt;
use gpui::{App, Modifiers};
use indoc::indoc;
use language::{Buffer, BufferRow, FakeLspAdapter, LanguageServerId, rust_lang};
use markdown::parser::MarkdownEvent;
use multi_buffer::MultiBuffer;
use parking_lot::Mutex;
use project::{
DebuggerHoverData, DebuggerHoverVariable, DocumentHighlight, Hover as ProjectHover,
InlayHint, InlayId, InvalidationStrategy, LocationLink, ProjectTransaction,
lsp_store::{BufferSemanticTokens, CacheInlayHints},
};
use settings::InlayHintSettingsContent;
use settings::{DelayMs, SettingsStore};
use std::sync::atomic;
use std::sync::atomic::AtomicUsize;
use std::{ops::Range, rc::Rc, sync::Arc};
use text::Bias;
use text::BufferId;
fn get_hover_popover_delay(cx: &gpui::TestAppContext) -> u64 {
cx.read(|cx: &App| -> u64 { EditorSettings::get_global(cx).hover_popover_delay.0 })
}
#[gpui::test]
fn test_hover_markdown_soft_breaks_reflow_per_commonmark(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let cx = cx.add_empty_window();
// JSDoc / Rust doc comment / Go doc style: single newlines inside a
// paragraph. Per CommonMark §6.7 these are soft breaks and must render
// as spaces, producing one reflowing paragraph. See issue #60777.
let text = concat!("This is a test\n", "for tooltip\n", "reflow");
let markdown = cx.new(|cx| Markdown::new(text.into(), None, None, cx));
cx.run_until_parked();
let rendered = MarkdownElement::rendered_text(markdown, cx, hover_markdown_style);
// No hard line breaks should appear: the two soft breaks collapse to spaces.
assert_eq!(
rendered.matches('\n').count(),
0,
"expected no hard line breaks, got {rendered:?}"
);
// The whole paragraph reflows onto a single line.
assert_eq!(rendered, "This is a test for tooltip reflow");
}
#[gpui::test]
fn test_hover_markdown_explicit_hard_breaks_preserved(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let cx = cx.add_empty_window();
// The spec-correct way for an LSP server to request line preservation
// is to emit CommonMark hard breaks. PR #54165 also maps `<br>` tags to
// hard breaks. Both must continue to render as forced line breaks under
// the default hover style.
let text = "first line \nsecond line\\\nthird line";
let markdown = cx.new(|cx| Markdown::new(text.into(), None, None, cx));
cx.run_until_parked();
let rendered = MarkdownElement::rendered_text(markdown, cx, hover_markdown_style);
// Two explicit hard breaks (two trailing spaces, and a trailing `\`)
// must render as two newline characters.
assert_eq!(
rendered.matches('\n').count(),
2,
"expected two hard line breaks, got {rendered:?}"
);
let lines: Vec<&str> = rendered.split('\n').collect();
assert_eq!(lines, ["first line", "second line", "third line"]);
}
#[derive(Clone)]
struct TestHoverSemanticsProvider {
hover_response: Vec<ProjectHover>,
debugger_response: Option<project::DebuggerHover>,
lsp_gate: Option<Rc<RefCell<Option<oneshot::Receiver<()>>>>>,
}
fn test_debugger_hover(editor: &Editor, cx: &App) -> project::DebuggerHover {
let buffer = editor.buffer.read(cx).as_singleton().unwrap();
let snapshot = buffer.read(cx).snapshot();
project::DebuggerHover {
range: snapshot.anchor_before(12)..snapshot.anchor_after(17),
data: DebuggerHoverData {
session_id: SessionId(1),
session_name: "Debug application".into(),
root: DebuggerHoverVariable {
name: "point".to_string(),
evaluate_name: Some("point".to_string()),
value: "Point { x: 42 }".to_string(),
type_name: Some("Point".to_string()),
variables_reference: 0,
},
},
}
}
impl crate::SemanticsProvider for TestHoverSemanticsProvider {
fn hover(
&self,
_buffer: &Entity<Buffer>,
_position: text::Anchor,
cx: &mut App,
) -> Option<Task<Option<Vec<ProjectHover>>>> {
if let Some(gate) = &self.lsp_gate {
let receiver = gate.borrow_mut().take()?;
let response = self.hover_response.clone();
Some(cx.background_spawn(async move {
receiver.await.ok()?;
Some(response)
}))
} else {
Some(Task::ready(Some(self.hover_response.clone())))
}
}
fn debugger_hover(
&self,
_buffer: &Entity<Buffer>,
_position: text::Anchor,
_cx: &mut App,
) -> Option<Task<Option<project::DebuggerHover>>> {
self.debugger_response
.clone()
.map(|response| Task::ready(Some(response)))
}
fn inline_values(
&self,
_buffer_handle: Entity<Buffer>,
_range: Range<text::Anchor>,
_cx: &mut App,
) -> Option<Task<anyhow::Result<Vec<InlayHint>>>> {
None
}
fn applicable_inlay_chunks(
&self,
_buffer: &Entity<Buffer>,
_ranges: &[Range<text::Anchor>],
_cx: &mut App,
) -> Vec<Range<BufferRow>> {
Vec::new()
}
fn invalidate_inlay_hints(&self, _for_buffers: &HashSet<BufferId>, _cx: &mut App) {}
fn inlay_hints(
&self,
_invalidate: InvalidationStrategy,
_buffer: Entity<Buffer>,
_ranges: Vec<Range<text::Anchor>>,
_known_chunks: Option<(clock::Global, HashSet<Range<BufferRow>>)>,
_cx: &mut App,
) -> Option<HashMap<Range<BufferRow>, Task<anyhow::Result<CacheInlayHints>>>> {
None
}
fn semantic_tokens(
&self,
_buffer: Entity<Buffer>,
_cx: &mut App,
) -> Option<Shared<Task<std::result::Result<BufferSemanticTokens, Arc<anyhow::Error>>>>>
{
None
}
fn supports_inlay_hints(&self, _buffer: &Entity<Buffer>, _cx: &mut App) -> bool {
false
}
fn supports_semantic_tokens(&self, _buffer: &Entity<Buffer>, _cx: &mut App) -> bool {
false
}
fn document_highlights(
&self,
_buffer: &Entity<Buffer>,
_position: text::Anchor,
_cx: &mut App,
) -> Option<Task<anyhow::Result<Vec<DocumentHighlight>>>> {
None
}
fn definitions(
&self,
_buffer: &Entity<Buffer>,
_position: text::Anchor,
_kind: crate::GotoDefinitionKind,
_cx: &mut App,
) -> Option<Task<anyhow::Result<Option<Vec<LocationLink>>>>> {
None
}
fn range_for_rename(
&self,
_buffer: &Entity<Buffer>,
_position: text::Anchor,
_cx: &mut App,
) -> Task<anyhow::Result<Option<RenameTarget>>> {
Task::ready(Ok(None))
}
fn perform_rename(
&self,
_buffer: &Entity<Buffer>,
_position: text::Anchor,
_new_name: String,
_language_server_id: Option<LanguageServerId>,
_cx: &mut App,
) -> Option<Task<anyhow::Result<ProjectTransaction>>> {
None
}
}
impl InfoPopover {
fn get_rendered_text(&self, cx: &gpui::App) -> String {
let mut rendered_text = String::new();
if let Some(parsed_content) = self.parsed_content.clone() {
let markdown = parsed_content.read(cx);
let text = markdown.parsed_markdown().source().to_string();
let data = markdown.parsed_markdown().events();
let slice = data;
for (range, event) in slice.iter() {
match event {
MarkdownEvent::SubstitutedText(parsed) => {
rendered_text.push_str(parsed.as_str())
}
MarkdownEvent::Text | MarkdownEvent::Code => {
rendered_text.push_str(&text[range.clone()])
}
_ => {}
}
}
}
rendered_text
}
}
#[gpui::test]
async fn test_mouse_hover_info_popover_with_autocomplete_popover(
cx: &mut gpui::TestAppContext,
) {
init_test(cx, |_| {});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
completion_provider: Some(lsp::CompletionOptions {
trigger_characters: Some(vec![".".to_string(), ":".to_string()]),
resolve_provider: Some(true),
..Default::default()
}),
..Default::default()
},
cx,
)
.await;
let counter = Arc::new(AtomicUsize::new(0));
// Basic hover delays and then pops without moving the mouse
cx.set_state(indoc! {"
oneˇ
two
three
fn test() { println!(); }
"});
//prompt autocompletion menu
cx.simulate_keystroke(".");
handle_completion_request(
indoc! {"
one.|<>
two
three
"},
vec!["first_completion", "second_completion"],
true,
counter.clone(),
&mut cx,
)
.await;
cx.condition(|editor, _| editor.context_menu_visible()) // wait until completion menu is visible
.await;
assert_eq!(counter.load(atomic::Ordering::Acquire), 1); // 1 completion request
let hover_point = cx.display_point(indoc! {"
one.
two
three
fn test() { printˇln!(); }
"});
cx.update_editor(|editor, window, cx| {
let snapshot = editor.snapshot(window, cx);
let anchor = snapshot
.buffer_snapshot()
.anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
hover_at(editor, Some(anchor), None, window, cx)
});
assert!(!cx.editor(|editor, _window, _cx| editor.hover_state.visible()));
// After delay, hover should be visible.
let symbol_range = cx.lsp_range(indoc! {"
one.
two
three
fn test() { «println!»(); }
"});
let mut requests =
cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Markup(lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
value: "some basic docs".to_string(),
}),
range: Some(symbol_range),
}))
});
cx.background_executor
.advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
requests.next().await;
cx.editor(|editor, _window, cx| {
assert!(editor.hover_state.visible());
assert_eq!(
editor.hover_state.info_popovers.len(),
1,
"Expected exactly one hover but got: {:?}",
editor.hover_state.info_popovers.len()
);
let rendered_text = editor
.hover_state
.info_popovers
.first()
.unwrap()
.get_rendered_text(cx);
assert_eq!(rendered_text, "some basic docs".to_string())
});
// check that the completion menu is still visible and that there still has only been 1 completion request
cx.editor(|editor, _, _| assert!(editor.context_menu_visible()));
assert_eq!(counter.load(atomic::Ordering::Acquire), 1);
//apply a completion and check it was successfully applied
let _apply_additional_edits = cx.update_editor(|editor, window, cx| {
editor.context_menu_next(&Default::default(), window, cx);
editor
.confirm_completion(&ConfirmCompletion::default(), window, cx)
.unwrap()
});
cx.assert_editor_state(indoc! {"
one.second_completionˇ
two
three
fn test() { println!(); }
"});
// check that the completion menu is no longer visible and that there still has only been 1 completion request
cx.editor(|editor, _, _| assert!(!editor.context_menu_visible()));
assert_eq!(counter.load(atomic::Ordering::Acquire), 1);
//verify the information popover is still visible and unchanged
cx.editor(|editor, _, cx| {
assert!(editor.hover_state.visible());
assert_eq!(
editor.hover_state.info_popovers.len(),
1,
"Expected exactly one hover but got: {:?}",
editor.hover_state.info_popovers.len()
);
let rendered_text = editor
.hover_state
.info_popovers
.first()
.unwrap()
.get_rendered_text(cx);
assert_eq!(rendered_text, "some basic docs".to_string())
});
// Mouse moved with no hover response dismisses
let hover_point = cx.display_point(indoc! {"
one.second_completionˇ
two
three
fn teˇst() { println!(); }
"});
let mut request = cx
.lsp
.set_request_handler::<lsp::request::HoverRequest, _, _>(
|_, _| async move { Ok(None) },
);
cx.update_editor(|editor, window, cx| {
let snapshot = editor.snapshot(window, cx);
let anchor = snapshot
.buffer_snapshot()
.anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
hover_at(editor, Some(anchor), None, window, cx)
});
cx.background_executor
.advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
request.next().await;
// verify that the information popover is no longer visible
cx.editor(|editor, _, _| {
assert!(!editor.hover_state.visible());
});
}
#[gpui::test]
async fn test_debugger_hover_separates_lsp_markdown_content(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut editor_cx = EditorTestContext::new(cx).await;
editor_cx.set_state("let value = ˇpoint.x;\n");
editor_cx.update_editor(|editor, _, cx| {
let mut debugger_response = test_debugger_hover(editor, cx);
debugger_response.data.root.value = "Point { x: 42 }\n".repeat(40);
editor.set_semantics_provider(Some(Rc::new(TestHoverSemanticsProvider {
hover_response: vec![ProjectHover {
contents: vec![HoverBlock {
text: "Documentation for point\n\n".repeat(40),
kind: HoverBlockKind::Markdown,
}],
range: None,
language: None,
}],
debugger_response: Some(debugger_response),
lsp_gate: None,
})));
});
editor_cx.update_editor(|editor, window, cx| hover(editor, &Hover, window, cx));
editor_cx.run_until_parked();
editor_cx.update_editor(|editor, _, cx| {
assert_eq!(editor.hover_state.info_popovers.len(), 2);
let popover = editor
.hover_state
.info_popovers
.first()
.expect("expected debugger hover popover");
assert!(popover.debugger_hover.is_some());
assert!(popover.parsed_content.is_none());
let documentation = editor.hover_state.info_popovers.last().unwrap();
assert!(documentation.debugger_hover.is_none());
assert!(
documentation
.get_rendered_text(cx)
.contains("Documentation for point")
);
});
let handles = editor_cx.update_editor(|editor, _, _| {
editor
.hover_state
.info_popovers
.iter()
.map(|popover| popover.scroll_handle.clone())
.collect::<Vec<_>>()
});
for (index, handle) in handles.iter().enumerate() {
let viewport = handle.bounds();
let max_offset = handle.max_offset();
assert!(max_offset.y > px(20.));
let other_offset = handles[1 - index].offset();
let before = handle.offset();
editor_cx.simulate_event(gpui::ScrollEvent {
position: viewport.center(),
delta: gpui::ScrollDelta::Pixels(gpui::point(px(0.), px(-20.))),
modifiers: Modifiers::none(),
touch_phase: gpui::TouchPhase::Moved,
source: gpui::ScrollSource::Pointer,
});
editor_cx.run_until_parked();
assert_eq!(handle.offset(), before + gpui::point(px(0.), px(-20.)));
assert_eq!(handle.bounds(), viewport);
assert_eq!(handle.max_offset(), max_offset);
assert_eq!(handles[1 - index].offset(), other_offset);
}
}
#[gpui::test]
async fn test_debugger_hover_keeps_tree_when_lsp_documentation_arrives_late(
cx: &mut gpui::TestAppContext,
) {
init_test(cx, |_| {});
let mut editor_cx = EditorTestContext::new(cx).await;
editor_cx.set_state("let value = ˇpoint.x;\n");
let (send_lsp, receive_lsp) = oneshot::channel();
editor_cx.update_editor(|editor, _, cx| {
editor.set_semantics_provider(Some(Rc::new(TestHoverSemanticsProvider {
hover_response: vec![
ProjectHover {
contents: vec![HoverBlock {
text: "Point is documented here".to_string(),
kind: HoverBlockKind::Markdown,
}],
range: None,
language: None,
},
ProjectHover {
contents: vec![HoverBlock {
text: "Additional type documentation".to_string(),
kind: HoverBlockKind::Markdown,
}],
range: None,
language: None,
},
],
debugger_response: Some(test_debugger_hover(editor, cx)),
lsp_gate: Some(Rc::new(RefCell::new(Some(receive_lsp)))),
})));
});
editor_cx.update_editor(|editor, window, cx| hover(editor, &Hover, window, cx));
editor_cx.run_until_parked();
let tree = editor_cx.update_editor(|editor, _, _cx| {
let popover = editor.hover_state.info_popovers.first().unwrap();
assert!(popover.parsed_content.is_none());
assert!(editor.hover_state.is_single_debugger_hover());
popover.debugger_hover.as_ref().unwrap().entity_id()
});
send_lsp.send(()).unwrap();
editor_cx.run_until_parked();
editor_cx.update_editor(|editor, _, cx| {
assert_eq!(editor.hover_state.info_popovers.len(), 2);
let popover = editor.hover_state.info_popovers.first().unwrap();
assert_eq!(popover.debugger_hover.as_ref().unwrap().entity_id(), tree);
assert!(popover.parsed_content.is_none());
let documentation = editor.hover_state.info_popovers.last().unwrap();
assert!(documentation.debugger_hover.is_none());
let rendered = documentation.get_rendered_text(cx);
assert!(rendered.contains("Point is documented here"));
assert!(rendered.contains("Additional type documentation"));
});
}
#[test]
fn test_debugger_hover_type_suffix_is_inline() {
assert_eq!(debugger_hover_type_suffix(0, None), None);
assert_eq!(
debugger_hover_type_suffix(0, Some("Point")),
Some(": Point".to_string())
);
assert_eq!(debugger_hover_type_suffix(1, Some("Point")), None);
}
#[gpui::test]
fn test_debugger_hover_variable_colors_use_theme_syntax(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let colors = cx.read(|cx: &App| debugger_hover_variable_colors(cx));
assert!(colors.name.is_some());
assert!(colors.value.is_some());
assert!(colors.type_name.is_some());
}
#[gpui::test]
async fn test_mouse_hover_info_popover(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await;
// Basic hover delays and then pops without moving the mouse
cx.set_state(indoc! {"
fn ˇtest() { println!(); }
"});
let hover_point = cx.display_point(indoc! {"
fn test() { printˇln!(); }
"});
cx.update_editor(|editor, window, cx| {
let snapshot = editor.snapshot(window, cx);
let anchor = snapshot
.buffer_snapshot()
.anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
hover_at(editor, Some(anchor), None, window, cx)
});
assert!(!cx.editor(|editor, _window, _cx| editor.hover_state.visible()));
// After delay, hover should be visible.
let symbol_range = cx.lsp_range(indoc! {"
fn test() { «println!»(); }
"});
let mut requests =
cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Markup(lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
value: "some basic docs".to_string(),
}),
range: Some(symbol_range),
}))
});
cx.background_executor
.advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
requests.next().await;
cx.editor(|editor, _, cx| {
assert!(editor.hover_state.visible());
assert_eq!(
editor.hover_state.info_popovers.len(),
1,
"Expected exactly one hover but got: {:?}",
editor.hover_state.info_popovers.len()
);
let rendered_text = editor
.hover_state
.info_popovers
.first()
.unwrap()
.get_rendered_text(cx);
assert_eq!(rendered_text, "some basic docs".to_string())
});
// Mouse moved with no hover response dismisses
let hover_point = cx.display_point(indoc! {"
fn teˇst() { println!(); }
"});
let mut request = cx
.lsp
.set_request_handler::<lsp::request::HoverRequest, _, _>(
|_, _| async move { Ok(None) },
);
cx.update_editor(|editor, window, cx| {
let snapshot = editor.snapshot(window, cx);
let anchor = snapshot
.buffer_snapshot()
.anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
hover_at(editor, Some(anchor), None, window, cx)
});
cx.background_executor
.advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
request.next().await;
cx.editor(|editor, _, _| {
assert!(!editor.hover_state.visible());
});
}
#[gpui::test]
async fn test_mouse_hover_cancelled_before_delay(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await;
cx.set_state(indoc! {"
fn ˇtest() { println!(); }
"});
let hover_point = cx.display_point(indoc! {"
fn test() { printˇln!(); }
"});
cx.update_editor(|editor, window, cx| {
let snapshot = editor.snapshot(window, cx);
let anchor = snapshot
.buffer_snapshot()
.anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
hover_at(editor, Some(anchor), None, window, cx);
hover_at(editor, None, None, window, cx);
});
let request_count = Arc::new(AtomicUsize::new(0));
cx.set_request_handler::<lsp::request::HoverRequest, _, _>({
let request_count = request_count.clone();
move |_, _, _| {
let request_count = request_count.clone();
async move {
request_count.fetch_add(1, atomic::Ordering::Release);
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Markup(lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
value: "some basic docs".to_string(),
}),
range: None,
}))
}
}
});
cx.background_executor
.advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
cx.background_executor.run_until_parked();
cx.run_until_parked();
assert_eq!(request_count.load(atomic::Ordering::Acquire), 0);
cx.editor(|editor, _, _| {
assert!(!editor.hover_state.visible());
});
}
#[gpui::test]
async fn test_keyboard_hover_info_popover(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await;
// Hover with keyboard has no delay
cx.set_state(indoc! {"
fˇn test() { println!(); }
"});
cx.update_editor(|editor, window, cx| hover(editor, &Hover, window, cx));
let symbol_range = cx.lsp_range(indoc! {"
«fn» test() { println!(); }
"});
cx.editor(|editor, _window, _cx| {
assert!(!editor.hover_state.visible());
assert_eq!(
editor.hover_state.info_popovers.len(),
0,
"Expected no hovers but got but got: {:?}",
editor.hover_state.info_popovers.len()
);
});
let mut requests =
cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Markup(lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
value: "some other basic docs".to_string(),
}),
range: Some(symbol_range),
}))
});
requests.next().await;
cx.dispatch_action(Hover);
cx.condition(|editor, _| editor.hover_state.visible()).await;
cx.editor(|editor, _, cx| {
assert_eq!(
editor.hover_state.info_popovers.len(),
1,
"Expected exactly one hover but got: {:?}",
editor.hover_state.info_popovers.len()
);
let rendered_text = editor
.hover_state
.info_popovers
.first()
.unwrap()
.get_rendered_text(cx);
assert_eq!(rendered_text, "some other basic docs".to_string())
});
}
#[gpui::test]
async fn test_empty_hovers_filtered(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await;
// Hover with keyboard has no delay
cx.set_state(indoc! {"
fˇn test() { println!(); }
"});
cx.update_editor(|editor, window, cx| hover(editor, &Hover, window, cx));
let symbol_range = cx.lsp_range(indoc! {"
«fn» test() { println!(); }
"});
cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Array(vec![
lsp::MarkedString::String("regular text for hover to show".to_string()),
lsp::MarkedString::String("".to_string()),
lsp::MarkedString::LanguageString(lsp::LanguageString {
language: "Rust".to_string(),
value: "".to_string(),
}),
]),
range: Some(symbol_range),
}))
})
.next()
.await;
cx.dispatch_action(Hover);
cx.condition(|editor, _| editor.hover_state.visible()).await;
cx.editor(|editor, _, cx| {
assert_eq!(
editor.hover_state.info_popovers.len(),
1,
"Expected exactly one hover but got: {:?}",
editor.hover_state.info_popovers.len()
);
let rendered_text = editor
.hover_state
.info_popovers
.first()
.unwrap()
.get_rendered_text(cx);
assert_eq!(
rendered_text,
"regular text for hover to show".to_string(),
"No empty string hovers should be shown"
);
});
}
#[gpui::test]
async fn test_oversized_hover_truncated(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await;
cx.set_state(indoc! {"
fˇn test() { println!(); }
"});
cx.update_editor(|editor, window, cx| hover(editor, &Hover, window, cx));
let symbol_range = cx.lsp_range(indoc! {"
«fn» test() { println!(); }
"});
let oversized_content = "a".repeat(MAX_HOVER_BYTES + 1234);
cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| {
let contents = oversized_content.clone();
async move {
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Markup(lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
value: contents,
}),
range: Some(symbol_range),
}))
}
})
.next()
.await;
cx.dispatch_action(Hover);
cx.condition(|editor, _| editor.hover_state.visible()).await;
cx.editor(|editor, _, cx| {
let rendered_text = editor
.hover_state
.info_popovers
.first()
.unwrap()
.get_rendered_text(cx);
assert_eq!(
rendered_text,
"a".repeat(MAX_HOVER_BYTES - "…".len()) + "…",
"Oversized hover contents should be truncated before display"
);
});
}
#[test]
fn test_truncate_hover_markdown_closes_open_code_fence() {
let text = "intro\n```rust\nlet aaa = 1;";
assert_eq!(
truncate_hover_markdown(text, text.len() - 1 + "…\n```".len()),
"intro\n```rust\nlet aaa = 1…\n```",
"Truncating inside a code block should close its fence"
);
let text = "~~~~\ncode\nmore code";
assert_eq!(
truncate_hover_markdown(text, text.len() - 5 + "…\n~~~~".len()),
"~~~~\ncode\nmore…\n~~~~",
"The closing fence should match the opening fence's character and length"
);
let text = "```rust\ncode\n```\nafter text";
assert_eq!(
truncate_hover_markdown(text, text.len() - 5 + "…".len()),
"```rust\ncode\n```\nafter…",
"Truncating after a closed code block should not add a fence"
);
}
#[test]
fn test_truncate_hover_markdown_respects_char_boundaries() {
assert_eq!(
truncate_hover_markdown("€€€€€", 12),
"€€€…",
"Three euro signs and the ellipsis fill the budget exactly"
);
assert_eq!(
truncate_hover_markdown("€€€€€", 11),
"€€…",
"Truncation should back off to the nearest char boundary"
);
}
#[test]
fn test_truncate_hover_markdown_never_exceeds_budget() {
let text = format!("intro\n{}\n{}", "`".repeat(1000), "x".repeat(2000));
assert_eq!(
truncate_hover_markdown(&text, 500),
"intro\n…",
"A budget landing inside a giant fence run must not emit the run unclosed"
);
assert_eq!(
truncate_hover_markdown(&text, 2000),
"intro\n…",
"A block whose closing fence cannot fit must be dropped entirely"
);
}
#[test]
fn test_truncate_hover_markdown_ellipsis_preserves_fence_lines() {
let prefix = "intro\n```rust\ncode\n```";
let text = format!("{prefix}\nmore text past the budget");
assert_eq!(
truncate_hover_markdown(&text, prefix.len() + "\n…".len()),
format!("{prefix}\n…"),
"An ellipsis appended right after a closing fence would reopen the block"
);
let prefix = "body\n```rust";
let text = format!("{prefix}\ncode past the budget");
assert_eq!(
truncate_hover_markdown(&text, prefix.len() + "\n…\n```".len()),
format!("{prefix}\n…\n```"),
"An ellipsis appended to an opening fence would join its info string"
);
}
#[test]
fn test_backtick_fence_with_backtick_info_is_not_a_fence() {
let text = "```js`x\nnot a code block";
assert_eq!(
truncate_hover_markdown(text, text.len() - 6 + "…".len()),
"```js`x\nnot a code…",
"A backtick fence with a backtick in its info string is paragraph text"
);
}
#[test]
fn test_truncation_does_not_forge_fences_from_partial_lines() {
let text = "```js`x\nnot a code block";
assert_eq!(
truncate_hover_markdown(text, "```js".len() + "…".len()),
"…",
"Cutting \"```js`x\" down to \"```js\" would forge a fence out of paragraph text"
);
let text = "intro\n```rustacean\ncode";
assert_eq!(
truncate_hover_markdown(text, "intro\n```rust".len() + "…".len()),
"intro\n…",
"A fence with a cut-off info string would open a block the original does not have"
);
let text = "intro\n```rust\ncode\n``` and more text";
assert_eq!(
truncate_hover_markdown(text, "intro\n```rust\ncode\n```".len() + "\n…".len()),
"intro\n```rust\ncode\n…\n```",
"\"``` and more text\" does not close the block, so the cut must stay inside it"
);
}
#[test]
fn test_hover_blocks_share_byte_budget() {
let blocks = [
HoverBlock {
text: "a".repeat(MAX_HOVER_BYTES - 20),
kind: HoverBlockKind::Markdown,
},
HoverBlock {
text: "b".repeat(100),
kind: HoverBlockKind::Markdown,
},
HoverBlock {
text: "never shown".to_owned(),
kind: HoverBlockKind::Markdown,
},
];
let second_block_budget = 20 - "\n\n…".len() - "\n\n".len();
let combined = combine_hover_blocks(&blocks);
assert_eq!(
combined,
format!(
"{}\n\n{}…\n\n…",
"a".repeat(MAX_HOVER_BYTES - 20),
"b".repeat(second_block_budget - "…".len())
),
"The byte budget applies to the hover as a whole, and dropping the last block must leave a marker"
);
assert_eq!(
combined.len(),
MAX_HOVER_BYTES,
"The truncated hover must use the whole byte budget"
);
}
#[test]
fn test_dropped_hover_blocks_leave_ellipsis() {
let blocks = [
HoverBlock {
text: "a".repeat(MAX_HOVER_BYTES - "\n\n…".len()),
kind: HoverBlockKind::Markdown,
},
HoverBlock {
text: "never shown".to_owned(),
kind: HoverBlockKind::Markdown,
},
];
let combined = combine_hover_blocks(&blocks);
assert_eq!(
combined,
format!("{}\n\n…", "a".repeat(MAX_HOVER_BYTES - "\n\n…".len())),
"Blocks dropped after an exactly fitting block must leave a truncation indicator"
);
assert_eq!(
combined.len(),
MAX_HOVER_BYTES,
"The dropped-blocks indicator must fit within the byte budget"
);
}
#[test]
fn test_whitespace_hover_blocks_are_skipped() {
let mut blocks = vec![HoverBlock {
text: "a".repeat(MAX_HOVER_BYTES - 6),
kind: HoverBlockKind::Markdown,
}];
blocks.extend((0..100).map(|_| HoverBlock {
text: " ".to_owned(),
kind: HoverBlockKind::Markdown,
}));
blocks.push(HoverBlock {
text: "bbb".to_owned(),
kind: HoverBlockKind::Markdown,
});
let combined = combine_hover_blocks(&blocks);
assert_eq!(
combined,
format!("{}\n\nbbb", "a".repeat(MAX_HOVER_BYTES - 6)),
"Whitespace-only blocks must not emit separators or consume the byte budget"
);
}
#[test]
fn test_unaffordable_code_fence_overhead_drops_the_block() {
let blocks = [
HoverBlock {
text: "a".repeat(MAX_HOVER_BYTES - 6),
kind: HoverBlockKind::Markdown,
},
HoverBlock {
text: "let x = 1;".to_owned(),
kind: HoverBlockKind::Code {
language: "rust".to_owned(),
},
},
];
let combined = combine_hover_blocks(&blocks);
assert_eq!(
combined,
format!("{}\n\n…", "a".repeat(MAX_HOVER_BYTES - 6)),
"A code block whose fence overhead does not fit must be dropped, not overflow the budget"
);
}
#[test]
fn test_dropping_the_last_block_stays_within_the_budget() {
let blocks = [
HoverBlock {
text: "a".repeat(MAX_HOVER_BYTES - 2),
kind: HoverBlockKind::Markdown,
},
HoverBlock {
text: "bbb".to_owned(),
kind: HoverBlockKind::Markdown,
},
];
let combined = combine_hover_blocks(&blocks);
assert_eq!(
combined,
format!("{}…\n\n…", "a".repeat(MAX_HOVER_BYTES - 8)),
"Reserving the dropped-blocks marker must keep the total within the budget"
);
assert_eq!(combined.len(), MAX_HOVER_BYTES);
}
#[test]
fn test_code_hover_budget_includes_fence_overhead() {
let blocks = [HoverBlock {
text: "x".repeat(MAX_HOVER_BYTES),
kind: HoverBlockKind::Code {
language: "rust".to_owned(),
},
}];
let overhead = "```rust\n".len() + "…\n```".len();
assert_eq!(
combine_hover_blocks(&blocks),
format!("```rust\n{}…\n```", "x".repeat(MAX_HOVER_BYTES - overhead)),
"The fence markup must be counted against the byte budget"
);
}
#[test]
fn test_truncation_does_not_split_fence_runs() {
let text = "text\n`````\ncode";
assert_eq!(
truncate_hover_markdown(text, 10),
"text\n…",
"Cutting a ````` run down to ``` would forge a fence the original does not have"
);
assert_eq!(
truncate_hover_markdown(text, 10 + "\n…\n`````".len()),
"text\n`````\n…\n`````",
"A cut right after a full fence run keeps the fence and closes it"
);
}
#[test]
fn test_tab_indented_fence_is_content() {
let text = "```rust\ncode\n\t```\nmore code";
assert_eq!(
truncate_hover_markdown(text, text.len() - 5 + "…\n```".len()),
"```rust\ncode\n\t```\nmore…\n```",
"A tab-indented fence is indented too far to close the block"
);
}
#[test]
fn test_code_hover_language_is_sanitized() {
let blocks = [HoverBlock {
text: "let x = 1;".to_owned(),
kind: HoverBlockKind::Code {
language: "ru`st\n".to_owned(),
},
}];
assert_eq!(
combine_hover_blocks(&blocks),
"```rust\nlet x = 1;\n```",
"Backticks and newlines in the language id would break the fence line"
);
}
#[test]
fn test_wrapping_code_fence_outgrows_content_backticks() {
assert_eq!(wrapping_code_fence("let a = 1;"), "```");
assert_eq!(wrapping_code_fence("let a = \"``\";"), "```");
assert_eq!(wrapping_code_fence("docs with ``` inside"), "````");
assert_eq!(wrapping_code_fence("````"), "`````");
}
#[gpui::test]
async fn test_line_ends_trimmed(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await;
// Hover with keyboard has no delay
cx.set_state(indoc! {"
fˇn test() { println!(); }
"});
cx.update_editor(|editor, window, cx| hover(editor, &Hover, window, cx));
let symbol_range = cx.lsp_range(indoc! {"
«fn» test() { println!(); }
"});
let code_str = "\nlet hovered_point: Vector2F // size = 8, align = 0x4\n";
let markdown_string = format!("\n```rust\n{code_str}```");
let closure_markdown_string = markdown_string.clone();
cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| {
let future_markdown_string = closure_markdown_string.clone();
async move {
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Markup(lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
value: future_markdown_string,
}),
range: Some(symbol_range),
}))
}
})
.next()
.await;
cx.dispatch_action(Hover);
cx.condition(|editor, _| editor.hover_state.visible()).await;
cx.editor(|editor, _, cx| {
assert_eq!(
editor.hover_state.info_popovers.len(),
1,
"Expected exactly one hover but got: {:?}",
editor.hover_state.info_popovers.len()
);
let rendered_text = editor
.hover_state
.info_popovers
.first()
.unwrap()
.get_rendered_text(cx);
assert_eq!(
rendered_text, code_str,
"Should not have extra line breaks at end of rendered hover"
);
});
}
#[gpui::test]
// https://github.com/zed-industries/zed/issues/15498
async fn test_info_hover_with_hrs(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await;
cx.set_state(indoc! {"
fn fuˇnc(abc def: i32) -> u32 {
}
"});
cx.lsp
.set_request_handler::<lsp::request::HoverRequest, _, _>({
|_, _| async move {
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Markup(lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
value: indoc!(
r#"
### function `errands_data_read`
---
→ `char *`
Function to read a file into a string
---
```cpp
static char *errands_data_read()
```
"#
)
.to_string(),
}),
range: None,
}))
}
});
cx.update_editor(|editor, window, cx| hover(editor, &Default::default(), window, cx));
cx.run_until_parked();
cx.update_editor(|editor, _, cx| {
let popover = editor.hover_state.info_popovers.first().unwrap();
let content = popover.get_rendered_text(cx);
assert!(content.contains("Function to read a file"));
});
}
#[gpui::test]
async fn test_hover_inlay_label_parts(cx: &mut gpui::TestAppContext) {
init_test(cx, |settings| {
settings.defaults.inlay_hints = Some(InlayHintSettingsContent {
show_value_hints: Some(true),
enabled: Some(true),
edit_debounce_ms: Some(0),
scroll_debounce_ms: Some(0),
show_type_hints: Some(true),
show_parameter_hints: Some(true),
show_other_hints: Some(true),
show_background: Some(false),
toggle_on_modifiers_press: None,
})
});
let resolved_hint_label = Arc::new(Mutex::new(None::<lsp::InlayHintLabel>));
let mut cx = EditorLspTestContext::new_with_adapter(
Arc::into_inner(rust_lang()).expect("test language"),
FakeLspAdapter {
capabilities: lsp::ServerCapabilities {
inlay_hint_provider: Some(lsp::OneOf::Right(
lsp::InlayHintServerCapabilities::Options(lsp::InlayHintOptions {
resolve_provider: Some(true),
..lsp::InlayHintOptions::default()
}),
)),
..lsp::ServerCapabilities::default()
},
initializer: Some(Box::new({
let resolved_hint_label = resolved_hint_label.clone();
move |server| {
let resolved_hint_label = resolved_hint_label.clone();
let mut resolved_hint_positions = BTreeSet::new();
server.set_request_handler::<lsp::request::InlayHintResolveRequest, _, _>(
move |mut hint_to_resolve, _| {
let inserted =
resolved_hint_positions.insert(hint_to_resolve.position);
assert!(inserted, "Hint {hint_to_resolve:?} was resolved twice");
hint_to_resolve.label = resolved_hint_label
.lock()
.clone()
.expect("resolved hint label");
async move { Ok(hint_to_resolve) }
},
);
}
})),
..FakeLspAdapter::default()
},
cx,
)
.await;
cx.set_state(indoc! {"
struct TestStruct;
// ==================
struct TestNewType<T>(T);
fn main() {
let variableˇ = TestNewType(TestStruct);
}
"});
let hint_start_offset = cx.ranges(indoc! {"
struct TestStruct;
// ==================
struct TestNewType<T>(T);
fn main() {
let variableˇ = TestNewType(TestStruct);
}
"})[0]
.start;
let hint_position = cx.to_lsp(MultiBufferOffset(hint_start_offset));
let new_type_target_range = cx.lsp_range(indoc! {"
struct TestStruct;
// ==================
struct «TestNewType»<T>(T);
fn main() {
let variable = TestNewType(TestStruct);
}
"});
let struct_target_range = cx.lsp_range(indoc! {"
struct «TestStruct»;
// ==================
struct TestNewType<T>(T);
fn main() {
let variable = TestNewType(TestStruct);
}
"});
let uri = cx.buffer_lsp_url.clone();
let new_type_label = "TestNewType";
let struct_label = "TestStruct";
let entire_hint_label = ": TestNewType<TestStruct>";
// `: TestNewType<TestStruct>`
*resolved_hint_label.lock() = Some(lsp::InlayHintLabel::LabelParts(vec![
lsp::InlayHintLabelPart {
value: ": ".to_string(),
..lsp::InlayHintLabelPart::default()
},
lsp::InlayHintLabelPart {
value: new_type_label.to_string(),
location: Some(lsp::Location {
uri: uri.clone(),
range: new_type_target_range,
}),
tooltip: Some(lsp::InlayHintLabelPartTooltip::String(format!(
"A tooltip for `{new_type_label}`"
))),
..lsp::InlayHintLabelPart::default()
},
lsp::InlayHintLabelPart {
value: "<".to_string(),
..lsp::InlayHintLabelPart::default()
},
lsp::InlayHintLabelPart {
value: struct_label.to_string(),
location: Some(lsp::Location {
uri: uri.clone(),
range: struct_target_range,
}),
tooltip: Some(lsp::InlayHintLabelPartTooltip::MarkupContent(
lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
value: format!("A tooltip for `{struct_label}`"),
},
)),
..lsp::InlayHintLabelPart::default()
},
lsp::InlayHintLabelPart {
value: ">".to_string(),
..lsp::InlayHintLabelPart::default()
},
]));
let closure_uri = uri.clone();
cx.lsp
.set_request_handler::<lsp::request::InlayHintRequest, _, _>(move |params, _| {
let task_uri = closure_uri.clone();
async move {
assert_eq!(params.text_document.uri, task_uri);
Ok(Some(vec![lsp::InlayHint {
position: hint_position,
label: lsp::InlayHintLabel::LabelParts(vec![lsp::InlayHintLabelPart {
value: entire_hint_label.to_string(),
..Default::default()
}]),
kind: Some(lsp::InlayHintKind::TYPE),
text_edits: None,
tooltip: None,
padding_left: Some(false),
padding_right: Some(false),
data: None,
}]))
}
})
.next()
.await;
cx.background_executor.run_until_parked();
cx.update_editor(|editor, _, cx| {
let expected_layers = vec![entire_hint_label.to_string()];
assert_eq!(expected_layers, cached_hint_labels(editor, cx));
assert_eq!(expected_layers, visible_hint_labels(editor, cx));
});
let inlay_range = cx
.ranges(indoc! {"
struct TestStruct;
// ==================
struct TestNewType<T>(T);
fn main() {
let variable« »= TestNewType(TestStruct);
}
"})
.first()
.cloned()
.unwrap();
for (label, range) in [(new_type_label, 2..13), (struct_label, 14..24)] {
cx.update_editor(|editor, window, cx| {
let snapshot = editor.snapshot(window, cx);
let start = MultiBufferOffset(inlay_range.start).to_display_point(&snapshot);
let hover_position = DisplayPoint::new(
start.row(),
start.column() + ((range.start + range.end) / 2) as u32,
);
editor.update_inlay_link_and_hover_points(
&snapshot,
Some(hover_position),
None,
true,
false,
window,
cx,
);
});
cx.background_executor
.advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
cx.update_editor(|editor, _, cx| {
assert!(editor.hover_state.diagnostic_popover.is_none());
assert_eq!(editor.hover_state.info_popovers.len(), 1);
let popover = &editor.hover_state.info_popovers[0];
let buffer_snapshot = editor.buffer().read(cx).snapshot(cx);
assert_eq!(
popover.symbol_range,
RangeInEditor::Inlay(InlayHighlight {
inlay: InlayId::Hint(0),
inlay_position: buffer_snapshot
.anchor_after(MultiBufferOffset(inlay_range.start)),
range,
}),
"{label}"
);
assert_eq!(
popover.get_rendered_text(cx),
format!("A tooltip for {label}")
);
});
}
}
#[gpui::test]
async fn test_hover_pending_hint_survives_previous_popover_hiding(
cx: &mut gpui::TestAppContext,
) {
init_test(cx, |settings| {
settings.defaults.inlay_hints = Some(InlayHintSettingsContent {
enabled: Some(true),
edit_debounce_ms: Some(0),
scroll_debounce_ms: Some(0),
..InlayHintSettingsContent::default()
})
});
let resolve_gate = Arc::new(Mutex::new(None::<oneshot::Receiver<()>>));
let hover_gate = Arc::new(Mutex::new(None::<oneshot::Receiver<()>>));
let mut cx = EditorLspTestContext::new_with_adapter(
Arc::into_inner(rust_lang()).expect("test language"),
FakeLspAdapter {
capabilities: lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
inlay_hint_provider: Some(lsp::OneOf::Right(
lsp::InlayHintServerCapabilities::Options(lsp::InlayHintOptions {
resolve_provider: Some(true),
..lsp::InlayHintOptions::default()
}),
)),
..lsp::ServerCapabilities::default()
},
initializer: Some(Box::new({
let resolve_gate = resolve_gate.clone();
let hover_gate = hover_gate.clone();
move |server| {
server.set_request_handler::<lsp::request::InlayHintRequest, _, _>(
move |_, _| async move {
Ok(Some(
[
(17, "a", false),
(28, "b", true),
(39, "c", true),
(50, "d", true),
(61, "e", false),
(72, "f", true),
(83, "g", true),
(94, "h", true),
]
.into_iter()
.map(|(column, name, resolve_tooltip)| lsp::InlayHint {
position: lsp::Position::new(0, column),
label: lsp::InlayHintLabel::String(format!(": {name}")),
kind: Some(lsp::InlayHintKind::TYPE),
text_edits: None,
tooltip: (!resolve_tooltip).then(|| {
lsp::InlayHintTooltip::String(format!("tooltip {name}"))
}),
padding_left: None,
padding_right: None,
data: resolve_tooltip
.then_some(serde_json::Value::Bool(true)),
})
.collect(),
))
},
);
let resolve_gate = resolve_gate.clone();
server.set_request_handler::<lsp::request::InlayHintResolveRequest, _, _>(
move |mut hint, _| {
let resolve_gate = resolve_gate.lock().take();
if hint.data.is_some()
&& let lsp::InlayHintLabel::String(label) = &hint.label
{
hint.tooltip = Some(lsp::InlayHintTooltip::String(format!(
"tooltip {}",
label.trim_start_matches(": ")
)));
}
async move {
if let Some(resolve_gate) = resolve_gate {
resolve_gate.await?;
}
Ok(hint)
}
},
);
let hover_gate = hover_gate.clone();
server.set_request_handler::<lsp::request::HoverRequest, _, _>(
move |_, _| {
let hover_gate = hover_gate.lock().take();
async move {
if let Some(hover_gate) = hover_gate {
hover_gate.await?;
}
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Scalar(
lsp::MarkedString::String("text hover".to_string()),
),
range: Some(lsp::Range::new(
lsp::Position::new(0, 3),
lsp::Position::new(0, 7),
)),
}))
}
},
);
}
})),
..FakeLspAdapter::default()
},
cx,
)
.await;
cx.set_state(
"fn main() { let aˇ = 1; let b = 2; let c = 3; let d = 4; let e = 5; let f = 6; let g = 7; let h = 8; }\n",
);
cx.run_until_parked();
cx.update_editor(|editor, _, cx| {
assert_eq!(
visible_hint_labels(editor, cx),
vec![": a", ": b", ": c", ": d", ": e", ": f", ": g", ": h"]
);
});
let hover_delay = Duration::from_millis(get_hover_popover_delay(&cx) + 100);
let hiding_delay = cx.read(|cx| {
Duration::from_millis(EditorSettings::get_global(cx).hover_popover_hiding_delay.0 + 100)
});
let hint_a_point = cx.pixel_position_for(DisplayPoint::new(DisplayRow(0), 18));
cx.simulate_mouse_move(hint_a_point, None, Modifiers::none());
cx.background_executor.advance_clock(hover_delay);
cx.update_editor(|editor, _, cx| {
assert_eq!(rendered_popovers(editor, cx), vec!["tooltip a"]);
});
let (release_resolve, gate) = oneshot::channel();
*resolve_gate.lock() = Some(gate);
let hint_b_point = cx.pixel_position_for(DisplayPoint::new(DisplayRow(0), 33));
cx.simulate_mouse_move(hint_b_point, None, Modifiers::none());
cx.background_executor.advance_clock(hiding_delay);
cx.update_editor(|editor, _, cx| {
assert_eq!(rendered_popovers(editor, cx), Vec::<String>::new());
});
release_resolve.send(()).expect("pending resolve gate");
cx.background_executor.advance_clock(hover_delay);
cx.update_editor(|editor, _, cx| {
assert_eq!(rendered_popovers(editor, cx), vec!["tooltip b"]);
});
let (release_resolve, gate) = oneshot::channel();
*resolve_gate.lock() = Some(gate);
let hint_c_point = cx.pixel_position_for(DisplayPoint::new(DisplayRow(0), 46));
cx.simulate_mouse_move(hint_c_point, None, Modifiers::none());
cx.dispatch_action(Cancel);
release_resolve.send(()).expect("pending resolve gate");
cx.background_executor.advance_clock(hover_delay);
cx.update_editor(|editor, _, cx| {
assert_eq!(rendered_popovers(editor, cx), Vec::<String>::new());
});
cx.simulate_mouse_move(hint_a_point, None, Modifiers::none());
cx.background_executor.advance_clock(hover_delay);
let popover_a_center = cx.update_editor(|editor, _, cx| {
assert_eq!(rendered_popovers(editor, cx), vec!["tooltip a"]);
editor.hover_state.info_popovers[0]
.last_bounds
.get()
.expect("painted popover bounds")
.center()
});
let (release_resolve, gate) = oneshot::channel();
*resolve_gate.lock() = Some(gate);
let hint_d_point = cx.pixel_position_for(DisplayPoint::new(DisplayRow(0), 60));
cx.simulate_mouse_move(hint_d_point, None, Modifiers::none());
cx.update_editor(|editor, _, _| {
assert!(editor.hover_state.hint_hover_task.is_some());
});
cx.simulate_mouse_move(popover_a_center, None, Modifiers::none());
release_resolve.send(()).expect("pending resolve gate");
cx.background_executor.advance_clock(hover_delay);
cx.update_editor(|editor, _, cx| {
assert_eq!(
rendered_popovers(editor, cx),
vec!["tooltip a"],
"entering the shown popover cancels the pending hint hover"
);
});
let hint_e_point = cx.pixel_position_for(DisplayPoint::new(DisplayRow(0), 74));
cx.simulate_mouse_move(hint_e_point, None, Modifiers::none());
cx.update_editor(|editor, _, _| {
assert!(editor.hover_state.hint_hover_task.is_some());
});
cx.simulate_mouse_move(popover_a_center, None, Modifiers::none());
cx.background_executor.advance_clock(hover_delay);
cx.update_editor(|editor, _, cx| {
assert_eq!(
rendered_popovers(editor, cx),
vec!["tooltip a"],
"entering the shown popover cancels the delayed resolved hint hover"
);
});
let (release_resolve, gate) = oneshot::channel();
*resolve_gate.lock() = Some(gate);
let hint_f_point = cx.pixel_position_for(DisplayPoint::new(DisplayRow(0), 88));
cx.simulate_mouse_move(hint_f_point, None, Modifiers::none());
release_resolve.send(()).expect("pending resolve gate");
cx.run_until_parked();
cx.update_editor(|editor, _, cx| {
assert!(editor.hover_state.hint_hover_task.is_some());
assert_eq!(rendered_popovers(editor, cx), vec!["tooltip a"]);
});
cx.simulate_mouse_move(hint_a_point, None, Modifiers::none());
cx.background_executor.advance_clock(hover_delay);
cx.update_editor(|editor, _, cx| {
assert_eq!(
rendered_popovers(editor, cx),
vec!["tooltip a"],
"returning to the shown hint cancels the delayed hover of the hint left behind"
);
});
let text_point = cx.pixel_position_for(DisplayPoint::new(DisplayRow(0), 4));
cx.simulate_mouse_move(text_point, None, Modifiers::none());
cx.background_executor.advance_clock(hover_delay);
cx.update_editor(|editor, _, cx| {
assert_eq!(rendered_popovers(editor, cx), vec!["text hover"]);
});
let (release_resolve, gate) = oneshot::channel();
*resolve_gate.lock() = Some(gate);
let hint_g_point = cx.pixel_position_for(DisplayPoint::new(DisplayRow(0), 102));
cx.simulate_mouse_move(hint_g_point, None, Modifiers::none());
release_resolve.send(()).expect("pending resolve gate");
cx.run_until_parked();
cx.update_editor(|editor, _, cx| {
assert!(editor.hover_state.hint_hover_task.is_some());
assert_eq!(rendered_popovers(editor, cx), vec!["text hover"]);
});
cx.simulate_mouse_move(text_point, None, Modifiers::none());
cx.background_executor.advance_clock(hover_delay);
cx.update_editor(|editor, _, cx| {
assert_eq!(
rendered_popovers(editor, cx),
vec!["text hover"],
"returning to the hovered text cancels the delayed hover of the hint left behind"
);
});
cx.dispatch_action(Cancel);
cx.update(|_, cx| crate::set_diagnostic_renderer(TestDiagnosticRenderer, cx));
cx.lsp
.notify::<lsp::notification::PublishDiagnostics>(lsp::PublishDiagnosticsParams {
uri: cx.buffer_lsp_url.clone(),
diagnostics: vec![lsp::Diagnostic {
range: lsp::Range::new(lsp::Position::new(0, 3), lsp::Position::new(0, 7)),
severity: Some(lsp::DiagnosticSeverity::ERROR),
message: lsp::DiagnosticMessage::from("diagnostic".to_string()),
..lsp::Diagnostic::default()
}],
version: None,
});
cx.run_until_parked();
cx.simulate_mouse_move(text_point, None, Modifiers::none());
cx.background_executor.advance_clock(hover_delay);
let diagnostic_popover_center = cx.update_editor(|editor, _, cx| {
assert_eq!(rendered_popovers(editor, cx), vec!["text hover"]);
editor
.hover_state
.diagnostic_popover
.as_ref()
.expect("diagnostic popover")
.last_bounds
.get()
.expect("painted diagnostic popover bounds")
.center()
});
let (release_resolve, gate) = oneshot::channel();
*resolve_gate.lock() = Some(gate);
let hint_h_point = cx.pixel_position_for(DisplayPoint::new(DisplayRow(0), 116));
cx.simulate_mouse_move(hint_h_point, None, Modifiers::none());
release_resolve.send(()).expect("pending resolve gate");
cx.run_until_parked();
cx.update_editor(|editor, _, _| {
assert!(editor.hover_state.hint_hover_task.is_some());
assert!(editor.hover_state.diagnostic_popover.is_some());
});
cx.simulate_mouse_move(diagnostic_popover_center, None, Modifiers::none());
cx.background_executor.advance_clock(hover_delay);
cx.update_editor(|editor, _, cx| {
assert!(
editor.hover_state.diagnostic_popover.is_some(),
"entering the diagnostic popover cancels the delayed hint hover"
);
assert_eq!(rendered_popovers(editor, cx), vec!["text hover"]);
});
cx.dispatch_action(Cancel);
let (release_hover, gate) = oneshot::channel();
*hover_gate.lock() = Some(gate);
cx.simulate_mouse_move(text_point, None, Modifiers::none());
cx.background_executor.advance_clock(hover_delay);
cx.update_editor(|editor, _, cx| {
assert!(editor.hover_state.info_task.is_some());
assert_eq!(rendered_popovers(editor, cx), Vec::<String>::new());
});
cx.simulate_mouse_move(hint_e_point, None, Modifiers::none());
cx.background_executor.advance_clock(hover_delay);
cx.update_editor(|editor, _, cx| {
assert_eq!(rendered_popovers(editor, cx), vec!["tooltip e"]);
});
release_hover.send(()).ok();
cx.run_until_parked();
cx.update_editor(|editor, _, cx| {
assert_eq!(
rendered_popovers(editor, cx),
vec!["tooltip e"],
"a pending text hover must not replace the hint tooltip"
);
});
}
#[test]
fn test_find_hovered_hint_part_with_multibyte_characters() {
for (parts, end) in [
(vec![("→ app/Livewire/UserProfile.php", 0..32)], 32),
(
vec![
("", 0..0),
("→ ", 0..4),
("", 4..4),
("path", 4..8),
("", 8..8),
],
8,
),
(vec![("é", 0..2), ("🦀", 2..6)], 6),
(vec![("", 0..0)], 0),
(Vec::new(), 0),
] {
let label_parts = parts
.iter()
.map(|(value, _)| InlayHintLabelPart {
value: value.to_string(),
tooltip: None,
location: None,
command: None,
})
.collect::<Vec<_>>();
for (value, range) in parts {
for offset in range.clone() {
let result = find_hovered_hint_part(label_parts.clone(), offset);
assert_eq!(
result.map(|(part, range)| (part.value, range)),
Some((value.to_string(), range.clone())),
"offset {offset}"
);
}
}
for offset in [end, usize::MAX] {
assert!(find_hovered_hint_part(label_parts.clone(), offset).is_none());
}
}
}
#[gpui::test]
async fn test_hover_popover_hiding_delay(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let custom_delay_ms = 500u64;
cx.update(|cx| {
cx.update_global::<SettingsStore, _>(|settings, cx| {
settings.update_user_settings(cx, |settings| {
settings.editor.hover_popover_sticky = Some(true);
settings.editor.hover_popover_hiding_delay = Some(DelayMs(custom_delay_ms));
});
});
});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await;
cx.set_state(indoc! {"
fn ˇtest() { println!(); }
"});
// Trigger hover on a symbol
let hover_point = cx.display_point(indoc! {"
fn test() { printˇln!(); }
"});
let symbol_range = cx.lsp_range(indoc! {"
fn test() { «println!»(); }
"});
let mut requests =
cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Markup(lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
value: "some basic docs".to_string(),
}),
range: Some(symbol_range),
}))
});
cx.update_editor(|editor, window, cx| {
let snapshot = editor.snapshot(window, cx);
let anchor = snapshot
.buffer_snapshot()
.anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
hover_at(editor, Some(anchor), None, window, cx)
});
cx.background_executor
.advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
requests.next().await;
// Hover should be visible
cx.editor(|editor, _, _| {
assert!(editor.hover_state.visible());
});
// Move mouse away (hover_at with None anchor triggers the hiding delay)
cx.update_editor(|editor, window, cx| hover_at(editor, None, None, window, cx));
// Popover should still be visible before the custom hiding delay expires
cx.background_executor
.advance_clock(Duration::from_millis(custom_delay_ms - 100));
cx.editor(|editor, _, _| {
assert!(
editor.hover_state.visible(),
"Popover should remain visible before the hiding delay expires"
);
});
// After the full custom delay, the popover should be hidden
cx.background_executor
.advance_clock(Duration::from_millis(200));
cx.editor(|editor, _, _| {
assert!(
!editor.hover_state.visible(),
"Popover should be hidden after the hiding delay expires"
);
});
}
#[gpui::test]
async fn test_hover_popover_sticky_disabled(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
cx.update(|cx| {
cx.update_global::<SettingsStore, _>(|settings, cx| {
settings.update_user_settings(cx, |settings| {
settings.editor.hover_popover_sticky = Some(false);
});
});
});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await;
cx.set_state(indoc! {"
fn ˇtest() { println!(); }
"});
// Trigger hover on a symbol
let hover_point = cx.display_point(indoc! {"
fn test() { printˇln!(); }
"});
let symbol_range = cx.lsp_range(indoc! {"
fn test() { «println!»(); }
"});
let mut requests =
cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Markup(lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
value: "some basic docs".to_string(),
}),
range: Some(symbol_range),
}))
});
cx.update_editor(|editor, window, cx| {
let snapshot = editor.snapshot(window, cx);
let anchor = snapshot
.buffer_snapshot()
.anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
hover_at(editor, Some(anchor), None, window, cx)
});
cx.background_executor
.advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
requests.next().await;
// Hover should be visible
cx.editor(|editor, _, _| {
assert!(editor.hover_state.visible());
});
// Move mouse away — with sticky disabled, hide immediately
cx.update_editor(|editor, window, cx| hover_at(editor, None, None, window, cx));
// Popover should be hidden immediately without any delay
cx.editor(|editor, _, _| {
assert!(
!editor.hover_state.visible(),
"Popover should be hidden immediately when sticky is disabled"
);
});
}
#[gpui::test]
async fn test_hover_popover_hiding_delay_restarts_when_mouse_gets_closer(
cx: &mut gpui::TestAppContext,
) {
init_test(cx, |_| {});
let custom_delay_ms = 600u64;
cx.update(|cx| {
cx.update_global::<SettingsStore, _>(|settings, cx| {
settings.update_user_settings(cx, |settings| {
settings.editor.hover_popover_sticky = Some(true);
settings.editor.hover_popover_hiding_delay = Some(DelayMs(custom_delay_ms));
});
});
});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await;
cx.set_state(indoc! {"
fn ˇtest() { println!(); }
"});
let hover_point = cx.display_point(indoc! {"
fn test() { printˇln!(); }
"});
let symbol_range = cx.lsp_range(indoc! {"
fn test() { «println!»(); }
"});
let mut requests =
cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Markup(lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
value: "some basic docs".to_string(),
}),
range: Some(symbol_range),
}))
});
cx.update_editor(|editor, window, cx| {
let snapshot = editor.snapshot(window, cx);
let anchor = snapshot
.buffer_snapshot()
.anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
hover_at(editor, Some(anchor), None, window, cx)
});
cx.background_executor
.advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
requests.next().await;
cx.editor(|editor, _, _| {
assert!(editor.hover_state.visible());
});
cx.update_editor(|editor, _, _| {
let popover = editor.hover_state.info_popovers.first().unwrap();
popover.last_bounds.set(Some(Bounds {
origin: gpui::Point {
x: px(100.0),
y: px(100.0),
},
size: Size {
width: px(100.0),
height: px(60.0),
},
}));
});
let far_point = gpui::Point {
x: px(260.0),
y: px(130.0),
};
cx.update_editor(|editor, window, cx| hover_at(editor, None, Some(far_point), window, cx));
cx.background_executor
.advance_clock(Duration::from_millis(400));
cx.background_executor.run_until_parked();
let closer_point = gpui::Point {
x: px(220.0),
y: px(130.0),
};
cx.update_editor(|editor, window, cx| {
hover_at(editor, None, Some(closer_point), window, cx)
});
cx.background_executor
.advance_clock(Duration::from_millis(250));
cx.background_executor.run_until_parked();
cx.editor(|editor, _, _| {
assert!(
editor.hover_state.visible(),
"Popover should remain visible because moving closer restarts the hiding timer"
);
});
cx.background_executor
.advance_clock(Duration::from_millis(350));
cx.background_executor.run_until_parked();
cx.editor(|editor, _, _| {
assert!(
!editor.hover_state.visible(),
"Popover should hide after the restarted hiding timer expires"
);
});
}
#[gpui::test]
async fn test_hover_popover_cancel_hide_on_rehover(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let custom_delay_ms = 500u64;
cx.update(|cx| {
cx.update_global::<SettingsStore, _>(|settings, cx| {
settings.update_user_settings(cx, |settings| {
settings.editor.hover_popover_sticky = Some(true);
settings.editor.hover_popover_hiding_delay = Some(DelayMs(custom_delay_ms));
});
});
});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await;
cx.set_state(indoc! {"
fn ˇtest() { println!(); }
"});
let hover_point = cx.display_point(indoc! {"
fn test() { printˇln!(); }
"});
let symbol_range = cx.lsp_range(indoc! {"
fn test() { «println!»(); }
"});
let mut requests =
cx.set_request_handler::<lsp::request::HoverRequest, _, _>(move |_, _, _| async move {
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Markup(lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
value: "some basic docs".to_string(),
}),
range: Some(symbol_range),
}))
});
cx.update_editor(|editor, window, cx| {
let snapshot = editor.snapshot(window, cx);
let anchor = snapshot
.buffer_snapshot()
.anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
hover_at(editor, Some(anchor), None, window, cx)
});
cx.background_executor
.advance_clock(Duration::from_millis(get_hover_popover_delay(&cx) + 100));
requests.next().await;
cx.editor(|editor, _, _| {
assert!(editor.hover_state.visible());
});
// Move mouse away — starts the 500ms hide timer
cx.update_editor(|editor, window, cx| hover_at(editor, None, None, window, cx));
cx.background_executor
.advance_clock(Duration::from_millis(300));
cx.background_executor.run_until_parked();
cx.editor(|editor, _, _| {
assert!(
editor.hover_state.visible(),
"Popover should still be visible before hiding delay expires"
);
});
// Move back to the symbol — should cancel the hiding timer
cx.update_editor(|editor, window, cx| {
let snapshot = editor.snapshot(window, cx);
let anchor = snapshot
.buffer_snapshot()
.anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
hover_at(editor, Some(anchor), None, window, cx)
});
// Advance past the original deadline — popover should still be visible
// because re-hovering cleared the hiding_delay_task
cx.background_executor
.advance_clock(Duration::from_millis(300));
cx.background_executor.run_until_parked();
cx.editor(|editor, _, _| {
assert!(
editor.hover_state.visible(),
"Popover should remain visible after re-hovering the symbol"
);
assert!(
editor.hover_state.hiding_delay_task.is_none(),
"Hiding delay task should have been cleared by re-hover"
);
});
// Move away again — starts a fresh 500ms timer
cx.update_editor(|editor, window, cx| hover_at(editor, None, None, window, cx));
cx.background_executor
.advance_clock(Duration::from_millis(custom_delay_ms + 100));
cx.background_executor.run_until_parked();
cx.editor(|editor, _, _| {
assert!(
!editor.hover_state.visible(),
"Popover should hide after the new hiding timer expires"
);
});
}
#[gpui::test]
async fn test_hover_popover_enabled_false_ignores_sticky(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
cx.update(|cx| {
cx.update_global::<SettingsStore, _>(|settings, cx| {
settings.update_user_settings(cx, |settings| {
settings.editor.hover_popover_enabled = Some(false);
settings.editor.hover_popover_sticky = Some(true);
settings.editor.hover_popover_hiding_delay = Some(DelayMs(500));
});
});
});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await;
cx.set_state(indoc! {"
fn ˇtest() { println!(); }
"});
let hover_point = cx.display_point(indoc! {"
fn test() { printˇln!(); }
"});
// Trigger hover_at — should be gated by hover_popover_enabled=false
cx.update_editor(|editor, window, cx| {
let snapshot = editor.snapshot(window, cx);
let anchor = snapshot
.buffer_snapshot()
.anchor_before(hover_point.to_offset(&snapshot, Bias::Left));
hover_at(editor, Some(anchor), None, window, cx)
});
// No need to advance clock or wait for LSP — the gate should prevent any work
cx.editor(|editor, _, _| {
assert!(
!editor.hover_state.visible(),
"Popover should not appear when hover_popover_enabled is false"
);
assert!(
editor.hover_state.info_task.is_none(),
"No hover info task should be scheduled when hover is disabled"
);
});
}
async fn plain_text_lsp_context(cx: &mut gpui::TestAppContext) -> EditorLspTestContext {
let plain_text_lang = language::Language::new(
language::LanguageConfig {
name: "Plain Text".into(),
matcher: language::LanguageMatcher {
path_suffixes: vec!["txt".into()],
..Default::default()
}
.into(),
..Default::default()
},
None,
);
EditorLspTestContext::new(
plain_text_lang,
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await
}
fn handle_hover_requests(
cx: &mut EditorLspTestContext,
respond: impl Fn(lsp::Position) -> (&'static str, Option<lsp::Range>) + Send + 'static,
) -> Arc<AtomicUsize> {
let request_count = Arc::new(AtomicUsize::new(0));
cx.set_request_handler::<lsp::request::HoverRequest, _, _>({
let request_count = request_count.clone();
move |_, params, _| {
request_count.fetch_add(1, atomic::Ordering::AcqRel);
let (value, range) = respond(params.text_document_position_params.position);
async move {
Ok(Some(lsp::Hover {
contents: lsp::HoverContents::Markup(lsp::MarkupContent {
kind: lsp::MarkupKind::Markdown,
value: value.to_string(),
}),
range,
}))
}
}
});
request_count
}
/// Each case is `(marked text, expected symbol range, expected hover text, expected total
/// number of hover requests)`.
fn assert_hovers(
cx: &mut EditorLspTestContext,
request_count: &AtomicUsize,
cases: &[(&str, Range<usize>, &str, usize)],
) {
for (marked_text, range, text, expected_requests) in cases {
let display_point = cx.display_point(marked_text);
let refresh_expected =
*expected_requests > request_count.load(atomic::Ordering::Acquire);
cx.update_editor(|editor, window, cx| {
let snapshot = editor.snapshot(window, cx);
let anchor = snapshot
.buffer_snapshot()
.anchor_before(display_point.to_offset(&snapshot, Bias::Left));
hover_at(editor, Some(anchor), None, window, cx);
if refresh_expected {
assert!(
!editor.hover_state.visible(),
"previous hover should be hidden immediately at {marked_text}"
);
}
});
let delay = get_hover_popover_delay(cx);
cx.background_executor
.advance_clock(Duration::from_millis(delay + 100));
cx.run_until_parked();
let symbol = cx.editor(|editor, window, cx| {
assert!(editor.hover_state.visible(), "hover at {marked_text}");
let popover = editor.hover_state.info_popovers.first().unwrap();
let snapshot = editor.snapshot(window, cx);
let symbol_range = popover
.symbol_range
.as_text_range()
.unwrap()
.to_offset(&snapshot.buffer_snapshot());
(
symbol_range.start.0..symbol_range.end.0,
popover.get_rendered_text(cx),
)
});
assert_eq!(
symbol,
(range.clone(), text.to_string()),
"hover at {marked_text}"
);
assert_eq!(
request_count.load(atomic::Ordering::Acquire),
*expected_requests,
"hover at {marked_text}"
);
}
}
#[gpui::test]
async fn test_hover_without_usable_range_falls_back_to_word(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = plain_text_lsp_context(cx).await;
cx.set_state("hello foˇobar world");
let zero_width_range = cx.lsp_range("hello fo«»obar world");
for lsp_range in [Some(zero_width_range), None] {
let request_count = handle_hover_requests(&mut cx, move |_| ("docs", lsp_range));
assert_hovers(
&mut cx,
&request_count,
&[
("hello fˇoobar world", 6..12, "docs", 1),
("hello foobˇar world", 6..12, "docs", 1),
("hello foobarˇ world", 6..12, "docs", 1),
("hello foobar ˇworld", 13..18, "docs", 2),
],
);
}
}
#[gpui::test]
async fn test_fallback_hover_refreshes_at_token_boundaries(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = plain_text_lsp_context(cx).await;
cx.set_state("fˇoo+=bar");
let zero_width_range = cx.lsp_range("foo«»+=bar");
let request_count =
handle_hover_requests(&mut cx, move |position| match position.character {
0..=2 => ("foo docs", None),
3..=4 => ("operator docs", Some(zero_width_range)),
_ => ("bar docs", None),
});
assert_hovers(
&mut cx,
&request_count,
&[
("fˇoo+=bar", 0..3, "foo docs", 1),
("fooˇ+=bar", 3..3, "operator docs", 2),
("foo+ˇ=bar", 4..4, "operator docs", 3),
("foo+=ˇbar", 5..8, "bar docs", 4),
("fˇoo+=bar", 0..3, "foo docs", 5),
],
);
}
#[gpui::test]
async fn test_fallback_hover_does_not_merge_punctuation(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = plain_text_lsp_context(cx).await;
cx.set_state("foo()ˇ+bar");
for zero_width_range in [false, true] {
let request_count = handle_hover_requests(&mut cx, move |position| {
let text = match position.character {
3 => "open docs",
4 => "close docs",
5 => "plus docs",
_ => "word docs",
};
let range = zero_width_range.then(|| lsp::Range::new(position, position));
(text, range)
});
assert_hovers(
&mut cx,
&request_count,
&[
("foo()ˇ+bar", 5..5, "plus docs", 1),
("foo(ˇ)+bar", 4..4, "close docs", 2),
("fooˇ()+bar", 3..3, "open docs", 3),
("fˇoo()+bar", 0..3, "word docs", 4),
],
);
}
}
#[gpui::test]
async fn test_fallback_hover_refreshes_after_external_edits(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = plain_text_lsp_context(cx).await;
for (initial, initial_range, edit_range, replacement, edited, edited_range) in [
("fˇoo ", 0..3, 3..3, " bar", "foo ˇbar ", 4..7),
(" fˇoo", 1..4, 1..1, "bar ", " ˇbar foo", 1..4),
("foo bˇar ", 4..7, 3..4, "", "foobarˇ ", 0..6),
("fooˇ+ ", 3..3, 3..4, "", "fooˇ ", 0..3),
] {
cx.set_state(initial);
let request_count = handle_hover_requests(&mut cx, |_| ("docs", None));
assert_hovers(
&mut cx,
&request_count,
&[(initial, initial_range, "docs", 1)],
);
cx.update_buffer(|buffer, cx| {
buffer.edit([(edit_range, replacement)], None, cx);
});
assert_hovers(
&mut cx,
&request_count,
&[(edited, edited_range, "docs", 2)],
);
}
}
#[gpui::test]
async fn test_fallback_hover_refreshes_after_language_change(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = plain_text_lsp_context(cx).await;
cx.set_state("fooˇ# ");
let request_count = handle_hover_requests(&mut cx, |_| ("docs", None));
assert_hovers(&mut cx, &request_count, &[("fooˇ# ", 3..3, "docs", 1)]);
cx.update_buffer(|buffer, cx| {
let mut config = buffer
.language()
.expect("test buffer has a language")
.config()
.clone();
config.word_characters.insert('#');
buffer.set_language(Some(Arc::new(Language::new(config, None))), cx);
});
assert_hovers(&mut cx, &request_count, &[("fooˇ# ", 0..4, "docs", 2)]);
}
#[gpui::test]
async fn test_syntax_hover_refreshes_at_token_boundaries(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await;
cx.set_state("fn main(){fˇoo+=bar;}");
let request_count = handle_hover_requests(&mut cx, |position| match position.character {
10..=12 => ("foo docs", Some(lsp::Range::new(position, position))),
13..=14 => ("operator docs", None),
15..=17 => ("bar docs", Some(lsp::Range::new(position, position))),
18 => ("semicolon docs", None),
_ => ("brace docs", None),
});
assert_hovers(
&mut cx,
&request_count,
&[
("fn main(){fˇoo+=bar;}", 10..13, "foo docs", 1),
("fn main(){foˇo+=bar;}", 10..13, "foo docs", 1),
("fn main(){fooˇ+=bar;}", 13..15, "operator docs", 2),
("fn main(){foo+ˇ=bar;}", 13..15, "operator docs", 2),
("fn main(){foo+=ˇbar;}", 15..18, "bar docs", 3),
("fn main(){foo+=bˇar;}", 15..18, "bar docs", 3),
("fn main(){foo+=barˇ;}", 18..19, "semicolon docs", 4),
("fn main(){foo+=bar;ˇ}", 19..20, "brace docs", 5),
("fn main(){foo+=bar;}ˇ", 19..20, "brace docs", 5),
("fn main(){fˇoo+=bar;}", 10..13, "foo docs", 6),
],
);
cx.set_state("fn main(){fooˇ+= bar; }");
let request_count = handle_hover_requests(&mut cx, |position| match position.character {
13..=15 => ("operator docs", None),
19..=20 => ("semicolon docs", None),
_ => ("brace docs", None),
});
assert_hovers(
&mut cx,
&request_count,
&[
("fn main(){fooˇ+= bar; }", 13..15, "operator docs", 1),
("fn main(){foo+=ˇ bar; }", 13..15, "operator docs", 1),
("fn main(){foo+= barˇ; }", 19..20, "semicolon docs", 2),
("fn main(){foo+= bar;ˇ }", 19..20, "semicolon docs", 2),
("fn main(){foo+= bar; ˇ}", 21..22, "brace docs", 3),
],
);
}
#[gpui::test]
async fn test_syntax_hover_on_whitespace(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await;
cx.set_state("fn foo() {}\nˇ\nfn bar() {}\n\n");
for zero_width_range in [false, true] {
let request_count = handle_hover_requests(&mut cx, move |position| {
let text = match position.line {
0 => "foo docs",
2 => "bar docs",
_ => "whitespace docs",
};
let range = zero_width_range.then(|| lsp::Range::new(position, position));
(text, range)
});
assert_hovers(
&mut cx,
&request_count,
&[
(
"fn foo() {}\nˇ\nfn bar() {}\n\n",
12..12,
"whitespace docs",
1,
),
("fn fˇoo() {}\n\nfn bar() {}\n\n", 3..6, "foo docs", 2),
(
"fn foo() {}\n\nfn bar() {}\nˇ\n",
25..25,
"whitespace docs",
3,
),
("fn foo() {}\n\nfn bˇar() {}\n\n", 16..19, "bar docs", 4),
],
);
}
}
#[gpui::test]
async fn test_syntax_hover_first_requested_at_end_of_buffer(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = EditorLspTestContext::new_rust(
lsp::ServerCapabilities {
hover_provider: Some(lsp::HoverProviderCapability::Simple(true)),
..Default::default()
},
cx,
)
.await;
for trailing_whitespace in ["", " ", "\n"] {
let text = format!("fn main(){{foo+=bar;}}{trailing_whitespace}");
let end_marked_text = format!("{text}ˇ");
let word_marked_text = format!("fn main(){{fˇoo+=bar;}}{trailing_whitespace}");
let end_range = if trailing_whitespace.is_empty() {
19..20
} else {
text.len()..text.len()
};
cx.set_state(&end_marked_text);
for zero_width_range in [true, false] {
let request_count = handle_hover_requests(&mut cx, move |position| {
let text = if position.line == 0 && position.character == 11 {
"foo docs"
} else {
"EOF docs"
};
let range = zero_width_range.then(|| lsp::Range::new(position, position));
(text, range)
});
assert_hovers(
&mut cx,
&request_count,
&[
(&end_marked_text, end_range.clone(), "EOF docs", 1),
(&word_marked_text, 10..13, "foo docs", 2),
],
);
}
}
}
#[gpui::test]
async fn test_hover_preserves_lsp_and_end_of_buffer_boundaries(cx: &mut gpui::TestAppContext) {
init_test(cx, |_| {});
let mut cx = plain_text_lsp_context(cx).await;
cx.set_state("fˇoo+=bar");
let explicit_range = cx.lsp_range("«foo»+=bar");
let request_count = handle_hover_requests(&mut cx, move |position| {
if position.character <= 3 {
("foo docs", Some(explicit_range))
} else {
("bar docs", None)
}
});
assert_hovers(
&mut cx,
&request_count,
&[
("fˇoo+=bar", 0..3, "foo docs", 1),
("fooˇ+=bar", 0..3, "foo docs", 1),
("foo+=ˇbar", 5..8, "bar docs", 2),
("foo+=barˇ", 5..8, "bar docs", 2),
],
);
}
#[gpui::test]
fn test_fallback_hover_range(cx: &mut gpui::TestAppContext) {
// (text, offset of the hovered anchor, expected range)
let cases: &[(&str, usize, Range<usize>)] = &[
("foo+=bar", 0, 0..3),
("foo+=bar", 1, 0..3),
// Word end and operator start share an offset: the operator wins.
("foo+=bar", 3, 3..3),
("foo+=bar", 4, 4..4),
("foo+-bar", 3, 3..3),
("foo+-bar", 4, 4..4),
// Operator end and word start share an offset: the word wins.
("foo+=bar", 5, 5..8),
("foo+=bar", 8, 5..8),
// Whitespace next to a word never extends the range.
("foo bar", 3, 0..3),
("foo bar", 4, 4..7),
("foo bar", 4, 4..4),
("foo\n+bar", 3, 0..3),
("foo ", 4, 4..4),
("foo\n", 4, 4..4),
("", 0, 0..0),
// Ranges are byte offsets, so multi-byte characters must be measured in bytes.
("héllo+é", 6, 6..6),
("héllo+é", 7, 7..9),
("héllo+é", 9, 7..9),
];
for (text, offset, expected) in cases {
let snapshot = cx.update(|cx| {
let buffer = MultiBuffer::build_simple(text, cx);
buffer.read(cx).snapshot(cx)
});
let anchor = snapshot.anchor_before(MultiBufferOffset(*offset));
let range = fallback_hover_range(&snapshot, anchor);
assert_eq!(
range.start.to_offset(&snapshot).0..range.end.to_offset(&snapshot).0,
*expected,
"text {text:?} at offset {offset}",
);
if !expected.is_empty() {
assert_eq!(
(range.start.bias(), range.end.bias()),
(Bias::Right, Bias::Left),
"text {text:?} at offset {offset}",
);
}
}
}
#[test]
fn test_parse_file_links() {
assert_eq!(
parse_file_link("file:///path/to/file"),
Some((PathBuf::from("/path/to/file"), None))
);
assert_eq!(
parse_file_link("file:///path/to/file%20with%20spaces"),
Some((PathBuf::from("/path/to/file with spaces"), None))
);
assert_eq!(
parse_file_link("file:///path/to/file#123"),
Some((PathBuf::from("/path/to/file"), Some("123".to_string())))
);
assert_eq!(parse_file_link("http://example.com/"), None,);
}
struct TestDiagnosticRenderer;
impl crate::DiagnosticRenderer for TestDiagnosticRenderer {
fn render_group(
&self,
_: Vec<language::DiagnosticEntryRef<'_, text::Point>>,
_: text::BufferId,
_: EditorSnapshot,
_: gpui::WeakEntity<Editor>,
_: Option<std::sync::Arc<language::LanguageRegistry>>,
_: &mut App,
) -> Vec<crate::display_map::BlockProperties<Anchor>> {
Vec::new()
}
fn render_hover(
&self,
_: Vec<language::DiagnosticEntryRef<'_, text::Point>>,
_: Range<text::Point>,
_: text::BufferId,
_: Option<std::sync::Arc<language::LanguageRegistry>>,
cx: &mut App,
) -> Option<Entity<Markdown>> {
Some(cx.new(|cx| Markdown::new("diagnostic".into(), None, None, cx)))
}
fn open_link(
&self,
_: &mut Editor,
_: SharedString,
_: &mut Window,
_: &mut Context<Editor>,
) {
}
}
fn rendered_popovers(editor: &Editor, cx: &mut App) -> Vec<String> {
editor
.hover_state
.info_popovers
.iter()
.map(|popover| popover.get_rendered_text(cx))
.collect()
}
}