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