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