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