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