1use crate::{Grammar, InjectionConfig, Language, LanguageRegistry};
2use collections::HashMap;
3use lazy_static::lazy_static;
4use parking_lot::Mutex;
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, Point, 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 last_layer_language: Option<usize>,
110}
111
112#[derive(Clone, Debug)]
113struct SyntaxLayerPosition {
114 depth: usize,
115 range: Range<Anchor>,
116 language: Option<usize>,
117}
118
119#[derive(Clone, Debug)]
120struct ChangeStartPosition {
121 depth: usize,
122 position: Anchor,
123}
124
125#[derive(Clone, Debug)]
126struct SyntaxLayerPositionBeforeChange {
127 position: SyntaxLayerPosition,
128 change: ChangeStartPosition,
129}
130
131struct ParseStep {
132 depth: usize,
133 language: Arc<Language>,
134 range: Range<Anchor>,
135 included_ranges: Vec<tree_sitter::Range>,
136 mode: ParseMode,
137}
138
139enum ParseMode {
140 Single,
141 Combined {
142 parent_layer_range: Range<usize>,
143 parent_layer_changed_ranges: Vec<Range<usize>>,
144 },
145}
146
147#[derive(Debug, PartialEq, Eq)]
148struct ChangedRegion {
149 depth: usize,
150 range: Range<Anchor>,
151}
152
153#[derive(Default)]
154struct ChangeRegionSet(Vec<ChangedRegion>);
155
156struct TextProvider<'a>(&'a Rope);
157
158struct ByteChunks<'a>(text::Chunks<'a>);
159
160struct QueryCursorHandle(Option<QueryCursor>);
161
162impl SyntaxMap {
163 pub fn new() -> Self {
164 Self::default()
165 }
166
167 pub fn set_language_registry(&mut self, registry: Arc<LanguageRegistry>) {
168 self.language_registry = Some(registry);
169 }
170
171 pub fn snapshot(&self) -> SyntaxSnapshot {
172 self.snapshot.clone()
173 }
174
175 pub fn language_registry(&self) -> Option<Arc<LanguageRegistry>> {
176 self.language_registry.clone()
177 }
178
179 pub fn parsed_version(&self) -> clock::Global {
180 self.parsed_version.clone()
181 }
182
183 pub fn interpolate(&mut self, text: &BufferSnapshot) {
184 self.snapshot.interpolate(&self.interpolated_version, text);
185 self.interpolated_version = text.version.clone();
186 }
187
188 #[cfg(test)]
189 pub fn reparse(&mut self, language: Arc<Language>, text: &BufferSnapshot) {
190 self.snapshot.reparse(
191 &self.parsed_version,
192 text,
193 self.language_registry.clone(),
194 language,
195 );
196 self.parsed_version = text.version.clone();
197 self.interpolated_version = text.version.clone();
198 }
199
200 pub fn did_parse(&mut self, snapshot: SyntaxSnapshot, version: clock::Global) {
201 self.interpolated_version = version.clone();
202 self.parsed_version = version;
203 self.snapshot = snapshot;
204 }
205
206 pub fn clear(&mut self) {
207 self.snapshot = SyntaxSnapshot::default();
208 }
209}
210
211impl SyntaxSnapshot {
212 pub fn is_empty(&self) -> bool {
213 self.layers.is_empty()
214 }
215
216 pub fn interpolate(&mut self, from_version: &clock::Global, text: &BufferSnapshot) {
217 let edits = text
218 .anchored_edits_since::<(usize, Point)>(&from_version)
219 .collect::<Vec<_>>();
220 if edits.is_empty() {
221 return;
222 }
223
224 let mut layers = SumTree::new();
225 let mut first_edit_ix_for_depth = 0;
226 let mut prev_depth = 0;
227 let mut cursor = self.layers.cursor::<SyntaxLayerSummary>();
228 cursor.next(text);
229
230 'outer: loop {
231 let depth = cursor.end(text).max_depth;
232 if depth > prev_depth {
233 first_edit_ix_for_depth = 0;
234 prev_depth = depth;
235 }
236
237 // Preserve any layers at this depth that precede the first edit.
238 if let Some((_, edit_range)) = edits.get(first_edit_ix_for_depth) {
239 let target = ChangeStartPosition {
240 depth,
241 position: edit_range.start,
242 };
243 if target.cmp(&cursor.start(), text).is_gt() {
244 let slice = cursor.slice(&target, Bias::Left, text);
245 layers.push_tree(slice, text);
246 }
247 }
248 // If this layer follows all of the edits, then preserve it and any
249 // subsequent layers at this same depth.
250 else if cursor.item().is_some() {
251 let slice = cursor.slice(
252 &SyntaxLayerPosition {
253 depth: depth + 1,
254 range: Anchor::MIN..Anchor::MAX,
255 language: None,
256 },
257 Bias::Left,
258 text,
259 );
260 layers.push_tree(slice, text);
261 continue;
262 };
263
264 let Some(layer) = cursor.item() else { break };
265 let (start_byte, start_point) = layer.range.start.summary::<(usize, Point)>(text);
266
267 // Ignore edits that end before the start of this layer, and don't consider them
268 // for any subsequent layers at this same depth.
269 loop {
270 let Some((_, edit_range)) = edits.get(first_edit_ix_for_depth) else { continue 'outer };
271 if edit_range.end.cmp(&layer.range.start, text).is_le() {
272 first_edit_ix_for_depth += 1;
273 } else {
274 break;
275 }
276 }
277
278 let mut layer = layer.clone();
279 for (edit, edit_range) in &edits[first_edit_ix_for_depth..] {
280 // Ignore any edits that follow this layer.
281 if edit_range.start.cmp(&layer.range.end, text).is_ge() {
282 break;
283 }
284
285 // Apply any edits that intersect this layer to the layer's syntax tree.
286 let tree_edit = if edit_range.start.cmp(&layer.range.start, text).is_ge() {
287 tree_sitter::InputEdit {
288 start_byte: edit.new.start.0 - start_byte,
289 old_end_byte: edit.new.start.0 - start_byte
290 + (edit.old.end.0 - edit.old.start.0),
291 new_end_byte: edit.new.end.0 - start_byte,
292 start_position: (edit.new.start.1 - start_point).to_ts_point(),
293 old_end_position: (edit.new.start.1 - start_point
294 + (edit.old.end.1 - edit.old.start.1))
295 .to_ts_point(),
296 new_end_position: (edit.new.end.1 - start_point).to_ts_point(),
297 }
298 } else {
299 let node = layer.tree.root_node();
300 tree_sitter::InputEdit {
301 start_byte: 0,
302 old_end_byte: node.end_byte(),
303 new_end_byte: 0,
304 start_position: Default::default(),
305 old_end_position: node.end_position(),
306 new_end_position: Default::default(),
307 }
308 };
309
310 layer.tree.edit(&tree_edit);
311 }
312
313 debug_assert!(
314 layer.tree.root_node().end_byte() <= text.len(),
315 "tree's size {}, is larger than text size {}",
316 layer.tree.root_node().end_byte(),
317 text.len(),
318 );
319
320 layers.push(layer, text);
321 cursor.next(text);
322 }
323
324 layers.push_tree(cursor.suffix(&text), &text);
325 drop(cursor);
326 self.layers = layers;
327 }
328
329 pub fn reparse(
330 &mut self,
331 from_version: &clock::Global,
332 text: &BufferSnapshot,
333 registry: Option<Arc<LanguageRegistry>>,
334 root_language: Arc<Language>,
335 ) {
336 let edits = text.edits_since::<usize>(from_version).collect::<Vec<_>>();
337 let max_depth = self.layers.summary().max_depth;
338 let mut cursor = self.layers.cursor::<SyntaxLayerSummary>();
339 cursor.next(&text);
340 let mut layers = SumTree::new();
341
342 let mut changed_regions = ChangeRegionSet::default();
343 let mut queue = BinaryHeap::new();
344 let mut combined_injection_ranges = HashMap::default();
345 queue.push(ParseStep {
346 depth: 0,
347 language: root_language.clone(),
348 included_ranges: vec![tree_sitter::Range {
349 start_byte: 0,
350 end_byte: text.len(),
351 start_point: Point::zero().to_ts_point(),
352 end_point: text.max_point().to_ts_point(),
353 }],
354 range: Anchor::MIN..Anchor::MAX,
355 mode: ParseMode::Single,
356 });
357
358 loop {
359 let step = queue.pop();
360 let position = if let Some(step) = &step {
361 SyntaxLayerPosition {
362 depth: step.depth,
363 range: step.range.clone(),
364 language: step.language.id(),
365 }
366 } else {
367 SyntaxLayerPosition {
368 depth: max_depth + 1,
369 range: Anchor::MAX..Anchor::MAX,
370 language: None,
371 }
372 };
373
374 let mut done = cursor.item().is_none();
375 while !done && position.cmp(&cursor.end(text), &text).is_gt() {
376 done = true;
377
378 let bounded_position = SyntaxLayerPositionBeforeChange {
379 position: position.clone(),
380 change: changed_regions.start_position(),
381 };
382 if bounded_position.cmp(&cursor.start(), &text).is_gt() {
383 let slice = cursor.slice(&bounded_position, Bias::Left, text);
384 if !slice.is_empty() {
385 layers.push_tree(slice, &text);
386 if changed_regions.prune(cursor.end(text), text) {
387 done = false;
388 }
389 }
390 }
391
392 while position.cmp(&cursor.end(text), text).is_gt() {
393 let Some(layer) = cursor.item() else { break };
394
395 if changed_regions.intersects(&layer, text) {
396 changed_regions.insert(
397 ChangedRegion {
398 depth: layer.depth + 1,
399 range: layer.range.clone(),
400 },
401 text,
402 );
403 } else {
404 layers.push(layer.clone(), text);
405 }
406
407 cursor.next(text);
408 if changed_regions.prune(cursor.end(text), text) {
409 done = false;
410 }
411 }
412 }
413
414 let Some(step) = step else { break };
415 let (step_start_byte, step_start_point) =
416 step.range.start.summary::<(usize, Point)>(text);
417 let step_end_byte = step.range.end.to_offset(text);
418 let Some(grammar) = step.language.grammar.as_deref() else { continue };
419
420 let mut old_layer = cursor.item();
421 if let Some(layer) = old_layer {
422 if layer.range.to_offset(text) == (step_start_byte..step_end_byte)
423 && layer.language.id() == step.language.id()
424 {
425 cursor.next(&text);
426 } else {
427 old_layer = None;
428 }
429 }
430
431 let tree;
432 let changed_ranges;
433 let mut included_ranges = step.included_ranges;
434 if let Some(old_layer) = old_layer {
435 if let ParseMode::Combined {
436 parent_layer_changed_ranges,
437 ..
438 } = step.mode
439 {
440 included_ranges = splice_included_ranges(
441 old_layer.tree.included_ranges(),
442 &parent_layer_changed_ranges,
443 &included_ranges,
444 );
445 }
446
447 tree = parse_text(
448 grammar,
449 text.as_rope(),
450 step_start_byte,
451 step_start_point,
452 included_ranges,
453 Some(old_layer.tree.clone()),
454 );
455 changed_ranges = join_ranges(
456 edits.iter().map(|e| e.new.clone()).filter(|range| {
457 range.start <= step_end_byte && range.end >= step_start_byte
458 }),
459 old_layer
460 .tree
461 .changed_ranges(&tree)
462 .map(|r| step_start_byte + r.start_byte..step_start_byte + r.end_byte),
463 );
464 } else {
465 tree = parse_text(
466 grammar,
467 text.as_rope(),
468 step_start_byte,
469 step_start_point,
470 included_ranges,
471 None,
472 );
473 changed_ranges = vec![step_start_byte..step_end_byte];
474 }
475
476 layers.push(
477 SyntaxLayer {
478 depth: step.depth,
479 range: step.range,
480 tree: tree.clone(),
481 language: step.language.clone(),
482 },
483 &text,
484 );
485
486 if let (Some((config, registry)), false) = (
487 grammar.injection_config.as_ref().zip(registry.as_ref()),
488 changed_ranges.is_empty(),
489 ) {
490 for range in &changed_ranges {
491 changed_regions.insert(
492 ChangedRegion {
493 depth: step.depth + 1,
494 range: text.anchor_before(range.start)..text.anchor_after(range.end),
495 },
496 text,
497 );
498 }
499 get_injections(
500 config,
501 text,
502 tree.root_node_with_offset(step_start_byte, step_start_point.to_ts_point()),
503 registry,
504 step.depth + 1,
505 &changed_ranges,
506 &mut combined_injection_ranges,
507 &mut queue,
508 );
509 }
510 }
511
512 drop(cursor);
513 self.layers = layers;
514 }
515
516 pub fn single_tree_captures<'a>(
517 range: Range<usize>,
518 text: &'a Rope,
519 tree: &'a Tree,
520 language: &'a Arc<Language>,
521 query: fn(&Grammar) -> Option<&Query>,
522 ) -> SyntaxMapCaptures<'a> {
523 SyntaxMapCaptures::new(
524 range.clone(),
525 text,
526 [SyntaxLayerInfo {
527 language,
528 depth: 0,
529 node: tree.root_node(),
530 }]
531 .into_iter(),
532 query,
533 )
534 }
535
536 pub fn captures<'a>(
537 &'a self,
538 range: Range<usize>,
539 buffer: &'a BufferSnapshot,
540 query: fn(&Grammar) -> Option<&Query>,
541 ) -> SyntaxMapCaptures {
542 SyntaxMapCaptures::new(
543 range.clone(),
544 buffer.as_rope(),
545 self.layers_for_range(range, buffer).into_iter(),
546 query,
547 )
548 }
549
550 pub fn matches<'a>(
551 &'a self,
552 range: Range<usize>,
553 buffer: &'a BufferSnapshot,
554 query: fn(&Grammar) -> Option<&Query>,
555 ) -> SyntaxMapMatches {
556 SyntaxMapMatches::new(
557 range.clone(),
558 buffer.as_rope(),
559 self.layers_for_range(range, buffer).into_iter(),
560 query,
561 )
562 }
563
564 #[cfg(test)]
565 pub fn layers<'a>(&'a self, buffer: &'a BufferSnapshot) -> Vec<SyntaxLayerInfo> {
566 self.layers_for_range(0..buffer.len(), buffer).collect()
567 }
568
569 pub fn layers_for_range<'a, T: ToOffset>(
570 &'a self,
571 range: Range<T>,
572 buffer: &'a BufferSnapshot,
573 ) -> impl 'a + Iterator<Item = SyntaxLayerInfo> {
574 let start = buffer.anchor_before(range.start.to_offset(buffer));
575 let end = buffer.anchor_after(range.end.to_offset(buffer));
576
577 let mut cursor = self.layers.filter::<_, ()>(move |summary| {
578 if summary.max_depth > summary.min_depth {
579 true
580 } else {
581 let is_before_start = summary.range.end.cmp(&start, buffer).is_lt();
582 let is_after_end = summary.range.start.cmp(&end, buffer).is_gt();
583 !is_before_start && !is_after_end
584 }
585 });
586
587 cursor.next(buffer);
588 std::iter::from_fn(move || {
589 if let Some(layer) = cursor.item() {
590 let info = SyntaxLayerInfo {
591 language: &layer.language,
592 depth: layer.depth,
593 node: layer.tree.root_node_with_offset(
594 layer.range.start.to_offset(buffer),
595 layer.range.start.to_point(buffer).to_ts_point(),
596 ),
597 };
598 cursor.next(buffer);
599 Some(info)
600 } else {
601 None
602 }
603 })
604 }
605}
606
607impl<'a> SyntaxMapCaptures<'a> {
608 fn new(
609 range: Range<usize>,
610 text: &'a Rope,
611 layers: impl Iterator<Item = SyntaxLayerInfo<'a>>,
612 query: fn(&Grammar) -> Option<&Query>,
613 ) -> Self {
614 let mut result = Self {
615 layers: Vec::new(),
616 grammars: Vec::new(),
617 active_layer_count: 0,
618 };
619 for SyntaxLayerInfo {
620 language,
621 depth,
622 node,
623 } in layers
624 {
625 let grammar = match &language.grammar {
626 Some(grammer) => grammer,
627 None => continue,
628 };
629 let query = match query(&grammar) {
630 Some(query) => query,
631 None => continue,
632 };
633
634 let mut query_cursor = QueryCursorHandle::new();
635
636 // TODO - add a Tree-sitter API to remove the need for this.
637 let cursor = unsafe {
638 std::mem::transmute::<_, &'static mut QueryCursor>(query_cursor.deref_mut())
639 };
640
641 cursor.set_byte_range(range.clone());
642 let captures = cursor.captures(query, node, TextProvider(text));
643 let grammar_index = result
644 .grammars
645 .iter()
646 .position(|g| g.id == grammar.id())
647 .unwrap_or_else(|| {
648 result.grammars.push(grammar);
649 result.grammars.len() - 1
650 });
651 let mut layer = SyntaxMapCapturesLayer {
652 depth,
653 grammar_index,
654 next_capture: None,
655 captures,
656 _query_cursor: query_cursor,
657 };
658
659 layer.advance();
660 if layer.next_capture.is_some() {
661 let key = layer.sort_key();
662 let ix = match result.layers[..result.active_layer_count]
663 .binary_search_by_key(&key, |layer| layer.sort_key())
664 {
665 Ok(ix) | Err(ix) => ix,
666 };
667 result.layers.insert(ix, layer);
668 result.active_layer_count += 1;
669 } else {
670 result.layers.push(layer);
671 }
672 }
673
674 result
675 }
676
677 pub fn grammars(&self) -> &[&'a Grammar] {
678 &self.grammars
679 }
680
681 pub fn peek(&self) -> Option<SyntaxMapCapture<'a>> {
682 let layer = self.layers[..self.active_layer_count].first()?;
683 let capture = layer.next_capture?;
684 Some(SyntaxMapCapture {
685 depth: layer.depth,
686 grammar_index: layer.grammar_index,
687 index: capture.index,
688 node: capture.node,
689 })
690 }
691
692 pub fn advance(&mut self) -> bool {
693 let layer = if let Some(layer) = self.layers[..self.active_layer_count].first_mut() {
694 layer
695 } else {
696 return false;
697 };
698
699 layer.advance();
700 if layer.next_capture.is_some() {
701 let key = layer.sort_key();
702 let i = 1 + self.layers[1..self.active_layer_count]
703 .iter()
704 .position(|later_layer| key < later_layer.sort_key())
705 .unwrap_or(self.active_layer_count - 1);
706 self.layers[0..i].rotate_left(1);
707 } else {
708 self.layers[0..self.active_layer_count].rotate_left(1);
709 self.active_layer_count -= 1;
710 }
711
712 true
713 }
714
715 pub fn set_byte_range(&mut self, range: Range<usize>) {
716 for layer in &mut self.layers {
717 layer.captures.set_byte_range(range.clone());
718 if let Some(capture) = &layer.next_capture {
719 if capture.node.end_byte() > range.start {
720 continue;
721 }
722 }
723 layer.advance();
724 }
725 self.layers.sort_unstable_by_key(|layer| layer.sort_key());
726 self.active_layer_count = self
727 .layers
728 .iter()
729 .position(|layer| layer.next_capture.is_none())
730 .unwrap_or(self.layers.len());
731 }
732}
733
734impl<'a> SyntaxMapMatches<'a> {
735 fn new(
736 range: Range<usize>,
737 text: &'a Rope,
738 layers: impl Iterator<Item = SyntaxLayerInfo<'a>>,
739 query: fn(&Grammar) -> Option<&Query>,
740 ) -> Self {
741 let mut result = Self::default();
742 for SyntaxLayerInfo {
743 language,
744 depth,
745 node,
746 } in layers
747 {
748 let grammar = match &language.grammar {
749 Some(grammer) => grammer,
750 None => continue,
751 };
752 let query = match query(&grammar) {
753 Some(query) => query,
754 None => continue,
755 };
756
757 let mut query_cursor = QueryCursorHandle::new();
758
759 // TODO - add a Tree-sitter API to remove the need for this.
760 let cursor = unsafe {
761 std::mem::transmute::<_, &'static mut QueryCursor>(query_cursor.deref_mut())
762 };
763
764 cursor.set_byte_range(range.clone());
765 let matches = cursor.matches(query, node, TextProvider(text));
766 let grammar_index = result
767 .grammars
768 .iter()
769 .position(|g| g.id == grammar.id())
770 .unwrap_or_else(|| {
771 result.grammars.push(grammar);
772 result.grammars.len() - 1
773 });
774 let mut layer = SyntaxMapMatchesLayer {
775 depth,
776 grammar_index,
777 matches,
778 next_pattern_index: 0,
779 next_captures: Vec::new(),
780 has_next: false,
781 _query_cursor: query_cursor,
782 };
783
784 layer.advance();
785 if layer.has_next {
786 let key = layer.sort_key();
787 let ix = match result.layers[..result.active_layer_count]
788 .binary_search_by_key(&key, |layer| layer.sort_key())
789 {
790 Ok(ix) | Err(ix) => ix,
791 };
792 result.layers.insert(ix, layer);
793 result.active_layer_count += 1;
794 } else {
795 result.layers.push(layer);
796 }
797 }
798 result
799 }
800
801 pub fn grammars(&self) -> &[&'a Grammar] {
802 &self.grammars
803 }
804
805 pub fn peek(&self) -> Option<SyntaxMapMatch> {
806 let layer = self.layers.first()?;
807 if !layer.has_next {
808 return None;
809 }
810 Some(SyntaxMapMatch {
811 depth: layer.depth,
812 grammar_index: layer.grammar_index,
813 pattern_index: layer.next_pattern_index,
814 captures: &layer.next_captures,
815 })
816 }
817
818 pub fn advance(&mut self) -> bool {
819 let layer = if let Some(layer) = self.layers.first_mut() {
820 layer
821 } else {
822 return false;
823 };
824
825 layer.advance();
826 if layer.has_next {
827 let key = layer.sort_key();
828 let i = 1 + self.layers[1..self.active_layer_count]
829 .iter()
830 .position(|later_layer| key < later_layer.sort_key())
831 .unwrap_or(self.active_layer_count - 1);
832 self.layers[0..i].rotate_left(1);
833 } else {
834 self.layers[0..self.active_layer_count].rotate_left(1);
835 self.active_layer_count -= 1;
836 }
837
838 true
839 }
840}
841
842impl<'a> SyntaxMapCapturesLayer<'a> {
843 fn advance(&mut self) {
844 self.next_capture = self.captures.next().map(|(mat, ix)| mat.captures[ix]);
845 }
846
847 fn sort_key(&self) -> (usize, Reverse<usize>, usize) {
848 if let Some(capture) = &self.next_capture {
849 let range = capture.node.byte_range();
850 (range.start, Reverse(range.end), self.depth)
851 } else {
852 (usize::MAX, Reverse(0), usize::MAX)
853 }
854 }
855}
856
857impl<'a> SyntaxMapMatchesLayer<'a> {
858 fn advance(&mut self) {
859 if let Some(mat) = self.matches.next() {
860 self.next_captures.clear();
861 self.next_captures.extend_from_slice(&mat.captures);
862 self.next_pattern_index = mat.pattern_index;
863 self.has_next = true;
864 } else {
865 self.has_next = false;
866 }
867 }
868
869 fn sort_key(&self) -> (usize, Reverse<usize>, usize) {
870 if self.has_next {
871 let captures = &self.next_captures;
872 if let Some((first, last)) = captures.first().zip(captures.last()) {
873 return (
874 first.node.start_byte(),
875 Reverse(last.node.end_byte()),
876 self.depth,
877 );
878 }
879 }
880 (usize::MAX, Reverse(0), usize::MAX)
881 }
882}
883
884impl<'a> Iterator for SyntaxMapCaptures<'a> {
885 type Item = SyntaxMapCapture<'a>;
886
887 fn next(&mut self) -> Option<Self::Item> {
888 let result = self.peek();
889 self.advance();
890 result
891 }
892}
893
894fn join_ranges(
895 a: impl Iterator<Item = Range<usize>>,
896 b: impl Iterator<Item = Range<usize>>,
897) -> Vec<Range<usize>> {
898 let mut result = Vec::<Range<usize>>::new();
899 let mut a = a.peekable();
900 let mut b = b.peekable();
901 loop {
902 let range = match (a.peek(), b.peek()) {
903 (Some(range_a), Some(range_b)) => {
904 if range_a.start < range_b.start {
905 a.next().unwrap()
906 } else {
907 b.next().unwrap()
908 }
909 }
910 (None, Some(_)) => b.next().unwrap(),
911 (Some(_), None) => a.next().unwrap(),
912 (None, None) => break,
913 };
914
915 if let Some(last) = result.last_mut() {
916 if range.start <= last.end {
917 last.end = last.end.max(range.end);
918 continue;
919 }
920 }
921 result.push(range);
922 }
923 result
924}
925
926fn parse_text(
927 grammar: &Grammar,
928 text: &Rope,
929 start_byte: usize,
930 start_point: Point,
931 mut ranges: Vec<tree_sitter::Range>,
932 old_tree: Option<Tree>,
933) -> Tree {
934 for range in &mut ranges {
935 range.start_byte -= start_byte;
936 range.end_byte -= start_byte;
937 range.start_point = (Point::from_ts_point(range.start_point) - start_point).to_ts_point();
938 range.end_point = (Point::from_ts_point(range.end_point) - start_point).to_ts_point();
939 }
940
941 PARSER.with(|parser| {
942 let mut parser = parser.borrow_mut();
943 let mut chunks = text.chunks_in_range(start_byte..text.len());
944 parser
945 .set_included_ranges(&ranges)
946 .expect("overlapping ranges");
947 parser
948 .set_language(grammar.ts_language)
949 .expect("incompatible grammar");
950 parser
951 .parse_with(
952 &mut move |offset, _| {
953 chunks.seek(start_byte + offset);
954 chunks.next().unwrap_or("").as_bytes()
955 },
956 old_tree.as_ref(),
957 )
958 .expect("invalid language")
959 })
960}
961
962fn get_injections(
963 config: &InjectionConfig,
964 text: &BufferSnapshot,
965 node: Node,
966 language_registry: &LanguageRegistry,
967 depth: usize,
968 changed_ranges: &[Range<usize>],
969 combined_injection_ranges: &mut HashMap<Arc<Language>, Vec<tree_sitter::Range>>,
970 queue: &mut BinaryHeap<ParseStep>,
971) -> bool {
972 let mut result = false;
973 let mut query_cursor = QueryCursorHandle::new();
974 let mut prev_match = None;
975
976 combined_injection_ranges.clear();
977 for pattern in &config.patterns {
978 if let (Some(language_name), true) = (pattern.language.as_ref(), pattern.combined) {
979 if let Some(language) = language_registry.get_language(language_name) {
980 combined_injection_ranges.insert(language, Vec::new());
981 }
982 }
983 }
984
985 for query_range in changed_ranges {
986 query_cursor.set_byte_range(query_range.start.saturating_sub(1)..query_range.end + 1);
987 for mat in query_cursor.matches(&config.query, node, TextProvider(text.as_rope())) {
988 let content_ranges = mat
989 .nodes_for_capture_index(config.content_capture_ix)
990 .map(|node| node.range())
991 .collect::<Vec<_>>();
992 if content_ranges.is_empty() {
993 continue;
994 }
995
996 // Avoid duplicate matches if two changed ranges intersect the same injection.
997 let content_range =
998 content_ranges.first().unwrap().start_byte..content_ranges.last().unwrap().end_byte;
999 if let Some((last_pattern_ix, last_range)) = &prev_match {
1000 if mat.pattern_index == *last_pattern_ix && content_range == *last_range {
1001 continue;
1002 }
1003 }
1004 prev_match = Some((mat.pattern_index, content_range.clone()));
1005
1006 let combined = config.patterns[mat.pattern_index].combined;
1007 let language_name = config.patterns[mat.pattern_index]
1008 .language
1009 .as_ref()
1010 .map(|s| Cow::Borrowed(s.as_ref()))
1011 .or_else(|| {
1012 let ix = config.language_capture_ix?;
1013 let node = mat.nodes_for_capture_index(ix).next()?;
1014 Some(Cow::Owned(text.text_for_range(node.byte_range()).collect()))
1015 });
1016
1017 if let Some(language_name) = language_name {
1018 if let Some(language) = language_registry.get_language(language_name.as_ref()) {
1019 result = true;
1020 let range = text.anchor_before(content_range.start)
1021 ..text.anchor_after(content_range.end);
1022 if combined {
1023 combined_injection_ranges
1024 .get_mut(&language.clone())
1025 .unwrap()
1026 .extend(content_ranges);
1027 } else {
1028 queue.push(ParseStep {
1029 depth,
1030 language,
1031 included_ranges: content_ranges,
1032 range,
1033 mode: ParseMode::Single,
1034 });
1035 }
1036 }
1037 }
1038 }
1039 }
1040
1041 for (language, mut included_ranges) in combined_injection_ranges.drain() {
1042 included_ranges.sort_unstable();
1043 let range = text.anchor_before(node.start_byte())..text.anchor_after(node.end_byte());
1044 queue.push(ParseStep {
1045 depth,
1046 language,
1047 range,
1048 included_ranges,
1049 mode: ParseMode::Combined {
1050 parent_layer_range: node.start_byte()..node.end_byte(),
1051 parent_layer_changed_ranges: changed_ranges.to_vec(),
1052 },
1053 })
1054 }
1055
1056 result
1057}
1058
1059fn splice_included_ranges(
1060 mut ranges: Vec<tree_sitter::Range>,
1061 changed_ranges: &[Range<usize>],
1062 new_ranges: &[tree_sitter::Range],
1063) -> Vec<tree_sitter::Range> {
1064 let mut changed_ranges = changed_ranges.into_iter().peekable();
1065 let mut new_ranges = new_ranges.into_iter().peekable();
1066 let mut ranges_ix = 0;
1067 loop {
1068 let new_range = new_ranges.peek();
1069 let mut changed_range = changed_ranges.peek();
1070
1071 // Remove ranges that have changed before inserting any new ranges
1072 // into those ranges.
1073 if let Some((changed, new)) = changed_range.zip(new_range) {
1074 if new.end_byte < changed.start {
1075 changed_range = None;
1076 }
1077 }
1078
1079 if let Some(changed) = changed_range {
1080 let mut start_ix = ranges_ix
1081 + match ranges[ranges_ix..].binary_search_by_key(&changed.start, |r| r.end_byte) {
1082 Ok(ix) | Err(ix) => ix,
1083 };
1084 let mut end_ix = ranges_ix
1085 + match ranges[ranges_ix..].binary_search_by_key(&changed.end, |r| r.start_byte) {
1086 Ok(ix) => ix + 1,
1087 Err(ix) => ix,
1088 };
1089
1090 // If there are empty ranges, then there may be multiple ranges with the same
1091 // start or end. Expand the splice to include any adjacent ranges that touch
1092 // the changed range.
1093 while start_ix > 0 {
1094 if ranges[start_ix - 1].end_byte == changed.start {
1095 start_ix -= 1;
1096 } else {
1097 break;
1098 }
1099 }
1100 while let Some(range) = ranges.get(end_ix) {
1101 if range.start_byte == changed.end {
1102 end_ix += 1;
1103 } else {
1104 break;
1105 }
1106 }
1107
1108 if end_ix > start_ix {
1109 ranges.splice(start_ix..end_ix, []);
1110 }
1111 changed_ranges.next();
1112 ranges_ix = start_ix;
1113 } else if let Some(new_range) = new_range {
1114 let ix = ranges_ix
1115 + match ranges[ranges_ix..]
1116 .binary_search_by_key(&new_range.start_byte, |r| r.start_byte)
1117 {
1118 Ok(ix) | Err(ix) => ix,
1119 };
1120 ranges.insert(ix, **new_range);
1121 new_ranges.next();
1122 ranges_ix = ix + 1;
1123 } else {
1124 break;
1125 }
1126 }
1127 ranges
1128}
1129
1130impl<'a> SyntaxLayerInfo<'a> {
1131 pub(crate) fn override_id(&self, offset: usize, text: &text::BufferSnapshot) -> Option<u32> {
1132 let text = TextProvider(text.as_rope());
1133 let config = self.language.grammar.as_ref()?.override_config.as_ref()?;
1134
1135 let mut query_cursor = QueryCursorHandle::new();
1136 query_cursor.set_byte_range(offset..offset);
1137
1138 let mut smallest_match: Option<(u32, Range<usize>)> = None;
1139 for mat in query_cursor.matches(&config.query, self.node, text) {
1140 for capture in mat.captures {
1141 if !config.values.contains_key(&capture.index) {
1142 continue;
1143 }
1144
1145 let range = capture.node.byte_range();
1146 if offset <= range.start || offset >= range.end {
1147 continue;
1148 }
1149
1150 if let Some((_, smallest_range)) = &smallest_match {
1151 if range.len() < smallest_range.len() {
1152 smallest_match = Some((capture.index, range))
1153 }
1154 continue;
1155 }
1156
1157 smallest_match = Some((capture.index, range));
1158 }
1159 }
1160
1161 smallest_match.map(|(index, _)| index)
1162 }
1163}
1164
1165impl std::ops::Deref for SyntaxMap {
1166 type Target = SyntaxSnapshot;
1167
1168 fn deref(&self) -> &Self::Target {
1169 &self.snapshot
1170 }
1171}
1172
1173impl PartialEq for ParseStep {
1174 fn eq(&self, _: &Self) -> bool {
1175 false
1176 }
1177}
1178
1179impl Eq for ParseStep {}
1180
1181impl PartialOrd for ParseStep {
1182 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
1183 Some(self.cmp(&other))
1184 }
1185}
1186
1187impl Ord for ParseStep {
1188 fn cmp(&self, other: &Self) -> Ordering {
1189 let range_a = self.range();
1190 let range_b = other.range();
1191 Ord::cmp(&other.depth, &self.depth)
1192 .then_with(|| Ord::cmp(&range_b.start, &range_a.start))
1193 .then_with(|| Ord::cmp(&range_a.end, &range_b.end))
1194 .then_with(|| self.language.id().cmp(&other.language.id()))
1195 }
1196}
1197
1198impl ParseStep {
1199 fn range(&self) -> Range<usize> {
1200 if let ParseMode::Combined {
1201 parent_layer_range, ..
1202 } = &self.mode
1203 {
1204 parent_layer_range.clone()
1205 } else {
1206 let start = self.included_ranges.first().map_or(0, |r| r.start_byte);
1207 let end = self.included_ranges.last().map_or(0, |r| r.end_byte);
1208 start..end
1209 }
1210 }
1211}
1212
1213impl ChangedRegion {
1214 fn cmp(&self, other: &Self, buffer: &BufferSnapshot) -> Ordering {
1215 let range_a = &self.range;
1216 let range_b = &other.range;
1217 Ord::cmp(&self.depth, &other.depth)
1218 .then_with(|| range_a.start.cmp(&range_b.start, buffer))
1219 .then_with(|| range_b.end.cmp(&range_a.end, buffer))
1220 }
1221}
1222
1223impl ChangeRegionSet {
1224 fn start_position(&self) -> ChangeStartPosition {
1225 self.0.first().map_or(
1226 ChangeStartPosition {
1227 depth: usize::MAX,
1228 position: Anchor::MAX,
1229 },
1230 |region| ChangeStartPosition {
1231 depth: region.depth,
1232 position: region.range.start,
1233 },
1234 )
1235 }
1236
1237 fn intersects(&self, layer: &SyntaxLayer, text: &BufferSnapshot) -> bool {
1238 for region in &self.0 {
1239 if region.depth < layer.depth {
1240 continue;
1241 }
1242 if region.depth > layer.depth {
1243 break;
1244 }
1245 if region.range.end.cmp(&layer.range.start, text).is_le() {
1246 continue;
1247 }
1248 if region.range.start.cmp(&layer.range.end, text).is_ge() {
1249 break;
1250 }
1251 return true;
1252 }
1253 false
1254 }
1255
1256 fn insert(&mut self, region: ChangedRegion, text: &BufferSnapshot) {
1257 if let Err(ix) = self.0.binary_search_by(|probe| probe.cmp(®ion, text)) {
1258 self.0.insert(ix, region);
1259 }
1260 }
1261
1262 fn prune(&mut self, summary: SyntaxLayerSummary, text: &BufferSnapshot) -> bool {
1263 let prev_len = self.0.len();
1264 self.0.retain(|region| {
1265 region.depth > summary.max_depth
1266 || (region.depth == summary.max_depth
1267 && region
1268 .range
1269 .end
1270 .cmp(&summary.last_layer_range.start, text)
1271 .is_gt())
1272 });
1273 self.0.len() < prev_len
1274 }
1275}
1276
1277impl Default for SyntaxLayerSummary {
1278 fn default() -> Self {
1279 Self {
1280 max_depth: 0,
1281 min_depth: 0,
1282 range: Anchor::MAX..Anchor::MIN,
1283 last_layer_range: Anchor::MIN..Anchor::MAX,
1284 last_layer_language: None,
1285 }
1286 }
1287}
1288
1289impl sum_tree::Summary for SyntaxLayerSummary {
1290 type Context = BufferSnapshot;
1291
1292 fn add_summary(&mut self, other: &Self, buffer: &Self::Context) {
1293 if other.max_depth > self.max_depth {
1294 self.max_depth = other.max_depth;
1295 self.range = other.range.clone();
1296 } else {
1297 if other.range.start.cmp(&self.range.start, buffer).is_lt() {
1298 self.range.start = other.range.start;
1299 }
1300 if other.range.end.cmp(&self.range.end, buffer).is_gt() {
1301 self.range.end = other.range.end;
1302 }
1303 }
1304 self.last_layer_range = other.last_layer_range.clone();
1305 self.last_layer_language = other.last_layer_language;
1306 }
1307}
1308
1309impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary> for SyntaxLayerPosition {
1310 fn cmp(&self, cursor_location: &SyntaxLayerSummary, buffer: &BufferSnapshot) -> Ordering {
1311 Ord::cmp(&self.depth, &cursor_location.max_depth)
1312 .then_with(|| {
1313 self.range
1314 .start
1315 .cmp(&cursor_location.last_layer_range.start, buffer)
1316 })
1317 .then_with(|| {
1318 cursor_location
1319 .last_layer_range
1320 .end
1321 .cmp(&self.range.end, buffer)
1322 })
1323 .then_with(|| self.language.cmp(&cursor_location.last_layer_language))
1324 }
1325}
1326
1327impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary> for ChangeStartPosition {
1328 fn cmp(&self, cursor_location: &SyntaxLayerSummary, text: &BufferSnapshot) -> Ordering {
1329 Ord::cmp(&self.depth, &cursor_location.max_depth)
1330 .then_with(|| self.position.cmp(&cursor_location.range.end, text))
1331 }
1332}
1333
1334impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary>
1335 for SyntaxLayerPositionBeforeChange
1336{
1337 fn cmp(&self, cursor_location: &SyntaxLayerSummary, buffer: &BufferSnapshot) -> Ordering {
1338 if self.change.cmp(cursor_location, buffer).is_le() {
1339 return Ordering::Less;
1340 } else {
1341 self.position.cmp(cursor_location, buffer)
1342 }
1343 }
1344}
1345
1346impl sum_tree::Item for SyntaxLayer {
1347 type Summary = SyntaxLayerSummary;
1348
1349 fn summary(&self) -> Self::Summary {
1350 SyntaxLayerSummary {
1351 min_depth: self.depth,
1352 max_depth: self.depth,
1353 range: self.range.clone(),
1354 last_layer_range: self.range.clone(),
1355 last_layer_language: self.language.id(),
1356 }
1357 }
1358}
1359
1360impl std::fmt::Debug for SyntaxLayer {
1361 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1362 f.debug_struct("SyntaxLayer")
1363 .field("depth", &self.depth)
1364 .field("range", &self.range)
1365 .field("tree", &self.tree)
1366 .finish()
1367 }
1368}
1369
1370impl<'a> tree_sitter::TextProvider<'a> for TextProvider<'a> {
1371 type I = ByteChunks<'a>;
1372
1373 fn text(&mut self, node: tree_sitter::Node) -> Self::I {
1374 ByteChunks(self.0.chunks_in_range(node.byte_range()))
1375 }
1376}
1377
1378impl<'a> Iterator for ByteChunks<'a> {
1379 type Item = &'a [u8];
1380
1381 fn next(&mut self) -> Option<Self::Item> {
1382 self.0.next().map(str::as_bytes)
1383 }
1384}
1385
1386impl QueryCursorHandle {
1387 pub(crate) fn new() -> Self {
1388 let mut cursor = QUERY_CURSORS.lock().pop().unwrap_or_else(QueryCursor::new);
1389 cursor.set_match_limit(64);
1390 QueryCursorHandle(Some(cursor))
1391 }
1392}
1393
1394impl Deref for QueryCursorHandle {
1395 type Target = QueryCursor;
1396
1397 fn deref(&self) -> &Self::Target {
1398 self.0.as_ref().unwrap()
1399 }
1400}
1401
1402impl DerefMut for QueryCursorHandle {
1403 fn deref_mut(&mut self) -> &mut Self::Target {
1404 self.0.as_mut().unwrap()
1405 }
1406}
1407
1408impl Drop for QueryCursorHandle {
1409 fn drop(&mut self) {
1410 let mut cursor = self.0.take().unwrap();
1411 cursor.set_byte_range(0..usize::MAX);
1412 cursor.set_point_range(Point::zero().to_ts_point()..Point::MAX.to_ts_point());
1413 QUERY_CURSORS.lock().push(cursor)
1414 }
1415}
1416
1417pub(crate) trait ToTreeSitterPoint {
1418 fn to_ts_point(self) -> tree_sitter::Point;
1419 fn from_ts_point(point: tree_sitter::Point) -> Self;
1420}
1421
1422impl ToTreeSitterPoint for Point {
1423 fn to_ts_point(self) -> tree_sitter::Point {
1424 tree_sitter::Point::new(self.row as usize, self.column as usize)
1425 }
1426
1427 fn from_ts_point(point: tree_sitter::Point) -> Self {
1428 Point::new(point.row as u32, point.column as u32)
1429 }
1430}
1431
1432#[cfg(test)]
1433mod tests {
1434 use super::*;
1435 use crate::LanguageConfig;
1436 use rand::rngs::StdRng;
1437 use std::env;
1438 use text::Buffer;
1439 use unindent::Unindent as _;
1440 use util::test::marked_text_ranges;
1441
1442 #[test]
1443 fn test_splice_included_ranges() {
1444 let ranges = vec![ts_range(20..30), ts_range(50..60), ts_range(80..90)];
1445
1446 let new_ranges = splice_included_ranges(
1447 ranges.clone(),
1448 &[54..56, 58..68],
1449 &[ts_range(50..54), ts_range(59..67)],
1450 );
1451 assert_eq!(
1452 new_ranges,
1453 &[
1454 ts_range(20..30),
1455 ts_range(50..54),
1456 ts_range(59..67),
1457 ts_range(80..90),
1458 ]
1459 );
1460
1461 let new_ranges = splice_included_ranges(ranges.clone(), &[70..71, 91..100], &[]);
1462 assert_eq!(
1463 new_ranges,
1464 &[ts_range(20..30), ts_range(50..60), ts_range(80..90)]
1465 );
1466
1467 let new_ranges =
1468 splice_included_ranges(ranges.clone(), &[], &[ts_range(0..2), ts_range(70..75)]);
1469 assert_eq!(
1470 new_ranges,
1471 &[
1472 ts_range(0..2),
1473 ts_range(20..30),
1474 ts_range(50..60),
1475 ts_range(70..75),
1476 ts_range(80..90)
1477 ]
1478 );
1479
1480 let new_ranges = splice_included_ranges(ranges.clone(), &[30..50], &[ts_range(25..55)]);
1481 assert_eq!(new_ranges, &[ts_range(25..55), ts_range(80..90)]);
1482
1483 fn ts_range(range: Range<usize>) -> tree_sitter::Range {
1484 tree_sitter::Range {
1485 start_byte: range.start,
1486 start_point: tree_sitter::Point {
1487 row: 0,
1488 column: range.start,
1489 },
1490 end_byte: range.end,
1491 end_point: tree_sitter::Point {
1492 row: 0,
1493 column: range.end,
1494 },
1495 }
1496 }
1497 }
1498
1499 #[gpui::test]
1500 fn test_syntax_map_layers_for_range() {
1501 let registry = Arc::new(LanguageRegistry::test());
1502 let language = Arc::new(rust_lang());
1503 registry.add(language.clone());
1504
1505 let mut buffer = Buffer::new(
1506 0,
1507 0,
1508 r#"
1509 fn a() {
1510 assert_eq!(
1511 b(vec![C {}]),
1512 vec![d.e],
1513 );
1514 println!("{}", f(|_| true));
1515 }
1516 "#
1517 .unindent(),
1518 );
1519
1520 let mut syntax_map = SyntaxMap::new();
1521 syntax_map.set_language_registry(registry.clone());
1522 syntax_map.reparse(language.clone(), &buffer);
1523
1524 assert_layers_for_range(
1525 &syntax_map,
1526 &buffer,
1527 Point::new(2, 0)..Point::new(2, 0),
1528 &[
1529 "...(function_item ... (block (expression_statement (macro_invocation...",
1530 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1531 ],
1532 );
1533 assert_layers_for_range(
1534 &syntax_map,
1535 &buffer,
1536 Point::new(2, 14)..Point::new(2, 16),
1537 &[
1538 "...(function_item ...",
1539 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1540 "...(array_expression (struct_expression ...",
1541 ],
1542 );
1543 assert_layers_for_range(
1544 &syntax_map,
1545 &buffer,
1546 Point::new(3, 14)..Point::new(3, 16),
1547 &[
1548 "...(function_item ...",
1549 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1550 "...(array_expression (field_expression ...",
1551 ],
1552 );
1553 assert_layers_for_range(
1554 &syntax_map,
1555 &buffer,
1556 Point::new(5, 12)..Point::new(5, 16),
1557 &[
1558 "...(function_item ...",
1559 "...(call_expression ... (arguments (closure_expression ...",
1560 ],
1561 );
1562
1563 // Replace a vec! macro invocation with a plain slice, removing a syntactic layer.
1564 let macro_name_range = range_for_text(&buffer, "vec!");
1565 buffer.edit([(macro_name_range, "&")]);
1566 syntax_map.interpolate(&buffer);
1567 syntax_map.reparse(language.clone(), &buffer);
1568
1569 assert_layers_for_range(
1570 &syntax_map,
1571 &buffer,
1572 Point::new(2, 14)..Point::new(2, 16),
1573 &[
1574 "...(function_item ...",
1575 "...(tuple_expression (call_expression ... arguments: (arguments (reference_expression value: (array_expression...",
1576 ],
1577 );
1578
1579 // Put the vec! macro back, adding back the syntactic layer.
1580 buffer.undo();
1581 syntax_map.interpolate(&buffer);
1582 syntax_map.reparse(language.clone(), &buffer);
1583
1584 assert_layers_for_range(
1585 &syntax_map,
1586 &buffer,
1587 Point::new(2, 14)..Point::new(2, 16),
1588 &[
1589 "...(function_item ...",
1590 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1591 "...(array_expression (struct_expression ...",
1592 ],
1593 );
1594 }
1595
1596 #[gpui::test]
1597 fn test_typing_multiple_new_injections() {
1598 let (buffer, syntax_map) = test_edit_sequence(
1599 "Rust",
1600 &[
1601 "fn a() { dbg }",
1602 "fn a() { dbg«!» }",
1603 "fn a() { dbg!«()» }",
1604 "fn a() { dbg!(«b») }",
1605 "fn a() { dbg!(b«.») }",
1606 "fn a() { dbg!(b.«c») }",
1607 "fn a() { dbg!(b.c«()») }",
1608 "fn a() { dbg!(b.c(«vec»)) }",
1609 "fn a() { dbg!(b.c(vec«!»)) }",
1610 "fn a() { dbg!(b.c(vec!«[]»)) }",
1611 "fn a() { dbg!(b.c(vec![«d»])) }",
1612 "fn a() { dbg!(b.c(vec![d«.»])) }",
1613 "fn a() { dbg!(b.c(vec![d.«e»])) }",
1614 ],
1615 );
1616
1617 assert_capture_ranges(
1618 &syntax_map,
1619 &buffer,
1620 &["field"],
1621 "fn a() { dbg!(b.«c»(vec![d.«e»])) }",
1622 );
1623 }
1624
1625 #[gpui::test]
1626 fn test_pasting_new_injection_line_between_others() {
1627 let (buffer, syntax_map) = test_edit_sequence(
1628 "Rust",
1629 &[
1630 "
1631 fn a() {
1632 b!(B {});
1633 c!(C {});
1634 d!(D {});
1635 e!(E {});
1636 f!(F {});
1637 g!(G {});
1638 }
1639 ",
1640 "
1641 fn a() {
1642 b!(B {});
1643 c!(C {});
1644 d!(D {});
1645 « h!(H {});
1646 » e!(E {});
1647 f!(F {});
1648 g!(G {});
1649 }
1650 ",
1651 ],
1652 );
1653
1654 assert_capture_ranges(
1655 &syntax_map,
1656 &buffer,
1657 &["struct"],
1658 "
1659 fn a() {
1660 b!(«B {}»);
1661 c!(«C {}»);
1662 d!(«D {}»);
1663 h!(«H {}»);
1664 e!(«E {}»);
1665 f!(«F {}»);
1666 g!(«G {}»);
1667 }
1668 ",
1669 );
1670 }
1671
1672 #[gpui::test]
1673 fn test_joining_injections_with_child_injections() {
1674 let (buffer, syntax_map) = test_edit_sequence(
1675 "Rust",
1676 &[
1677 "
1678 fn a() {
1679 b!(
1680 c![one.two.three],
1681 d![four.five.six],
1682 );
1683 e!(
1684 f![seven.eight],
1685 );
1686 }
1687 ",
1688 "
1689 fn a() {
1690 b!(
1691 c![one.two.three],
1692 d![four.five.six],
1693 ˇ f![seven.eight],
1694 );
1695 }
1696 ",
1697 ],
1698 );
1699
1700 assert_capture_ranges(
1701 &syntax_map,
1702 &buffer,
1703 &["field"],
1704 "
1705 fn a() {
1706 b!(
1707 c![one.«two».«three»],
1708 d![four.«five».«six»],
1709 f![seven.«eight»],
1710 );
1711 }
1712 ",
1713 );
1714 }
1715
1716 #[gpui::test]
1717 fn test_editing_edges_of_injection() {
1718 test_edit_sequence(
1719 "Rust",
1720 &[
1721 "
1722 fn a() {
1723 b!(c!())
1724 }
1725 ",
1726 "
1727 fn a() {
1728 «d»!(c!())
1729 }
1730 ",
1731 "
1732 fn a() {
1733 «e»d!(c!())
1734 }
1735 ",
1736 "
1737 fn a() {
1738 ed!«[»c!()«]»
1739 }
1740 ",
1741 ],
1742 );
1743 }
1744
1745 #[gpui::test]
1746 fn test_edits_preceding_and_intersecting_injection() {
1747 test_edit_sequence(
1748 "Rust",
1749 &[
1750 //
1751 "const aaaaaaaaaaaa: B = c!(d(e.f));",
1752 "const aˇa: B = c!(d(eˇ));",
1753 ],
1754 );
1755 }
1756
1757 #[gpui::test]
1758 fn test_non_local_changes_create_injections() {
1759 test_edit_sequence(
1760 "Rust",
1761 &[
1762 "
1763 // a! {
1764 static B: C = d;
1765 // }
1766 ",
1767 "
1768 ˇa! {
1769 static B: C = d;
1770 ˇ}
1771 ",
1772 ],
1773 );
1774 }
1775
1776 #[gpui::test]
1777 fn test_creating_many_injections_in_one_edit() {
1778 test_edit_sequence(
1779 "Rust",
1780 &[
1781 "
1782 fn a() {
1783 one(Two::three(3));
1784 four(Five::six(6));
1785 seven(Eight::nine(9));
1786 }
1787 ",
1788 "
1789 fn a() {
1790 one«!»(Two::three(3));
1791 four«!»(Five::six(6));
1792 seven«!»(Eight::nine(9));
1793 }
1794 ",
1795 "
1796 fn a() {
1797 one!(Two::three«!»(3));
1798 four!(Five::six«!»(6));
1799 seven!(Eight::nine«!»(9));
1800 }
1801 ",
1802 ],
1803 );
1804 }
1805
1806 #[gpui::test]
1807 fn test_editing_across_injection_boundary() {
1808 test_edit_sequence(
1809 "Rust",
1810 &[
1811 "
1812 fn one() {
1813 two();
1814 three!(
1815 three.four,
1816 five.six,
1817 );
1818 }
1819 ",
1820 "
1821 fn one() {
1822 two();
1823 th«irty_five![»
1824 three.four,
1825 five.six,
1826 « seven.eight,
1827 ];»
1828 }
1829 ",
1830 ],
1831 );
1832 }
1833
1834 #[gpui::test]
1835 fn test_removing_injection_by_replacing_across_boundary() {
1836 test_edit_sequence(
1837 "Rust",
1838 &[
1839 "
1840 fn one() {
1841 two!(
1842 three.four,
1843 );
1844 }
1845 ",
1846 "
1847 fn one() {
1848 t«en
1849 .eleven(
1850 twelve,
1851 »
1852 three.four,
1853 );
1854 }
1855 ",
1856 ],
1857 );
1858 }
1859
1860 #[gpui::test]
1861 fn test_combined_injections() {
1862 let (buffer, syntax_map) = test_edit_sequence(
1863 "ERB",
1864 &[
1865 "
1866 <body>
1867 <% if @one %>
1868 <div class=one>
1869 <% else %>
1870 <div class=two>
1871 <% end %>
1872 </div>
1873 </body>
1874 ",
1875 "
1876 <body>
1877 <% if @one %>
1878 <div class=one>
1879 ˇ else ˇ
1880 <div class=two>
1881 <% end %>
1882 </div>
1883 </body>
1884 ",
1885 "
1886 <body>
1887 <% if @one «;» end %>
1888 </div>
1889 </body>
1890 ",
1891 ],
1892 );
1893
1894 assert_capture_ranges(
1895 &syntax_map,
1896 &buffer,
1897 &["tag", "ivar"],
1898 "
1899 <«body»>
1900 <% if «@one» ; end %>
1901 </«div»>
1902 </«body»>
1903 ",
1904 );
1905 }
1906
1907 #[gpui::test]
1908 fn test_combined_injections_empty_ranges() {
1909 test_edit_sequence(
1910 "ERB",
1911 &[
1912 "
1913 <% if @one %>
1914 <% else %>
1915 <% end %>
1916 ",
1917 "
1918 <% if @one %>
1919 ˇ<% end %>
1920 ",
1921 ],
1922 );
1923 }
1924
1925 #[gpui::test]
1926 fn test_combined_injections_edit_edges_of_ranges() {
1927 let (buffer, syntax_map) = test_edit_sequence(
1928 "ERB",
1929 &[
1930 "
1931 <%= one @two %>
1932 <%= three @four %>
1933 ",
1934 "
1935 <%= one @two %ˇ
1936 <%= three @four %>
1937 ",
1938 "
1939 <%= one @two %«>»
1940 <%= three @four %>
1941 ",
1942 ],
1943 );
1944
1945 assert_capture_ranges(
1946 &syntax_map,
1947 &buffer,
1948 &["tag", "ivar"],
1949 "
1950 <%= one «@two» %>
1951 <%= three «@four» %>
1952 ",
1953 );
1954 }
1955
1956 #[gpui::test]
1957 fn test_combined_injections_splitting_some_injections() {
1958 let (_buffer, _syntax_map) = test_edit_sequence(
1959 "ERB",
1960 &[
1961 r#"
1962 <%A if b(:c) %>
1963 d
1964 <% end %>
1965 eee
1966 <% f %>
1967 "#,
1968 r#"
1969 <%« AAAAAAA %>
1970 hhhhhhh
1971 <%=» if b(:c) %>
1972 d
1973 <% end %>
1974 eee
1975 <% f %>
1976 "#,
1977 ],
1978 );
1979 }
1980
1981 #[gpui::test(iterations = 50)]
1982 fn test_random_syntax_map_edits(mut rng: StdRng) {
1983 let operations = env::var("OPERATIONS")
1984 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
1985 .unwrap_or(10);
1986
1987 let text = r#"
1988 fn test_something() {
1989 let vec = vec![5, 1, 3, 8];
1990 assert_eq!(
1991 vec
1992 .into_iter()
1993 .map(|i| i * 2)
1994 .collect::<Vec<usize>>(),
1995 vec![
1996 5 * 2, 1 * 2, 3 * 2, 8 * 2
1997 ],
1998 );
1999 }
2000 "#
2001 .unindent()
2002 .repeat(2);
2003
2004 let registry = Arc::new(LanguageRegistry::test());
2005 let language = Arc::new(rust_lang());
2006 registry.add(language.clone());
2007 let mut buffer = Buffer::new(0, 0, text);
2008
2009 let mut syntax_map = SyntaxMap::new();
2010 syntax_map.set_language_registry(registry.clone());
2011 syntax_map.reparse(language.clone(), &buffer);
2012
2013 let mut reference_syntax_map = SyntaxMap::new();
2014 reference_syntax_map.set_language_registry(registry.clone());
2015
2016 log::info!("initial text:\n{}", buffer.text());
2017
2018 for _ in 0..operations {
2019 let prev_buffer = buffer.snapshot();
2020 let prev_syntax_map = syntax_map.snapshot();
2021
2022 buffer.randomly_edit(&mut rng, 3);
2023 log::info!("text:\n{}", buffer.text());
2024
2025 syntax_map.interpolate(&buffer);
2026 check_interpolation(&prev_syntax_map, &syntax_map, &prev_buffer, &buffer);
2027
2028 syntax_map.reparse(language.clone(), &buffer);
2029
2030 reference_syntax_map.clear();
2031 reference_syntax_map.reparse(language.clone(), &buffer);
2032 }
2033
2034 for i in 0..operations {
2035 let i = operations - i - 1;
2036 buffer.undo();
2037 log::info!("undoing operation {}", i);
2038 log::info!("text:\n{}", buffer.text());
2039
2040 syntax_map.interpolate(&buffer);
2041 syntax_map.reparse(language.clone(), &buffer);
2042
2043 reference_syntax_map.clear();
2044 reference_syntax_map.reparse(language.clone(), &buffer);
2045 assert_eq!(
2046 syntax_map.layers(&buffer).len(),
2047 reference_syntax_map.layers(&buffer).len(),
2048 "wrong number of layers after undoing edit {i}"
2049 );
2050 }
2051
2052 let layers = syntax_map.layers(&buffer);
2053 let reference_layers = reference_syntax_map.layers(&buffer);
2054 for (edited_layer, reference_layer) in layers.into_iter().zip(reference_layers.into_iter())
2055 {
2056 assert_eq!(edited_layer.node.to_sexp(), reference_layer.node.to_sexp());
2057 assert_eq!(edited_layer.node.range(), reference_layer.node.range());
2058 }
2059 }
2060
2061 #[gpui::test(iterations = 50)]
2062 fn test_random_syntax_map_edits_with_combined_injections(mut rng: StdRng) {
2063 let operations = env::var("OPERATIONS")
2064 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
2065 .unwrap_or(10);
2066
2067 let text = r#"
2068 <div id="main">
2069 <% if one?(:two) %>
2070 <p class="three" four>
2071 <%= yield :five %>
2072 </p>
2073 <% elsif Six.seven(8) %>
2074 <p id="three" four>
2075 <%= yield :five %>
2076 </p>
2077 <% else %>
2078 <span>Ok</span>
2079 <% end %>
2080 </div>
2081 "#
2082 .unindent()
2083 .repeat(8);
2084
2085 let registry = Arc::new(LanguageRegistry::test());
2086 let language = Arc::new(erb_lang());
2087 registry.add(language.clone());
2088 registry.add(Arc::new(ruby_lang()));
2089 registry.add(Arc::new(html_lang()));
2090 let mut buffer = Buffer::new(0, 0, text);
2091
2092 let mut syntax_map = SyntaxMap::new();
2093 syntax_map.set_language_registry(registry.clone());
2094 syntax_map.reparse(language.clone(), &buffer);
2095
2096 let mut reference_syntax_map = SyntaxMap::new();
2097 reference_syntax_map.set_language_registry(registry.clone());
2098
2099 log::info!("initial text:\n{}", buffer.text());
2100
2101 for _ in 0..operations {
2102 let prev_buffer = buffer.snapshot();
2103 let prev_syntax_map = syntax_map.snapshot();
2104
2105 buffer.randomly_edit(&mut rng, 3);
2106 log::info!("text:\n{}", buffer.text());
2107
2108 syntax_map.interpolate(&buffer);
2109 check_interpolation(&prev_syntax_map, &syntax_map, &prev_buffer, &buffer);
2110
2111 syntax_map.reparse(language.clone(), &buffer);
2112
2113 reference_syntax_map.clear();
2114 reference_syntax_map.reparse(language.clone(), &buffer);
2115 }
2116
2117 for i in 0..operations {
2118 let i = operations - i - 1;
2119 buffer.undo();
2120 log::info!("undoing operation {}", i);
2121 log::info!("text:\n{}", buffer.text());
2122
2123 syntax_map.interpolate(&buffer);
2124 syntax_map.reparse(language.clone(), &buffer);
2125
2126 reference_syntax_map.clear();
2127 reference_syntax_map.reparse(language.clone(), &buffer);
2128 assert_eq!(
2129 syntax_map.layers(&buffer).len(),
2130 reference_syntax_map.layers(&buffer).len(),
2131 "wrong number of layers after undoing edit {i}"
2132 );
2133 }
2134
2135 let layers = syntax_map.layers(&buffer);
2136 let reference_layers = reference_syntax_map.layers(&buffer);
2137 for (edited_layer, reference_layer) in layers.into_iter().zip(reference_layers.into_iter())
2138 {
2139 assert_eq!(edited_layer.node.to_sexp(), reference_layer.node.to_sexp());
2140 assert_eq!(edited_layer.node.range(), reference_layer.node.range());
2141 }
2142 }
2143
2144 fn check_interpolation(
2145 old_syntax_map: &SyntaxSnapshot,
2146 new_syntax_map: &SyntaxSnapshot,
2147 old_buffer: &BufferSnapshot,
2148 new_buffer: &BufferSnapshot,
2149 ) {
2150 let edits = new_buffer
2151 .edits_since::<usize>(&old_buffer.version())
2152 .collect::<Vec<_>>();
2153
2154 for (old_layer, new_layer) in old_syntax_map
2155 .layers
2156 .iter()
2157 .zip(new_syntax_map.layers.iter())
2158 {
2159 assert_eq!(old_layer.range, new_layer.range);
2160 let old_start_byte = old_layer.range.start.to_offset(old_buffer);
2161 let new_start_byte = new_layer.range.start.to_offset(new_buffer);
2162 let old_start_point = old_layer.range.start.to_point(old_buffer).to_ts_point();
2163 let new_start_point = new_layer.range.start.to_point(new_buffer).to_ts_point();
2164 let old_node = old_layer
2165 .tree
2166 .root_node_with_offset(old_start_byte, old_start_point);
2167 let new_node = new_layer
2168 .tree
2169 .root_node_with_offset(new_start_byte, new_start_point);
2170 check_node_edits(
2171 old_layer.depth,
2172 &old_layer.range,
2173 old_node,
2174 new_node,
2175 old_buffer,
2176 new_buffer,
2177 &edits,
2178 );
2179 }
2180
2181 fn check_node_edits(
2182 depth: usize,
2183 range: &Range<Anchor>,
2184 old_node: Node,
2185 new_node: Node,
2186 old_buffer: &BufferSnapshot,
2187 new_buffer: &BufferSnapshot,
2188 edits: &[text::Edit<usize>],
2189 ) {
2190 assert_eq!(old_node.kind(), new_node.kind());
2191
2192 let old_range = old_node.byte_range();
2193 let new_range = new_node.byte_range();
2194
2195 let is_edited = edits
2196 .iter()
2197 .any(|edit| edit.new.start < new_range.end && edit.new.end > new_range.start);
2198 if is_edited {
2199 assert!(
2200 new_node.has_changes(),
2201 concat!(
2202 "failed to mark node as edited.\n",
2203 "layer depth: {}, old layer range: {:?}, new layer range: {:?},\n",
2204 "node kind: {}, old node range: {:?}, new node range: {:?}",
2205 ),
2206 depth,
2207 range.to_offset(old_buffer),
2208 range.to_offset(new_buffer),
2209 new_node.kind(),
2210 old_range,
2211 new_range,
2212 );
2213 }
2214
2215 if !new_node.has_changes() {
2216 assert_eq!(
2217 old_buffer
2218 .text_for_range(old_range.clone())
2219 .collect::<String>(),
2220 new_buffer
2221 .text_for_range(new_range.clone())
2222 .collect::<String>(),
2223 concat!(
2224 "mismatched text for node\n",
2225 "layer depth: {}, old layer range: {:?}, new layer range: {:?},\n",
2226 "node kind: {}, old node range:{:?}, new node range:{:?}",
2227 ),
2228 depth,
2229 range.to_offset(old_buffer),
2230 range.to_offset(new_buffer),
2231 new_node.kind(),
2232 old_range,
2233 new_range,
2234 );
2235 }
2236
2237 for i in 0..new_node.child_count() {
2238 check_node_edits(
2239 depth,
2240 range,
2241 old_node.child(i).unwrap(),
2242 new_node.child(i).unwrap(),
2243 old_buffer,
2244 new_buffer,
2245 edits,
2246 )
2247 }
2248 }
2249 }
2250
2251 fn test_edit_sequence(language_name: &str, steps: &[&str]) -> (Buffer, SyntaxMap) {
2252 let registry = Arc::new(LanguageRegistry::test());
2253 registry.add(Arc::new(rust_lang()));
2254 registry.add(Arc::new(ruby_lang()));
2255 registry.add(Arc::new(html_lang()));
2256 registry.add(Arc::new(erb_lang()));
2257 let language = registry.get_language(language_name).unwrap();
2258 let mut buffer = Buffer::new(0, 0, Default::default());
2259
2260 let mut mutated_syntax_map = SyntaxMap::new();
2261 mutated_syntax_map.set_language_registry(registry.clone());
2262 mutated_syntax_map.reparse(language.clone(), &buffer);
2263
2264 for (i, marked_string) in steps.into_iter().enumerate() {
2265 buffer.edit_via_marked_text(&marked_string.unindent());
2266
2267 // Reparse the syntax map
2268 mutated_syntax_map.interpolate(&buffer);
2269 mutated_syntax_map.reparse(language.clone(), &buffer);
2270
2271 // Create a second syntax map from scratch
2272 let mut reference_syntax_map = SyntaxMap::new();
2273 reference_syntax_map.set_language_registry(registry.clone());
2274 reference_syntax_map.reparse(language.clone(), &buffer);
2275
2276 // Compare the mutated syntax map to the new syntax map
2277 let mutated_layers = mutated_syntax_map.layers(&buffer);
2278 let reference_layers = reference_syntax_map.layers(&buffer);
2279 assert_eq!(
2280 mutated_layers.len(),
2281 reference_layers.len(),
2282 "wrong number of layers at step {i}"
2283 );
2284 for (edited_layer, reference_layer) in
2285 mutated_layers.into_iter().zip(reference_layers.into_iter())
2286 {
2287 assert_eq!(
2288 edited_layer.node.to_sexp(),
2289 reference_layer.node.to_sexp(),
2290 "different layer at step {i}"
2291 );
2292 assert_eq!(
2293 edited_layer.node.range(),
2294 reference_layer.node.range(),
2295 "different layer at step {i}"
2296 );
2297 }
2298 }
2299
2300 (buffer, mutated_syntax_map)
2301 }
2302
2303 fn html_lang() -> Language {
2304 Language::new(
2305 LanguageConfig {
2306 name: "HTML".into(),
2307 path_suffixes: vec!["html".to_string()],
2308 ..Default::default()
2309 },
2310 Some(tree_sitter_html::language()),
2311 )
2312 .with_highlights_query(
2313 r#"
2314 (tag_name) @tag
2315 (erroneous_end_tag_name) @tag
2316 (attribute_name) @property
2317 "#,
2318 )
2319 .unwrap()
2320 }
2321
2322 fn ruby_lang() -> Language {
2323 Language::new(
2324 LanguageConfig {
2325 name: "Ruby".into(),
2326 path_suffixes: vec!["rb".to_string()],
2327 ..Default::default()
2328 },
2329 Some(tree_sitter_ruby::language()),
2330 )
2331 .with_highlights_query(
2332 r#"
2333 ["if" "do" "else" "end"] @keyword
2334 (instance_variable) @ivar
2335 "#,
2336 )
2337 .unwrap()
2338 }
2339
2340 fn erb_lang() -> Language {
2341 Language::new(
2342 LanguageConfig {
2343 name: "ERB".into(),
2344 path_suffixes: vec!["erb".to_string()],
2345 ..Default::default()
2346 },
2347 Some(tree_sitter_embedded_template::language()),
2348 )
2349 .with_highlights_query(
2350 r#"
2351 ["<%" "%>"] @keyword
2352 "#,
2353 )
2354 .unwrap()
2355 .with_injection_query(
2356 r#"
2357 ((code) @content
2358 (#set! "language" "ruby")
2359 (#set! "combined"))
2360
2361 ((content) @content
2362 (#set! "language" "html")
2363 (#set! "combined"))
2364 "#,
2365 )
2366 .unwrap()
2367 }
2368
2369 fn rust_lang() -> Language {
2370 Language::new(
2371 LanguageConfig {
2372 name: "Rust".into(),
2373 path_suffixes: vec!["rs".to_string()],
2374 ..Default::default()
2375 },
2376 Some(tree_sitter_rust::language()),
2377 )
2378 .with_highlights_query(
2379 r#"
2380 (field_identifier) @field
2381 (struct_expression) @struct
2382 "#,
2383 )
2384 .unwrap()
2385 .with_injection_query(
2386 r#"
2387 (macro_invocation
2388 (token_tree) @content
2389 (#set! "language" "rust"))
2390 "#,
2391 )
2392 .unwrap()
2393 }
2394
2395 fn range_for_text(buffer: &Buffer, text: &str) -> Range<usize> {
2396 let start = buffer.as_rope().to_string().find(text).unwrap();
2397 start..start + text.len()
2398 }
2399
2400 fn assert_layers_for_range(
2401 syntax_map: &SyntaxMap,
2402 buffer: &BufferSnapshot,
2403 range: Range<Point>,
2404 expected_layers: &[&str],
2405 ) {
2406 let layers = syntax_map
2407 .layers_for_range(range, &buffer)
2408 .collect::<Vec<_>>();
2409 assert_eq!(
2410 layers.len(),
2411 expected_layers.len(),
2412 "wrong number of layers"
2413 );
2414 for (i, (SyntaxLayerInfo { node, .. }, expected_s_exp)) in
2415 layers.iter().zip(expected_layers.iter()).enumerate()
2416 {
2417 let actual_s_exp = node.to_sexp();
2418 assert!(
2419 string_contains_sequence(
2420 &actual_s_exp,
2421 &expected_s_exp.split("...").collect::<Vec<_>>()
2422 ),
2423 "layer {i}:\n\nexpected: {expected_s_exp}\nactual: {actual_s_exp}",
2424 );
2425 }
2426 }
2427
2428 fn assert_capture_ranges(
2429 syntax_map: &SyntaxMap,
2430 buffer: &BufferSnapshot,
2431 highlight_query_capture_names: &[&str],
2432 marked_string: &str,
2433 ) {
2434 let mut actual_ranges = Vec::<Range<usize>>::new();
2435 let captures = syntax_map.captures(0..buffer.len(), buffer, |grammar| {
2436 grammar.highlights_query.as_ref()
2437 });
2438 let queries = captures
2439 .grammars()
2440 .iter()
2441 .map(|grammar| grammar.highlights_query.as_ref().unwrap())
2442 .collect::<Vec<_>>();
2443 for capture in captures {
2444 let name = &queries[capture.grammar_index].capture_names()[capture.index as usize];
2445 if highlight_query_capture_names.contains(&name.as_str()) {
2446 actual_ranges.push(capture.node.byte_range());
2447 }
2448 }
2449
2450 let (text, expected_ranges) = marked_text_ranges(&marked_string.unindent(), false);
2451 assert_eq!(text, buffer.text());
2452 assert_eq!(actual_ranges, expected_ranges);
2453 }
2454
2455 pub fn string_contains_sequence(text: &str, parts: &[&str]) -> bool {
2456 let mut last_part_end = 0;
2457 for part in parts {
2458 if let Some(start_ix) = text[last_part_end..].find(part) {
2459 last_part_end = start_ix + part.len();
2460 } else {
2461 return false;
2462 }
2463 }
2464 true
2465 }
2466}