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