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.language_for_name(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 let language = language_registry
1019 .language_for_name(&language_name)
1020 .or_else(|| language_registry.language_for_extension(&language_name));
1021 if let Some(language) = language {
1022 result = true;
1023 let range = text.anchor_before(content_range.start)
1024 ..text.anchor_after(content_range.end);
1025 if combined {
1026 combined_injection_ranges
1027 .get_mut(&language.clone())
1028 .unwrap()
1029 .extend(content_ranges);
1030 } else {
1031 queue.push(ParseStep {
1032 depth,
1033 language,
1034 included_ranges: content_ranges,
1035 range,
1036 mode: ParseMode::Single,
1037 });
1038 }
1039 }
1040 }
1041 }
1042 }
1043
1044 for (language, mut included_ranges) in combined_injection_ranges.drain() {
1045 included_ranges.sort_unstable();
1046 let range = text.anchor_before(node.start_byte())..text.anchor_after(node.end_byte());
1047 queue.push(ParseStep {
1048 depth,
1049 language,
1050 range,
1051 included_ranges,
1052 mode: ParseMode::Combined {
1053 parent_layer_range: node.start_byte()..node.end_byte(),
1054 parent_layer_changed_ranges: changed_ranges.to_vec(),
1055 },
1056 })
1057 }
1058
1059 result
1060}
1061
1062fn splice_included_ranges(
1063 mut ranges: Vec<tree_sitter::Range>,
1064 changed_ranges: &[Range<usize>],
1065 new_ranges: &[tree_sitter::Range],
1066) -> Vec<tree_sitter::Range> {
1067 let mut changed_ranges = changed_ranges.into_iter().peekable();
1068 let mut new_ranges = new_ranges.into_iter().peekable();
1069 let mut ranges_ix = 0;
1070 loop {
1071 let new_range = new_ranges.peek();
1072 let mut changed_range = changed_ranges.peek();
1073
1074 // Remove ranges that have changed before inserting any new ranges
1075 // into those ranges.
1076 if let Some((changed, new)) = changed_range.zip(new_range) {
1077 if new.end_byte < changed.start {
1078 changed_range = None;
1079 }
1080 }
1081
1082 if let Some(changed) = changed_range {
1083 let mut start_ix = ranges_ix
1084 + match ranges[ranges_ix..].binary_search_by_key(&changed.start, |r| r.end_byte) {
1085 Ok(ix) | Err(ix) => ix,
1086 };
1087 let mut end_ix = ranges_ix
1088 + match ranges[ranges_ix..].binary_search_by_key(&changed.end, |r| r.start_byte) {
1089 Ok(ix) => ix + 1,
1090 Err(ix) => ix,
1091 };
1092
1093 // If there are empty ranges, then there may be multiple ranges with the same
1094 // start or end. Expand the splice to include any adjacent ranges that touch
1095 // the changed range.
1096 while start_ix > 0 {
1097 if ranges[start_ix - 1].end_byte == changed.start {
1098 start_ix -= 1;
1099 } else {
1100 break;
1101 }
1102 }
1103 while let Some(range) = ranges.get(end_ix) {
1104 if range.start_byte == changed.end {
1105 end_ix += 1;
1106 } else {
1107 break;
1108 }
1109 }
1110
1111 if end_ix > start_ix {
1112 ranges.splice(start_ix..end_ix, []);
1113 }
1114 changed_ranges.next();
1115 ranges_ix = start_ix;
1116 } else if let Some(new_range) = new_range {
1117 let ix = ranges_ix
1118 + match ranges[ranges_ix..]
1119 .binary_search_by_key(&new_range.start_byte, |r| r.start_byte)
1120 {
1121 Ok(ix) | Err(ix) => ix,
1122 };
1123 ranges.insert(ix, **new_range);
1124 new_ranges.next();
1125 ranges_ix = ix + 1;
1126 } else {
1127 break;
1128 }
1129 }
1130 ranges
1131}
1132
1133impl<'a> SyntaxLayerInfo<'a> {
1134 pub(crate) fn override_id(&self, offset: usize, text: &text::BufferSnapshot) -> Option<u32> {
1135 let text = TextProvider(text.as_rope());
1136 let config = self.language.grammar.as_ref()?.override_config.as_ref()?;
1137
1138 let mut query_cursor = QueryCursorHandle::new();
1139 query_cursor.set_byte_range(offset..offset);
1140
1141 let mut smallest_match: Option<(u32, Range<usize>)> = None;
1142 for mat in query_cursor.matches(&config.query, self.node, text) {
1143 for capture in mat.captures {
1144 if !config.values.contains_key(&capture.index) {
1145 continue;
1146 }
1147
1148 let range = capture.node.byte_range();
1149 if offset <= range.start || offset >= range.end {
1150 continue;
1151 }
1152
1153 if let Some((_, smallest_range)) = &smallest_match {
1154 if range.len() < smallest_range.len() {
1155 smallest_match = Some((capture.index, range))
1156 }
1157 continue;
1158 }
1159
1160 smallest_match = Some((capture.index, range));
1161 }
1162 }
1163
1164 smallest_match.map(|(index, _)| index)
1165 }
1166}
1167
1168impl std::ops::Deref for SyntaxMap {
1169 type Target = SyntaxSnapshot;
1170
1171 fn deref(&self) -> &Self::Target {
1172 &self.snapshot
1173 }
1174}
1175
1176impl PartialEq for ParseStep {
1177 fn eq(&self, _: &Self) -> bool {
1178 false
1179 }
1180}
1181
1182impl Eq for ParseStep {}
1183
1184impl PartialOrd for ParseStep {
1185 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
1186 Some(self.cmp(&other))
1187 }
1188}
1189
1190impl Ord for ParseStep {
1191 fn cmp(&self, other: &Self) -> Ordering {
1192 let range_a = self.range();
1193 let range_b = other.range();
1194 Ord::cmp(&other.depth, &self.depth)
1195 .then_with(|| Ord::cmp(&range_b.start, &range_a.start))
1196 .then_with(|| Ord::cmp(&range_a.end, &range_b.end))
1197 .then_with(|| self.language.id().cmp(&other.language.id()))
1198 }
1199}
1200
1201impl ParseStep {
1202 fn range(&self) -> Range<usize> {
1203 if let ParseMode::Combined {
1204 parent_layer_range, ..
1205 } = &self.mode
1206 {
1207 parent_layer_range.clone()
1208 } else {
1209 let start = self.included_ranges.first().map_or(0, |r| r.start_byte);
1210 let end = self.included_ranges.last().map_or(0, |r| r.end_byte);
1211 start..end
1212 }
1213 }
1214}
1215
1216impl ChangedRegion {
1217 fn cmp(&self, other: &Self, buffer: &BufferSnapshot) -> Ordering {
1218 let range_a = &self.range;
1219 let range_b = &other.range;
1220 Ord::cmp(&self.depth, &other.depth)
1221 .then_with(|| range_a.start.cmp(&range_b.start, buffer))
1222 .then_with(|| range_b.end.cmp(&range_a.end, buffer))
1223 }
1224}
1225
1226impl ChangeRegionSet {
1227 fn start_position(&self) -> ChangeStartPosition {
1228 self.0.first().map_or(
1229 ChangeStartPosition {
1230 depth: usize::MAX,
1231 position: Anchor::MAX,
1232 },
1233 |region| ChangeStartPosition {
1234 depth: region.depth,
1235 position: region.range.start,
1236 },
1237 )
1238 }
1239
1240 fn intersects(&self, layer: &SyntaxLayer, text: &BufferSnapshot) -> bool {
1241 for region in &self.0 {
1242 if region.depth < layer.depth {
1243 continue;
1244 }
1245 if region.depth > layer.depth {
1246 break;
1247 }
1248 if region.range.end.cmp(&layer.range.start, text).is_le() {
1249 continue;
1250 }
1251 if region.range.start.cmp(&layer.range.end, text).is_ge() {
1252 break;
1253 }
1254 return true;
1255 }
1256 false
1257 }
1258
1259 fn insert(&mut self, region: ChangedRegion, text: &BufferSnapshot) {
1260 if let Err(ix) = self.0.binary_search_by(|probe| probe.cmp(®ion, text)) {
1261 self.0.insert(ix, region);
1262 }
1263 }
1264
1265 fn prune(&mut self, summary: SyntaxLayerSummary, text: &BufferSnapshot) -> bool {
1266 let prev_len = self.0.len();
1267 self.0.retain(|region| {
1268 region.depth > summary.max_depth
1269 || (region.depth == summary.max_depth
1270 && region
1271 .range
1272 .end
1273 .cmp(&summary.last_layer_range.start, text)
1274 .is_gt())
1275 });
1276 self.0.len() < prev_len
1277 }
1278}
1279
1280impl Default for SyntaxLayerSummary {
1281 fn default() -> Self {
1282 Self {
1283 max_depth: 0,
1284 min_depth: 0,
1285 range: Anchor::MAX..Anchor::MIN,
1286 last_layer_range: Anchor::MIN..Anchor::MAX,
1287 last_layer_language: None,
1288 }
1289 }
1290}
1291
1292impl sum_tree::Summary for SyntaxLayerSummary {
1293 type Context = BufferSnapshot;
1294
1295 fn add_summary(&mut self, other: &Self, buffer: &Self::Context) {
1296 if other.max_depth > self.max_depth {
1297 self.max_depth = other.max_depth;
1298 self.range = other.range.clone();
1299 } else {
1300 if other.range.start.cmp(&self.range.start, buffer).is_lt() {
1301 self.range.start = other.range.start;
1302 }
1303 if other.range.end.cmp(&self.range.end, buffer).is_gt() {
1304 self.range.end = other.range.end;
1305 }
1306 }
1307 self.last_layer_range = other.last_layer_range.clone();
1308 self.last_layer_language = other.last_layer_language;
1309 }
1310}
1311
1312impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary> for SyntaxLayerPosition {
1313 fn cmp(&self, cursor_location: &SyntaxLayerSummary, buffer: &BufferSnapshot) -> Ordering {
1314 Ord::cmp(&self.depth, &cursor_location.max_depth)
1315 .then_with(|| {
1316 self.range
1317 .start
1318 .cmp(&cursor_location.last_layer_range.start, buffer)
1319 })
1320 .then_with(|| {
1321 cursor_location
1322 .last_layer_range
1323 .end
1324 .cmp(&self.range.end, buffer)
1325 })
1326 .then_with(|| self.language.cmp(&cursor_location.last_layer_language))
1327 }
1328}
1329
1330impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary> for ChangeStartPosition {
1331 fn cmp(&self, cursor_location: &SyntaxLayerSummary, text: &BufferSnapshot) -> Ordering {
1332 Ord::cmp(&self.depth, &cursor_location.max_depth)
1333 .then_with(|| self.position.cmp(&cursor_location.range.end, text))
1334 }
1335}
1336
1337impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary>
1338 for SyntaxLayerPositionBeforeChange
1339{
1340 fn cmp(&self, cursor_location: &SyntaxLayerSummary, buffer: &BufferSnapshot) -> Ordering {
1341 if self.change.cmp(cursor_location, buffer).is_le() {
1342 return Ordering::Less;
1343 } else {
1344 self.position.cmp(cursor_location, buffer)
1345 }
1346 }
1347}
1348
1349impl sum_tree::Item for SyntaxLayer {
1350 type Summary = SyntaxLayerSummary;
1351
1352 fn summary(&self) -> Self::Summary {
1353 SyntaxLayerSummary {
1354 min_depth: self.depth,
1355 max_depth: self.depth,
1356 range: self.range.clone(),
1357 last_layer_range: self.range.clone(),
1358 last_layer_language: self.language.id(),
1359 }
1360 }
1361}
1362
1363impl std::fmt::Debug for SyntaxLayer {
1364 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1365 f.debug_struct("SyntaxLayer")
1366 .field("depth", &self.depth)
1367 .field("range", &self.range)
1368 .field("tree", &self.tree)
1369 .finish()
1370 }
1371}
1372
1373impl<'a> tree_sitter::TextProvider<'a> for TextProvider<'a> {
1374 type I = ByteChunks<'a>;
1375
1376 fn text(&mut self, node: tree_sitter::Node) -> Self::I {
1377 ByteChunks(self.0.chunks_in_range(node.byte_range()))
1378 }
1379}
1380
1381impl<'a> Iterator for ByteChunks<'a> {
1382 type Item = &'a [u8];
1383
1384 fn next(&mut self) -> Option<Self::Item> {
1385 self.0.next().map(str::as_bytes)
1386 }
1387}
1388
1389impl QueryCursorHandle {
1390 pub(crate) fn new() -> Self {
1391 let mut cursor = QUERY_CURSORS.lock().pop().unwrap_or_else(QueryCursor::new);
1392 cursor.set_match_limit(64);
1393 QueryCursorHandle(Some(cursor))
1394 }
1395}
1396
1397impl Deref for QueryCursorHandle {
1398 type Target = QueryCursor;
1399
1400 fn deref(&self) -> &Self::Target {
1401 self.0.as_ref().unwrap()
1402 }
1403}
1404
1405impl DerefMut for QueryCursorHandle {
1406 fn deref_mut(&mut self) -> &mut Self::Target {
1407 self.0.as_mut().unwrap()
1408 }
1409}
1410
1411impl Drop for QueryCursorHandle {
1412 fn drop(&mut self) {
1413 let mut cursor = self.0.take().unwrap();
1414 cursor.set_byte_range(0..usize::MAX);
1415 cursor.set_point_range(Point::zero().to_ts_point()..Point::MAX.to_ts_point());
1416 QUERY_CURSORS.lock().push(cursor)
1417 }
1418}
1419
1420pub(crate) trait ToTreeSitterPoint {
1421 fn to_ts_point(self) -> tree_sitter::Point;
1422 fn from_ts_point(point: tree_sitter::Point) -> Self;
1423}
1424
1425impl ToTreeSitterPoint for Point {
1426 fn to_ts_point(self) -> tree_sitter::Point {
1427 tree_sitter::Point::new(self.row as usize, self.column as usize)
1428 }
1429
1430 fn from_ts_point(point: tree_sitter::Point) -> Self {
1431 Point::new(point.row as u32, point.column as u32)
1432 }
1433}
1434
1435#[cfg(test)]
1436mod tests {
1437 use super::*;
1438 use crate::LanguageConfig;
1439 use rand::rngs::StdRng;
1440 use std::env;
1441 use text::Buffer;
1442 use unindent::Unindent as _;
1443 use util::test::marked_text_ranges;
1444
1445 #[test]
1446 fn test_splice_included_ranges() {
1447 let ranges = vec![ts_range(20..30), ts_range(50..60), ts_range(80..90)];
1448
1449 let new_ranges = splice_included_ranges(
1450 ranges.clone(),
1451 &[54..56, 58..68],
1452 &[ts_range(50..54), ts_range(59..67)],
1453 );
1454 assert_eq!(
1455 new_ranges,
1456 &[
1457 ts_range(20..30),
1458 ts_range(50..54),
1459 ts_range(59..67),
1460 ts_range(80..90),
1461 ]
1462 );
1463
1464 let new_ranges = splice_included_ranges(ranges.clone(), &[70..71, 91..100], &[]);
1465 assert_eq!(
1466 new_ranges,
1467 &[ts_range(20..30), ts_range(50..60), ts_range(80..90)]
1468 );
1469
1470 let new_ranges =
1471 splice_included_ranges(ranges.clone(), &[], &[ts_range(0..2), ts_range(70..75)]);
1472 assert_eq!(
1473 new_ranges,
1474 &[
1475 ts_range(0..2),
1476 ts_range(20..30),
1477 ts_range(50..60),
1478 ts_range(70..75),
1479 ts_range(80..90)
1480 ]
1481 );
1482
1483 let new_ranges = splice_included_ranges(ranges.clone(), &[30..50], &[ts_range(25..55)]);
1484 assert_eq!(new_ranges, &[ts_range(25..55), ts_range(80..90)]);
1485
1486 fn ts_range(range: Range<usize>) -> tree_sitter::Range {
1487 tree_sitter::Range {
1488 start_byte: range.start,
1489 start_point: tree_sitter::Point {
1490 row: 0,
1491 column: range.start,
1492 },
1493 end_byte: range.end,
1494 end_point: tree_sitter::Point {
1495 row: 0,
1496 column: range.end,
1497 },
1498 }
1499 }
1500 }
1501
1502 #[gpui::test]
1503 fn test_syntax_map_layers_for_range() {
1504 let registry = Arc::new(LanguageRegistry::test());
1505 let language = Arc::new(rust_lang());
1506 registry.add(language.clone());
1507
1508 let mut buffer = Buffer::new(
1509 0,
1510 0,
1511 r#"
1512 fn a() {
1513 assert_eq!(
1514 b(vec![C {}]),
1515 vec![d.e],
1516 );
1517 println!("{}", f(|_| true));
1518 }
1519 "#
1520 .unindent(),
1521 );
1522
1523 let mut syntax_map = SyntaxMap::new();
1524 syntax_map.set_language_registry(registry.clone());
1525 syntax_map.reparse(language.clone(), &buffer);
1526
1527 assert_layers_for_range(
1528 &syntax_map,
1529 &buffer,
1530 Point::new(2, 0)..Point::new(2, 0),
1531 &[
1532 "...(function_item ... (block (expression_statement (macro_invocation...",
1533 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1534 ],
1535 );
1536 assert_layers_for_range(
1537 &syntax_map,
1538 &buffer,
1539 Point::new(2, 14)..Point::new(2, 16),
1540 &[
1541 "...(function_item ...",
1542 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1543 "...(array_expression (struct_expression ...",
1544 ],
1545 );
1546 assert_layers_for_range(
1547 &syntax_map,
1548 &buffer,
1549 Point::new(3, 14)..Point::new(3, 16),
1550 &[
1551 "...(function_item ...",
1552 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1553 "...(array_expression (field_expression ...",
1554 ],
1555 );
1556 assert_layers_for_range(
1557 &syntax_map,
1558 &buffer,
1559 Point::new(5, 12)..Point::new(5, 16),
1560 &[
1561 "...(function_item ...",
1562 "...(call_expression ... (arguments (closure_expression ...",
1563 ],
1564 );
1565
1566 // Replace a vec! macro invocation with a plain slice, removing a syntactic layer.
1567 let macro_name_range = range_for_text(&buffer, "vec!");
1568 buffer.edit([(macro_name_range, "&")]);
1569 syntax_map.interpolate(&buffer);
1570 syntax_map.reparse(language.clone(), &buffer);
1571
1572 assert_layers_for_range(
1573 &syntax_map,
1574 &buffer,
1575 Point::new(2, 14)..Point::new(2, 16),
1576 &[
1577 "...(function_item ...",
1578 "...(tuple_expression (call_expression ... arguments: (arguments (reference_expression value: (array_expression...",
1579 ],
1580 );
1581
1582 // Put the vec! macro back, adding back the syntactic layer.
1583 buffer.undo();
1584 syntax_map.interpolate(&buffer);
1585 syntax_map.reparse(language.clone(), &buffer);
1586
1587 assert_layers_for_range(
1588 &syntax_map,
1589 &buffer,
1590 Point::new(2, 14)..Point::new(2, 16),
1591 &[
1592 "...(function_item ...",
1593 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1594 "...(array_expression (struct_expression ...",
1595 ],
1596 );
1597 }
1598
1599 #[gpui::test]
1600 fn test_typing_multiple_new_injections() {
1601 let (buffer, syntax_map) = test_edit_sequence(
1602 "Rust",
1603 &[
1604 "fn a() { dbg }",
1605 "fn a() { dbg«!» }",
1606 "fn a() { dbg!«()» }",
1607 "fn a() { dbg!(«b») }",
1608 "fn a() { dbg!(b«.») }",
1609 "fn a() { dbg!(b.«c») }",
1610 "fn a() { dbg!(b.c«()») }",
1611 "fn a() { dbg!(b.c(«vec»)) }",
1612 "fn a() { dbg!(b.c(vec«!»)) }",
1613 "fn a() { dbg!(b.c(vec!«[]»)) }",
1614 "fn a() { dbg!(b.c(vec![«d»])) }",
1615 "fn a() { dbg!(b.c(vec![d«.»])) }",
1616 "fn a() { dbg!(b.c(vec![d.«e»])) }",
1617 ],
1618 );
1619
1620 assert_capture_ranges(
1621 &syntax_map,
1622 &buffer,
1623 &["field"],
1624 "fn a() { dbg!(b.«c»(vec![d.«e»])) }",
1625 );
1626 }
1627
1628 #[gpui::test]
1629 fn test_pasting_new_injection_line_between_others() {
1630 let (buffer, syntax_map) = test_edit_sequence(
1631 "Rust",
1632 &[
1633 "
1634 fn a() {
1635 b!(B {});
1636 c!(C {});
1637 d!(D {});
1638 e!(E {});
1639 f!(F {});
1640 g!(G {});
1641 }
1642 ",
1643 "
1644 fn a() {
1645 b!(B {});
1646 c!(C {});
1647 d!(D {});
1648 « h!(H {});
1649 » e!(E {});
1650 f!(F {});
1651 g!(G {});
1652 }
1653 ",
1654 ],
1655 );
1656
1657 assert_capture_ranges(
1658 &syntax_map,
1659 &buffer,
1660 &["struct"],
1661 "
1662 fn a() {
1663 b!(«B {}»);
1664 c!(«C {}»);
1665 d!(«D {}»);
1666 h!(«H {}»);
1667 e!(«E {}»);
1668 f!(«F {}»);
1669 g!(«G {}»);
1670 }
1671 ",
1672 );
1673 }
1674
1675 #[gpui::test]
1676 fn test_joining_injections_with_child_injections() {
1677 let (buffer, syntax_map) = test_edit_sequence(
1678 "Rust",
1679 &[
1680 "
1681 fn a() {
1682 b!(
1683 c![one.two.three],
1684 d![four.five.six],
1685 );
1686 e!(
1687 f![seven.eight],
1688 );
1689 }
1690 ",
1691 "
1692 fn a() {
1693 b!(
1694 c![one.two.three],
1695 d![four.five.six],
1696 ˇ f![seven.eight],
1697 );
1698 }
1699 ",
1700 ],
1701 );
1702
1703 assert_capture_ranges(
1704 &syntax_map,
1705 &buffer,
1706 &["field"],
1707 "
1708 fn a() {
1709 b!(
1710 c![one.«two».«three»],
1711 d![four.«five».«six»],
1712 f![seven.«eight»],
1713 );
1714 }
1715 ",
1716 );
1717 }
1718
1719 #[gpui::test]
1720 fn test_editing_edges_of_injection() {
1721 test_edit_sequence(
1722 "Rust",
1723 &[
1724 "
1725 fn a() {
1726 b!(c!())
1727 }
1728 ",
1729 "
1730 fn a() {
1731 «d»!(c!())
1732 }
1733 ",
1734 "
1735 fn a() {
1736 «e»d!(c!())
1737 }
1738 ",
1739 "
1740 fn a() {
1741 ed!«[»c!()«]»
1742 }
1743 ",
1744 ],
1745 );
1746 }
1747
1748 #[gpui::test]
1749 fn test_edits_preceding_and_intersecting_injection() {
1750 test_edit_sequence(
1751 "Rust",
1752 &[
1753 //
1754 "const aaaaaaaaaaaa: B = c!(d(e.f));",
1755 "const aˇa: B = c!(d(eˇ));",
1756 ],
1757 );
1758 }
1759
1760 #[gpui::test]
1761 fn test_non_local_changes_create_injections() {
1762 test_edit_sequence(
1763 "Rust",
1764 &[
1765 "
1766 // a! {
1767 static B: C = d;
1768 // }
1769 ",
1770 "
1771 ˇa! {
1772 static B: C = d;
1773 ˇ}
1774 ",
1775 ],
1776 );
1777 }
1778
1779 #[gpui::test]
1780 fn test_creating_many_injections_in_one_edit() {
1781 test_edit_sequence(
1782 "Rust",
1783 &[
1784 "
1785 fn a() {
1786 one(Two::three(3));
1787 four(Five::six(6));
1788 seven(Eight::nine(9));
1789 }
1790 ",
1791 "
1792 fn a() {
1793 one«!»(Two::three(3));
1794 four«!»(Five::six(6));
1795 seven«!»(Eight::nine(9));
1796 }
1797 ",
1798 "
1799 fn a() {
1800 one!(Two::three«!»(3));
1801 four!(Five::six«!»(6));
1802 seven!(Eight::nine«!»(9));
1803 }
1804 ",
1805 ],
1806 );
1807 }
1808
1809 #[gpui::test]
1810 fn test_editing_across_injection_boundary() {
1811 test_edit_sequence(
1812 "Rust",
1813 &[
1814 "
1815 fn one() {
1816 two();
1817 three!(
1818 three.four,
1819 five.six,
1820 );
1821 }
1822 ",
1823 "
1824 fn one() {
1825 two();
1826 th«irty_five![»
1827 three.four,
1828 five.six,
1829 « seven.eight,
1830 ];»
1831 }
1832 ",
1833 ],
1834 );
1835 }
1836
1837 #[gpui::test]
1838 fn test_removing_injection_by_replacing_across_boundary() {
1839 test_edit_sequence(
1840 "Rust",
1841 &[
1842 "
1843 fn one() {
1844 two!(
1845 three.four,
1846 );
1847 }
1848 ",
1849 "
1850 fn one() {
1851 t«en
1852 .eleven(
1853 twelve,
1854 »
1855 three.four,
1856 );
1857 }
1858 ",
1859 ],
1860 );
1861 }
1862
1863 #[gpui::test]
1864 fn test_combined_injections() {
1865 let (buffer, syntax_map) = test_edit_sequence(
1866 "ERB",
1867 &[
1868 "
1869 <body>
1870 <% if @one %>
1871 <div class=one>
1872 <% else %>
1873 <div class=two>
1874 <% end %>
1875 </div>
1876 </body>
1877 ",
1878 "
1879 <body>
1880 <% if @one %>
1881 <div class=one>
1882 ˇ else ˇ
1883 <div class=two>
1884 <% end %>
1885 </div>
1886 </body>
1887 ",
1888 "
1889 <body>
1890 <% if @one «;» end %>
1891 </div>
1892 </body>
1893 ",
1894 ],
1895 );
1896
1897 assert_capture_ranges(
1898 &syntax_map,
1899 &buffer,
1900 &["tag", "ivar"],
1901 "
1902 <«body»>
1903 <% if «@one» ; end %>
1904 </«div»>
1905 </«body»>
1906 ",
1907 );
1908 }
1909
1910 #[gpui::test]
1911 fn test_combined_injections_empty_ranges() {
1912 test_edit_sequence(
1913 "ERB",
1914 &[
1915 "
1916 <% if @one %>
1917 <% else %>
1918 <% end %>
1919 ",
1920 "
1921 <% if @one %>
1922 ˇ<% end %>
1923 ",
1924 ],
1925 );
1926 }
1927
1928 #[gpui::test]
1929 fn test_combined_injections_edit_edges_of_ranges() {
1930 let (buffer, syntax_map) = test_edit_sequence(
1931 "ERB",
1932 &[
1933 "
1934 <%= one @two %>
1935 <%= three @four %>
1936 ",
1937 "
1938 <%= one @two %ˇ
1939 <%= three @four %>
1940 ",
1941 "
1942 <%= one @two %«>»
1943 <%= three @four %>
1944 ",
1945 ],
1946 );
1947
1948 assert_capture_ranges(
1949 &syntax_map,
1950 &buffer,
1951 &["tag", "ivar"],
1952 "
1953 <%= one «@two» %>
1954 <%= three «@four» %>
1955 ",
1956 );
1957 }
1958
1959 #[gpui::test]
1960 fn test_combined_injections_splitting_some_injections() {
1961 let (_buffer, _syntax_map) = test_edit_sequence(
1962 "ERB",
1963 &[
1964 r#"
1965 <%A if b(:c) %>
1966 d
1967 <% end %>
1968 eee
1969 <% f %>
1970 "#,
1971 r#"
1972 <%« AAAAAAA %>
1973 hhhhhhh
1974 <%=» if b(:c) %>
1975 d
1976 <% end %>
1977 eee
1978 <% f %>
1979 "#,
1980 ],
1981 );
1982 }
1983
1984 #[gpui::test(iterations = 50)]
1985 fn test_random_syntax_map_edits(mut rng: StdRng) {
1986 let operations = env::var("OPERATIONS")
1987 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
1988 .unwrap_or(10);
1989
1990 let text = r#"
1991 fn test_something() {
1992 let vec = vec![5, 1, 3, 8];
1993 assert_eq!(
1994 vec
1995 .into_iter()
1996 .map(|i| i * 2)
1997 .collect::<Vec<usize>>(),
1998 vec![
1999 5 * 2, 1 * 2, 3 * 2, 8 * 2
2000 ],
2001 );
2002 }
2003 "#
2004 .unindent()
2005 .repeat(2);
2006
2007 let registry = Arc::new(LanguageRegistry::test());
2008 let language = Arc::new(rust_lang());
2009 registry.add(language.clone());
2010 let mut buffer = Buffer::new(0, 0, text);
2011
2012 let mut syntax_map = SyntaxMap::new();
2013 syntax_map.set_language_registry(registry.clone());
2014 syntax_map.reparse(language.clone(), &buffer);
2015
2016 let mut reference_syntax_map = SyntaxMap::new();
2017 reference_syntax_map.set_language_registry(registry.clone());
2018
2019 log::info!("initial text:\n{}", buffer.text());
2020
2021 for _ in 0..operations {
2022 let prev_buffer = buffer.snapshot();
2023 let prev_syntax_map = syntax_map.snapshot();
2024
2025 buffer.randomly_edit(&mut rng, 3);
2026 log::info!("text:\n{}", buffer.text());
2027
2028 syntax_map.interpolate(&buffer);
2029 check_interpolation(&prev_syntax_map, &syntax_map, &prev_buffer, &buffer);
2030
2031 syntax_map.reparse(language.clone(), &buffer);
2032
2033 reference_syntax_map.clear();
2034 reference_syntax_map.reparse(language.clone(), &buffer);
2035 }
2036
2037 for i in 0..operations {
2038 let i = operations - i - 1;
2039 buffer.undo();
2040 log::info!("undoing operation {}", i);
2041 log::info!("text:\n{}", buffer.text());
2042
2043 syntax_map.interpolate(&buffer);
2044 syntax_map.reparse(language.clone(), &buffer);
2045
2046 reference_syntax_map.clear();
2047 reference_syntax_map.reparse(language.clone(), &buffer);
2048 assert_eq!(
2049 syntax_map.layers(&buffer).len(),
2050 reference_syntax_map.layers(&buffer).len(),
2051 "wrong number of layers after undoing edit {i}"
2052 );
2053 }
2054
2055 let layers = syntax_map.layers(&buffer);
2056 let reference_layers = reference_syntax_map.layers(&buffer);
2057 for (edited_layer, reference_layer) in layers.into_iter().zip(reference_layers.into_iter())
2058 {
2059 assert_eq!(edited_layer.node.to_sexp(), reference_layer.node.to_sexp());
2060 assert_eq!(edited_layer.node.range(), reference_layer.node.range());
2061 }
2062 }
2063
2064 #[gpui::test(iterations = 50)]
2065 fn test_random_syntax_map_edits_with_combined_injections(mut rng: StdRng) {
2066 let operations = env::var("OPERATIONS")
2067 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
2068 .unwrap_or(10);
2069
2070 let text = r#"
2071 <div id="main">
2072 <% if one?(:two) %>
2073 <p class="three" four>
2074 <%= yield :five %>
2075 </p>
2076 <% elsif Six.seven(8) %>
2077 <p id="three" four>
2078 <%= yield :five %>
2079 </p>
2080 <% else %>
2081 <span>Ok</span>
2082 <% end %>
2083 </div>
2084 "#
2085 .unindent()
2086 .repeat(8);
2087
2088 let registry = Arc::new(LanguageRegistry::test());
2089 let language = Arc::new(erb_lang());
2090 registry.add(language.clone());
2091 registry.add(Arc::new(ruby_lang()));
2092 registry.add(Arc::new(html_lang()));
2093 let mut buffer = Buffer::new(0, 0, text);
2094
2095 let mut syntax_map = SyntaxMap::new();
2096 syntax_map.set_language_registry(registry.clone());
2097 syntax_map.reparse(language.clone(), &buffer);
2098
2099 let mut reference_syntax_map = SyntaxMap::new();
2100 reference_syntax_map.set_language_registry(registry.clone());
2101
2102 log::info!("initial text:\n{}", buffer.text());
2103
2104 for _ in 0..operations {
2105 let prev_buffer = buffer.snapshot();
2106 let prev_syntax_map = syntax_map.snapshot();
2107
2108 buffer.randomly_edit(&mut rng, 3);
2109 log::info!("text:\n{}", buffer.text());
2110
2111 syntax_map.interpolate(&buffer);
2112 check_interpolation(&prev_syntax_map, &syntax_map, &prev_buffer, &buffer);
2113
2114 syntax_map.reparse(language.clone(), &buffer);
2115
2116 reference_syntax_map.clear();
2117 reference_syntax_map.reparse(language.clone(), &buffer);
2118 }
2119
2120 for i in 0..operations {
2121 let i = operations - i - 1;
2122 buffer.undo();
2123 log::info!("undoing operation {}", i);
2124 log::info!("text:\n{}", buffer.text());
2125
2126 syntax_map.interpolate(&buffer);
2127 syntax_map.reparse(language.clone(), &buffer);
2128
2129 reference_syntax_map.clear();
2130 reference_syntax_map.reparse(language.clone(), &buffer);
2131 assert_eq!(
2132 syntax_map.layers(&buffer).len(),
2133 reference_syntax_map.layers(&buffer).len(),
2134 "wrong number of layers after undoing edit {i}"
2135 );
2136 }
2137
2138 let layers = syntax_map.layers(&buffer);
2139 let reference_layers = reference_syntax_map.layers(&buffer);
2140 for (edited_layer, reference_layer) in layers.into_iter().zip(reference_layers.into_iter())
2141 {
2142 assert_eq!(edited_layer.node.to_sexp(), reference_layer.node.to_sexp());
2143 assert_eq!(edited_layer.node.range(), reference_layer.node.range());
2144 }
2145 }
2146
2147 fn check_interpolation(
2148 old_syntax_map: &SyntaxSnapshot,
2149 new_syntax_map: &SyntaxSnapshot,
2150 old_buffer: &BufferSnapshot,
2151 new_buffer: &BufferSnapshot,
2152 ) {
2153 let edits = new_buffer
2154 .edits_since::<usize>(&old_buffer.version())
2155 .collect::<Vec<_>>();
2156
2157 for (old_layer, new_layer) in old_syntax_map
2158 .layers
2159 .iter()
2160 .zip(new_syntax_map.layers.iter())
2161 {
2162 assert_eq!(old_layer.range, new_layer.range);
2163 let old_start_byte = old_layer.range.start.to_offset(old_buffer);
2164 let new_start_byte = new_layer.range.start.to_offset(new_buffer);
2165 let old_start_point = old_layer.range.start.to_point(old_buffer).to_ts_point();
2166 let new_start_point = new_layer.range.start.to_point(new_buffer).to_ts_point();
2167 let old_node = old_layer
2168 .tree
2169 .root_node_with_offset(old_start_byte, old_start_point);
2170 let new_node = new_layer
2171 .tree
2172 .root_node_with_offset(new_start_byte, new_start_point);
2173 check_node_edits(
2174 old_layer.depth,
2175 &old_layer.range,
2176 old_node,
2177 new_node,
2178 old_buffer,
2179 new_buffer,
2180 &edits,
2181 );
2182 }
2183
2184 fn check_node_edits(
2185 depth: usize,
2186 range: &Range<Anchor>,
2187 old_node: Node,
2188 new_node: Node,
2189 old_buffer: &BufferSnapshot,
2190 new_buffer: &BufferSnapshot,
2191 edits: &[text::Edit<usize>],
2192 ) {
2193 assert_eq!(old_node.kind(), new_node.kind());
2194
2195 let old_range = old_node.byte_range();
2196 let new_range = new_node.byte_range();
2197
2198 let is_edited = edits
2199 .iter()
2200 .any(|edit| edit.new.start < new_range.end && edit.new.end > new_range.start);
2201 if is_edited {
2202 assert!(
2203 new_node.has_changes(),
2204 concat!(
2205 "failed to mark node as edited.\n",
2206 "layer depth: {}, old layer range: {:?}, new layer range: {:?},\n",
2207 "node kind: {}, old node range: {:?}, new node range: {:?}",
2208 ),
2209 depth,
2210 range.to_offset(old_buffer),
2211 range.to_offset(new_buffer),
2212 new_node.kind(),
2213 old_range,
2214 new_range,
2215 );
2216 }
2217
2218 if !new_node.has_changes() {
2219 assert_eq!(
2220 old_buffer
2221 .text_for_range(old_range.clone())
2222 .collect::<String>(),
2223 new_buffer
2224 .text_for_range(new_range.clone())
2225 .collect::<String>(),
2226 concat!(
2227 "mismatched text for node\n",
2228 "layer depth: {}, old layer range: {:?}, new layer range: {:?},\n",
2229 "node kind: {}, old node range:{:?}, new node range:{:?}",
2230 ),
2231 depth,
2232 range.to_offset(old_buffer),
2233 range.to_offset(new_buffer),
2234 new_node.kind(),
2235 old_range,
2236 new_range,
2237 );
2238 }
2239
2240 for i in 0..new_node.child_count() {
2241 check_node_edits(
2242 depth,
2243 range,
2244 old_node.child(i).unwrap(),
2245 new_node.child(i).unwrap(),
2246 old_buffer,
2247 new_buffer,
2248 edits,
2249 )
2250 }
2251 }
2252 }
2253
2254 fn test_edit_sequence(language_name: &str, steps: &[&str]) -> (Buffer, SyntaxMap) {
2255 let registry = Arc::new(LanguageRegistry::test());
2256 registry.add(Arc::new(rust_lang()));
2257 registry.add(Arc::new(ruby_lang()));
2258 registry.add(Arc::new(html_lang()));
2259 registry.add(Arc::new(erb_lang()));
2260 registry.add(Arc::new(markdown_lang()));
2261 let language = registry.language_for_name(language_name).unwrap();
2262 let mut buffer = Buffer::new(0, 0, Default::default());
2263
2264 let mut mutated_syntax_map = SyntaxMap::new();
2265 mutated_syntax_map.set_language_registry(registry.clone());
2266 mutated_syntax_map.reparse(language.clone(), &buffer);
2267
2268 for (i, marked_string) in steps.into_iter().enumerate() {
2269 buffer.edit_via_marked_text(&marked_string.unindent());
2270
2271 // Reparse the syntax map
2272 mutated_syntax_map.interpolate(&buffer);
2273 mutated_syntax_map.reparse(language.clone(), &buffer);
2274
2275 // Create a second syntax map from scratch
2276 let mut reference_syntax_map = SyntaxMap::new();
2277 reference_syntax_map.set_language_registry(registry.clone());
2278 reference_syntax_map.reparse(language.clone(), &buffer);
2279
2280 // Compare the mutated syntax map to the new syntax map
2281 let mutated_layers = mutated_syntax_map.layers(&buffer);
2282 let reference_layers = reference_syntax_map.layers(&buffer);
2283 assert_eq!(
2284 mutated_layers.len(),
2285 reference_layers.len(),
2286 "wrong number of layers at step {i}"
2287 );
2288 for (edited_layer, reference_layer) in
2289 mutated_layers.into_iter().zip(reference_layers.into_iter())
2290 {
2291 assert_eq!(
2292 edited_layer.node.to_sexp(),
2293 reference_layer.node.to_sexp(),
2294 "different layer at step {i}"
2295 );
2296 assert_eq!(
2297 edited_layer.node.range(),
2298 reference_layer.node.range(),
2299 "different layer at step {i}"
2300 );
2301 }
2302 }
2303
2304 (buffer, mutated_syntax_map)
2305 }
2306
2307 fn html_lang() -> Language {
2308 Language::new(
2309 LanguageConfig {
2310 name: "HTML".into(),
2311 path_suffixes: vec!["html".to_string()],
2312 ..Default::default()
2313 },
2314 Some(tree_sitter_html::language()),
2315 )
2316 .with_highlights_query(
2317 r#"
2318 (tag_name) @tag
2319 (erroneous_end_tag_name) @tag
2320 (attribute_name) @property
2321 "#,
2322 )
2323 .unwrap()
2324 }
2325
2326 fn ruby_lang() -> Language {
2327 Language::new(
2328 LanguageConfig {
2329 name: "Ruby".into(),
2330 path_suffixes: vec!["rb".to_string()],
2331 ..Default::default()
2332 },
2333 Some(tree_sitter_ruby::language()),
2334 )
2335 .with_highlights_query(
2336 r#"
2337 ["if" "do" "else" "end"] @keyword
2338 (instance_variable) @ivar
2339 "#,
2340 )
2341 .unwrap()
2342 }
2343
2344 fn erb_lang() -> Language {
2345 Language::new(
2346 LanguageConfig {
2347 name: "ERB".into(),
2348 path_suffixes: vec!["erb".to_string()],
2349 ..Default::default()
2350 },
2351 Some(tree_sitter_embedded_template::language()),
2352 )
2353 .with_highlights_query(
2354 r#"
2355 ["<%" "%>"] @keyword
2356 "#,
2357 )
2358 .unwrap()
2359 .with_injection_query(
2360 r#"
2361 ((code) @content
2362 (#set! "language" "ruby")
2363 (#set! "combined"))
2364
2365 ((content) @content
2366 (#set! "language" "html")
2367 (#set! "combined"))
2368 "#,
2369 )
2370 .unwrap()
2371 }
2372
2373 fn rust_lang() -> Language {
2374 Language::new(
2375 LanguageConfig {
2376 name: "Rust".into(),
2377 path_suffixes: vec!["rs".to_string()],
2378 ..Default::default()
2379 },
2380 Some(tree_sitter_rust::language()),
2381 )
2382 .with_highlights_query(
2383 r#"
2384 (field_identifier) @field
2385 (struct_expression) @struct
2386 "#,
2387 )
2388 .unwrap()
2389 .with_injection_query(
2390 r#"
2391 (macro_invocation
2392 (token_tree) @content
2393 (#set! "language" "rust"))
2394 "#,
2395 )
2396 .unwrap()
2397 }
2398
2399 fn markdown_lang() -> Language {
2400 Language::new(
2401 LanguageConfig {
2402 name: "Markdown".into(),
2403 path_suffixes: vec!["md".into()],
2404 ..Default::default()
2405 },
2406 Some(tree_sitter_markdown::language()),
2407 )
2408 .with_injection_query(
2409 r#"
2410 (fenced_code_block
2411 (info_string
2412 (language) @language)
2413 (code_fence_content) @content)
2414 "#,
2415 )
2416 .unwrap()
2417 }
2418
2419 fn range_for_text(buffer: &Buffer, text: &str) -> Range<usize> {
2420 let start = buffer.as_rope().to_string().find(text).unwrap();
2421 start..start + text.len()
2422 }
2423
2424 fn assert_layers_for_range(
2425 syntax_map: &SyntaxMap,
2426 buffer: &BufferSnapshot,
2427 range: Range<Point>,
2428 expected_layers: &[&str],
2429 ) {
2430 let layers = syntax_map
2431 .layers_for_range(range, &buffer)
2432 .collect::<Vec<_>>();
2433 assert_eq!(
2434 layers.len(),
2435 expected_layers.len(),
2436 "wrong number of layers"
2437 );
2438 for (i, (SyntaxLayerInfo { node, .. }, expected_s_exp)) in
2439 layers.iter().zip(expected_layers.iter()).enumerate()
2440 {
2441 let actual_s_exp = node.to_sexp();
2442 assert!(
2443 string_contains_sequence(
2444 &actual_s_exp,
2445 &expected_s_exp.split("...").collect::<Vec<_>>()
2446 ),
2447 "layer {i}:\n\nexpected: {expected_s_exp}\nactual: {actual_s_exp}",
2448 );
2449 }
2450 }
2451
2452 fn assert_capture_ranges(
2453 syntax_map: &SyntaxMap,
2454 buffer: &BufferSnapshot,
2455 highlight_query_capture_names: &[&str],
2456 marked_string: &str,
2457 ) {
2458 let mut actual_ranges = Vec::<Range<usize>>::new();
2459 let captures = syntax_map.captures(0..buffer.len(), buffer, |grammar| {
2460 grammar.highlights_query.as_ref()
2461 });
2462 let queries = captures
2463 .grammars()
2464 .iter()
2465 .map(|grammar| grammar.highlights_query.as_ref().unwrap())
2466 .collect::<Vec<_>>();
2467 for capture in captures {
2468 let name = &queries[capture.grammar_index].capture_names()[capture.index as usize];
2469 if highlight_query_capture_names.contains(&name.as_str()) {
2470 actual_ranges.push(capture.node.byte_range());
2471 }
2472 }
2473
2474 let (text, expected_ranges) = marked_text_ranges(&marked_string.unindent(), false);
2475 assert_eq!(text, buffer.text());
2476 assert_eq!(actual_ranges, expected_ranges);
2477 }
2478
2479 pub fn string_contains_sequence(text: &str, parts: &[&str]) -> bool {
2480 let mut last_part_end = 0;
2481 for part in parts {
2482 if let Some(start_ix) = text[last_part_end..].find(part) {
2483 last_part_end = start_ix + part.len();
2484 } else {
2485 return false;
2486 }
2487 }
2488 true
2489 }
2490}