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.

56.6 KB
Raw Blame
use std::ops::Range;

use gpui::{App, Context, HighlightStyle, Task};
use itertools::Itertools as _;
use language::language_settings::LanguageSettings;
use language::{Buffer, LanguageAwareStyling, OutlineItem, highlight_ranges_from_text};
use multi_buffer::{
    Anchor, AnchorRangeExt as _, MultiBufferOffset, MultiBufferRow, MultiBufferSnapshot,
    ToOffset as _,
};
use text::BufferId;
use theme::{ActiveTheme as _, SyntaxTheme};
use unicode_segmentation::UnicodeSegmentation as _;
use util::maybe;

use crate::display_map::DisplaySnapshot;
use crate::{Editor, LSP_REQUEST_DEBOUNCE_TIMEOUT, LspDataKind};

impl Editor {
    /// Returns all document outline items for a buffer, using LSP or
    /// tree-sitter based on the `document_symbols` setting.
    /// External consumers (outline modal, outline panel, breadcrumbs) should use this.
    pub fn buffer_outline_items(
        &self,
        buffer_id: BufferId,
        cx: &mut Context<Self>,
    ) -> Task<Vec<OutlineItem<text::Anchor>>> {
        let Some(buffer) = self.buffer.read(cx).buffer(buffer_id) else {
            return Task::ready(Vec::new());
        };

        if lsp_symbols_enabled(buffer.read(cx), cx) {
            let refresh_task = self
                .lsp_data_tasks
                .get(&buffer_id)
                .and_then(|tasks| tasks.get(&LspDataKind::DocumentSymbols))
                .cloned();
            cx.spawn(async move |editor, cx| {
                if let Some(refresh_task) = refresh_task {
                    refresh_task.await;
                }
                editor
                    .read_with(cx, |editor, _| {
                        editor
                            .lsp_document_symbols
                            .get(&buffer_id)
                            .cloned()
                            .unwrap_or_default()
                    })
                    .ok()
                    .unwrap_or_default()
            })
        } else {
            let buffer_snapshot = buffer.read(cx).snapshot();
            let syntax = cx.theme().syntax().clone();
            cx.background_executor()
                .spawn(async move { buffer_snapshot.outline(Some(&syntax)).items })
        }
    }

    /// Whether the buffer at `cursor` has LSP document symbols enabled.
    pub(super) fn uses_lsp_document_symbols(
        &self,
        cursor: Anchor,
        multi_buffer_snapshot: &MultiBufferSnapshot,
        cx: &Context<Self>,
    ) -> bool {
        let Some((anchor, _)) = multi_buffer_snapshot.anchor_to_buffer_anchor(cursor) else {
            return false;
        };
        let Some(buffer) = self.buffer.read(cx).buffer(anchor.buffer_id) else {
            return false;
        };
        lsp_symbols_enabled(buffer.read(cx), cx)
    }

    /// Filters editor-local LSP document symbols to the ancestor chain
    /// containing `cursor`. Never triggers an LSP request.
    pub(super) fn lsp_symbols_at_cursor(
        &self,
        cursor: Anchor,
        multi_buffer_snapshot: &MultiBufferSnapshot,
        _cx: &Context<Self>,
    ) -> Option<(BufferId, Vec<OutlineItem<Anchor>>)> {
        let (cursor_text_anchor, buffer) = multi_buffer_snapshot.anchor_to_buffer_anchor(cursor)?;
        let all_items = self
            .lsp_document_symbols
            .get(&cursor_text_anchor.buffer_id)?;
        if all_items.is_empty() {
            return None;
        }

        let mut symbols = all_items
            .iter()
            .filter(|item| {
                item.range.start.cmp(&cursor_text_anchor, buffer).is_le()
                    && item.range.end.cmp(&cursor_text_anchor, buffer).is_ge()
            })
            .filter_map(|item| {
                let range_start = multi_buffer_snapshot.anchor_in_buffer(item.range.start)?;
                let range_end = multi_buffer_snapshot.anchor_in_buffer(item.range.end)?;
                let source_range_for_text_start =
                    multi_buffer_snapshot.anchor_in_buffer(item.source_range_for_text.start)?;
                let source_range_for_text_end =
                    multi_buffer_snapshot.anchor_in_buffer(item.source_range_for_text.end)?;
                Some(OutlineItem {
                    depth: item.depth,
                    range: range_start..range_end,
                    selection_range: multi_buffer_snapshot
                        .anchor_in_buffer(item.selection_range.start)?
                        ..multi_buffer_snapshot.anchor_in_buffer(item.selection_range.end)?,
                    source_range_for_text: source_range_for_text_start..source_range_for_text_end,
                    text: item.text.clone(),
                    highlight_ranges: item.highlight_ranges.clone(),
                    name_ranges: item.name_ranges.clone(),
                    body_range: item.body_range.as_ref().and_then(|r| {
                        Some(
                            multi_buffer_snapshot.anchor_in_buffer(r.start)?
                                ..multi_buffer_snapshot.anchor_in_buffer(r.end)?,
                        )
                    }),
                    annotation_range: item.annotation_range.as_ref().and_then(|r| {
                        Some(
                            multi_buffer_snapshot.anchor_in_buffer(r.start)?
                                ..multi_buffer_snapshot.anchor_in_buffer(r.end)?,
                        )
                    }),
                })
            })
            .collect::<Vec<_>>();

        let mut prev_depth = None;
        symbols.retain(|item| {
            let retain = prev_depth.is_none_or(|prev_depth| item.depth > prev_depth);
            prev_depth = Some(item.depth);
            retain
        });

        Some((buffer.remote_id(), symbols))
    }

    /// Fetches document symbols from the LSP for buffers that have the setting
    /// enabled. Called from `update_lsp_data` on edits, server events, etc.
    /// When the fetch completes, stores results in `self.lsp_document_symbols`
    /// and triggers `refresh_outline_symbols_at_cursor` so breadcrumbs pick up the new data.
    pub(super) fn refresh_document_symbols(
        &mut self,
        for_buffer: Option<BufferId>,
        cx: &mut Context<Self>,
    ) {
        if !self.lsp_data_enabled() {
            return;
        }
        let Some(project) = self.project.as_ref().map(|p| p.downgrade()) else {
            return;
        };

        let buffers_to_query = self
            .visible_buffers(cx)
            .into_iter()
            .filter(|buffer| self.is_lsp_relevant(buffer.read(cx).file(), cx))
            .filter_map(|buffer| {
                let id = buffer.read(cx).remote_id();
                if for_buffer.is_none_or(|target| target == id)
                    && lsp_symbols_enabled(buffer.read(cx), cx)
                {
                    Some(buffer)
                } else {
                    None
                }
            })
            .unique_by(|buffer| buffer.read(cx).remote_id())
            .collect::<Vec<_>>();

        let mut symbols_altered = false;
        let multi_buffer = self.buffer().clone();
        self.lsp_document_symbols.retain(|buffer_id, _| {
            let Some(buffer) = multi_buffer.read(cx).buffer(*buffer_id) else {
                symbols_altered = true;
                return false;
            };
            let retain = lsp_symbols_enabled(buffer.read(cx), cx);
            symbols_altered |= !retain;
            retain
        });
        if symbols_altered {
            self.refresh_outline_symbols_at_cursor(cx);
        }

        if buffers_to_query.is_empty() {
            return;
        }

        self.spawn_lsp_data_tasks(
            LspDataKind::DocumentSymbols,
            for_buffer,
            buffers_to_query,
            cx,
            |buffer, cx| {
                let project = project.clone();
                let buffer_id = buffer.read(cx).remote_id();
                cx.spawn(async move |editor, cx| {
                    cx.background_executor()
                        .timer(LSP_REQUEST_DEBOUNCE_TIMEOUT)
                        .await;

                    let Ok(task) = project.update(cx, |project, cx| {
                        project.lsp_store().update(cx, |lsp_store, cx| {
                            lsp_store.fetch_document_symbols(&buffer, cx)
                        })
                    }) else {
                        return;
                    };

                    let mut items = task.await;
                    editor
                        .update(cx, |editor, cx| {
                            let syntax = cx.theme().syntax().clone();
                            let display_snapshot =
                                editor.display_map.update(cx, |map, cx| map.snapshot(cx));
                            let language = buffer.read(cx).language().cloned();
                            for item in &mut items {
                                if let Some(highlights) =
                                    highlights_from_buffer(&display_snapshot, item, &syntax)
                                {
                                    item.highlight_ranges = highlights;
                                } else if let Some(language) = &language {
                                    item.highlight_ranges =
                                        highlight_ranges_from_text(&item.text, language, &syntax);
                                }
                            }
                            editor.lsp_document_symbols.insert(buffer_id, items);
                            editor.refresh_outline_symbols_at_cursor(cx);
                        })
                        .ok();
                })
            },
        );
    }
}

fn lsp_symbols_enabled(buffer: &Buffer, cx: &App) -> bool {
    LanguageSettings::for_buffer(buffer, cx)
        .document_symbols
        .lsp_enabled()
}

/// Finds where the symbol name appears in the buffer and returns combined
/// (tree-sitter + semantic token) highlights for those positions.
///
/// First tries to find the name verbatim near the selection range so that
/// complex names (`impl Trait for Type`) get full highlighting. Falls back
/// to word-by-word matching for cases like `impl<T> Trait<T> for Type`
/// where the LSP name doesn't appear verbatim in the buffer.
fn highlights_from_buffer(
    display_snapshot: &DisplaySnapshot,
    item: &OutlineItem<text::Anchor>,
    syntax_theme: &SyntaxTheme,
) -> Option<Vec<(Range<usize>, HighlightStyle)>> {
    let outline_text = &item.text;
    if outline_text.is_empty() {
        return None;
    }

    let multi_buffer_snapshot = display_snapshot.buffer();
    let multi_buffer_source_range_anchors =
        multi_buffer_snapshot.text_anchors_to_visible_anchors([
            item.source_range_for_text.start,
            item.source_range_for_text.end,
        ]);
    let anchor_range = maybe!({
        Some(
            (*multi_buffer_source_range_anchors.get(0)?)?
                ..(*multi_buffer_source_range_anchors.get(1)?)?,
        )
    });
    let buffer_snapshot =
        multi_buffer_snapshot.buffer_for_id(item.source_range_for_text.start.buffer_id)?;
    let can_reuse_buffer_highlight_offsets = buffer_snapshot
        .text_for_range(item.source_range_for_text.clone())
        .flat_map(str::bytes)
        .eq(outline_text.bytes());
    if can_reuse_buffer_highlight_offsets {
        let visible_range = anchor_range
            .as_ref()
            .and_then(|_| {
                multi_buffer_snapshot
                    .buffer_anchor_range_to_anchor_range(item.source_range_for_text.clone())
            })
            .map(|range| range.to_offset(multi_buffer_snapshot))
            .filter(|range| range.end.0.checked_sub(range.start.0) == Some(outline_text.len()));
        let highlights = if let Some(range) = visible_range {
            display_snapshot.combined_highlights(range, syntax_theme)
        } else {
            let mut offset = 0;
            buffer_snapshot
                .chunks(
                    item.source_range_for_text.clone(),
                    LanguageAwareStyling {
                        tree_sitter: true,
                        diagnostics: false,
                    },
                )
                .filter_map(|chunk| {
                    let start = offset;
                    offset += chunk.text.len();
                    chunk
                        .syntax_highlight_id
                        .and_then(|id| syntax_theme.get(id))
                        .map(|style| (start..offset, *style))
                })
                .collect::<Vec<_>>()
        };
        return (!highlights.is_empty()).then_some(highlights);
    }

    let selection_point_range = anchor_range?.to_point(multi_buffer_snapshot);
    let mut search_start = selection_point_range.start;
    search_start.column = 0;
    let search_start_offset = search_start.to_offset(&multi_buffer_snapshot);
    let mut search_end = selection_point_range.end;
    search_end.column = multi_buffer_snapshot.line_len(MultiBufferRow(search_end.row));

    let search_text = multi_buffer_snapshot
        .text_for_range(search_start..search_end)
        .collect::<String>();

    let mut outline_text_highlights = Vec::new();
    match search_text.find(outline_text.as_str()) {
        Some(start_index) => {
            let multibuffer_start = search_start_offset + MultiBufferOffset(start_index);
            let multibuffer_end = multibuffer_start + MultiBufferOffset(outline_text.len());
            outline_text_highlights.extend(
                display_snapshot
                    .combined_highlights(multibuffer_start..multibuffer_end, syntax_theme),
            );
        }
        None => {
            for (outline_text_word_start, outline_word) in outline_text.split_word_bound_indices() {
                if let Some(start_index) = search_text.find(outline_word) {
                    let multibuffer_start = search_start_offset + MultiBufferOffset(start_index);
                    let multibuffer_end = multibuffer_start + MultiBufferOffset(outline_word.len());
                    outline_text_highlights.extend(
                        display_snapshot
                            .combined_highlights(multibuffer_start..multibuffer_end, syntax_theme)
                            .into_iter()
                            .map(|(range_in_word, style)| {
                                (
                                    outline_text_word_start + range_in_word.start
                                        ..outline_text_word_start + range_in_word.end,
                                    style,
                                )
                            }),
                    );
                }
            }
        }
    }

    if outline_text_highlights.is_empty() {
        None
    } else {
        Some(outline_text_highlights)
    }
}

#[cfg(test)]
mod tests {
    use std::{
        sync::{Arc, atomic},
        time::Duration,
    };

    use futures::StreamExt as _;
    use gpui::{
        App, AppContext as _, FontWeight, HighlightStyle, Hsla, SharedString, TestAppContext, font,
        px,
    };
    use language::{Buffer, Capability, OutlineItem, highlight_ranges_from_text};
    use languages::rust_lang;
    use lsp::LanguageServerId;
    use multi_buffer::{ExcerptRange, MultiBuffer, PathKey, ToPoint};
    use project::{lsp_store::TokenType, project_settings::DiagnosticSeverity};
    use settings::{DocumentSymbols, SettingsStore};
    use text::Point;
    use theme::SyntaxTheme;
    use util::path;
    use workspace::item::{Item, ItemEvent};
    use zed_actions::editor::MoveDown;

    use super::highlights_from_buffer;
    use crate::{
        Editor, LSP_REQUEST_DEBOUNCE_TIMEOUT,
        display_map::{
            DisplayMap, FoldPlaceholder, HighlightStyleInterner, SemanticTokenHighlight,
        },
        editor_tests::{init_test, update_test_language_settings},
        test::editor_lsp_test_context::EditorLspTestContext,
    };

    fn outline_symbol_names(editor: &Editor) -> Vec<&str> {
        editor
            .outline_symbols_at_cursor
            .as_ref()
            .expect("Should have outline symbols")
            .1
            .iter()
            .map(|s| s.text.as_str())
            .collect()
    }

    fn breadcrumb_texts(editor: &Editor, cx: &App) -> Vec<String> {
        editor
            .breadcrumbs(cx)
            .expect("Should have breadcrumbs")
            .0
            .into_iter()
            .map(|segment| segment.text.to_string())
            .collect()
    }

    fn lsp_range(start_line: u32, start_char: u32, end_line: u32, end_char: u32) -> lsp::Range {
        lsp::Range {
            start: lsp::Position::new(start_line, start_char),
            end: lsp::Position::new(end_line, end_char),
        }
    }

    fn nested_symbol(
        name: &str,
        kind: lsp::SymbolKind,
        range: lsp::Range,
        selection_range: lsp::Range,
        children: Vec<lsp::DocumentSymbol>,
    ) -> lsp::DocumentSymbol {
        #[allow(deprecated)]
        lsp::DocumentSymbol {
            name: name.to_string(),
            detail: None,
            kind,
            tags: None,
            deprecated: None,
            range,
            selection_range,
            children: if children.is_empty() {
                None
            } else {
                Some(children)
            },
        }
    }

    #[gpui::test]
    async fn test_document_symbol_highlights_across_excerpts(cx: &mut TestAppContext) {
        init_test(cx, |_| {});

        let syntax = SyntaxTheme::new_test([("function", Hsla::blue())]);
        let language = rust_lang();
        language.set_theme(&syntax);
        let semantic_style = HighlightStyle {
            font_weight: Some(FontWeight::BOLD),
            ..HighlightStyle::default()
        };
        let function_style = HighlightStyle::color(Hsla::blue());

        for (prefix, label, name_range) in [
            (
                "\t",
                "pub(super) async fn handle_resolve_inlay_hint",
                20..45,
            ),
            ("\t", "pub(super) async fn résolve", 20..28),
            (
                "\tconst LABEL: &str = \"pub(super) async fn résolve\"; ",
                "pub(super) async fn résolve",
                20..28,
            ),
        ] {
            let buffer = cx.new(|cx| {
                Buffer::local(
                    format!("{prefix}{label}() {{\n    let probe = ();\n}}\n"),
                    cx,
                )
                .with_language(language.clone(), cx)
            });
            cx.condition(&buffer, |buffer, _| !buffer.is_parsing())
                .await;
            let snapshot = buffer.read_with(cx, |buffer, _| buffer.snapshot());
            let item = OutlineItem {
                depth: 0,
                range: snapshot.anchor_after(0)..snapshot.anchor_before(snapshot.len()),
                selection_range: snapshot.anchor_after(prefix.len() + name_range.start)
                    ..snapshot.anchor_before(prefix.len() + name_range.end),
                source_range_for_text: snapshot.anchor_after(prefix.len())
                    ..snapshot.anchor_before(prefix.len() + label.len()),
                text: SharedString::from(label),
                highlight_ranges: Vec::new(),
                name_ranges: vec![name_range.clone()],
                body_range: None,
                annotation_range: None,
            };
            let label_start = Point::new(0, prefix.len() as u32);
            let label_end = Point::new(0, (prefix.len() + label.len()) as u32);
            let name_start = Point::new(0, (prefix.len() + name_range.start) as u32);
            for (ranges, expected_style) in [
                (vec![Point::new(1, 0)..Point::new(1, 19)], function_style),
                (
                    vec![label_start..label_end],
                    function_style.highlight(semantic_style),
                ),
                (
                    vec![Point::new(0, name_start.column + 1)..label_end],
                    function_style,
                ),
                (
                    vec![
                        label_start..Point::new(0, name_start.column - 1),
                        name_start..label_end,
                    ],
                    function_style,
                ),
            ] {
                let multibuffer = cx.new(|cx| {
                    let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
                    multibuffer.set_excerpt_ranges_for_path(
                        PathKey::sorted(0),
                        buffer.clone(),
                        &snapshot,
                        ranges
                            .iter()
                            .cloned()
                            .map(ExcerptRange::new)
                            .collect::<Vec<_>>(),
                        cx,
                    );
                    multibuffer
                });
                let display_map = cx.new(|cx| {
                    DisplayMap::new(
                        multibuffer,
                        font("Helvetica"),
                        px(14.0),
                        None,
                        1,
                        1,
                        FoldPlaceholder::test(),
                        DiagnosticSeverity::Warning,
                        cx,
                    )
                });
                display_map.update(cx, |display_map, cx| {
                    let display_snapshot = display_map.snapshot(cx);
                    if let Some(range) = display_snapshot
                        .buffer()
                        .buffer_anchor_range_to_anchor_range(item.selection_range.clone())
                    {
                        let mut interner = HighlightStyleInterner::default();
                        let token = SemanticTokenHighlight {
                            range,
                            style: interner.intern(semantic_style),
                            token_type: TokenType(0),
                            token_modifiers: 0,
                            server_id: LanguageServerId(0),
                            precedence: 0,
                        };
                        Arc::make_mut(&mut display_map.semantic_token_highlights).insert(
                            snapshot.remote_id(),
                            (Arc::from([token]), Arc::new(interner)),
                        );
                    }
                    assert_eq!(
                        highlights_from_buffer(&display_map.snapshot(cx), &item, &syntax),
                        Some(vec![(name_range.clone(), expected_style)]),
                        "prefix {prefix:?}, label {label:?}, excerpts {ranges:?}",
                    );
                });
            }
        }
    }

    #[gpui::test]
    async fn test_nonverbatim_document_symbols_outside_excerpts(cx: &mut TestAppContext) {
        init_test(cx, |_| {});

        let syntax = SyntaxTheme::new_test([("keyword", Hsla::blue()), ("type", Hsla::green())]);
        let language = rust_lang();
        language.set_theme(&syntax);
        let keyword = HighlightStyle::color(Hsla::blue());
        let type_style = HighlightStyle::color(Hsla::green());
        for (source, label, selection, expected) in [
            (
                "impl<T> Trait<T>\n    for Type<T> {\n    fn probe() {}\n}\n",
                "impl Trait<T> for Type<T>",
                Point::new(1, 8)..Point::new(1, 15),
                vec![
                    (0..4, keyword),
                    (5..10, type_style),
                    (11..12, type_style),
                    (14..17, keyword),
                    (18..22, type_style),
                    (23..24, type_style),
                ],
            ),
            (
                "impl\n    Simplify {\n    fn probe() {}\n}\n",
                "impl Simplify",
                Point::new(1, 4)..Point::new(1, 12),
                vec![(0..4, keyword), (5..13, type_style)],
            ),
        ] {
            let buffer = cx.new(|cx| Buffer::local(source, cx).with_language(language.clone(), cx));
            cx.condition(&buffer, |buffer, _| !buffer.is_parsing())
                .await;
            let snapshot = buffer.read_with(cx, |buffer, _| buffer.snapshot());
            let selection =
                snapshot.anchor_after(selection.start)..snapshot.anchor_before(selection.end);
            let item = OutlineItem {
                depth: 0,
                range: snapshot.anchor_after(0)..snapshot.anchor_before(snapshot.len()),
                selection_range: selection.clone(),
                source_range_for_text: selection,
                text: SharedString::from(label),
                highlight_ranges: Vec::new(),
                name_ranges: vec![0..label.len()],
                body_range: None,
                annotation_range: None,
            };
            let multibuffer = cx.new(|cx| {
                let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
                multibuffer.set_excerpt_ranges_for_path(
                    PathKey::sorted(0),
                    buffer.clone(),
                    &snapshot,
                    vec![ExcerptRange::new(
                        Point::new(2, 0)..Point::new(2, snapshot.line_len(2)),
                    )],
                    cx,
                );
                multibuffer
            });
            let display_map = cx.new(|cx| {
                DisplayMap::new(
                    multibuffer,
                    font("Helvetica"),
                    px(14.0),
                    None,
                    1,
                    1,
                    FoldPlaceholder::test(),
                    DiagnosticSeverity::Warning,
                    cx,
                )
            });
            let highlights = display_map
                .update(cx, |display_map, cx| {
                    highlights_from_buffer(&display_map.snapshot(cx), &item, &syntax)
                })
                .unwrap_or_else(|| highlight_ranges_from_text(label, &language, &syntax));
            assert_eq!(highlights, expected, "label {label:?}");
        }
    }

    #[gpui::test]
    async fn test_lsp_document_symbols_fetches_when_enabled(cx: &mut TestAppContext) {
        init_test(cx, |_| {});

        update_test_language_settings(cx, &|settings| {
            settings.defaults.document_symbols = Some(DocumentSymbols::On);
        });

        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                document_symbol_provider: Some(lsp::OneOf::Left(true)),
                ..lsp::ServerCapabilities::default()
            },
            cx,
        )
        .await;
        let mut symbol_request = cx
            .set_request_handler::<lsp::request::DocumentSymbolRequest, _, _>(
                move |_, _, _| async move {
                    Ok(Some(lsp::DocumentSymbolResponse::Nested(vec![
                        nested_symbol(
                            "main",
                            lsp::SymbolKind::FUNCTION,
                            lsp_range(0, 0, 2, 1),
                            lsp_range(0, 3, 0, 7),
                            Vec::new(),
                        ),
                    ])))
                },
            );

        cx.set_state("fn maˇin() {\n    let x = 1;\n}\n");
        assert!(symbol_request.next().await.is_some());
        cx.run_until_parked();

        cx.update_editor(|editor, _window, _cx| {
            assert_eq!(outline_symbol_names(editor), vec!["fn main"]);
        });
    }

    #[gpui::test]
    async fn test_lsp_document_symbols_nested(cx: &mut TestAppContext) {
        init_test(cx, |_| {});

        update_test_language_settings(cx, &|settings| {
            settings.defaults.document_symbols = Some(DocumentSymbols::On);
        });

        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                document_symbol_provider: Some(lsp::OneOf::Left(true)),
                ..lsp::ServerCapabilities::default()
            },
            cx,
        )
        .await;
        let mut symbol_request = cx
            .set_request_handler::<lsp::request::DocumentSymbolRequest, _, _>(
                move |_, _, _| async move {
                    Ok(Some(lsp::DocumentSymbolResponse::Nested(vec![
                        nested_symbol(
                            "Foo",
                            lsp::SymbolKind::STRUCT,
                            lsp_range(0, 0, 3, 1),
                            lsp_range(0, 7, 0, 10),
                            vec![
                                nested_symbol(
                                    "bar",
                                    lsp::SymbolKind::FIELD,
                                    lsp_range(1, 4, 1, 13),
                                    lsp_range(1, 4, 1, 7),
                                    Vec::new(),
                                ),
                                nested_symbol(
                                    "baz",
                                    lsp::SymbolKind::FIELD,
                                    lsp_range(2, 4, 2, 15),
                                    lsp_range(2, 4, 2, 7),
                                    Vec::new(),
                                ),
                            ],
                        ),
                    ])))
                },
            );

        cx.set_state("struct Foo {\n    baˇr: u32,\n    baz: String,\n}\n");
        assert!(symbol_request.next().await.is_some());
        cx.run_until_parked();

        cx.update_editor(|editor, _window, _cx| {
            assert_eq!(
                outline_symbol_names(editor),
                vec!["struct Foo", "bar"],
                "cursor is inside Foo > bar, so we expect the containing chain"
            );
        });
    }

    #[gpui::test]
    async fn test_lsp_document_symbols_switch_tree_sitter_to_lsp_and_back(cx: &mut TestAppContext) {
        init_test(cx, |_| {});

        // Start with tree-sitter (default)
        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                document_symbol_provider: Some(lsp::OneOf::Left(true)),
                ..lsp::ServerCapabilities::default()
            },
            cx,
        )
        .await;
        let mut symbol_request = cx
            .set_request_handler::<lsp::request::DocumentSymbolRequest, _, _>(
                move |_, _, _| async move {
                    Ok(Some(lsp::DocumentSymbolResponse::Nested(vec![
                        nested_symbol(
                            "lsp_main_symbol",
                            lsp::SymbolKind::FUNCTION,
                            lsp_range(0, 0, 2, 1),
                            lsp_range(0, 3, 0, 7),
                            Vec::new(),
                        ),
                    ])))
                },
            );

        cx.set_state("fn maˇin() {\n    let x = 1;\n}\n");
        cx.run_until_parked();

        // Step 1: With tree-sitter (default), breadcrumbs use tree-sitter outline
        cx.update_editor(|editor, _window, _cx| {
            assert_eq!(
                outline_symbol_names(editor),
                vec!["fn main"],
                "Tree-sitter should produce 'fn main'"
            );
        });

        // Step 2: Switch to LSP
        update_test_language_settings(&mut cx.cx.cx, &|settings| {
            settings.defaults.document_symbols = Some(DocumentSymbols::On);
        });
        assert!(symbol_request.next().await.is_some());
        cx.run_until_parked();

        cx.update_editor(|editor, _window, _cx| {
            assert_eq!(
                outline_symbol_names(editor),
                vec!["lsp_main_symbol"],
                "After switching to LSP, should see LSP symbols"
            );
        });

        // Step 3: Switch back to tree-sitter, the symbols should refresh
        // without any extra selection changes
        update_test_language_settings(&mut cx.cx.cx, &|settings| {
            settings.defaults.document_symbols = Some(DocumentSymbols::Off);
        });
        cx.run_until_parked();

        cx.update_editor(|editor, _window, _cx| {
            assert_eq!(
                outline_symbol_names(editor),
                vec!["fn main"],
                "After switching back to tree-sitter, should see tree-sitter symbols again"
            );
        });
    }

    #[gpui::test]
    async fn test_lsp_document_symbols_caches_results(cx: &mut TestAppContext) {
        init_test(cx, |_| {});

        update_test_language_settings(cx, &|settings| {
            settings.defaults.document_symbols = Some(DocumentSymbols::On);
        });

        let request_count = Arc::new(atomic::AtomicUsize::new(0));
        let request_count_clone = request_count.clone();

        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                document_symbol_provider: Some(lsp::OneOf::Left(true)),
                ..lsp::ServerCapabilities::default()
            },
            cx,
        )
        .await;

        let mut symbol_request = cx
            .set_request_handler::<lsp::request::DocumentSymbolRequest, _, _>(move |_, _, _| {
                request_count_clone.fetch_add(1, atomic::Ordering::AcqRel);
                async move {
                    Ok(Some(lsp::DocumentSymbolResponse::Nested(vec![
                        nested_symbol(
                            "main",
                            lsp::SymbolKind::FUNCTION,
                            lsp_range(0, 0, 2, 1),
                            lsp_range(0, 3, 0, 7),
                            Vec::new(),
                        ),
                    ])))
                }
            });

        cx.set_state("fn maˇin() {\n    let x = 1;\n}\n");
        assert!(symbol_request.next().await.is_some());
        cx.run_until_parked();

        let first_count = request_count.load(atomic::Ordering::Acquire);
        assert_eq!(first_count, 1, "Should have made exactly one request");

        // Move cursor within the same buffer version — should use cache
        cx.update_editor(|editor, window, cx| {
            editor.move_down(&MoveDown, window, cx);
        });
        cx.background_executor
            .advance_clock(LSP_REQUEST_DEBOUNCE_TIMEOUT + Duration::from_millis(100));
        cx.run_until_parked();

        assert_eq!(
            first_count,
            request_count.load(atomic::Ordering::Acquire),
            "Moving cursor without editing should use cached symbols"
        );
    }

    #[gpui::test]
    async fn test_lsp_document_symbols_flat_response(cx: &mut TestAppContext) {
        init_test(cx, |_| {});

        update_test_language_settings(cx, &|settings| {
            settings.defaults.document_symbols = Some(DocumentSymbols::On);
        });

        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                document_symbol_provider: Some(lsp::OneOf::Left(true)),
                ..lsp::ServerCapabilities::default()
            },
            cx,
        )
        .await;
        let mut symbol_request = cx
            .set_request_handler::<lsp::request::DocumentSymbolRequest, _, _>(
                move |_, _, _| async move {
                    #[allow(deprecated)]
                    Ok(Some(lsp::DocumentSymbolResponse::Flat(vec![
                        lsp::SymbolInformation {
                            name: "main".to_string(),
                            kind: lsp::SymbolKind::FUNCTION,
                            tags: None,
                            deprecated: None,
                            location: lsp::Location {
                                uri: lsp::Uri::from_file_path(path!("/a/main.rs")).unwrap(),
                                range: lsp_range(0, 0, 2, 1),
                            },
                            container_name: None,
                        },
                    ])))
                },
            );

        cx.set_state("fn maˇin() {\n    let x = 1;\n}\n");
        assert!(symbol_request.next().await.is_some());
        cx.run_until_parked();

        cx.update_editor(|editor, _window, _cx| {
            assert_eq!(outline_symbol_names(editor), vec!["main"]);
        });
    }

    #[gpui::test]
    async fn test_breadcrumbs_use_lsp_symbols(cx: &mut TestAppContext) {
        init_test(cx, |_| {});

        update_test_language_settings(cx, &|settings| {
            settings.defaults.document_symbols = Some(DocumentSymbols::On);
        });

        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                document_symbol_provider: Some(lsp::OneOf::Left(true)),
                ..lsp::ServerCapabilities::default()
            },
            cx,
        )
        .await;
        let mut symbol_request = cx
            .set_request_handler::<lsp::request::DocumentSymbolRequest, _, _>(
                move |_, _, _| async move {
                    Ok(Some(lsp::DocumentSymbolResponse::Nested(vec![
                        nested_symbol(
                            "MyModule",
                            lsp::SymbolKind::MODULE,
                            lsp_range(0, 0, 4, 1),
                            lsp_range(0, 4, 0, 12),
                            vec![nested_symbol(
                                "my_function",
                                lsp::SymbolKind::FUNCTION,
                                lsp_range(1, 4, 3, 5),
                                lsp_range(1, 7, 1, 18),
                                Vec::new(),
                            )],
                        ),
                    ])))
                },
            );

        cx.set_state("mod MyModule {\n    fn my_fuˇnction() {\n        let x = 1;\n    }\n}\n");
        assert!(symbol_request.next().await.is_some());
        cx.run_until_parked();

        cx.update_editor(|editor, _window, _cx| {
            assert_eq!(
                outline_symbol_names(editor),
                vec!["mod MyModule", "fn my_function"]
            );
        });
    }

    #[gpui::test]
    async fn test_lsp_document_symbols_multibyte_highlights(cx: &mut TestAppContext) {
        init_test(cx, |_| {});

        update_test_language_settings(cx, &|settings| {
            settings.defaults.document_symbols = Some(DocumentSymbols::On);
        });

        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                document_symbol_provider: Some(lsp::OneOf::Left(true)),
                ..lsp::ServerCapabilities::default()
            },
            cx,
        )
        .await;
        let mut symbol_request = cx
            .set_request_handler::<lsp::request::DocumentSymbolRequest, _, _>(
                move |_, _, _| async move {
                    // Buffer: "/// αyzabc\nfn test() {}\n"
                    // Bytes 0-3: "/// ", bytes 4-5: α (2-byte UTF-8), bytes 6-11: "yzabc\n"
                    // Line 1 starts at byte 12: "fn test() {}"
                    //
                    // Symbol range includes doc comment (line 0-1).
                    // Selection points to "test" on line 1.
                    // enriched_symbol_text extracts "fn test" with source_range_for_text.start at byte 12.
                    // search_start = max(12 - 7, 0) = 5, which is INSIDE the 2-byte 'α' char.
                    Ok(Some(lsp::DocumentSymbolResponse::Nested(vec![
                        nested_symbol(
                            "test",
                            lsp::SymbolKind::FUNCTION,
                            lsp_range(0, 0, 1, 13), // includes doc comment
                            lsp_range(1, 3, 1, 7),  // "test"
                            Vec::new(),
                        ),
                    ])))
                },
            );

        // "/// αyzabc\n" = 12 bytes, then "fn test() {}\n"
        // search_start = 12 - 7 = 5, which is byte 5 = second byte of 'α' (not a char boundary)
        cx.set_state("/// αyzabc\nfn teˇst() {}\n");
        assert!(symbol_request.next().await.is_some());
        cx.run_until_parked();

        cx.update_editor(|editor, _window, cx| {
            let (_, symbols) = editor
                .outline_symbols_at_cursor
                .as_ref()
                .expect("Should have outline symbols");
            assert_eq!(symbols.len(), 1);

            let symbol = &symbols[0];
            let multi_buffer_snapshot = editor.buffer.read(cx).snapshot(cx);
            assert_eq!(symbol.text, "fn test");
            assert_eq!(
                symbol
                    .selection_range
                    .start
                    .to_point(&multi_buffer_snapshot),
                Point::new(1, 3)
            );
            assert_eq!(
                symbol.selection_range.end.to_point(&multi_buffer_snapshot),
                Point::new(1, 7)
            );

            // Verify all highlight ranges are valid byte boundaries in the text
            for (range, _style) in &symbol.highlight_ranges {
                assert!(
                    symbol.text.is_char_boundary(range.start),
                    "highlight range start {} is not a char boundary in {:?}",
                    range.start,
                    symbol.text
                );
                assert!(
                    symbol.text.is_char_boundary(range.end),
                    "highlight range end {} is not a char boundary in {:?}",
                    range.end,
                    symbol.text
                );
                assert!(
                    range.end <= symbol.text.len(),
                    "highlight range end {} exceeds text length {} for {:?}",
                    range.end,
                    symbol.text.len(),
                    symbol.text
                );
            }
        });
    }

    #[gpui::test]
    async fn test_lsp_document_symbols_fall_back_to_reparsed_text_highlights(
        cx: &mut TestAppContext,
    ) {
        use ui::ActiveTheme as _;

        init_test(cx, |_| {});

        update_test_language_settings(cx, &|settings| {
            settings.defaults.document_symbols = Some(DocumentSymbols::On);
        });

        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                document_symbol_provider: Some(lsp::OneOf::Left(true)),
                ..lsp::ServerCapabilities::default()
            },
            cx,
        )
        .await;
        cx.update_editor(|editor, _window, cx| {
            editor
                .project
                .as_ref()
                .expect("editor should have a project")
                .read(cx)
                .languages()
                .set_theme(cx.theme().clone());
        });
        let mut symbol_request = cx
            .set_request_handler::<lsp::request::DocumentSymbolRequest, _, _>(
                move |_, _, _| async move {
                    Ok(Some(lsp::DocumentSymbolResponse::Nested(vec![
                        nested_symbol(
                            "impl ZzzMissing",
                            lsp::SymbolKind::OBJECT,
                            lsp_range(0, 0, 0, 12),
                            lsp_range(0, 3, 0, 7),
                            Vec::new(),
                        ),
                    ])))
                },
            );

        cx.set_state("fn teˇst() {}\n");
        assert!(symbol_request.next().await.is_some());
        cx.run_until_parked();

        cx.update_editor(|editor, _window, cx| {
            let (_, symbols) = editor
                .outline_symbols_at_cursor
                .as_ref()
                .expect("Should have outline symbols");
            assert_eq!(symbols.len(), 1);
            let symbol = &symbols[0];
            assert_eq!(symbol.text, "impl ZzzMissing");

            let language = editor
                .buffer
                .read(cx)
                .as_singleton()
                .expect("singleton buffer")
                .read(cx)
                .language()
                .cloned()
                .expect("buffer language");
            let expected = highlight_ranges_from_text(&symbol.text, &language, cx.theme().syntax());
            assert_eq!(
                expected.first().map(|(range, _)| range.clone()),
                Some(0..4),
                "reparsing the symbol text should highlight the `impl` keyword"
            );
            assert_eq!(symbol.highlight_ranges, expected);
        });
    }

    #[gpui::test]
    async fn test_lsp_document_symbols_empty_response(cx: &mut TestAppContext) {
        init_test(cx, |_| {});

        update_test_language_settings(cx, &|settings| {
            settings.defaults.document_symbols = Some(DocumentSymbols::On);
        });

        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                document_symbol_provider: Some(lsp::OneOf::Left(true)),
                ..lsp::ServerCapabilities::default()
            },
            cx,
        )
        .await;
        let mut symbol_request = cx
            .set_request_handler::<lsp::request::DocumentSymbolRequest, _, _>(
                move |_, _, _| async move {
                    Ok(Some(lsp::DocumentSymbolResponse::Nested(Vec::new())))
                },
            );

        cx.set_state("fn maˇin() {\n    let x = 1;\n}\n");
        assert!(symbol_request.next().await.is_some());
        cx.run_until_parked();
        cx.update_editor(|editor, _window, _cx| {
            // With LSP enabled but empty response, outline_symbols_at_cursor should be None
            // (no symbols to show in breadcrumbs)
            assert!(
                editor.outline_symbols_at_cursor.is_none(),
                "Empty LSP response should result in no outline symbols"
            );
        });
    }

    #[gpui::test]
    async fn test_lsp_document_symbols_disabled_by_default(cx: &mut TestAppContext) {
        init_test(cx, |_| {});

        let request_count = Arc::new(atomic::AtomicUsize::new(0));
        // Do NOT enable document_symbols — defaults to Off
        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                document_symbol_provider: Some(lsp::OneOf::Left(true)),
                ..lsp::ServerCapabilities::default()
            },
            cx,
        )
        .await;
        let request_count_clone = request_count.clone();
        let _symbol_request =
            cx.set_request_handler::<lsp::request::DocumentSymbolRequest, _, _>(move |_, _, _| {
                request_count_clone.fetch_add(1, atomic::Ordering::AcqRel);
                async move {
                    Ok(Some(lsp::DocumentSymbolResponse::Nested(vec![
                        nested_symbol(
                            "should_not_appear",
                            lsp::SymbolKind::FUNCTION,
                            lsp_range(0, 0, 2, 1),
                            lsp_range(0, 3, 0, 7),
                            Vec::new(),
                        ),
                    ])))
                }
            });

        cx.set_state("fn maˇin() {\n    let x = 1;\n}\n");
        cx.run_until_parked();

        // Tree-sitter should be used instead
        cx.update_editor(|editor, _window, _cx| {
            assert_eq!(
                outline_symbol_names(editor),
                vec!["fn main"],
                "With document_symbols off, should use tree-sitter"
            );
        });

        assert_eq!(
            request_count.load(atomic::Ordering::Acquire),
            0,
            "Should not have made any LSP document symbol requests when setting is off"
        );
    }

    #[gpui::test]
    async fn test_breadcrumb_highlights_update_on_theme_change(cx: &mut TestAppContext) {
        use collections::IndexMap;
        use gpui::{Hsla, Rgba, UpdateGlobal as _};
        use theme_settings::{HighlightStyleContent, ThemeStyleContent};
        use ui::ActiveTheme as _;

        init_test(cx, |_| {});

        let mut cx = EditorLspTestContext::new_rust(lsp::ServerCapabilities::default(), cx).await;

        // Set the initial theme with a red keyword color and sync it to the
        // language registry so tree-sitter highlight maps are up to date.
        let red_color: Hsla = Rgba {
            r: 1.0,
            g: 0.0,
            b: 0.0,
            a: 1.0,
        }
        .into();
        cx.update(|_, cx| {
            SettingsStore::update_global(cx, |store, cx| {
                store.update_user_settings(cx, |settings| {
                    settings.theme.experimental_theme_overrides = Some(ThemeStyleContent {
                        syntax: IndexMap::from_iter([(
                            "keyword".to_string(),
                            HighlightStyleContent {
                                color: Some("#ff0000".into()),
                                background_color: None,
                                font_style: None,
                                font_weight: None,
                            },
                        )]),
                        ..ThemeStyleContent::default()
                    });
                });
            });
        });
        cx.update_editor(|editor, _window, cx| {
            editor
                .project
                .as_ref()
                .expect("editor should have a project")
                .read(cx)
                .languages()
                .set_theme(cx.theme().clone());
        });
        cx.set_state("fn maˇin() {}");
        cx.run_until_parked();

        cx.update_editor(|editor, _window, cx| {
            let breadcrumbs = editor
                .breadcrumbs_inner(cx)
                .expect("Should have breadcrumbs");
            let symbol_segment = breadcrumbs
                .iter()
                .find(|b| b.text.as_ref() == "fn main")
                .expect("Should have 'fn main' breadcrumb");
            let keyword_highlight = symbol_segment
                .highlights
                .iter()
                .find(|(range, _)| &symbol_segment.text[range.clone()] == "fn")
                .expect("Should have a highlight for the 'fn' keyword");
            assert_eq!(
                keyword_highlight.1.color,
                Some(red_color),
                "The 'fn' keyword should have red color"
            );
        });

        // Change the theme to use a blue keyword color. This simulates a user
        // switching themes. The language registry set_theme call mirrors what
        // the application does in main.rs on theme change.
        let blue_color: Hsla = Rgba {
            r: 0.0,
            g: 0.0,
            b: 1.0,
            a: 1.0,
        }
        .into();
        cx.update(|_, cx| {
            SettingsStore::update_global(cx, |store, cx| {
                store.update_user_settings(cx, |settings| {
                    settings.theme.experimental_theme_overrides = Some(ThemeStyleContent {
                        syntax: IndexMap::from_iter([(
                            "keyword".to_string(),
                            HighlightStyleContent {
                                color: Some("#0000ff".into()),
                                background_color: None,
                                font_style: None,
                                font_weight: None,
                            },
                        )]),
                        ..ThemeStyleContent::default()
                    });
                });
            });
        });
        cx.update_editor(|editor, _window, cx| {
            editor
                .project
                .as_ref()
                .expect("editor should have a project")
                .read(cx)
                .languages()
                .set_theme(cx.theme().clone());
        });
        cx.run_until_parked();

        cx.update_editor(|editor, _window, cx| {
            let breadcrumbs = editor
                .breadcrumbs_inner(cx)
                .expect("Should have breadcrumbs after theme change");
            let symbol_segment = breadcrumbs
                .iter()
                .find(|b| b.text.as_ref() == "fn main")
                .expect("Should have 'fn main' breadcrumb after theme change");
            let keyword_highlight = symbol_segment
                .highlights
                .iter()
                .find(|(range, _)| &symbol_segment.text[range.clone()] == "fn")
                .expect("Should have a highlight for the 'fn' keyword after theme change");
            assert_eq!(
                keyword_highlight.1.color,
                Some(blue_color),
                "The 'fn' keyword should have blue color after theme change"
            );
        });
    }

    #[gpui::test]
    async fn test_breadcrumbs_keep_file_name_without_lsp_symbols(cx: &mut TestAppContext) {
        init_test(cx, |_| {});

        update_test_language_settings(cx, &|settings| {
            settings.defaults.document_symbols = Some(DocumentSymbols::On);
        });

        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                document_symbol_provider: Some(lsp::OneOf::Left(true)),
                ..lsp::ServerCapabilities::default()
            },
            cx,
        )
        .await;
        let mut symbol_request = cx
            .set_request_handler::<lsp::request::DocumentSymbolRequest, _, _>(
                move |_, _, _| async move {
                    Ok(Some(lsp::DocumentSymbolResponse::Nested(Vec::new())))
                },
            );

        cx.set_state("fn maˇin() {\n    let x = 1;\n}\n");
        assert!(symbol_request.next().await.is_some());
        cx.run_until_parked();

        cx.update_editor(|editor, _window, cx| {
            assert_eq!(
                breadcrumb_texts(editor, cx),
                vec![path!("dir/file.rs").to_string()],
                "Breadcrumbs should fall back to the file name when the language server returns no symbols"
            );

            editor.set_breadcrumb_header("Last 1000 lines in the log".to_string());
            assert_eq!(
                breadcrumb_texts(editor, cx),
                vec!["Last 1000 lines in the log".to_string()],
                "A custom breadcrumb header should never disappear"
            );
        });
    }

    #[gpui::test]
    async fn test_breadcrumbs_refresh_on_document_symbols_setting_change(cx: &mut TestAppContext) {
        init_test(cx, |_| {});

        let mut cx = EditorLspTestContext::new_rust(
            lsp::ServerCapabilities {
                document_symbol_provider: Some(lsp::OneOf::Left(true)),
                ..lsp::ServerCapabilities::default()
            },
            cx,
        )
        .await;
        let mut symbol_request = cx
            .set_request_handler::<lsp::request::DocumentSymbolRequest, _, _>(
                move |_, _, _| async move {
                    Ok(Some(lsp::DocumentSymbolResponse::Nested(Vec::new())))
                },
            );

        cx.set_state("fn maˇin() {\n    let x = 1;\n}\n");
        cx.run_until_parked();

        cx.update_editor(|editor, _window, cx| {
            assert_eq!(
                breadcrumb_texts(editor, cx),
                vec![path!("dir/file.rs").to_string(), "fn main".to_string()],
                "With tree-sitter symbols, breadcrumbs should show the file name and the symbol"
            );
        });

        let breadcrumb_updates = Arc::new(atomic::AtomicUsize::new(0));
        let editor = cx.editor.clone();
        let _subscription = cx.update(|_, cx| {
            cx.subscribe(&editor, {
                let breadcrumb_updates = breadcrumb_updates.clone();
                move |_, event, _| {
                    Editor::to_item_events(event, &mut |item_event| {
                        if item_event == ItemEvent::UpdateBreadcrumbs {
                            breadcrumb_updates.fetch_add(1, atomic::Ordering::AcqRel);
                        }
                    });
                }
            })
        });

        update_test_language_settings(&mut cx.cx.cx, &|settings| {
            settings.defaults.document_symbols = Some(DocumentSymbols::On);
        });
        assert!(symbol_request.next().await.is_some());
        cx.run_until_parked();

        cx.update_editor(|editor, _window, cx| {
            assert_eq!(
                breadcrumb_texts(editor, cx),
                vec![path!("dir/file.rs").to_string()],
                "After enabling LSP symbols that return nothing, breadcrumbs should keep the file name"
            );
        });
        assert!(
            breadcrumb_updates.load(atomic::Ordering::Acquire) > 0,
            "Breadcrumbs should refresh on the setting change, without extra selection changes"
        );

        breadcrumb_updates.store(0, atomic::Ordering::Release);
        update_test_language_settings(&mut cx.cx.cx, &|settings| {
            settings.defaults.document_symbols = Some(DocumentSymbols::Off);
        });
        cx.run_until_parked();

        cx.update_editor(|editor, _window, cx| {
            assert_eq!(
                breadcrumb_texts(editor, cx),
                vec![path!("dir/file.rs").to_string(), "fn main".to_string()],
                "After disabling LSP symbols, tree-sitter breadcrumbs should return"
            );
        });
        assert!(
            breadcrumb_updates.load(atomic::Ordering::Acquire) > 0,
            "Breadcrumbs should refresh on the setting change, without extra selection changes"
        );
    }
}