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