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