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.

Fix false syntax-layer ordering panic (#65663)

Kirill Bulatov32b16ce2ada9
diff --git a/crates/language/src/buffer.rs b/crates/language/src/buffer.rs
index 9244d3e10f1..bdee4377695 100644
--- a/crates/language/src/buffer.rs
+++ b/crates/language/src/buffer.rs
@@ -1245,7 +1245,7 @@ impl Buffer {
let mut syntax = SyntaxMap::new(&text).snapshot();
if let Some(language) = language.clone() {
let language_registry = language_registry.clone();
- syntax.reparse(&text, language_registry, language);
+ syntax.reparse(&text, None, language_registry, language);
}
let tree_sitter_data = TreeSitterData::new(&text);
BufferSnapshot {
@@ -1305,7 +1305,7 @@ impl Buffer {
.into_snapshot();
let mut syntax = SyntaxMap::new(&text).snapshot();
if let Some(language) = language.clone() {
- syntax.reparse(&text, language_registry, language);
+ syntax.reparse(&text, None, language_registry, language);
}
let tree_sitter_data = TreeSitterData::new(&text);
BufferSnapshot {
@@ -1392,10 +1392,16 @@ impl Buffer {
let old_snapshot = self.text.snapshot().clone();
let mut branch_buffer = self.text.branch();
let mut syntax_snapshot = self.syntax_map.lock().snapshot();
+ let file = self.file.clone();
cx.background_spawn(async move {
if !edits.is_empty() {
if let Some(language) = language.clone() {
- syntax_snapshot.reparse(&old_snapshot, registry.clone(), language);
+ syntax_snapshot.reparse(
+ &old_snapshot,
+ file.as_deref(),
+ registry.clone(),
+ language,
+ );
}
branch_buffer.edit(edits.iter().cloned());
@@ -1403,7 +1409,7 @@ impl Buffer {
syntax_snapshot.interpolate(&snapshot);
if let Some(language) = language {
- syntax_snapshot.reparse(&snapshot, registry, language);
+ syntax_snapshot.reparse(&snapshot, file.as_deref(), registry, language);
}
}
EditPreview {
@@ -1955,11 +1961,13 @@ impl Buffer {
let language_registry = syntax_map.language_registry();
let mut syntax_snapshot = syntax_map.snapshot();
drop(syntax_map);
+ let file = self.file.clone();
self.parse_status.0.send(ParseStatus::Parsing).unwrap();
if may_block && let Some(sync_parse_timeout) = self.sync_parse_timeout {
if let Ok(()) = syntax_snapshot.reparse_with_timeout(
&text,
+ file.as_deref(),
language_registry.clone(),
language.clone(),
sync_parse_timeout,
@@ -1979,7 +1987,7 @@ impl Buffer {
let language = language.clone();
let language_registry = language_registry.clone();
async move {
- syntax_snapshot.reparse(&text, language_registry, language);
+ syntax_snapshot.reparse(&text, file.as_deref(), language_registry, language);
syntax_snapshot
}
});
@@ -3561,13 +3569,18 @@ impl Buffer {
let new_text = self.text.snapshot_with_edits(edits);
cx.background_spawn(async move {
if let Some(language) = language.clone() {
- syntax.reparse(&text, registry.clone(), language);
+ syntax.reparse(&text, snapshot.file.as_deref(), registry.clone(), language);
}
syntax.interpolate(&new_text.snapshot);
if let Some(language) = language {
- syntax.reparse(&new_text.snapshot, registry, language);
+ syntax.reparse(
+ &new_text.snapshot,
+ snapshot.file.as_deref(),
+ registry,
+ language,
+ );
}
snapshot.text = new_text.snapshot.clone();
@@ -6363,7 +6376,7 @@ mod tests {
buffer.reparse.take();
let snapshot = buffer.snapshot();
let mut syntax = snapshot.syntax;
- syntax.reparse(&snapshot.text, None, rust_lang());
+ syntax.reparse(&snapshot.text, snapshot.file.as_deref(), None, rust_lang());
buffer.did_finish_parsing(syntax, None, false, cx);
assert!(buffer.pending_autoindent.is_some());
diff --git a/crates/language/src/syntax_map.rs b/crates/language/src/syntax_map.rs
index a254010fb4d..ced66d37722 100644
--- a/crates/language/src/syntax_map.rs
+++ b/crates/language/src/syntax_map.rs
@@ -2,8 +2,8 @@
mod syntax_map_tests;
use crate::{
- CaptureId, Grammar, InjectionConfig, Language, LanguageId, LanguageRegistry, QUERY_CURSORS,
- with_parser,
+ CaptureId, File, Grammar, InjectionConfig, Language, LanguageId, LanguageRegistry,
+ QUERY_CURSORS, with_parser,
};
use collections::HashMap;
use futures::FutureExt;
@@ -223,7 +223,7 @@ impl SyntaxLayerContent {
}
}
- #[cfg(debug_assertions)]
+ #[cfg(any(test, debug_assertions))]
fn language_name(&self) -> SharedString {
match self {
SyntaxLayerContent::Parsed { language, .. } => language.name().0,
@@ -378,7 +378,7 @@ impl SyntaxMap {
#[cfg(test)]
pub fn reparse(&mut self, language: Arc<Language>, text: &BufferSnapshot) {
self.snapshot
- .reparse(text, self.language_registry.clone(), language);
+ .reparse(text, None, self.language_registry.clone(), language);
}
pub fn did_parse(&mut self, snapshot: SyntaxSnapshot) {
@@ -542,27 +542,31 @@ impl SyntaxSnapshot {
pub fn reparse(
&mut self,
text: &BufferSnapshot,
+ file: Option<&dyn File>,
registry: Option<Arc<LanguageRegistry>>,
root_language: Arc<Language>,
) {
- self.reparse_(text, registry, root_language, None).ok();
+ self.reparse_(text, file, registry, root_language, None)
+ .ok();
}
#[ztracing::instrument(skip_all)]
pub fn reparse_with_timeout(
&mut self,
text: &BufferSnapshot,
+ file: Option<&dyn File>,
registry: Option<Arc<LanguageRegistry>>,
root_language: Arc<Language>,
budget: Duration,
) -> Result<(), ParseTimeout> {
- self.reparse_(text, registry, root_language, Some(budget))
+ self.reparse_(text, file, registry, root_language, Some(budget))
}
#[ztracing::instrument(skip_all, fields(lang = root_language.config.name.0.as_str()))]
fn reparse_(
&mut self,
text: &BufferSnapshot,
+ file: Option<&dyn File>,
registry: Option<Arc<LanguageRegistry>>,
root_language: Arc<Language>,
mut budget: Option<Duration>,
@@ -574,6 +578,7 @@ impl SyntaxSnapshot {
.collect::<Vec<_>>();
self.reparse_with_ranges(
text,
+ file,
root_language.clone(),
edit_ranges,
registry.as_ref(),
@@ -610,6 +615,7 @@ impl SyntaxSnapshot {
if !resolved_injection_ranges.is_empty() {
self.reparse_with_ranges(
text,
+ file,
root_language,
resolved_injection_ranges,
Some(&registry),
@@ -627,13 +633,15 @@ impl SyntaxSnapshot {
fn reparse_with_ranges(
&mut self,
text: &BufferSnapshot,
+ file: Option<&dyn File>,
root_language: Arc<Language>,
invalidated_ranges: Vec<Range<usize>>,
registry: Option<&Arc<LanguageRegistry>>,
budget: &mut Option<Duration>,
) -> Result<(), ParseTimeout> {
log::trace!(
- "reparse. invalidated ranges:{:?}",
+ "reparse. file:{:?}, invalidated ranges:{:?}",
+ file.map(File::path),
LogOffsetRanges(&invalidated_ranges, text),
);
@@ -991,15 +999,22 @@ impl SyntaxSnapshot {
self.layers = layers;
self.interpolated_version = text.version.clone();
self.parsed_version = text.version.clone();
- #[cfg(debug_assertions)]
- self.check_invariants(text);
+ #[cfg(any(test, debug_assertions))]
+ self.check_invariants(text, file);
Ok(())
}
- #[cfg(debug_assertions)]
- fn check_invariants(&self, text: &BufferSnapshot) {
+ #[cfg(any(test, debug_assertions))]
+ fn check_invariants(&self, text: &BufferSnapshot, file: Option<&dyn File>) {
let out_of_order = |reason: &str| -> ! {
- let mut dump = format!("layers out of order: {reason}\nlayers:\n");
+ let file_path = file.map_or_else(
+ || "<untitled>".to_owned(),
+ |file| format!("{:?}", file.path()),
+ );
+ let mut dump = format!(
+ "layers out of order: {reason}\nbuffer: {:?}\nfile: {file_path}\nlayers:\n",
+ text.remote_id(),
+ );
for layer in self.layers.iter() {
dump.push_str(&format!(
" depth={} range={:?} language={} id={:?}\n",
@@ -1022,24 +1037,22 @@ impl SyntaxSnapshot {
match layer.range.start.cmp(&prev_range.start, text) {
Ordering::Less => out_of_order("start decreased"),
Ordering::Equal => match layer.range.end.cmp(&prev_range.end, text) {
- Ordering::Less => out_of_order("end decreased at equal start"),
+ Ordering::Greater => out_of_order("end increased at equal start"),
Ordering::Equal => {
if layer.content.language_id() < prev_language_id {
out_of_order("language id decreased at equal range")
}
}
- Ordering::Greater => {}
+ Ordering::Less => {}
},
Ordering::Greater => {}
}
}
- prev_layer = Some((layer.range.clone(), layer.content.language_id()));
- }
- Ordering::Greater => {
- prev_layer = None;
}
+ Ordering::Greater => {}
}
+ prev_layer = Some((layer.range.clone(), layer.content.language_id()));
max_depth = layer.depth;
}
}
diff --git a/crates/language/src/syntax_map/syntax_map_tests.rs b/crates/language/src/syntax_map/syntax_map_tests.rs
index 2dd6723ec69..0564856e433 100644
--- a/crates/language/src/syntax_map/syntax_map_tests.rs
+++ b/crates/language/src/syntax_map/syntax_map_tests.rs
@@ -1076,6 +1076,63 @@ fn test_combined_injection_with_leading_content_layer_ordering(cx: &mut App) {
syntax_map.reparse(heex, &buffer);
}
+#[gpui::test]
+fn test_markdown_injections_with_same_start_and_different_ends(cx: &mut App) {
+ let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));
+ let markdown = markdown_lang();
+ let markdown_inline = Arc::new(
+ markdown_inline_lang()
+ .with_injection_query(include_str!(
+ "../../../grammars/src/markdown-inline/injections.scm"
+ ))
+ .unwrap(),
+ );
+ let html = Arc::new(html_lang());
+ registry.add(markdown.clone());
+ registry.add(markdown_inline.clone());
+ registry.add(html.clone());
+
+ let mut buffer = Buffer::new(
+ ReplicaId::LOCAL,
+ BufferId::new(1).unwrap(),
+ "a\n\n$x$ <b>\n".to_string(),
+ );
+ let mut syntax_map = SyntaxMap::new(&buffer);
+ syntax_map.set_language_registry(registry);
+ syntax_map.reparse(markdown.clone(), &buffer);
+ assert!(syntax_map.contains_unknown_injections());
+
+ for (range, replacement, document_end, inline_end, latex_end) in
+ [(4..5, "中", 13, 12, 8), (4..7, "x", 11, 10, 6)]
+ {
+ buffer.edit([(range, replacement)]);
+ syntax_map.interpolate(&buffer);
+ syntax_map.reparse(markdown.clone(), &buffer);
+
+ assert_eq!(
+ syntax_map
+ .snapshot
+ .layers
+ .iter()
+ .map(|layer| (
+ layer.depth,
+ layer.range.to_offset(&buffer),
+ layer.content.language_id(),
+ ))
+ .collect::<Vec<_>>(),
+ vec![
+ (0, 0..document_end, Some(markdown.id)),
+ (1, 0..1, Some(markdown_inline.id)),
+ (1, 3..inline_end, Some(markdown_inline.id)),
+ (2, 0..1, Some(html.id)),
+ (2, 3..inline_end, Some(html.id)),
+ (2, 3..latex_end, None),
+ ],
+ );
+ assert!(syntax_map.contains_unknown_injections());
+ }
+}
+
#[gpui::test]
fn test_comment_triggered_injection_toggle(cx: &mut App) {
let registry = Arc::new(LanguageRegistry::test(cx.background_executor().clone()));