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