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