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