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