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!(