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.

Avoid allocations related to markdown parsing (#65409)

Kirill Bulatov7fa2adbe088c
diff --git a/crates/agent_ui/src/conversation_view.rs b/crates/agent_ui/src/conversation_view.rs
index d881dd2f24e..4256fad77f2 100644
--- a/crates/agent_ui/src/conversation_view.rs
+++ b/crates/agent_ui/src/conversation_view.rs
@@ -34,7 +34,7 @@ use gpui::{
TextStyle, WeakEntity, Window, WindowHandle, div, ease_in_out, img, linear_color_stop,
linear_gradient, list, pulsating_between,
};
-use language::{Buffer, Language, Rope};
+use language::{Buffer, Language};
use language_model::{
LanguageModelCompletionError, ProviderErrorCategory, ZED_CLOUD_PROVIDER_NAME,
};
diff --git a/crates/agent_ui/src/conversation_view/thread_view.rs b/crates/agent_ui/src/conversation_view/thread_view.rs
index 6d032ce8876..75dd0ef22e1 100644
--- a/crates/agent_ui/src/conversation_view/thread_view.rs
+++ b/crates/agent_ui/src/conversation_view/thread_view.rs
@@ -455,7 +455,7 @@ fn highlight_code_runs(
let mut runs = Vec::new();
let mut offset = 0;
- for (range, highlight_id) in language.highlight_text(&Rope::from(code), 0..code.len()) {
+ for (range, highlight_id) in language.highlight_text(code, 0..code.len()) {
if range.start > offset {
runs.push(code_text_style.to_run(range.start - offset));
}
diff --git a/crates/benchmarks/benches/editor_render.rs b/crates/benchmarks/benches/editor_render.rs
index e4f7492f8d5..22852c24098 100644
--- a/crates/benchmarks/benches/editor_render.rs
+++ b/crates/benchmarks/benches/editor_render.rs
@@ -390,9 +390,10 @@ fn render_highlighted_editor(cx: &mut BenchAppContext) {
});
let probe = "fn main() {}";
assert!(
- !language
+ language
.highlight_text(&Rope::from(probe), 0..probe.len())
- .is_empty(),
+ .next()
+ .is_some(),
"the benchmark language must resolve syntax highlights against the theme"
);
let buffer = cx.update(|cx| {
diff --git a/crates/call_hierarchy/src/call_hierarchy.rs b/crates/call_hierarchy/src/call_hierarchy.rs
index 377c7a0d76e..f635acc9e42 100644
--- a/crates/call_hierarchy/src/call_hierarchy.rs
+++ b/crates/call_hierarchy/src/call_hierarchy.rs
@@ -1023,7 +1023,9 @@ fn signature_label(item: &CallHierarchyItem, language: &Arc<Language>) -> Option
let name_start = find_symbol_name(&signature, &item.name)?;
let filter_range = name_start..name_start + item.name.len();
let source = Rope::from_iter([signature.as_str(), " {}"]);
- let runs = language.highlight_text(&source, 0..signature.len());
+ let runs = language
+ .highlight_text(&source, 0..signature.len())
+ .collect();
Some(CodeLabel::new(signature, filter_range, runs))
}
diff --git a/crates/editor/src/inline_input.rs b/crates/editor/src/inline_input.rs
index 5cce637c250..6d73219017d 100644
--- a/crates/editor/src/inline_input.rs
+++ b/crates/editor/src/inline_input.rs
@@ -66,7 +66,7 @@ impl InlineInputPreview {
struct RenderedPreview {
text: SharedString,
- highlights: Vec<(Range<usize>, HighlightId)>,
+ highlights: Arc<[(Range<usize>, HighlightId)]>,
height_in_lines: u32,
is_error: bool,
}
@@ -80,9 +80,11 @@ impl RenderedPreview {
let (text, height_in_lines) = preview.display_text(max_lines);
let highlights = match (preview, language) {
(InlineInputPreview::Text(_), Some(language)) => {
- language.highlight_text(&Rope::from(text.as_str()), 0..text.len())
+ language
+ .highlight_text_resolved(text.as_str(), 0..text.len())
+ .runs
}
- _ => Vec::new(),
+ _ => Arc::default(),
};
Self {
text: SharedString::from(text),
diff --git a/crates/editor/src/signature_help.rs b/crates/editor/src/signature_help.rs
index 99d2ed710b6..4ba6cac4f52 100644
--- a/crates/editor/src/signature_help.rs
+++ b/crates/editor/src/signature_help.rs
@@ -12,7 +12,6 @@ use multi_buffer::{Anchor, MultiBufferOffset, ToOffset};
use settings::Settings;
use std::ops::Range;
use std::time::Duration;
-use text::Rope;
use theme_settings::ThemeSettings;
use ui::{
ActiveTheme, AnyElement, ButtonCommon, ButtonStyle, Clickable, FluentBuilder, IconButton,
@@ -232,10 +231,11 @@ impl Editor {
if let Some(language) = language {
for signature in &mut signature_help.signatures {
- let text = Rope::from(signature.label.as_ref());
let highlights = language
- .highlight_text(&text, 0..signature.label.len())
- .into_iter()
+ .highlight_text(
+ signature.label.as_str(),
+ 0..signature.label.len(),
+ )
.flat_map(|(range, highlight_id)| {
Some((range, *cx.theme().syntax().get(highlight_id)?))
});
diff --git a/crates/keymap_editor/src/keymap_editor.rs b/crates/keymap_editor/src/keymap_editor.rs
index cf3f4e7ab08..c081fcbd198 100644
--- a/crates/keymap_editor/src/keymap_editor.rs
+++ b/crates/keymap_editor/src/keymap_editor.rs
@@ -2425,13 +2425,12 @@ impl RenderOnce for SyntaxHighlightedText {
let text = self.text.clone();
- let highlights = self
- .language
- .highlight_text(&text.as_ref().into(), 0..text.len());
- let mut runs = Vec::with_capacity(highlights.len());
+ let mut runs = Vec::new();
let mut offset = 0;
- for (highlight_range, highlight_id) in highlights {
+ for (highlight_range, highlight_id) in
+ self.language.highlight_text(text.as_str(), 0..text.len())
+ {
// Add un-highlighted text before the current highlight
if highlight_range.start > offset {
runs.push(text_style.to_run(highlight_range.start - offset));
diff --git a/crates/language/src/language.rs b/crates/language/src/language.rs
index 496f71efe35..50068ea6f4e 100644
--- a/crates/language/src/language.rs
+++ b/crates/language/src/language.rs
@@ -49,6 +49,7 @@ pub use language_core::{
use futures::future::FutureExt as _;
use language_core::highlight_cache::{MAX_TEXT_HIGHLIGHT_ENTRY_BYTES, TextHighlightKey};
+use language_core::highlight_map::HighlightCaptureRef;
pub use language_core::{
BlockCommentConfig, BracketPair, BracketPairConfig, BracketPairContent, BracketsConfig,
BracketsPatternConfig, CodeLabel, CodeLabelBuilder, DebugVariablesConfig, DebuggerTextObject,
@@ -78,13 +79,14 @@ use std::{
ffi::OsStr,
fmt::Debug,
hash::Hash,
- mem,
+ iter, mem,
ops::{DerefMut, Range},
path::{Path, PathBuf},
str,
sync::{Arc, LazyLock},
};
-use syntax_map::{QueryCursorHandle, SyntaxSnapshot, flattened_highlight_regions};
+use streaming_iterator::StreamingIterator as _;
+use syntax_map::{QueryCursorHandle, TextProvider, flatten_capture_regions};
use task::RunnableTag;
pub use task_context::{ContextLocation, ContextProvider};
pub use text_diff::{
@@ -1130,17 +1132,18 @@ impl Language {
self.toolchain.clone()
}
- pub fn highlight_text<'a>(
- self: &'a Arc<Self>,
- text: &'a Rope,
+ pub fn highlight_text<Source: HighlightSource + ?Sized>(
+ self: &Arc<Self>,
+ text: &Source,
range: Range<usize>,
- ) -> Vec<(Range<usize>, HighlightId)> {
- self.highlight_text_resolved(text, range).runs.to_vec()
+ ) -> impl Iterator<Item = (Range<usize>, HighlightId)> + 'static + use<Source> {
+ self.highlight_text_resolved(text, 0..text.source_len())
+ .runs_in_range(range)
}
pub fn highlight_text_resolved(
self: &Arc<Self>,
- text: &Rope,
+ text: &(impl HighlightSource + ?Sized),
range: Range<usize>,
) -> ResolvedHighlights {
let Some(grammar) = &self.grammar else {
@@ -1149,58 +1152,62 @@ impl Language {
let Some(highlights_config) = &grammar.highlights_config else {
return ResolvedHighlights::default();
};
- let highlights = if text.len() > MAX_TEXT_HIGHLIGHT_ENTRY_BYTES {
- self.compute_resolved_highlights(grammar, text)
+ let text_len = text.source_len();
+ let highlights = if text_len > MAX_TEXT_HIGHLIGHT_ENTRY_BYTES {
+ Self::compute_resolved_highlights(grammar, &highlights_config.query, text)
} else {
- let key = TextHighlightKey::new(text.chunks(), text.len());
+ let key = TextHighlightKey::new(text.source_chunks(), text_len);
match highlights_config
.text_highlight_cache
- .get(&key, text.chunks())
+ .get(&key, text.source_chunks())
{
Some(highlights) => highlights,
- None => highlights_config.text_highlight_cache.insert(
- key,
- Arc::from(text.chunks().collect::<String>()),
- self.compute_resolved_highlights(grammar, text),
- ),
+ None => {
+ let mut cached_text = String::with_capacity(text_len);
+ cached_text.extend(text.source_chunks());
+ highlights_config.text_highlight_cache.insert(
+ key,
+ cached_text,
+ Self::compute_resolved_highlights(grammar, &highlights_config.query, text),
+ )
+ }
}
};
- if range.start == 0 && range.end >= text.len() {
+ if range.start == 0 && range.end >= text_len {
return highlights;
}
ResolvedHighlights {
sources: highlights.sources.clone(),
- runs: highlights
- .runs
- .iter()
- .filter(|(run_range, _)| run_range.start < range.end && run_range.end > range.start)
- .map(|(run_range, highlight_id)| {
- (
- run_range.start.max(range.start) - range.start
- ..run_range.end.min(range.end) - range.start,
- *highlight_id,
- )
- })
- .collect(),
+ runs: highlights.runs_in_range(range).collect(),
}
}
fn compute_resolved_highlights(
- self: &Arc<Self>,
grammar: &Arc<Grammar>,
- text: &Rope,
+ query: &tree_sitter::Query,
+ text: &(impl HighlightSource + ?Sized),
) -> ResolvedHighlights {
let highlight_map = grammar.highlight_map();
- let tree = parse_text(grammar, text, None);
- let captures =
- SyntaxSnapshot::single_tree_captures(0..text.len(), text, &tree, self, |grammar| {
- grammar
- .highlights_config
- .as_ref()
- .map(|config| &config.query)
+ let text_len = text.source_len();
+ let tree = text.parse(grammar);
+ let regions = with_query_cursor(|cursor| {
+ cursor.set_byte_range(0..text_len);
+ let mut captures = cursor.captures(query, tree.root_node(), text.text_provider());
+ let capture_refs = iter::from_fn(move || {
+ let (query_match, capture_index) = captures.next()?;
+ let capture = query_match.captures[*capture_index];
+ Some((
+ capture.node.byte_range(),
+ HighlightCaptureRef {
+ grammar_index: 0,
+ capture_id: CaptureId(capture.index),
+ },
+ ))
});
+ flatten_capture_regions(0..text_len, capture_refs)
+ });
let mut runs = Vec::<(Range<usize>, HighlightId)>::new();
- for region in flattened_highlight_regions(captures, 0..text.len()) {
+ for region in regions {
let highlight_id = region
.stack
.iter()
@@ -1460,6 +1467,54 @@ impl Debug for Language {
}
}
+pub trait HighlightSource {
+ fn source_len(&self) -> usize;
+ fn source_chunks(&self) -> impl Iterator<Item = &str>;
+ fn parse(&self, grammar: &Grammar) -> Tree;
+ fn text_provider<'a>(&'a self) -> impl tree_sitter::TextProvider<&'a [u8]> + 'a;
+}
+
+impl HighlightSource for str {
+ fn source_len(&self) -> usize {
+ self.len()
+ }
+
+ fn source_chunks(&self) -> impl Iterator<Item = &str> {
+ iter::once(self)
+ }
+
+ fn parse(&self, grammar: &Grammar) -> Tree {
+ with_parser(|parser| {
+ parser
+ .set_language(&grammar.ts_language)
+ .expect("incompatible grammar");
+ parser.parse(self, None).unwrap()
+ })
+ }
+
+ fn text_provider<'a>(&'a self) -> impl tree_sitter::TextProvider<&'a [u8]> + 'a {
+ self.as_bytes()
+ }
+}
+
+impl HighlightSource for Rope {
+ fn source_len(&self) -> usize {
+ self.len()
+ }
+
+ fn source_chunks(&self) -> impl Iterator<Item = &str> {
+ self.chunks()
+ }
+
+ fn parse(&self, grammar: &Grammar) -> Tree {
+ parse_text(grammar, self, None)
+ }
+
+ fn text_provider<'a>(&'a self) -> impl tree_sitter::TextProvider<&'a [u8]> + 'a {
+ TextProvider(self)
+ }
+}
+
pub(crate) fn parse_text(grammar: &Grammar, text: &Rope, old_tree: Option<Tree>) -> Tree {
with_parser(|parser| {
parser
@@ -1838,6 +1893,11 @@ mod tests {
Arc::ptr_eq(&highlights.runs, &memoized.runs),
"repeated highlighting of the same text must be memoized"
);
+ let memoized_str = language.highlight_text_resolved(code, 0..code.len());
+ assert!(
+ Arc::ptr_eq(&highlights.runs, &memoized_str.runs),
+ "str and rope sources of the same text must share memoized highlights"
+ );
let partial = language.highlight_text_resolved(&Rope::from(code), 0..2);
assert!(
!Arc::ptr_eq(&highlights.runs, &partial.runs),
@@ -1845,6 +1905,8 @@ mod tests {
);
assert_eq!(partial.runs.as_ref(), &[(0..2, highlights.runs[0].1)]);
+ let runs = language.highlight_text(String::from(code).as_str(), 1..5);
+
let richer_theme = SyntaxTheme::new(
[
("function", rgba(0x100000ff)),
@@ -1855,6 +1917,13 @@ mod tests {
.map(|(name, color)| (name.to_string(), (*color).into())),
);
language.set_theme(&richer_theme);
+ assert_eq!(
+ runs.map(|(range, highlight_id)| {
+ (range, theme.get_capture_name(highlight_id).unwrap())
+ })
+ .collect::<Vec<_>>(),
+ vec![(0..1, "keyword"), (1..4, "function")]
+ );
assert!(
!highlights.is_current(),
"a theme change must invalidate previously resolved highlights"
@@ -1916,6 +1985,14 @@ mod tests {
small_highlights.runs.as_ref(),
"texts over the cache entry cap must still be highlighted"
);
+ assert_eq!(
+ language
+ .highlight_text_resolved(oversized_code.as_str(), 0..oversized_code.len())
+ .runs
+ .as_ref(),
+ first_highlights.runs.as_ref(),
+ "str and rope sources must be highlighted identically"
+ );
let second_highlights =
language.highlight_text_resolved(&oversized_rope, 0..oversized_code.len());
assert_eq!(
diff --git a/crates/language/src/outline.rs b/crates/language/src/outline.rs
index e3e9ec51018..536fd3b91c5 100644
--- a/crates/language/src/outline.rs
+++ b/crates/language/src/outline.rs
@@ -2,7 +2,6 @@ use crate::{BufferSnapshot, Language, Point, ToPoint, ToTreeSitterPoint};
use fuzzy_nucleo::{Case, LengthPenalty, StringMatch, StringMatchCandidate};
use gpui::{BackgroundExecutor, HighlightStyle, SharedString};
use std::{ops::Range, sync::Arc};
-use text::Rope;
use theme::SyntaxTheme;
/// An outline of all the symbols contained in a buffer.
@@ -269,9 +268,10 @@ pub fn highlight_ranges_from_text(
language: &Arc<Language>,
syntax_theme: &SyntaxTheme,
) -> Vec<(Range<usize>, HighlightStyle)> {
- let rope = Rope::from(text);
- let runs = language.highlight_text(&rope, 0..text.len());
- syntax_theme.resolve_runs(&runs).collect()
+ language
+ .highlight_text(text, 0..text.len())
+ .filter_map(|(range, highlight_id)| Some((range, *syntax_theme.get(highlight_id)?)))
+ .collect()
}
/// Interleaves synthetic [`OutlineSearchEntry::Ancestor`] rows before each match so callers
diff --git a/crates/language/src/syntax_map.rs b/crates/language/src/syntax_map.rs
index 0e151f74f3e..a254010fb4d 100644
--- a/crates/language/src/syntax_map.rs
+++ b/crates/language/src/syntax_map.rs
@@ -115,7 +115,7 @@ pub(crate) fn flattened_highlight_regions(
flatten_capture_regions(range, capture_refs)
}
-fn flatten_capture_regions(
+pub(crate) fn flatten_capture_regions(
range: Range<usize>,
mut captures: impl Iterator<Item = (Range<usize>, HighlightCaptureRef)>,
) -> Vec<HighlightCaptureRegion> {
@@ -347,7 +347,7 @@ struct ChangedRegion {
#[derive(Default)]
struct ChangeRegionSet(Vec<ChangedRegion>);
-struct TextProvider<'a>(&'a Rope);
+pub(crate) struct TextProvider<'a>(pub(crate) &'a Rope);
pub(crate) struct QueryCursorHandle(Option<QueryCursor>);
@@ -1044,28 +1044,6 @@ impl SyntaxSnapshot {
}
}
- pub fn single_tree_captures<'a>(
- range: Range<usize>,
- text: &'a Rope,
- tree: &'a tree_sitter::Tree,
- language: &'a Arc<Language>,
- query: fn(&Grammar) -> Option<&Query>,
- ) -> SyntaxMapCaptures<'a> {
- SyntaxMapCaptures::new(
- range,
- text,
- [SyntaxLayer {
- language,
- tree,
- included_sub_ranges: None,
- depth: 0,
- offset: (0, tree_sitter::Point::new(0, 0)),
- }]
- .into_iter(),
- query,
- )
- }
-
pub fn captures<'a>(
&'a self,
range: Range<usize>,
diff --git a/crates/language_core/src/highlight_cache.rs b/crates/language_core/src/highlight_cache.rs
index 86741ec4d43..07cc1fd99a5 100644
--- a/crates/language_core/src/highlight_cache.rs
+++ b/crates/language_core/src/highlight_cache.rs
@@ -43,6 +43,23 @@ pub struct ResolvedHighlights {
}
impl ResolvedHighlights {
+ pub fn runs_in_range(
+ self,
+ range: Range<usize>,
+ ) -> impl Iterator<Item = (Range<usize>, HighlightId)> {
+ let runs = self.runs;
+ (0..runs.len()).filter_map(move |index| {
+ let (run_range, highlight_id) = &runs[index];
+ (run_range.start < range.end && run_range.end > range.start).then(|| {
+ (
+ run_range.start.max(range.start) - range.start
+ ..run_range.end.min(range.end) - range.start,
+ *highlight_id,
+ )
+ })
+ })
+ }
+
pub fn is_current(&self) -> bool {
self.sources
.iter()
@@ -94,7 +111,7 @@ impl TextHighlightCache {
pub fn insert(
&self,
key: TextHighlightKey,
- text: Arc<str>,
+ text: String,
highlights: ResolvedHighlights,
) -> ResolvedHighlights {
let cost = text.len() + highlights.cost_bytes();
@@ -196,7 +213,7 @@ impl<K: Hash + Eq, V> CostBudgetedLru<K, V> {
}
struct TextHighlightEntry {
- text: Arc<str>,
+ text: String,
highlights: ResolvedHighlights,
}
@@ -215,6 +232,54 @@ fn chunks_match_text<'a>(text: &str, text_chunks: impl Iterator<Item = &'a str>)
mod tests {
use super::*;
+ #[test]
+ fn test_runs_in_range() {
+ let first = HighlightId::new(0);
+ let second = HighlightId::new(1);
+ let runs = Arc::from([(2..5, first), (7..11, second)]);
+ for (range, expected) in [
+ (0..usize::MAX, vec![(2..5, first), (7..11, second)]),
+ (1..9, vec![(1..4, first), (6..8, second)]),
+ (3..8, vec![(0..2, first), (4..5, second)]),
+ (5..7, Vec::new()),
+ (0..0, Vec::new()),
+ (6..6, Vec::new()),
+ (11..usize::MAX, Vec::new()),
+ (usize::MAX..usize::MAX, Vec::new()),
+ ] {
+ let highlights = ResolvedHighlights {
+ runs: Arc::clone(&runs),
+ ..ResolvedHighlights::default()
+ };
+ assert_eq!(
+ highlights.runs_in_range(range.clone()).collect::<Vec<_>>(),
+ expected,
+ "{range:?}"
+ );
+ }
+ assert_eq!(
+ ResolvedHighlights::default()
+ .runs_in_range(0..usize::MAX)
+ .next(),
+ None
+ );
+
+ let weak_runs = Arc::downgrade(&runs);
+ let highlights = ResolvedHighlights {
+ runs: Arc::clone(&runs),
+ ..ResolvedHighlights::default()
+ };
+ let mut iterator = highlights.runs_in_range(3..9);
+ assert_eq!(Arc::strong_count(&runs), 2);
+ drop(runs);
+ assert_eq!(iterator.next(), Some((0..2, first)));
+ assert_eq!(iterator.next(), Some((4..6, second)));
+ assert_eq!(iterator.next(), None);
+ assert_eq!(iterator.next(), None);
+ drop(iterator);
+ assert!(weak_runs.upgrade().is_none());
+ }
+
#[test]
fn test_budget_evicts_least_recently_used() {
let overhead = CostBudgetedLru::<&str, u32>::ENTRY_OVERHEAD_BYTES;
@@ -285,7 +350,7 @@ mod tests {
#[test]
fn test_oversized_highlights_are_returned_but_not_cached() {
- let text = Arc::<str>::from("fn main() {}");
+ let text = "fn main() {}";
let run_bytes = size_of::<(Range<usize>, HighlightId)>();
let max_entry_cost = text.len() + 2 * run_bytes;
let cache = TextHighlightCache(Mutex::new(CostBudgetedLru::new(
@@ -300,12 +365,12 @@ mod tests {
.collect(),
};
- let small_text = Arc::<str>::from("fn f() {}");
- let small_key = TextHighlightKey::new([small_text.as_ref()].into_iter(), small_text.len());
+ let small_text = "fn f() {}";
+ let small_key = TextHighlightKey::new([small_text].into_iter(), small_text.len());
let small_range = 0..2;
let small_highlights = cache.insert(
small_key.clone(),
- Arc::clone(&small_text),
+ small_text.to_owned(),
resolved(std::slice::from_ref(&small_range)),
);
assert_eq!(
@@ -314,17 +379,17 @@ mod tests {
);
assert_eq!(
cache
- .get(&small_key, [small_text.as_ref()].into_iter())
+ .get(&small_key, [small_text].into_iter())
.map(|highlights| highlights.runs),
Some(small_highlights.runs.clone()),
"highlights within the entry budget must be cached as-is"
);
- let big_key = TextHighlightKey::new([text.as_ref()].into_iter(), text.len());
+ let big_key = TextHighlightKey::new([text].into_iter(), text.len());
let big_highlights_source = resolved(&[0..2, 3..7, 8..9]);
let big_highlights = cache.insert(
big_key.clone(),
- Arc::clone(&text),
+ text.to_owned(),
big_highlights_source.clone(),
);
assert!(
@@ -332,7 +397,7 @@ mod tests {
"highlights over the entry budget must be returned unchanged"
);
assert!(
- cache.get(&big_key, [text.as_ref()].into_iter()).is_none(),
+ cache.get(&big_key, [text].into_iter()).is_none(),
"highlights over the entry budget must not be cached"
);
}
diff --git a/crates/language_extension/src/extension_lsp_adapter.rs b/crates/language_extension/src/extension_lsp_adapter.rs
index 18241a94235..2d6026938f8 100644
--- a/crates/language_extension/src/extension_lsp_adapter.rs
+++ b/crates/language_extension/src/extension_lsp_adapter.rs
@@ -511,9 +511,11 @@ fn labels_from_extension(
.map(|label| {
let label = label?;
let runs = if label.code.is_empty() {
- Vec::new()
+ Arc::default()
} else {
- language.highlight_text(&label.code.as_str().into(), 0..label.code.len())
+ language
+ .highlight_text_resolved(label.code.as_str(), 0..label.code.len())
+ .runs
};
build_code_label(&label, &runs, language)
})
diff --git a/crates/languages/src/c.rs b/crates/languages/src/c.rs
index ee2d214caf6..8ab9da4e98e 100644
--- a/crates/languages/src/c.rs
+++ b/crates/languages/src/c.rs
@@ -211,8 +211,10 @@ impl super::LspAdapter for CLspAdapter {
Some(lsp::CompletionItemKind::FIELD) if completion.detail.is_some() => {
let detail = completion.detail.as_ref().unwrap();
let text = format!("{} {}", detail, label);
- let source = Rope::from(format!("struct S {{ {} }}", text).as_str());
- let runs = language.highlight_text(&source, 11..11 + text.len());
+ let source = format!("struct S {{ {} }}", text);
+ let runs = language
+ .highlight_text(source.as_str(), 11..11 + text.len())
+ .collect();
let filter_range = completion
.filter_text
.as_deref()
@@ -228,7 +230,9 @@ impl super::LspAdapter for CLspAdapter {
{
let detail = completion.detail.as_ref().unwrap();
let text = format!("{} {}", detail, label);
- let runs = language.highlight_text(&Rope::from(text.as_str()), 0..text.len());
+ let runs = language
+ .highlight_text(text.as_str(), 0..text.len())
+ .collect();
let filter_range = completion
.filter_text
.as_deref()
@@ -244,7 +248,9 @@ impl super::LspAdapter for CLspAdapter {
{
let detail = completion.detail.as_ref().unwrap();
let text = format!("{} {}", detail, label);
- let runs = language.highlight_text(&Rope::from(text.as_str()), 0..text.len());
+ let runs = language
+ .highlight_text(text.as_str(), 0..text.len())
+ .collect();
let filter_range = completion
.filter_text
.as_deref()
@@ -348,7 +354,9 @@ impl super::LspAdapter for CLspAdapter {
Some(CodeLabel::new(
text[display_range.clone()].to_string(),
filter_range,
- language.highlight_text(&text.as_str().into(), display_range),
+ language
+ .highlight_text(text.as_str(), display_range)
+ .collect(),
))
}
diff --git a/crates/languages/src/go.rs b/crates/languages/src/go.rs
index 3357966da35..91f081f73b5 100644
--- a/crates/languages/src/go.rs
+++ b/crates/languages/src/go.rs
@@ -278,8 +278,10 @@ impl LspAdapter for GoLspAdapter {
match completion.kind.zip(completion.detail.as_ref()) {
Some((lsp::CompletionItemKind::MODULE, detail)) => {
let text = format!("{label} {detail}");
- let source = Rope::from(format!("import {text}").as_str());
- let runs = language.highlight_text(&source, 7..7 + text[name_offset..].len());
+ let source = format!("import {text}");
+ let runs = language
+ .highlight_text(source.as_str(), 7..7 + text[name_offset..].len())
+ .collect();
let filter_range = completion
.filter_text
.as_deref()
@@ -295,11 +297,10 @@ impl LspAdapter for GoLspAdapter {
detail,
)) => {
let text = format!("{label} {detail}");
- let source =
- Rope::from(format!("var {} {}", &text[name_offset..], detail).as_str());
+ let source = format!("var {} {}", &text[name_offset..], detail);
let runs = adjust_runs(
name_offset,
- language.highlight_text(&source, 4..4 + text[name_offset..].len()),
+ language.highlight_text(source.as_str(), 4..4 + text[name_offset..].len()),
);
let filter_range = completion
.filter_text
@@ -313,10 +314,10 @@ impl LspAdapter for GoLspAdapter {
}
Some((lsp::CompletionItemKind::STRUCT, _)) => {
let text = format!("{label} struct {{}}");
- let source = Rope::from(format!("type {}", &text[name_offset..]).as_str());
+ let source = format!("type {}", &text[name_offset..]);
let runs = adjust_runs(
name_offset,
- language.highlight_text(&source, 5..5 + text[name_offset..].len()),
+ language.highlight_text(source.as_str(), 5..5 + text[name_offset..].len()),
);
let filter_range = completion
.filter_text
@@ -330,10 +331,10 @@ impl LspAdapter for GoLspAdapter {
}
Some((lsp::CompletionItemKind::INTERFACE, _)) => {
let text = format!("{label} interface {{}}");
- let source = Rope::from(format!("type {}", &text[name_offset..]).as_str());
+ let source = format!("type {}", &text[name_offset..]);
let runs = adjust_runs(
name_offset,
- language.highlight_text(&source, 5..5 + text[name_offset..].len()),
+ language.highlight_text(source.as_str(), 5..5 + text[name_offset..].len()),
);
let filter_range = completion
.filter_text
@@ -347,11 +348,10 @@ impl LspAdapter for GoLspAdapter {
}
Some((lsp::CompletionItemKind::FIELD, detail)) => {
let text = format!("{label} {detail}");
- let source =
- Rope::from(format!("type T struct {{ {} }}", &text[name_offset..]).as_str());
+ let source = format!("type T struct {{ {} }}", &text[name_offset..]);
let runs = adjust_runs(
name_offset,
- language.highlight_text(&source, 16..16 + text[name_offset..].len()),
+ language.highlight_text(source.as_str(), 16..16 + text[name_offset..].len()),
);
let filter_range = completion
.filter_text
@@ -366,10 +366,10 @@ impl LspAdapter for GoLspAdapter {
Some((lsp::CompletionItemKind::FUNCTION | lsp::CompletionItemKind::METHOD, detail)) => {
if let Some(signature) = detail.strip_prefix("func") {
let text = format!("{label}{signature}");
- let source = Rope::from(format!("func {} {{}}", &text[name_offset..]).as_str());
+ let source = format!("func {} {{}}", &text[name_offset..]);
let runs = adjust_runs(
name_offset,
- language.highlight_text(&source, 5..5 + text[name_offset..].len()),
+ language.highlight_text(source.as_str(), 5..5 + text[name_offset..].len()),
);
let filter_range = completion
.filter_text
@@ -442,7 +442,9 @@ impl LspAdapter for GoLspAdapter {
Some(CodeLabel::new(
text[display_range.clone()].to_string(),
filter_range,
- language.highlight_text(&text.as_str().into(), display_range),
+ language
+ .highlight_text(text.as_str(), display_range)
+ .collect(),
))
}
@@ -575,13 +577,10 @@ async fn get_cached_server_binary(container_dir: &Path) -> Option<LanguageServer
fn adjust_runs(
delta: usize,
- mut runs: Vec<(Range<usize>, HighlightId)>,
+ runs: impl Iterator<Item = (Range<usize>, HighlightId)>,
) -> Vec<(Range<usize>, HighlightId)> {
- for (range, _) in &mut runs {
- range.start += delta;
- range.end += delta;
- }
- runs
+ runs.map(|(range, highlight_id)| (range.start + delta..range.end + delta, highlight_id))
+ .collect()
}
pub(crate) struct GoContextProvider;
diff --git a/crates/languages/src/python.rs b/crates/languages/src/python.rs
index 2dcce71a38e..dedcf1f32ef 100644
--- a/crates/languages/src/python.rs
+++ b/crates/languages/src/python.rs
@@ -243,7 +243,9 @@ fn label_for_python_symbol(
Some(language::CodeLabel::new(
text[display_range.clone()].to_string(),
filter_range,
- language.highlight_text(&text.as_str().into(), display_range),
+ language
+ .highlight_text(text.as_str(), display_range)
+ .collect(),
))
}
diff --git a/crates/languages/src/rust.rs b/crates/languages/src/rust.rs
index 2cfa0590762..320b464d848 100644
--- a/crates/languages/src/rust.rs
+++ b/crates/languages/src/rust.rs
@@ -381,8 +381,9 @@ impl LspAdapter for RustLspAdapter {
let text = format!("{name}: {signature}");
let prefix = "struct S { ";
let source = Rope::from_iter([prefix, &text, " }"]);
- let runs =
- language.highlight_text(&source, prefix.len()..prefix.len() + text.len());
+ let runs = language
+ .highlight_text(&source, prefix.len()..prefix.len() + text.len())
+ .collect();
mk_label(text, &|| 0..completion.label.len(), runs)
}
(
@@ -393,8 +394,9 @@ impl LspAdapter for RustLspAdapter {
let text = format!("{name}: {signature}",);
let prefix = "let ";
let source = Rope::from_iter([prefix, &text, " = ();"]);
- let runs =
- language.highlight_text(&source, prefix.len()..prefix.len() + text.len());
+ let runs = language
+ .highlight_text(&source, prefix.len()..prefix.len() + text.len())
+ .collect();
mk_label(text, &|| 0..completion.label.len(), runs)
}
(
@@ -430,8 +432,9 @@ impl LspAdapter for RustLspAdapter {
.filter(|it| it.contains(&label))
.and_then(|it| Some((it, FULL_SIGNATURE_REGEX.find(it)?)))
{
- let source = Rope::from(function_signature);
- let runs = language.highlight_text(&source, 0..function_signature.len());
+ let runs = language
+ .highlight_text(function_signature, 0..function_signature.len())
+ .collect();
mk_label(
function_signature.to_owned(),
&|| match_.range().start + 3..match_.range().end - 1,
@@ -441,13 +444,14 @@ impl LspAdapter for RustLspAdapter {
let text = format!("{label}{suffix}");
let source = Rope::from_iter([prefix, " ", &text, " {}"]);
let run_start = prefix.len() + 1;
- let runs = language.highlight_text(&source, run_start..run_start + text.len());
+ let runs = language
+ .highlight_text(&source, run_start..run_start + text.len())
+ .collect();
mk_label(text, &|| 0..label.len(), runs)
} else if detail_right.is_some_and(|detail| detail.starts_with("macro_rules! ")) {
let text = completion.label.clone();
let len = text.len();
- let source = Rope::from(text.as_str());
- let runs = language.highlight_text(&source, 0..len);
+ let runs = language.highlight_text(text.as_str(), 0..len).collect();
mk_label(text, &|| 0..completion.label.len(), runs)
} else if detail_left.is_none() {
return None;
@@ -544,7 +548,7 @@ impl LspAdapter for RustLspAdapter {
detail_left.take();
}
- runs.extend(language.highlight_text(&Rope::from(&label), 0..label.len()));
+ runs.extend(language.highlight_text(label.as_str(), 0..label.len()));
} else {
let highlight_name = kind.and_then(|kind| match kind {
lsp::CompletionItemKind::STRUCT
@@ -663,10 +667,12 @@ impl LspAdapter for RustLspAdapter {
return Some(CodeLabel::new(
name.to_string(),
0..name.len(),
- language.highlight_text(
- &Rope::from_iter([prefix, name, "}"]),
- prefix.len()..prefix.len() + name.len(),
- ),
+ language
+ .highlight_text(
+ &Rope::from_iter([prefix, name, "}"]),
+ prefix.len()..prefix.len() + name.len(),
+ )
+ .collect(),
));
}
_ => return None,
@@ -677,7 +683,9 @@ impl LspAdapter for RustLspAdapter {
Some(CodeLabel::new(
format!("{prefix}{name}"),
filter_range,
- language.highlight_text(&Rope::from_iter([prefix, name, suffix]), display_range),
+ language
+ .highlight_text(&Rope::from_iter([prefix, name, suffix]), display_range)
+ .collect(),
))
}
diff --git a/crates/languages/src/typescript.rs b/crates/languages/src/typescript.rs
index 7245671c337..38e2edb5b88 100644
--- a/crates/languages/src/typescript.rs
+++ b/crates/languages/src/typescript.rs
@@ -945,7 +945,9 @@ mod tests {
.expect("type.class highlight should be defined");
assert_eq!(
- language.highlight_text(&source, 0..source.len()),
+ language
+ .highlight_text(&source, 0..source.len())
+ .collect::<Vec<_>>(),
vec![(6..9, class_highlight), (29..32, class_highlight)],
"{} class instantiations should use the type.class highlight",
language.name()
diff --git a/crates/markdown/src/markdown.rs b/crates/markdown/src/markdown.rs
index 5a28ca7988a..10bd60d62cf 100644
--- a/crates/markdown/src/markdown.rs
+++ b/crates/markdown/src/markdown.rs
@@ -1674,6 +1674,13 @@ fn compute_code_block_highlights(parsed: &ParsedMarkdown) -> CodeBlockHighlights
}
fn highlight_code_block(block: PendingCodeBlock, code_block_highlights: &mut CodeBlockHighlights) {
+ if let [(event_index, text)] = block.texts.as_slice() {
+ let resolved = block.language.highlight_text_resolved(*text, 0..text.len());
+ if !resolved.runs.is_empty() {
+ code_block_highlights.insert(*event_index, resolved);
+ }
+ return;
+ }
let mut combined = String::new();
let mut text_offsets = Vec::with_capacity(block.texts.len());
for (_, text) in &block.texts {
@@ -1682,14 +1689,10 @@ fn highlight_code_block(block: PendingCodeBlock, code_block_highlights: &mut Cod
}
let resolved = block
.language
- .highlight_text_resolved(&Rope::from(combined.as_str()), 0..combined.len());
+ .highlight_text_resolved(combined.as_str(), 0..combined.len());
if resolved.runs.is_empty() {
return;
}
- if let [(event_index, _)] = block.texts.as_slice() {
- code_block_highlights.insert(*event_index, resolved);
- return;
- }
let mut runs = resolved.runs.iter().peekable();
for ((event_index, text), text_offset) in block.texts.iter().zip(text_offsets) {
let text_end = text_offset + text.len();
@@ -4169,9 +4172,7 @@ impl MarkdownElementBuilder {
let runs = if resolved.is_current() {
resolved.runs.clone()
} else {
- language
- .highlight_text_resolved(&Rope::from(text), 0..text.len())
- .runs
+ language.highlight_text_resolved(text, 0..text.len()).runs
};
let mut offset = 0;
for (run_range, highlight_id) in runs.iter() {
@@ -5644,7 +5645,9 @@ mod tests {
let code_text = "fn main() {}\n";
let code_start = source.find(code_text).unwrap();
let cached = cached_code_block_highlights(&markdown, code_start, cx);
- let expected = language.highlight_text(&Rope::from(code_text), 0..code_text.len());
+ let expected = language
+ .highlight_text(&Rope::from(code_text), 0..code_text.len())
+ .collect::<Vec<_>>();
assert_eq!(
cached.runs.to_vec(),
expected,