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