Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

editor: Fix hover hiding delay when symbol_range is zero-width (#64032)

daydalekcb981d5ac6ad
diff --git a/crates/editor/src/hover_popover.rs b/crates/editor/src/hover_popover.rs
index 43c28b2cdde..a006d8049fa 100644
--- a/crates/editor/src/hover_popover.rs
+++ b/crates/editor/src/hover_popover.rs
@@ -14,10 +14,10 @@ use gpui::{
StatefulInteractiveElement, StyleRefinement, Styled, Subscription, Task, TaskExt,
TextStyleRefinement, Window, canvas, div, px,
};
-use language::{DiagnosticEntry, Language, LanguageRegistry};
+use language::{CharKind, DiagnosticEntry, Language, LanguageRegistry};
use lsp::DiagnosticSeverity;
use markdown::{CopyButtonVisibility, Markdown, MarkdownElement, MarkdownStyle};
-use multi_buffer::{MultiBufferOffset, ToOffset, ToPoint};
+use multi_buffer::{MultiBufferOffset, MultiBufferSnapshot, ToOffset, ToPoint};
use project::{HoverBlock, HoverBlockKind, InlayHintLabelPart};
use settings::Settings;
use std::{
@@ -195,6 +195,7 @@ pub fn hover_at_inlay(
editor.hover_state.diagnostic_popover = None;
editor.hover_state.info_popovers = vec![InfoPopover {
symbol_range,
+ fallback_state: None,
parsed_content,
scroll_handle: ScrollHandle::new(),
keyboard_grace: Rc::new(RefCell::new(false)),
@@ -443,6 +444,7 @@ fn show_hover(
.flatten();
info_popovers.push(InfoPopover {
symbol_range: RangeInEditor::Text(range),
+ fallback_state: None,
parsed_content,
scroll_handle,
keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
@@ -473,22 +475,19 @@ fn show_hover(
None => Vec::new(),
};
+ let buffer_snapshot = snapshot.buffer_snapshot();
for hover_result in hovers_response {
// Create symbol range of anchors for highlighting and filtering of future requests.
- let range = hover_result
+ let (range, fallback_state) = hover_result
.range
- .and_then(|range| {
- let range = snapshot
- .buffer_snapshot()
- .buffer_anchor_range_to_anchor_range(range)?;
- Some(range)
- })
- .or_else(|| {
- let snapshot = &snapshot.buffer_snapshot();
- let range = snapshot.syntax_ancestor(anchor..anchor)?.1;
- Some(snapshot.anchor_before(range.start)..snapshot.anchor_after(range.end))
- })
- .unwrap_or_else(|| anchor..anchor);
+ .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 blocks = hover_result.contents;
let language = hover_result.language;
@@ -506,6 +505,7 @@ fn show_hover(
.flatten();
info_popovers.push(InfoPopover {
symbol_range: RangeInEditor::Text(range),
+ fallback_state,
parsed_content,
scroll_handle,
keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
@@ -532,6 +532,7 @@ fn show_hover(
.flatten();
info_popovers.push(InfoPopover {
symbol_range: RangeInEditor::Text(multi_buffer_range),
+ fallback_state: None,
parsed_content,
scroll_handle,
keyboard_grace: Rc::new(RefCell::new(ignore_timeout)),
@@ -569,23 +570,83 @@ fn show_hover(
None
}
-fn same_info_hover(editor: &Editor, snapshot: &EditorSnapshot, anchor: Anchor) -> bool {
- editor
- .hover_state
- .info_popovers
- .iter()
- .any(|InfoPopover { symbol_range, .. }| {
+/// 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 hover_range = range.to_offset(&snapshot.buffer_snapshot());
- let offset = anchor.to_offset(&snapshot.buffer_snapshot());
+ 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 {
@@ -1204,9 +1265,30 @@ pub struct InfoPopover {
pub keyboard_grace: Rc<RefCell<bool>>,
pub anchor: Option<Anchor>,
pub last_bounds: Rc<Cell<Option<Bounds<Pixels>>>>,
+ fallback_state: Option<FallbackHoverState>,
_subscription: Option<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,
@@ -1460,6 +1542,7 @@ mod tests {
use indoc::indoc;
use language::{FakeLspAdapter, rust_lang};
use markdown::parser::MarkdownEvent;
+ use multi_buffer::MultiBuffer;
use parking_lot::Mutex;
use project::InlayId;
use settings::InlayHintSettingsContent;
@@ -3489,6 +3572,462 @@ mod tests {
});
}
+ 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!(