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