Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
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"
);
}
}