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