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