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