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