1use crate::{Grammar, InjectionConfig, Language, LanguageRegistry};
2use lazy_static::lazy_static;
3use parking_lot::Mutex;
4use std::{
5 borrow::Cow,
6 cell::RefCell,
7 cmp::{Ordering, Reverse},
8 collections::BinaryHeap,
9 ops::{Deref, DerefMut, Range},
10 sync::Arc,
11};
12use sum_tree::{Bias, SeekTarget, SumTree};
13use text::{Anchor, BufferSnapshot, OffsetRangeExt, Point, Rope, ToOffset, ToPoint};
14use tree_sitter::{
15 Node, Parser, Query, QueryCapture, QueryCaptures, QueryCursor, QueryMatches, Tree,
16};
17
18thread_local! {
19 static PARSER: RefCell<Parser> = RefCell::new(Parser::new());
20}
21
22lazy_static! {
23 static ref QUERY_CURSORS: Mutex<Vec<QueryCursor>> = Default::default();
24}
25
26#[derive(Default)]
27pub struct SyntaxMap {
28 parsed_version: clock::Global,
29 interpolated_version: clock::Global,
30 snapshot: SyntaxSnapshot,
31 language_registry: Option<Arc<LanguageRegistry>>,
32}
33
34#[derive(Clone, Default)]
35pub struct SyntaxSnapshot {
36 layers: SumTree<SyntaxLayer>,
37}
38
39#[derive(Default)]
40pub struct SyntaxMapCaptures<'a> {
41 layers: Vec<SyntaxMapCapturesLayer<'a>>,
42 active_layer_count: usize,
43 grammars: Vec<&'a Grammar>,
44}
45
46#[derive(Default)]
47pub struct SyntaxMapMatches<'a> {
48 layers: Vec<SyntaxMapMatchesLayer<'a>>,
49 active_layer_count: usize,
50 grammars: Vec<&'a Grammar>,
51}
52
53#[derive(Debug)]
54pub struct SyntaxMapCapture<'a> {
55 pub depth: usize,
56 pub node: Node<'a>,
57 pub index: u32,
58 pub grammar_index: usize,
59}
60
61#[derive(Debug)]
62pub struct SyntaxMapMatch<'a> {
63 pub depth: usize,
64 pub pattern_index: usize,
65 pub captures: &'a [QueryCapture<'a>],
66 pub grammar_index: usize,
67}
68
69struct SyntaxMapCapturesLayer<'a> {
70 depth: usize,
71 captures: QueryCaptures<'a, 'a, TextProvider<'a>>,
72 next_capture: Option<QueryCapture<'a>>,
73 grammar_index: usize,
74 _query_cursor: QueryCursorHandle,
75}
76
77struct SyntaxMapMatchesLayer<'a> {
78 depth: usize,
79 next_pattern_index: usize,
80 next_captures: Vec<QueryCapture<'a>>,
81 has_next: bool,
82 matches: QueryMatches<'a, 'a, TextProvider<'a>>,
83 grammar_index: usize,
84 _query_cursor: QueryCursorHandle,
85}
86
87#[derive(Clone)]
88struct SyntaxLayer {
89 depth: usize,
90 range: Range<Anchor>,
91 tree: tree_sitter::Tree,
92 language: Arc<Language>,
93}
94
95#[derive(Debug)]
96pub struct SyntaxLayerInfo<'a> {
97 pub depth: usize,
98 pub node: Node<'a>,
99 pub language: &'a Arc<Language>,
100}
101
102#[derive(Debug, Clone)]
103struct SyntaxLayerSummary {
104 min_depth: usize,
105 max_depth: usize,
106 range: Range<Anchor>,
107 last_layer_range: Range<Anchor>,
108}
109
110#[derive(Clone, Debug)]
111struct DepthAndRange(usize, Range<Anchor>);
112
113#[derive(Clone, Debug)]
114struct DepthAndMaxPosition(usize, Anchor);
115
116#[derive(Clone, Debug)]
117struct DepthAndRangeOrMaxPosition(DepthAndRange, DepthAndMaxPosition);
118
119struct ReparseStep {
120 depth: usize,
121 language: Arc<Language>,
122 ranges: Vec<tree_sitter::Range>,
123 range: Range<Anchor>,
124}
125
126#[derive(Debug, PartialEq, Eq)]
127struct ChangedRegion {
128 depth: usize,
129 range: Range<Anchor>,
130}
131
132#[derive(Default)]
133struct ChangeRegionSet(Vec<ChangedRegion>);
134
135struct TextProvider<'a>(&'a Rope);
136
137struct ByteChunks<'a>(text::Chunks<'a>);
138
139struct QueryCursorHandle(Option<QueryCursor>);
140
141impl SyntaxMap {
142 pub fn new() -> Self {
143 Self::default()
144 }
145
146 pub fn set_language_registry(&mut self, registry: Arc<LanguageRegistry>) {
147 self.language_registry = Some(registry);
148 }
149
150 pub fn snapshot(&self) -> SyntaxSnapshot {
151 self.snapshot.clone()
152 }
153
154 pub fn language_registry(&self) -> Option<Arc<LanguageRegistry>> {
155 self.language_registry.clone()
156 }
157
158 pub fn parsed_version(&self) -> clock::Global {
159 self.parsed_version.clone()
160 }
161
162 pub fn interpolate(&mut self, text: &BufferSnapshot) {
163 self.snapshot.interpolate(&self.interpolated_version, text);
164 self.interpolated_version = text.version.clone();
165 }
166
167 #[cfg(test)]
168 pub fn reparse(&mut self, language: Arc<Language>, text: &BufferSnapshot) {
169 self.snapshot.reparse(
170 &self.parsed_version,
171 text,
172 self.language_registry.clone(),
173 language,
174 );
175 self.parsed_version = text.version.clone();
176 self.interpolated_version = text.version.clone();
177 }
178
179 pub fn did_parse(&mut self, snapshot: SyntaxSnapshot, version: clock::Global) {
180 self.interpolated_version = version.clone();
181 self.parsed_version = version;
182 self.snapshot = snapshot;
183 }
184
185 pub fn clear(&mut self) {
186 self.snapshot = SyntaxSnapshot::default();
187 }
188}
189
190impl SyntaxSnapshot {
191 pub fn is_empty(&self) -> bool {
192 self.layers.is_empty()
193 }
194
195 pub fn interpolate(&mut self, from_version: &clock::Global, text: &BufferSnapshot) {
196 let edits = text
197 .anchored_edits_since::<(usize, Point)>(&from_version)
198 .collect::<Vec<_>>();
199 if edits.is_empty() {
200 return;
201 }
202
203 let mut layers = SumTree::new();
204 let mut first_edit_ix_for_depth = 0;
205 let mut prev_depth = 0;
206 let mut cursor = self.layers.cursor::<SyntaxLayerSummary>();
207 cursor.next(text);
208
209 'outer: loop {
210 let depth = cursor.end(text).max_depth;
211 if depth > prev_depth {
212 first_edit_ix_for_depth = 0;
213 prev_depth = depth;
214 }
215
216 // Preserve any layers at this depth that precede the first edit.
217 if let Some((_, edit_range)) = edits.get(first_edit_ix_for_depth) {
218 let target = DepthAndMaxPosition(depth, edit_range.start);
219 if target.cmp(&cursor.start(), text).is_gt() {
220 let slice = cursor.slice(&target, Bias::Left, text);
221 layers.push_tree(slice, text);
222 }
223 }
224 // If this layer follows all of the edits, then preserve it and any
225 // subsequent layers at this same depth.
226 else if cursor.item().is_some() {
227 let slice = cursor.slice(
228 &DepthAndRange(depth + 1, Anchor::MIN..Anchor::MAX),
229 Bias::Left,
230 text,
231 );
232 layers.push_tree(slice, text);
233 continue;
234 };
235
236 let layer = if let Some(layer) = cursor.item() {
237 layer
238 } else {
239 break;
240 };
241 let (start_byte, start_point) = layer.range.start.summary::<(usize, Point)>(text);
242
243 // Ignore edits that end before the start of this layer, and don't consider them
244 // for any subsequent layers at this same depth.
245 loop {
246 if let Some((_, edit_range)) = edits.get(first_edit_ix_for_depth) {
247 if edit_range.end.cmp(&layer.range.start, text).is_le() {
248 first_edit_ix_for_depth += 1;
249 } else {
250 break;
251 }
252 } else {
253 continue 'outer;
254 }
255 }
256
257 let mut layer = layer.clone();
258 for (edit, edit_range) in &edits[first_edit_ix_for_depth..] {
259 // Ignore any edits that follow this layer.
260 if edit_range.start.cmp(&layer.range.end, text).is_ge() {
261 break;
262 }
263
264 // Apply any edits that intersect this layer to the layer's syntax tree.
265 let tree_edit = if edit_range.start.cmp(&layer.range.start, text).is_ge() {
266 tree_sitter::InputEdit {
267 start_byte: edit.new.start.0 - start_byte,
268 old_end_byte: edit.new.start.0 - start_byte
269 + (edit.old.end.0 - edit.old.start.0),
270 new_end_byte: edit.new.end.0 - start_byte,
271 start_position: (edit.new.start.1 - start_point).to_ts_point(),
272 old_end_position: (edit.new.start.1 - start_point
273 + (edit.old.end.1 - edit.old.start.1))
274 .to_ts_point(),
275 new_end_position: (edit.new.end.1 - start_point).to_ts_point(),
276 }
277 } else {
278 let node = layer.tree.root_node();
279 tree_sitter::InputEdit {
280 start_byte: 0,
281 old_end_byte: node.end_byte(),
282 new_end_byte: 0,
283 start_position: Default::default(),
284 old_end_position: node.end_position(),
285 new_end_position: Default::default(),
286 }
287 };
288
289 layer.tree.edit(&tree_edit);
290 }
291
292 debug_assert!(
293 layer.tree.root_node().end_byte() <= text.len(),
294 "tree's size {}, is larger than text size {}",
295 layer.tree.root_node().end_byte(),
296 text.len(),
297 );
298
299 layers.push(layer, text);
300 cursor.next(text);
301 }
302
303 layers.push_tree(cursor.suffix(&text), &text);
304 drop(cursor);
305 self.layers = layers;
306 }
307
308 pub fn reparse(
309 &mut self,
310 from_version: &clock::Global,
311 text: &BufferSnapshot,
312 registry: Option<Arc<LanguageRegistry>>,
313 language: Arc<Language>,
314 ) {
315 let edits = text.edits_since::<usize>(from_version).collect::<Vec<_>>();
316 let max_depth = self.layers.summary().max_depth;
317 let mut cursor = self.layers.cursor::<SyntaxLayerSummary>();
318 cursor.next(&text);
319 let mut layers = SumTree::new();
320
321 let mut changed_regions = ChangeRegionSet::default();
322 let mut queue = BinaryHeap::new();
323 queue.push(ReparseStep {
324 depth: 0,
325 language: language.clone(),
326 ranges: Vec::new(),
327 range: Anchor::MIN..Anchor::MAX,
328 });
329
330 loop {
331 let step = queue.pop();
332 let (depth, range) = if let Some(step) = &step {
333 (step.depth, step.range.clone())
334 } else {
335 (max_depth + 1, Anchor::MAX..Anchor::MAX)
336 };
337
338 let target = DepthAndRange(depth, range.clone());
339 let mut done = cursor.item().is_none();
340 while !done && target.cmp(&cursor.end(text), &text).is_gt() {
341 done = true;
342
343 let bounded_target =
344 DepthAndRangeOrMaxPosition(target.clone(), changed_regions.start_position());
345 if bounded_target.cmp(&cursor.start(), &text).is_gt() {
346 let slice = cursor.slice(&bounded_target, Bias::Left, text);
347 if !slice.is_empty() {
348 layers.push_tree(slice, &text);
349 if changed_regions.prune(cursor.end(text), text) {
350 done = false;
351 }
352 }
353 }
354
355 while target.cmp(&cursor.end(text), text).is_gt() {
356 let layer = if let Some(layer) = cursor.item() {
357 layer
358 } else {
359 break;
360 };
361
362 if changed_regions.intersects(&layer, text) {
363 changed_regions.insert(
364 ChangedRegion {
365 depth: layer.depth + 1,
366 range: layer.range.clone(),
367 },
368 text,
369 );
370 } else {
371 layers.push(layer.clone(), text);
372 }
373
374 cursor.next(text);
375 if changed_regions.prune(cursor.end(text), text) {
376 done = false;
377 }
378 }
379 }
380
381 let (ranges, language) = if let Some(step) = step {
382 (step.ranges, step.language)
383 } else {
384 break;
385 };
386
387 let start_point;
388 let start_byte;
389 let end_byte;
390 if let Some((first, last)) = ranges.first().zip(ranges.last()) {
391 start_point = first.start_point;
392 start_byte = first.start_byte;
393 end_byte = last.end_byte;
394 } else {
395 start_point = Point::zero().to_ts_point();
396 start_byte = 0;
397 end_byte = text.len();
398 };
399
400 let mut old_layer = cursor.item();
401 if let Some(layer) = old_layer {
402 if layer.range.to_offset(text) == (start_byte..end_byte) {
403 cursor.next(&text);
404 } else {
405 old_layer = None;
406 }
407 }
408
409 let grammar = if let Some(grammar) = language.grammar.as_deref() {
410 grammar
411 } else {
412 continue;
413 };
414
415 let tree;
416 let changed_ranges;
417 if let Some(old_layer) = old_layer {
418 tree = parse_text(
419 grammar,
420 text.as_rope(),
421 Some(old_layer.tree.clone()),
422 ranges,
423 );
424 changed_ranges = join_ranges(
425 edits
426 .iter()
427 .map(|e| e.new.clone())
428 .filter(|range| range.start < end_byte && range.end > start_byte),
429 old_layer
430 .tree
431 .changed_ranges(&tree)
432 .map(|r| start_byte + r.start_byte..start_byte + r.end_byte),
433 );
434 } else {
435 tree = parse_text(grammar, text.as_rope(), None, ranges);
436 changed_ranges = vec![start_byte..end_byte];
437 }
438
439 layers.push(
440 SyntaxLayer {
441 depth,
442 range,
443 tree: tree.clone(),
444 language: language.clone(),
445 },
446 &text,
447 );
448
449 if let (Some((config, registry)), false) = (
450 grammar.injection_config.as_ref().zip(registry.as_ref()),
451 changed_ranges.is_empty(),
452 ) {
453 let depth = depth + 1;
454 for range in &changed_ranges {
455 changed_regions.insert(
456 ChangedRegion {
457 depth,
458 range: text.anchor_before(range.start)..text.anchor_after(range.end),
459 },
460 text,
461 );
462 }
463 get_injections(
464 config,
465 text,
466 tree.root_node_with_offset(start_byte, start_point),
467 registry,
468 depth,
469 &changed_ranges,
470 &mut queue,
471 );
472 }
473 }
474
475 drop(cursor);
476 self.layers = layers;
477 }
478
479 pub fn single_tree_captures<'a>(
480 range: Range<usize>,
481 text: &'a Rope,
482 tree: &'a Tree,
483 language: &'a Arc<Language>,
484 query: fn(&Grammar) -> Option<&Query>,
485 ) -> SyntaxMapCaptures<'a> {
486 SyntaxMapCaptures::new(
487 range.clone(),
488 text,
489 [SyntaxLayerInfo {
490 language,
491 depth: 0,
492 node: tree.root_node(),
493 }]
494 .into_iter(),
495 query,
496 )
497 }
498
499 pub fn captures<'a>(
500 &'a self,
501 range: Range<usize>,
502 buffer: &'a BufferSnapshot,
503 query: fn(&Grammar) -> Option<&Query>,
504 ) -> SyntaxMapCaptures {
505 SyntaxMapCaptures::new(
506 range.clone(),
507 buffer.as_rope(),
508 self.layers_for_range(range, buffer).into_iter(),
509 query,
510 )
511 }
512
513 pub fn matches<'a>(
514 &'a self,
515 range: Range<usize>,
516 buffer: &'a BufferSnapshot,
517 query: fn(&Grammar) -> Option<&Query>,
518 ) -> SyntaxMapMatches {
519 SyntaxMapMatches::new(
520 range.clone(),
521 buffer.as_rope(),
522 self.layers_for_range(range, buffer).into_iter(),
523 query,
524 )
525 }
526
527 #[cfg(test)]
528 pub fn layers<'a>(&'a self, buffer: &'a BufferSnapshot) -> Vec<SyntaxLayerInfo> {
529 self.layers_for_range(0..buffer.len(), buffer).collect()
530 }
531
532 pub fn layers_for_range<'a, T: ToOffset>(
533 &'a self,
534 range: Range<T>,
535 buffer: &'a BufferSnapshot,
536 ) -> impl 'a + Iterator<Item = SyntaxLayerInfo> {
537 let start = buffer.anchor_before(range.start.to_offset(buffer));
538 let end = buffer.anchor_after(range.end.to_offset(buffer));
539
540 let mut cursor = self.layers.filter::<_, ()>(move |summary| {
541 if summary.max_depth > summary.min_depth {
542 true
543 } else {
544 let is_before_start = summary.range.end.cmp(&start, buffer).is_lt();
545 let is_after_end = summary.range.start.cmp(&end, buffer).is_gt();
546 !is_before_start && !is_after_end
547 }
548 });
549
550 // let mut result = Vec::new();
551 cursor.next(buffer);
552 std::iter::from_fn(move || {
553 if let Some(layer) = cursor.item() {
554 let info = SyntaxLayerInfo {
555 language: &layer.language,
556 depth: layer.depth,
557 node: layer.tree.root_node_with_offset(
558 layer.range.start.to_offset(buffer),
559 layer.range.start.to_point(buffer).to_ts_point(),
560 ),
561 };
562 cursor.next(buffer);
563 Some(info)
564 } else {
565 None
566 }
567 })
568
569 // result
570 }
571}
572
573impl<'a> SyntaxMapCaptures<'a> {
574 fn new(
575 range: Range<usize>,
576 text: &'a Rope,
577 layers: impl Iterator<Item = SyntaxLayerInfo<'a>>,
578 query: fn(&Grammar) -> Option<&Query>,
579 ) -> Self {
580 let mut result = Self {
581 layers: Vec::new(),
582 grammars: Vec::new(),
583 active_layer_count: 0,
584 };
585 for SyntaxLayerInfo {
586 language,
587 depth,
588 node,
589 } in layers
590 {
591 let grammar = match &language.grammar {
592 Some(grammer) => grammer,
593 None => continue,
594 };
595 let query = match query(&grammar) {
596 Some(query) => query,
597 None => continue,
598 };
599
600 let mut query_cursor = QueryCursorHandle::new();
601
602 // TODO - add a Tree-sitter API to remove the need for this.
603 let cursor = unsafe {
604 std::mem::transmute::<_, &'static mut QueryCursor>(query_cursor.deref_mut())
605 };
606
607 cursor.set_byte_range(range.clone());
608 let captures = cursor.captures(query, node, TextProvider(text));
609 let grammar_index = result
610 .grammars
611 .iter()
612 .position(|g| g.id == grammar.id())
613 .unwrap_or_else(|| {
614 result.grammars.push(grammar);
615 result.grammars.len() - 1
616 });
617 let mut layer = SyntaxMapCapturesLayer {
618 depth,
619 grammar_index,
620 next_capture: None,
621 captures,
622 _query_cursor: query_cursor,
623 };
624
625 layer.advance();
626 if layer.next_capture.is_some() {
627 let key = layer.sort_key();
628 let ix = match result.layers[..result.active_layer_count]
629 .binary_search_by_key(&key, |layer| layer.sort_key())
630 {
631 Ok(ix) | Err(ix) => ix,
632 };
633 result.layers.insert(ix, layer);
634 result.active_layer_count += 1;
635 } else {
636 result.layers.push(layer);
637 }
638 }
639
640 result
641 }
642
643 pub fn grammars(&self) -> &[&'a Grammar] {
644 &self.grammars
645 }
646
647 pub fn peek(&self) -> Option<SyntaxMapCapture<'a>> {
648 let layer = self.layers[..self.active_layer_count].first()?;
649 let capture = layer.next_capture?;
650 Some(SyntaxMapCapture {
651 depth: layer.depth,
652 grammar_index: layer.grammar_index,
653 index: capture.index,
654 node: capture.node,
655 })
656 }
657
658 pub fn advance(&mut self) -> bool {
659 let layer = if let Some(layer) = self.layers[..self.active_layer_count].first_mut() {
660 layer
661 } else {
662 return false;
663 };
664
665 layer.advance();
666 if layer.next_capture.is_some() {
667 let key = layer.sort_key();
668 let i = 1 + self.layers[1..self.active_layer_count]
669 .iter()
670 .position(|later_layer| key < later_layer.sort_key())
671 .unwrap_or(self.active_layer_count - 1);
672 self.layers[0..i].rotate_left(1);
673 } else {
674 self.layers[0..self.active_layer_count].rotate_left(1);
675 self.active_layer_count -= 1;
676 }
677
678 true
679 }
680
681 pub fn set_byte_range(&mut self, range: Range<usize>) {
682 for layer in &mut self.layers {
683 layer.captures.set_byte_range(range.clone());
684 if let Some(capture) = &layer.next_capture {
685 if capture.node.end_byte() > range.start {
686 continue;
687 }
688 }
689 layer.advance();
690 }
691 self.layers.sort_unstable_by_key(|layer| layer.sort_key());
692 self.active_layer_count = self
693 .layers
694 .iter()
695 .position(|layer| layer.next_capture.is_none())
696 .unwrap_or(self.layers.len());
697 }
698}
699
700impl<'a> SyntaxMapMatches<'a> {
701 fn new(
702 range: Range<usize>,
703 text: &'a Rope,
704 layers: impl Iterator<Item = SyntaxLayerInfo<'a>>,
705 query: fn(&Grammar) -> Option<&Query>,
706 ) -> Self {
707 let mut result = Self::default();
708 for SyntaxLayerInfo {
709 language,
710 depth,
711 node,
712 } in layers
713 {
714 let grammar = match &language.grammar {
715 Some(grammer) => grammer,
716 None => continue,
717 };
718 let query = match query(&grammar) {
719 Some(query) => query,
720 None => continue,
721 };
722
723 let mut query_cursor = QueryCursorHandle::new();
724
725 // TODO - add a Tree-sitter API to remove the need for this.
726 let cursor = unsafe {
727 std::mem::transmute::<_, &'static mut QueryCursor>(query_cursor.deref_mut())
728 };
729
730 cursor.set_byte_range(range.clone());
731 let matches = cursor.matches(query, node, TextProvider(text));
732 let grammar_index = result
733 .grammars
734 .iter()
735 .position(|g| g.id == grammar.id())
736 .unwrap_or_else(|| {
737 result.grammars.push(grammar);
738 result.grammars.len() - 1
739 });
740 let mut layer = SyntaxMapMatchesLayer {
741 depth,
742 grammar_index,
743 matches,
744 next_pattern_index: 0,
745 next_captures: Vec::new(),
746 has_next: false,
747 _query_cursor: query_cursor,
748 };
749
750 layer.advance();
751 if layer.has_next {
752 let key = layer.sort_key();
753 let ix = match result.layers[..result.active_layer_count]
754 .binary_search_by_key(&key, |layer| layer.sort_key())
755 {
756 Ok(ix) | Err(ix) => ix,
757 };
758 result.layers.insert(ix, layer);
759 result.active_layer_count += 1;
760 } else {
761 result.layers.push(layer);
762 }
763 }
764 result
765 }
766
767 pub fn grammars(&self) -> &[&'a Grammar] {
768 &self.grammars
769 }
770
771 pub fn peek(&self) -> Option<SyntaxMapMatch> {
772 let layer = self.layers.first()?;
773 if !layer.has_next {
774 return None;
775 }
776 Some(SyntaxMapMatch {
777 depth: layer.depth,
778 grammar_index: layer.grammar_index,
779 pattern_index: layer.next_pattern_index,
780 captures: &layer.next_captures,
781 })
782 }
783
784 pub fn advance(&mut self) -> bool {
785 let layer = if let Some(layer) = self.layers.first_mut() {
786 layer
787 } else {
788 return false;
789 };
790
791 layer.advance();
792 if layer.has_next {
793 let key = layer.sort_key();
794 let i = 1 + self.layers[1..self.active_layer_count]
795 .iter()
796 .position(|later_layer| key < later_layer.sort_key())
797 .unwrap_or(self.active_layer_count - 1);
798 self.layers[0..i].rotate_left(1);
799 } else {
800 self.layers[0..self.active_layer_count].rotate_left(1);
801 self.active_layer_count -= 1;
802 }
803
804 true
805 }
806}
807
808impl<'a> SyntaxMapCapturesLayer<'a> {
809 fn advance(&mut self) {
810 self.next_capture = self.captures.next().map(|(mat, ix)| mat.captures[ix]);
811 }
812
813 fn sort_key(&self) -> (usize, Reverse<usize>, usize) {
814 if let Some(capture) = &self.next_capture {
815 let range = capture.node.byte_range();
816 (range.start, Reverse(range.end), self.depth)
817 } else {
818 (usize::MAX, Reverse(0), usize::MAX)
819 }
820 }
821}
822
823impl<'a> SyntaxMapMatchesLayer<'a> {
824 fn advance(&mut self) {
825 if let Some(mat) = self.matches.next() {
826 self.next_captures.clear();
827 self.next_captures.extend_from_slice(&mat.captures);
828 self.next_pattern_index = mat.pattern_index;
829 self.has_next = true;
830 } else {
831 self.has_next = false;
832 }
833 }
834
835 fn sort_key(&self) -> (usize, Reverse<usize>, usize) {
836 if self.has_next {
837 let captures = &self.next_captures;
838 if let Some((first, last)) = captures.first().zip(captures.last()) {
839 return (
840 first.node.start_byte(),
841 Reverse(last.node.end_byte()),
842 self.depth,
843 );
844 }
845 }
846 (usize::MAX, Reverse(0), usize::MAX)
847 }
848}
849
850impl<'a> Iterator for SyntaxMapCaptures<'a> {
851 type Item = SyntaxMapCapture<'a>;
852
853 fn next(&mut self) -> Option<Self::Item> {
854 let result = self.peek();
855 self.advance();
856 result
857 }
858}
859
860fn join_ranges(
861 a: impl Iterator<Item = Range<usize>>,
862 b: impl Iterator<Item = Range<usize>>,
863) -> Vec<Range<usize>> {
864 let mut result = Vec::<Range<usize>>::new();
865 let mut a = a.peekable();
866 let mut b = b.peekable();
867 loop {
868 let range = match (a.peek(), b.peek()) {
869 (Some(range_a), Some(range_b)) => {
870 if range_a.start < range_b.start {
871 a.next().unwrap()
872 } else {
873 b.next().unwrap()
874 }
875 }
876 (None, Some(_)) => b.next().unwrap(),
877 (Some(_), None) => a.next().unwrap(),
878 (None, None) => break,
879 };
880
881 if let Some(last) = result.last_mut() {
882 if range.start <= last.end {
883 last.end = last.end.max(range.end);
884 continue;
885 }
886 }
887 result.push(range);
888 }
889 result
890}
891
892fn parse_text(
893 grammar: &Grammar,
894 text: &Rope,
895 old_tree: Option<Tree>,
896 mut ranges: Vec<tree_sitter::Range>,
897) -> Tree {
898 let (start_byte, start_point) = ranges
899 .first()
900 .map(|range| (range.start_byte, Point::from_ts_point(range.start_point)))
901 .unwrap_or_default();
902
903 for range in &mut ranges {
904 range.start_byte -= start_byte;
905 range.end_byte -= start_byte;
906 range.start_point = (Point::from_ts_point(range.start_point) - start_point).to_ts_point();
907 range.end_point = (Point::from_ts_point(range.end_point) - start_point).to_ts_point();
908 }
909
910 PARSER.with(|parser| {
911 let mut parser = parser.borrow_mut();
912 let mut chunks = text.chunks_in_range(start_byte..text.len());
913 parser
914 .set_included_ranges(&ranges)
915 .expect("overlapping ranges");
916 parser
917 .set_language(grammar.ts_language)
918 .expect("incompatible grammar");
919 parser
920 .parse_with(
921 &mut move |offset, _| {
922 chunks.seek(start_byte + offset);
923 chunks.next().unwrap_or("").as_bytes()
924 },
925 old_tree.as_ref(),
926 )
927 .expect("invalid language")
928 })
929}
930
931fn get_injections(
932 config: &InjectionConfig,
933 text: &BufferSnapshot,
934 node: Node,
935 language_registry: &LanguageRegistry,
936 depth: usize,
937 query_ranges: &[Range<usize>],
938 queue: &mut BinaryHeap<ReparseStep>,
939) -> bool {
940 let mut result = false;
941 let mut query_cursor = QueryCursorHandle::new();
942 let mut prev_match = None;
943 for query_range in query_ranges {
944 query_cursor.set_byte_range(query_range.start.saturating_sub(1)..query_range.end);
945 for mat in query_cursor.matches(&config.query, node, TextProvider(text.as_rope())) {
946 let content_ranges = mat
947 .nodes_for_capture_index(config.content_capture_ix)
948 .map(|node| node.range())
949 .collect::<Vec<_>>();
950 if content_ranges.is_empty() {
951 continue;
952 }
953
954 // Avoid duplicate matches if two changed ranges intersect the same injection.
955 let content_range =
956 content_ranges.first().unwrap().start_byte..content_ranges.last().unwrap().end_byte;
957 if let Some((last_pattern_ix, last_range)) = &prev_match {
958 if mat.pattern_index == *last_pattern_ix && content_range == *last_range {
959 continue;
960 }
961 }
962 prev_match = Some((mat.pattern_index, content_range.clone()));
963
964 let language_name = config.patterns[mat.pattern_index].language
965 .as_ref()
966 .map(|s| Cow::Borrowed(s.as_ref()))
967 .or_else(|| {
968 let ix = config.language_capture_ix?;
969 let node = mat.nodes_for_capture_index(ix).next()?;
970 Some(Cow::Owned(text.text_for_range(node.byte_range()).collect()))
971 });
972
973 if let Some(language_name) = language_name {
974 if let Some(language) = language_registry.get_language(language_name.as_ref()) {
975 result = true;
976 let range = text.anchor_before(content_range.start)
977 ..text.anchor_after(content_range.end);
978 queue.push(ReparseStep {
979 depth,
980 language,
981 ranges: content_ranges,
982 range,
983 })
984 }
985 }
986 }
987 }
988 result
989}
990
991impl std::ops::Deref for SyntaxMap {
992 type Target = SyntaxSnapshot;
993
994 fn deref(&self) -> &Self::Target {
995 &self.snapshot
996 }
997}
998
999impl PartialEq for ReparseStep {
1000 fn eq(&self, _: &Self) -> bool {
1001 false
1002 }
1003}
1004
1005impl Eq for ReparseStep {}
1006
1007impl PartialOrd for ReparseStep {
1008 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
1009 Some(self.cmp(&other))
1010 }
1011}
1012
1013impl Ord for ReparseStep {
1014 fn cmp(&self, other: &Self) -> Ordering {
1015 let range_a = self.range();
1016 let range_b = other.range();
1017 Ord::cmp(&other.depth, &self.depth)
1018 .then_with(|| Ord::cmp(&range_b.start, &range_a.start))
1019 .then_with(|| Ord::cmp(&range_a.end, &range_b.end))
1020 }
1021}
1022
1023impl ReparseStep {
1024 fn range(&self) -> Range<usize> {
1025 let start = self.ranges.first().map_or(0, |r| r.start_byte);
1026 let end = self.ranges.last().map_or(0, |r| r.end_byte);
1027 start..end
1028 }
1029}
1030
1031impl ChangedRegion {
1032 fn cmp(&self, other: &Self, buffer: &BufferSnapshot) -> Ordering {
1033 let range_a = &self.range;
1034 let range_b = &other.range;
1035 Ord::cmp(&self.depth, &other.depth)
1036 .then_with(|| range_a.start.cmp(&range_b.start, buffer))
1037 .then_with(|| range_b.end.cmp(&range_a.end, buffer))
1038 }
1039}
1040
1041impl ChangeRegionSet {
1042 fn start_position(&self) -> DepthAndMaxPosition {
1043 self.0
1044 .first()
1045 .map_or(DepthAndMaxPosition(usize::MAX, Anchor::MAX), |region| {
1046 DepthAndMaxPosition(region.depth, region.range.start)
1047 })
1048 }
1049
1050 fn intersects(&self, layer: &SyntaxLayer, text: &BufferSnapshot) -> bool {
1051 for region in &self.0 {
1052 if region.depth < layer.depth {
1053 continue;
1054 }
1055 if region.depth > layer.depth {
1056 break;
1057 }
1058 if region.range.end.cmp(&layer.range.start, text).is_le() {
1059 continue;
1060 }
1061 if region.range.start.cmp(&layer.range.end, text).is_ge() {
1062 break;
1063 }
1064 return true;
1065 }
1066 false
1067 }
1068
1069 fn insert(&mut self, region: ChangedRegion, text: &BufferSnapshot) {
1070 if let Err(ix) = self.0.binary_search_by(|probe| probe.cmp(®ion, text)) {
1071 self.0.insert(ix, region);
1072 }
1073 }
1074
1075 fn prune(&mut self, summary: SyntaxLayerSummary, text: &BufferSnapshot) -> bool {
1076 let prev_len = self.0.len();
1077 self.0.retain(|region| {
1078 region.depth > summary.max_depth
1079 || (region.depth == summary.max_depth
1080 && region
1081 .range
1082 .end
1083 .cmp(&summary.last_layer_range.start, text)
1084 .is_gt())
1085 });
1086 self.0.len() < prev_len
1087 }
1088}
1089
1090impl Default for SyntaxLayerSummary {
1091 fn default() -> Self {
1092 Self {
1093 max_depth: 0,
1094 min_depth: 0,
1095 range: Anchor::MAX..Anchor::MIN,
1096 last_layer_range: Anchor::MIN..Anchor::MAX,
1097 }
1098 }
1099}
1100
1101impl sum_tree::Summary for SyntaxLayerSummary {
1102 type Context = BufferSnapshot;
1103
1104 fn add_summary(&mut self, other: &Self, buffer: &Self::Context) {
1105 if other.max_depth > self.max_depth {
1106 self.max_depth = other.max_depth;
1107 self.range = other.range.clone();
1108 } else {
1109 if other.range.start.cmp(&self.range.start, buffer).is_lt() {
1110 self.range.start = other.range.start;
1111 }
1112 if other.range.end.cmp(&self.range.end, buffer).is_gt() {
1113 self.range.end = other.range.end;
1114 }
1115 }
1116 self.last_layer_range = other.last_layer_range.clone();
1117 }
1118}
1119
1120impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary> for DepthAndRange {
1121 fn cmp(&self, cursor_location: &SyntaxLayerSummary, buffer: &BufferSnapshot) -> Ordering {
1122 Ord::cmp(&self.0, &cursor_location.max_depth)
1123 .then_with(|| {
1124 self.1
1125 .start
1126 .cmp(&cursor_location.last_layer_range.start, buffer)
1127 })
1128 .then_with(|| {
1129 cursor_location
1130 .last_layer_range
1131 .end
1132 .cmp(&self.1.end, buffer)
1133 })
1134 }
1135}
1136
1137impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary> for DepthAndMaxPosition {
1138 fn cmp(&self, cursor_location: &SyntaxLayerSummary, text: &BufferSnapshot) -> Ordering {
1139 Ord::cmp(&self.0, &cursor_location.max_depth)
1140 .then_with(|| self.1.cmp(&cursor_location.range.end, text))
1141 }
1142}
1143
1144impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary> for DepthAndRangeOrMaxPosition {
1145 fn cmp(&self, cursor_location: &SyntaxLayerSummary, buffer: &BufferSnapshot) -> Ordering {
1146 if self.1.cmp(cursor_location, buffer).is_le() {
1147 return Ordering::Less;
1148 } else {
1149 self.0.cmp(cursor_location, buffer)
1150 }
1151 }
1152}
1153
1154impl sum_tree::Item for SyntaxLayer {
1155 type Summary = SyntaxLayerSummary;
1156
1157 fn summary(&self) -> Self::Summary {
1158 SyntaxLayerSummary {
1159 min_depth: self.depth,
1160 max_depth: self.depth,
1161 range: self.range.clone(),
1162 last_layer_range: self.range.clone(),
1163 }
1164 }
1165}
1166
1167impl std::fmt::Debug for SyntaxLayer {
1168 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1169 f.debug_struct("SyntaxLayer")
1170 .field("depth", &self.depth)
1171 .field("range", &self.range)
1172 .field("tree", &self.tree)
1173 .finish()
1174 }
1175}
1176
1177impl<'a> tree_sitter::TextProvider<'a> for TextProvider<'a> {
1178 type I = ByteChunks<'a>;
1179
1180 fn text(&mut self, node: tree_sitter::Node) -> Self::I {
1181 ByteChunks(self.0.chunks_in_range(node.byte_range()))
1182 }
1183}
1184
1185impl<'a> Iterator for ByteChunks<'a> {
1186 type Item = &'a [u8];
1187
1188 fn next(&mut self) -> Option<Self::Item> {
1189 self.0.next().map(str::as_bytes)
1190 }
1191}
1192
1193impl QueryCursorHandle {
1194 pub(crate) fn new() -> Self {
1195 let mut cursor = QUERY_CURSORS.lock().pop().unwrap_or_else(QueryCursor::new);
1196 cursor.set_match_limit(64);
1197 QueryCursorHandle(Some(cursor))
1198 }
1199}
1200
1201impl Deref for QueryCursorHandle {
1202 type Target = QueryCursor;
1203
1204 fn deref(&self) -> &Self::Target {
1205 self.0.as_ref().unwrap()
1206 }
1207}
1208
1209impl DerefMut for QueryCursorHandle {
1210 fn deref_mut(&mut self) -> &mut Self::Target {
1211 self.0.as_mut().unwrap()
1212 }
1213}
1214
1215impl Drop for QueryCursorHandle {
1216 fn drop(&mut self) {
1217 let mut cursor = self.0.take().unwrap();
1218 cursor.set_byte_range(0..usize::MAX);
1219 cursor.set_point_range(Point::zero().to_ts_point()..Point::MAX.to_ts_point());
1220 QUERY_CURSORS.lock().push(cursor)
1221 }
1222}
1223
1224pub(crate) trait ToTreeSitterPoint {
1225 fn to_ts_point(self) -> tree_sitter::Point;
1226 fn from_ts_point(point: tree_sitter::Point) -> Self;
1227}
1228
1229impl ToTreeSitterPoint for Point {
1230 fn to_ts_point(self) -> tree_sitter::Point {
1231 tree_sitter::Point::new(self.row as usize, self.column as usize)
1232 }
1233
1234 fn from_ts_point(point: tree_sitter::Point) -> Self {
1235 Point::new(point.row as u32, point.column as u32)
1236 }
1237}
1238
1239#[cfg(test)]
1240mod tests {
1241 use super::*;
1242 use crate::LanguageConfig;
1243 use rand::rngs::StdRng;
1244 use std::env;
1245 use text::Buffer;
1246 use unindent::Unindent as _;
1247 use util::test::marked_text_ranges;
1248
1249 #[gpui::test]
1250 fn test_syntax_map_layers_for_range() {
1251 let registry = Arc::new(LanguageRegistry::test());
1252 let language = Arc::new(rust_lang());
1253 registry.add(language.clone());
1254
1255 let mut buffer = Buffer::new(
1256 0,
1257 0,
1258 r#"
1259 fn a() {
1260 assert_eq!(
1261 b(vec![C {}]),
1262 vec![d.e],
1263 );
1264 println!("{}", f(|_| true));
1265 }
1266 "#
1267 .unindent(),
1268 );
1269
1270 let mut syntax_map = SyntaxMap::new();
1271 syntax_map.set_language_registry(registry.clone());
1272 syntax_map.reparse(language.clone(), &buffer);
1273
1274 assert_layers_for_range(
1275 &syntax_map,
1276 &buffer,
1277 Point::new(2, 0)..Point::new(2, 0),
1278 &[
1279 "...(function_item ... (block (expression_statement (macro_invocation...",
1280 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1281 ],
1282 );
1283 assert_layers_for_range(
1284 &syntax_map,
1285 &buffer,
1286 Point::new(2, 14)..Point::new(2, 16),
1287 &[
1288 "...(function_item ...",
1289 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1290 "...(array_expression (struct_expression ...",
1291 ],
1292 );
1293 assert_layers_for_range(
1294 &syntax_map,
1295 &buffer,
1296 Point::new(3, 14)..Point::new(3, 16),
1297 &[
1298 "...(function_item ...",
1299 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1300 "...(array_expression (field_expression ...",
1301 ],
1302 );
1303 assert_layers_for_range(
1304 &syntax_map,
1305 &buffer,
1306 Point::new(5, 12)..Point::new(5, 16),
1307 &[
1308 "...(function_item ...",
1309 "...(call_expression ... (arguments (closure_expression ...",
1310 ],
1311 );
1312
1313 // Replace a vec! macro invocation with a plain slice, removing a syntactic layer.
1314 let macro_name_range = range_for_text(&buffer, "vec!");
1315 buffer.edit([(macro_name_range, "&")]);
1316 syntax_map.interpolate(&buffer);
1317 syntax_map.reparse(language.clone(), &buffer);
1318
1319 assert_layers_for_range(
1320 &syntax_map,
1321 &buffer,
1322 Point::new(2, 14)..Point::new(2, 16),
1323 &[
1324 "...(function_item ...",
1325 "...(tuple_expression (call_expression ... arguments: (arguments (reference_expression value: (array_expression...",
1326 ],
1327 );
1328
1329 // Put the vec! macro back, adding back the syntactic layer.
1330 buffer.undo();
1331 syntax_map.interpolate(&buffer);
1332 syntax_map.reparse(language.clone(), &buffer);
1333
1334 assert_layers_for_range(
1335 &syntax_map,
1336 &buffer,
1337 Point::new(2, 14)..Point::new(2, 16),
1338 &[
1339 "...(function_item ...",
1340 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1341 "...(array_expression (struct_expression ...",
1342 ],
1343 );
1344 }
1345
1346 #[gpui::test]
1347 fn test_typing_multiple_new_injections() {
1348 let (buffer, syntax_map) = test_edit_sequence(&[
1349 "fn a() { dbg }",
1350 "fn a() { dbg«!» }",
1351 "fn a() { dbg!«()» }",
1352 "fn a() { dbg!(«b») }",
1353 "fn a() { dbg!(b«.») }",
1354 "fn a() { dbg!(b.«c») }",
1355 "fn a() { dbg!(b.c«()») }",
1356 "fn a() { dbg!(b.c(«vec»)) }",
1357 "fn a() { dbg!(b.c(vec«!»)) }",
1358 "fn a() { dbg!(b.c(vec!«[]»)) }",
1359 "fn a() { dbg!(b.c(vec![«d»])) }",
1360 "fn a() { dbg!(b.c(vec![d«.»])) }",
1361 "fn a() { dbg!(b.c(vec![d.«e»])) }",
1362 ]);
1363
1364 assert_capture_ranges(
1365 &syntax_map,
1366 &buffer,
1367 &["field"],
1368 "fn a() { dbg!(b.«c»(vec![d.«e»])) }",
1369 );
1370 }
1371
1372 #[gpui::test]
1373 fn test_pasting_new_injection_line_between_others() {
1374 let (buffer, syntax_map) = test_edit_sequence(&[
1375 "
1376 fn a() {
1377 b!(B {});
1378 c!(C {});
1379 d!(D {});
1380 e!(E {});
1381 f!(F {});
1382 g!(G {});
1383 }
1384 ",
1385 "
1386 fn a() {
1387 b!(B {});
1388 c!(C {});
1389 d!(D {});
1390 « h!(H {});
1391 » e!(E {});
1392 f!(F {});
1393 g!(G {});
1394 }
1395 ",
1396 ]);
1397
1398 assert_capture_ranges(
1399 &syntax_map,
1400 &buffer,
1401 &["struct"],
1402 "
1403 fn a() {
1404 b!(«B {}»);
1405 c!(«C {}»);
1406 d!(«D {}»);
1407 h!(«H {}»);
1408 e!(«E {}»);
1409 f!(«F {}»);
1410 g!(«G {}»);
1411 }
1412 ",
1413 );
1414 }
1415
1416 #[gpui::test]
1417 fn test_joining_injections_with_child_injections() {
1418 let (buffer, syntax_map) = test_edit_sequence(&[
1419 "
1420 fn a() {
1421 b!(
1422 c![one.two.three],
1423 d![four.five.six],
1424 );
1425 e!(
1426 f![seven.eight],
1427 );
1428 }
1429 ",
1430 "
1431 fn a() {
1432 b!(
1433 c![one.two.three],
1434 d![four.five.six],
1435 ˇ f![seven.eight],
1436 );
1437 }
1438 ",
1439 ]);
1440
1441 assert_capture_ranges(
1442 &syntax_map,
1443 &buffer,
1444 &["field"],
1445 "
1446 fn a() {
1447 b!(
1448 c![one.«two».«three»],
1449 d![four.«five».«six»],
1450 f![seven.«eight»],
1451 );
1452 }
1453 ",
1454 );
1455 }
1456
1457 #[gpui::test]
1458 fn test_editing_edges_of_injection() {
1459 test_edit_sequence(&[
1460 "
1461 fn a() {
1462 b!(c!())
1463 }
1464 ",
1465 "
1466 fn a() {
1467 «d»!(c!())
1468 }
1469 ",
1470 "
1471 fn a() {
1472 «e»d!(c!())
1473 }
1474 ",
1475 "
1476 fn a() {
1477 ed!«[»c!()«]»
1478 }
1479 ",
1480 ]);
1481 }
1482
1483 #[gpui::test]
1484 fn test_edits_preceding_and_intersecting_injection() {
1485 test_edit_sequence(&[
1486 //
1487 "const aaaaaaaaaaaa: B = c!(d(e.f));",
1488 "const aˇa: B = c!(d(eˇ));",
1489 ]);
1490 }
1491
1492 #[gpui::test]
1493 fn test_non_local_changes_create_injections() {
1494 test_edit_sequence(&[
1495 "
1496 // a! {
1497 static B: C = d;
1498 // }
1499 ",
1500 "
1501 ˇa! {
1502 static B: C = d;
1503 ˇ}
1504 ",
1505 ]);
1506 }
1507
1508 #[gpui::test]
1509 fn test_creating_many_injections_in_one_edit() {
1510 test_edit_sequence(&[
1511 "
1512 fn a() {
1513 one(Two::three(3));
1514 four(Five::six(6));
1515 seven(Eight::nine(9));
1516 }
1517 ",
1518 "
1519 fn a() {
1520 one«!»(Two::three(3));
1521 four«!»(Five::six(6));
1522 seven«!»(Eight::nine(9));
1523 }
1524 ",
1525 "
1526 fn a() {
1527 one!(Two::three«!»(3));
1528 four!(Five::six«!»(6));
1529 seven!(Eight::nine«!»(9));
1530 }
1531 ",
1532 ]);
1533 }
1534
1535 #[gpui::test]
1536 fn test_editing_across_injection_boundary() {
1537 test_edit_sequence(&[
1538 "
1539 fn one() {
1540 two();
1541 three!(
1542 three.four,
1543 five.six,
1544 );
1545 }
1546 ",
1547 "
1548 fn one() {
1549 two();
1550 th«irty_five![»
1551 three.four,
1552 five.six,
1553 « seven.eight,
1554 ];»
1555 }
1556 ",
1557 ]);
1558 }
1559
1560 #[gpui::test]
1561 fn test_removing_injection_by_replacing_across_boundary() {
1562 test_edit_sequence(&[
1563 "
1564 fn one() {
1565 two!(
1566 three.four,
1567 );
1568 }
1569 ",
1570 "
1571 fn one() {
1572 t«en
1573 .eleven(
1574 twelve,
1575 »
1576 three.four,
1577 );
1578 }
1579 ",
1580 ]);
1581 }
1582
1583 #[gpui::test(iterations = 100)]
1584 fn test_random_syntax_map_edits(mut rng: StdRng) {
1585 let operations = env::var("OPERATIONS")
1586 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
1587 .unwrap_or(10);
1588
1589 let text = r#"
1590 fn test_something() {
1591 let vec = vec![5, 1, 3, 8];
1592 assert_eq!(
1593 vec
1594 .into_iter()
1595 .map(|i| i * 2)
1596 .collect::<Vec<usize>>(),
1597 vec![
1598 5 * 2, 1 * 2, 3 * 2, 8 * 2
1599 ],
1600 );
1601 }
1602 "#
1603 .unindent()
1604 .repeat(2);
1605
1606 let registry = Arc::new(LanguageRegistry::test());
1607 let language = Arc::new(rust_lang());
1608 registry.add(language.clone());
1609 let mut buffer = Buffer::new(0, 0, text);
1610
1611 let mut syntax_map = SyntaxMap::new();
1612 syntax_map.set_language_registry(registry.clone());
1613 syntax_map.reparse(language.clone(), &buffer);
1614
1615 let mut reference_syntax_map = SyntaxMap::new();
1616 reference_syntax_map.set_language_registry(registry.clone());
1617
1618 log::info!("initial text:\n{}", buffer.text());
1619
1620 for _ in 0..operations {
1621 let prev_buffer = buffer.snapshot();
1622 let prev_syntax_map = syntax_map.snapshot();
1623
1624 buffer.randomly_edit(&mut rng, 3);
1625 log::info!("text:\n{}", buffer.text());
1626
1627 syntax_map.interpolate(&buffer);
1628 check_interpolation(&prev_syntax_map, &syntax_map, &prev_buffer, &buffer);
1629
1630 syntax_map.reparse(language.clone(), &buffer);
1631
1632 reference_syntax_map.clear();
1633 reference_syntax_map.reparse(language.clone(), &buffer);
1634 }
1635
1636 for i in 0..operations {
1637 let i = operations - i - 1;
1638 buffer.undo();
1639 log::info!("undoing operation {}", i);
1640 log::info!("text:\n{}", buffer.text());
1641
1642 syntax_map.interpolate(&buffer);
1643 syntax_map.reparse(language.clone(), &buffer);
1644
1645 reference_syntax_map.clear();
1646 reference_syntax_map.reparse(language.clone(), &buffer);
1647 assert_eq!(
1648 syntax_map.layers(&buffer).len(),
1649 reference_syntax_map.layers(&buffer).len(),
1650 "wrong number of layers after undoing edit {i}"
1651 );
1652 }
1653
1654 let layers = syntax_map.layers(&buffer);
1655 let reference_layers = reference_syntax_map.layers(&buffer);
1656 for (edited_layer, reference_layer) in layers.into_iter().zip(reference_layers.into_iter())
1657 {
1658 assert_eq!(edited_layer.node.to_sexp(), reference_layer.node.to_sexp());
1659 assert_eq!(edited_layer.node.range(), reference_layer.node.range());
1660 }
1661 }
1662
1663 fn check_interpolation(
1664 old_syntax_map: &SyntaxSnapshot,
1665 new_syntax_map: &SyntaxSnapshot,
1666 old_buffer: &BufferSnapshot,
1667 new_buffer: &BufferSnapshot,
1668 ) {
1669 let edits = new_buffer
1670 .edits_since::<usize>(&old_buffer.version())
1671 .collect::<Vec<_>>();
1672
1673 for (old_layer, new_layer) in old_syntax_map
1674 .layers
1675 .iter()
1676 .zip(new_syntax_map.layers.iter())
1677 {
1678 assert_eq!(old_layer.range, new_layer.range);
1679 let old_start_byte = old_layer.range.start.to_offset(old_buffer);
1680 let new_start_byte = new_layer.range.start.to_offset(new_buffer);
1681 let old_start_point = old_layer.range.start.to_point(old_buffer).to_ts_point();
1682 let new_start_point = new_layer.range.start.to_point(new_buffer).to_ts_point();
1683 let old_node = old_layer
1684 .tree
1685 .root_node_with_offset(old_start_byte, old_start_point);
1686 let new_node = new_layer
1687 .tree
1688 .root_node_with_offset(new_start_byte, new_start_point);
1689 check_node_edits(
1690 old_layer.depth,
1691 &old_layer.range,
1692 old_node,
1693 new_node,
1694 old_buffer,
1695 new_buffer,
1696 &edits,
1697 );
1698 }
1699
1700 fn check_node_edits(
1701 depth: usize,
1702 range: &Range<Anchor>,
1703 old_node: Node,
1704 new_node: Node,
1705 old_buffer: &BufferSnapshot,
1706 new_buffer: &BufferSnapshot,
1707 edits: &[text::Edit<usize>],
1708 ) {
1709 assert_eq!(old_node.kind(), new_node.kind());
1710
1711 let old_range = old_node.byte_range();
1712 let new_range = new_node.byte_range();
1713
1714 let is_edited = edits
1715 .iter()
1716 .any(|edit| edit.new.start < new_range.end && edit.new.end > new_range.start);
1717 if is_edited {
1718 assert!(
1719 new_node.has_changes(),
1720 concat!(
1721 "failed to mark node as edited.\n",
1722 "layer depth: {}, old layer range: {:?}, new layer range: {:?},\n",
1723 "node kind: {}, old node range: {:?}, new node range: {:?}",
1724 ),
1725 depth,
1726 range.to_offset(old_buffer),
1727 range.to_offset(new_buffer),
1728 new_node.kind(),
1729 old_range,
1730 new_range,
1731 );
1732 }
1733
1734 if !new_node.has_changes() {
1735 assert_eq!(
1736 old_buffer
1737 .text_for_range(old_range.clone())
1738 .collect::<String>(),
1739 new_buffer
1740 .text_for_range(new_range.clone())
1741 .collect::<String>(),
1742 concat!(
1743 "mismatched text for node\n",
1744 "layer depth: {}, old layer range: {:?}, new layer range: {:?},\n",
1745 "node kind: {}, old node range:{:?}, new node range:{:?}",
1746 ),
1747 depth,
1748 range.to_offset(old_buffer),
1749 range.to_offset(new_buffer),
1750 new_node.kind(),
1751 old_range,
1752 new_range,
1753 );
1754 }
1755
1756 for i in 0..new_node.child_count() {
1757 check_node_edits(
1758 depth,
1759 range,
1760 old_node.child(i).unwrap(),
1761 new_node.child(i).unwrap(),
1762 old_buffer,
1763 new_buffer,
1764 edits,
1765 )
1766 }
1767 }
1768 }
1769
1770 fn test_edit_sequence(steps: &[&str]) -> (Buffer, SyntaxMap) {
1771 let registry = Arc::new(LanguageRegistry::test());
1772 let language = Arc::new(rust_lang());
1773 registry.add(language.clone());
1774 let mut buffer = Buffer::new(0, 0, Default::default());
1775
1776 let mut mutated_syntax_map = SyntaxMap::new();
1777 mutated_syntax_map.set_language_registry(registry.clone());
1778 mutated_syntax_map.reparse(language.clone(), &buffer);
1779
1780 for (i, marked_string) in steps.into_iter().enumerate() {
1781 edit_buffer(&mut buffer, &marked_string.unindent());
1782
1783 // Reparse the syntax map
1784 mutated_syntax_map.interpolate(&buffer);
1785 mutated_syntax_map.reparse(language.clone(), &buffer);
1786
1787 // Create a second syntax map from scratch
1788 let mut reference_syntax_map = SyntaxMap::new();
1789 reference_syntax_map.set_language_registry(registry.clone());
1790 reference_syntax_map.reparse(language.clone(), &buffer);
1791
1792 // Compare the mutated syntax map to the new syntax map
1793 let mutated_layers = mutated_syntax_map.layers(&buffer);
1794 let reference_layers = reference_syntax_map.layers(&buffer);
1795 assert_eq!(
1796 mutated_layers.len(),
1797 reference_layers.len(),
1798 "wrong number of layers at step {i}"
1799 );
1800 for (edited_layer, reference_layer) in
1801 mutated_layers.into_iter().zip(reference_layers.into_iter())
1802 {
1803 assert_eq!(
1804 edited_layer.node.to_sexp(),
1805 reference_layer.node.to_sexp(),
1806 "different layer at step {i}"
1807 );
1808 assert_eq!(
1809 edited_layer.node.range(),
1810 reference_layer.node.range(),
1811 "different layer at step {i}"
1812 );
1813 }
1814 }
1815
1816 (buffer, mutated_syntax_map)
1817 }
1818
1819 fn rust_lang() -> Language {
1820 Language::new(
1821 LanguageConfig {
1822 name: "Rust".into(),
1823 path_suffixes: vec!["rs".to_string()],
1824 ..Default::default()
1825 },
1826 Some(tree_sitter_rust::language()),
1827 )
1828 .with_highlights_query(
1829 r#"
1830 (field_identifier) @field
1831 (struct_expression) @struct
1832 "#,
1833 )
1834 .unwrap()
1835 .with_injection_query(
1836 r#"
1837 (macro_invocation
1838 (token_tree) @content
1839 (#set! "language" "rust"))
1840 "#,
1841 )
1842 .unwrap()
1843 }
1844
1845 fn range_for_text(buffer: &Buffer, text: &str) -> Range<usize> {
1846 let start = buffer.as_rope().to_string().find(text).unwrap();
1847 start..start + text.len()
1848 }
1849
1850 fn assert_layers_for_range(
1851 syntax_map: &SyntaxMap,
1852 buffer: &BufferSnapshot,
1853 range: Range<Point>,
1854 expected_layers: &[&str],
1855 ) {
1856 let layers = syntax_map
1857 .layers_for_range(range, &buffer)
1858 .collect::<Vec<_>>();
1859 assert_eq!(
1860 layers.len(),
1861 expected_layers.len(),
1862 "wrong number of layers"
1863 );
1864 for (i, (SyntaxLayerInfo { node, .. }, expected_s_exp)) in
1865 layers.iter().zip(expected_layers.iter()).enumerate()
1866 {
1867 let actual_s_exp = node.to_sexp();
1868 assert!(
1869 string_contains_sequence(
1870 &actual_s_exp,
1871 &expected_s_exp.split("...").collect::<Vec<_>>()
1872 ),
1873 "layer {i}:\n\nexpected: {expected_s_exp}\nactual: {actual_s_exp}",
1874 );
1875 }
1876 }
1877
1878 fn assert_capture_ranges(
1879 syntax_map: &SyntaxMap,
1880 buffer: &BufferSnapshot,
1881 highlight_query_capture_names: &[&str],
1882 marked_string: &str,
1883 ) {
1884 let mut actual_ranges = Vec::<Range<usize>>::new();
1885 let captures = syntax_map.captures(0..buffer.len(), buffer, |grammar| {
1886 grammar.highlights_query.as_ref()
1887 });
1888 let queries = captures
1889 .grammars()
1890 .iter()
1891 .map(|grammar| grammar.highlights_query.as_ref().unwrap())
1892 .collect::<Vec<_>>();
1893 for capture in captures {
1894 let name = &queries[capture.grammar_index].capture_names()[capture.index as usize];
1895 if highlight_query_capture_names.contains(&name.as_str()) {
1896 actual_ranges.push(capture.node.byte_range());
1897 }
1898 }
1899
1900 let (text, expected_ranges) = marked_text_ranges(&marked_string.unindent(), false);
1901 assert_eq!(text, buffer.text());
1902 assert_eq!(actual_ranges, expected_ranges);
1903 }
1904
1905 fn edit_buffer(buffer: &mut Buffer, marked_string: &str) {
1906 let old_text = buffer.text();
1907 let (new_text, mut ranges) = marked_text_ranges(marked_string, false);
1908 if ranges.is_empty() {
1909 ranges.push(0..new_text.len());
1910 }
1911
1912 assert_eq!(
1913 old_text[..ranges[0].start],
1914 new_text[..ranges[0].start],
1915 "invalid edit"
1916 );
1917
1918 let mut delta = 0;
1919 let mut edits = Vec::new();
1920 let mut ranges = ranges.into_iter().peekable();
1921
1922 while let Some(inserted_range) = ranges.next() {
1923 let new_start = inserted_range.start;
1924 let old_start = (new_start as isize - delta) as usize;
1925
1926 let following_text = if let Some(next_range) = ranges.peek() {
1927 &new_text[inserted_range.end..next_range.start]
1928 } else {
1929 &new_text[inserted_range.end..]
1930 };
1931
1932 let inserted_len = inserted_range.len();
1933 let deleted_len = old_text[old_start..]
1934 .find(following_text)
1935 .expect("invalid edit");
1936
1937 let old_range = old_start..old_start + deleted_len;
1938 edits.push((old_range, new_text[inserted_range].to_string()));
1939 delta += inserted_len as isize - deleted_len as isize;
1940 }
1941
1942 assert_eq!(
1943 old_text.len() as isize + delta,
1944 new_text.len() as isize,
1945 "invalid edit"
1946 );
1947
1948 buffer.edit(edits);
1949 }
1950
1951 pub fn string_contains_sequence(text: &str, parts: &[&str]) -> bool {
1952 let mut last_part_end = 0;
1953 for part in parts {
1954 if let Some(start_ix) = text[last_part_end..].find(part) {
1955 last_part_end = start_ix + part.len();
1956 } else {
1957 return false;
1958 }
1959 }
1960 true
1961 }
1962}