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.push_tree(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.push_tree(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.push_tree(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.push_tree(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 let Some(SyntaxLayerContent::Parsed { tree: old_tree, .. }) =
545 old_layer.map(|layer| &layer.content)
546 {
547 if let ParseMode::Combined {
548 mut parent_layer_changed_ranges,
549 ..
550 } = step.mode
551 {
552 for range in &mut parent_layer_changed_ranges {
553 range.start -= step_start_byte;
554 range.end -= step_start_byte;
555 }
556
557 included_ranges = splice_included_ranges(
558 old_tree.included_ranges(),
559 &parent_layer_changed_ranges,
560 &included_ranges,
561 );
562 }
563
564 tree = parse_text(
565 grammar,
566 text.as_rope(),
567 step_start_byte,
568 included_ranges,
569 Some(old_tree.clone()),
570 );
571 changed_ranges = join_ranges(
572 invalidated_ranges.iter().cloned().filter(|range| {
573 range.start <= step_end_byte && range.end >= step_start_byte
574 }),
575 old_tree.changed_ranges(&tree).map(|r| {
576 step_start_byte + r.start_byte..step_start_byte + r.end_byte
577 }),
578 );
579 } else {
580 tree = parse_text(
581 grammar,
582 text.as_rope(),
583 step_start_byte,
584 included_ranges,
585 None,
586 );
587 changed_ranges = vec![step_start_byte..step_end_byte];
588 }
589
590 if let (Some((config, registry)), false) = (
591 grammar.injection_config.as_ref().zip(registry.as_ref()),
592 changed_ranges.is_empty(),
593 ) {
594 for range in &changed_ranges {
595 changed_regions.insert(
596 ChangedRegion {
597 depth: step.depth + 1,
598 range: text.anchor_before(range.start)
599 ..text.anchor_after(range.end),
600 },
601 text,
602 );
603 }
604 get_injections(
605 config,
606 text,
607 tree.root_node_with_offset(
608 step_start_byte,
609 step_start_point.to_ts_point(),
610 ),
611 registry,
612 step.depth + 1,
613 &changed_ranges,
614 &mut combined_injection_ranges,
615 &mut queue,
616 );
617 }
618
619 SyntaxLayerContent::Parsed { tree, language }
620 }
621 ParseStepLanguage::Pending { name } => SyntaxLayerContent::Pending {
622 language_name: name,
623 },
624 };
625
626 layers.push(
627 SyntaxLayer {
628 depth: step.depth,
629 range: step.range,
630 content,
631 },
632 &text,
633 );
634 }
635
636 drop(cursor);
637 self.layers = layers;
638 self.interpolated_version = text.version.clone();
639 self.parsed_version = text.version.clone();
640 #[cfg(debug_assertions)]
641 self.check_invariants(text);
642 }
643
644 #[cfg(debug_assertions)]
645 fn check_invariants(&self, text: &BufferSnapshot) {
646 let mut max_depth = 0;
647 let mut prev_range: Option<Range<Anchor>> = None;
648 for layer in self.layers.iter() {
649 if layer.depth == max_depth {
650 if let Some(prev_range) = prev_range {
651 match layer.range.start.cmp(&prev_range.start, text) {
652 Ordering::Less => panic!("layers out of order"),
653 Ordering::Equal => {
654 assert!(layer.range.end.cmp(&prev_range.end, text).is_ge())
655 }
656 Ordering::Greater => {}
657 }
658 }
659 } else if layer.depth < max_depth {
660 panic!("layers out of order")
661 }
662 max_depth = layer.depth;
663 prev_range = Some(layer.range.clone());
664 }
665 }
666
667 pub fn single_tree_captures<'a>(
668 range: Range<usize>,
669 text: &'a Rope,
670 tree: &'a Tree,
671 language: &'a Arc<Language>,
672 query: fn(&Grammar) -> Option<&Query>,
673 ) -> SyntaxMapCaptures<'a> {
674 SyntaxMapCaptures::new(
675 range.clone(),
676 text,
677 [SyntaxLayerInfo {
678 language,
679 tree,
680 depth: 0,
681 offset: (0, tree_sitter::Point::new(0, 0)),
682 }]
683 .into_iter(),
684 query,
685 )
686 }
687
688 pub fn captures<'a>(
689 &'a self,
690 range: Range<usize>,
691 buffer: &'a BufferSnapshot,
692 query: fn(&Grammar) -> Option<&Query>,
693 ) -> SyntaxMapCaptures {
694 SyntaxMapCaptures::new(
695 range.clone(),
696 buffer.as_rope(),
697 self.layers_for_range(range, buffer).into_iter(),
698 query,
699 )
700 }
701
702 pub fn matches<'a>(
703 &'a self,
704 range: Range<usize>,
705 buffer: &'a BufferSnapshot,
706 query: fn(&Grammar) -> Option<&Query>,
707 ) -> SyntaxMapMatches {
708 SyntaxMapMatches::new(
709 range.clone(),
710 buffer.as_rope(),
711 self.layers_for_range(range, buffer).into_iter(),
712 query,
713 )
714 }
715
716 #[cfg(test)]
717 pub fn layers<'a>(&'a self, buffer: &'a BufferSnapshot) -> Vec<SyntaxLayerInfo> {
718 self.layers_for_range(0..buffer.len(), buffer).collect()
719 }
720
721 pub fn layers_for_range<'a, T: ToOffset>(
722 &'a self,
723 range: Range<T>,
724 buffer: &'a BufferSnapshot,
725 ) -> impl 'a + Iterator<Item = SyntaxLayerInfo> {
726 let start = buffer.anchor_before(range.start.to_offset(buffer));
727 let end = buffer.anchor_after(range.end.to_offset(buffer));
728
729 let mut cursor = self.layers.filter::<_, ()>(move |summary| {
730 if summary.max_depth > summary.min_depth {
731 true
732 } else {
733 let is_before_start = summary.range.end.cmp(&start, buffer).is_lt();
734 let is_after_end = summary.range.start.cmp(&end, buffer).is_gt();
735 !is_before_start && !is_after_end
736 }
737 });
738
739 cursor.next(buffer);
740 iter::from_fn(move || {
741 while let Some(layer) = cursor.item() {
742 if let SyntaxLayerContent::Parsed { tree, language } = &layer.content {
743 let info = SyntaxLayerInfo {
744 tree,
745 language,
746 depth: layer.depth,
747 offset: (
748 layer.range.start.to_offset(buffer),
749 layer.range.start.to_point(buffer).to_ts_point(),
750 ),
751 };
752 cursor.next(buffer);
753 return Some(info);
754 } else {
755 cursor.next(buffer);
756 }
757 }
758 None
759 })
760 }
761
762 pub fn contains_unknown_injections(&self) -> bool {
763 self.layers.summary().contains_unknown_injections
764 }
765
766 pub fn language_registry_version(&self) -> usize {
767 self.language_registry_version
768 }
769}
770
771impl<'a> SyntaxMapCaptures<'a> {
772 fn new(
773 range: Range<usize>,
774 text: &'a Rope,
775 layers: impl Iterator<Item = SyntaxLayerInfo<'a>>,
776 query: fn(&Grammar) -> Option<&Query>,
777 ) -> Self {
778 let mut result = Self {
779 layers: Vec::new(),
780 grammars: Vec::new(),
781 active_layer_count: 0,
782 };
783 for layer in layers {
784 let grammar = match &layer.language.grammar {
785 Some(grammar) => grammar,
786 None => continue,
787 };
788 let query = match query(&grammar) {
789 Some(query) => query,
790 None => continue,
791 };
792
793 let mut query_cursor = QueryCursorHandle::new();
794
795 // TODO - add a Tree-sitter API to remove the need for this.
796 let cursor = unsafe {
797 std::mem::transmute::<_, &'static mut QueryCursor>(query_cursor.deref_mut())
798 };
799
800 cursor.set_byte_range(range.clone());
801 let captures = cursor.captures(query, layer.node(), TextProvider(text));
802 let grammar_index = result
803 .grammars
804 .iter()
805 .position(|g| g.id == grammar.id())
806 .unwrap_or_else(|| {
807 result.grammars.push(grammar);
808 result.grammars.len() - 1
809 });
810 let mut layer = SyntaxMapCapturesLayer {
811 depth: layer.depth,
812 grammar_index,
813 next_capture: None,
814 captures,
815 _query_cursor: query_cursor,
816 };
817
818 layer.advance();
819 if layer.next_capture.is_some() {
820 let key = layer.sort_key();
821 let ix = match result.layers[..result.active_layer_count]
822 .binary_search_by_key(&key, |layer| layer.sort_key())
823 {
824 Ok(ix) | Err(ix) => ix,
825 };
826 result.layers.insert(ix, layer);
827 result.active_layer_count += 1;
828 } else {
829 result.layers.push(layer);
830 }
831 }
832
833 result
834 }
835
836 pub fn grammars(&self) -> &[&'a Grammar] {
837 &self.grammars
838 }
839
840 pub fn peek(&self) -> Option<SyntaxMapCapture<'a>> {
841 let layer = self.layers[..self.active_layer_count].first()?;
842 let capture = layer.next_capture?;
843 Some(SyntaxMapCapture {
844 depth: layer.depth,
845 grammar_index: layer.grammar_index,
846 index: capture.index,
847 node: capture.node,
848 })
849 }
850
851 pub fn advance(&mut self) -> bool {
852 let layer = if let Some(layer) = self.layers[..self.active_layer_count].first_mut() {
853 layer
854 } else {
855 return false;
856 };
857
858 layer.advance();
859 if layer.next_capture.is_some() {
860 let key = layer.sort_key();
861 let i = 1 + self.layers[1..self.active_layer_count]
862 .iter()
863 .position(|later_layer| key < later_layer.sort_key())
864 .unwrap_or(self.active_layer_count - 1);
865 self.layers[0..i].rotate_left(1);
866 } else {
867 self.layers[0..self.active_layer_count].rotate_left(1);
868 self.active_layer_count -= 1;
869 }
870
871 true
872 }
873
874 pub fn set_byte_range(&mut self, range: Range<usize>) {
875 for layer in &mut self.layers {
876 layer.captures.set_byte_range(range.clone());
877 if let Some(capture) = &layer.next_capture {
878 if capture.node.end_byte() > range.start {
879 continue;
880 }
881 }
882 layer.advance();
883 }
884 self.layers.sort_unstable_by_key(|layer| layer.sort_key());
885 self.active_layer_count = self
886 .layers
887 .iter()
888 .position(|layer| layer.next_capture.is_none())
889 .unwrap_or(self.layers.len());
890 }
891}
892
893impl<'a> SyntaxMapMatches<'a> {
894 fn new(
895 range: Range<usize>,
896 text: &'a Rope,
897 layers: impl Iterator<Item = SyntaxLayerInfo<'a>>,
898 query: fn(&Grammar) -> Option<&Query>,
899 ) -> Self {
900 let mut result = Self::default();
901 for layer in layers {
902 let grammar = match &layer.language.grammar {
903 Some(grammar) => grammar,
904 None => continue,
905 };
906 let query = match query(&grammar) {
907 Some(query) => query,
908 None => continue,
909 };
910
911 let mut query_cursor = QueryCursorHandle::new();
912
913 // TODO - add a Tree-sitter API to remove the need for this.
914 let cursor = unsafe {
915 std::mem::transmute::<_, &'static mut QueryCursor>(query_cursor.deref_mut())
916 };
917
918 cursor.set_byte_range(range.clone());
919 let matches = cursor.matches(query, layer.node(), TextProvider(text));
920 let grammar_index = result
921 .grammars
922 .iter()
923 .position(|g| g.id == grammar.id())
924 .unwrap_or_else(|| {
925 result.grammars.push(grammar);
926 result.grammars.len() - 1
927 });
928 let mut layer = SyntaxMapMatchesLayer {
929 depth: layer.depth,
930 grammar_index,
931 matches,
932 next_pattern_index: 0,
933 next_captures: Vec::new(),
934 has_next: false,
935 _query_cursor: query_cursor,
936 };
937
938 layer.advance();
939 if layer.has_next {
940 let key = layer.sort_key();
941 let ix = match result.layers[..result.active_layer_count]
942 .binary_search_by_key(&key, |layer| layer.sort_key())
943 {
944 Ok(ix) | Err(ix) => ix,
945 };
946 result.layers.insert(ix, layer);
947 result.active_layer_count += 1;
948 } else {
949 result.layers.push(layer);
950 }
951 }
952 result
953 }
954
955 pub fn grammars(&self) -> &[&'a Grammar] {
956 &self.grammars
957 }
958
959 pub fn peek(&self) -> Option<SyntaxMapMatch> {
960 let layer = self.layers.first()?;
961 if !layer.has_next {
962 return None;
963 }
964 Some(SyntaxMapMatch {
965 depth: layer.depth,
966 grammar_index: layer.grammar_index,
967 pattern_index: layer.next_pattern_index,
968 captures: &layer.next_captures,
969 })
970 }
971
972 pub fn advance(&mut self) -> bool {
973 let layer = if let Some(layer) = self.layers.first_mut() {
974 layer
975 } else {
976 return false;
977 };
978
979 layer.advance();
980 if layer.has_next {
981 let key = layer.sort_key();
982 let i = 1 + self.layers[1..self.active_layer_count]
983 .iter()
984 .position(|later_layer| key < later_layer.sort_key())
985 .unwrap_or(self.active_layer_count - 1);
986 self.layers[0..i].rotate_left(1);
987 } else {
988 self.layers[0..self.active_layer_count].rotate_left(1);
989 self.active_layer_count -= 1;
990 }
991
992 true
993 }
994}
995
996impl<'a> SyntaxMapCapturesLayer<'a> {
997 fn advance(&mut self) {
998 self.next_capture = self.captures.next().map(|(mat, ix)| mat.captures[ix]);
999 }
1000
1001 fn sort_key(&self) -> (usize, Reverse<usize>, usize) {
1002 if let Some(capture) = &self.next_capture {
1003 let range = capture.node.byte_range();
1004 (range.start, Reverse(range.end), self.depth)
1005 } else {
1006 (usize::MAX, Reverse(0), usize::MAX)
1007 }
1008 }
1009}
1010
1011impl<'a> SyntaxMapMatchesLayer<'a> {
1012 fn advance(&mut self) {
1013 if let Some(mat) = self.matches.next() {
1014 self.next_captures.clear();
1015 self.next_captures.extend_from_slice(&mat.captures);
1016 self.next_pattern_index = mat.pattern_index;
1017 self.has_next = true;
1018 } else {
1019 self.has_next = false;
1020 }
1021 }
1022
1023 fn sort_key(&self) -> (usize, Reverse<usize>, usize) {
1024 if self.has_next {
1025 let captures = &self.next_captures;
1026 if let Some((first, last)) = captures.first().zip(captures.last()) {
1027 return (
1028 first.node.start_byte(),
1029 Reverse(last.node.end_byte()),
1030 self.depth,
1031 );
1032 }
1033 }
1034 (usize::MAX, Reverse(0), usize::MAX)
1035 }
1036}
1037
1038impl<'a> Iterator for SyntaxMapCaptures<'a> {
1039 type Item = SyntaxMapCapture<'a>;
1040
1041 fn next(&mut self) -> Option<Self::Item> {
1042 let result = self.peek();
1043 self.advance();
1044 result
1045 }
1046}
1047
1048fn join_ranges(
1049 a: impl Iterator<Item = Range<usize>>,
1050 b: impl Iterator<Item = Range<usize>>,
1051) -> Vec<Range<usize>> {
1052 let mut result = Vec::<Range<usize>>::new();
1053 let mut a = a.peekable();
1054 let mut b = b.peekable();
1055 loop {
1056 let range = match (a.peek(), b.peek()) {
1057 (Some(range_a), Some(range_b)) => {
1058 if range_a.start < range_b.start {
1059 a.next().unwrap()
1060 } else {
1061 b.next().unwrap()
1062 }
1063 }
1064 (None, Some(_)) => b.next().unwrap(),
1065 (Some(_), None) => a.next().unwrap(),
1066 (None, None) => break,
1067 };
1068
1069 if let Some(last) = result.last_mut() {
1070 if range.start <= last.end {
1071 last.end = last.end.max(range.end);
1072 continue;
1073 }
1074 }
1075 result.push(range);
1076 }
1077 result
1078}
1079
1080fn parse_text(
1081 grammar: &Grammar,
1082 text: &Rope,
1083 start_byte: usize,
1084 ranges: Vec<tree_sitter::Range>,
1085 old_tree: Option<Tree>,
1086) -> Tree {
1087 PARSER.with(|parser| {
1088 let mut parser = parser.borrow_mut();
1089 let mut chunks = text.chunks_in_range(start_byte..text.len());
1090 parser
1091 .set_included_ranges(&ranges)
1092 .expect("overlapping ranges");
1093 parser
1094 .set_language(grammar.ts_language)
1095 .expect("incompatible grammar");
1096 parser
1097 .parse_with(
1098 &mut move |offset, _| {
1099 chunks.seek(start_byte + offset);
1100 chunks.next().unwrap_or("").as_bytes()
1101 },
1102 old_tree.as_ref(),
1103 )
1104 .expect("invalid language")
1105 })
1106}
1107
1108fn get_injections(
1109 config: &InjectionConfig,
1110 text: &BufferSnapshot,
1111 node: Node,
1112 language_registry: &Arc<LanguageRegistry>,
1113 depth: usize,
1114 changed_ranges: &[Range<usize>],
1115 combined_injection_ranges: &mut HashMap<Arc<Language>, Vec<tree_sitter::Range>>,
1116 queue: &mut BinaryHeap<ParseStep>,
1117) {
1118 let mut query_cursor = QueryCursorHandle::new();
1119 let mut prev_match = None;
1120
1121 // Ensure that a `ParseStep` is created for every combined injection language, even
1122 // if there currently no matches for that injection.
1123 combined_injection_ranges.clear();
1124 for pattern in &config.patterns {
1125 if let (Some(language_name), true) = (pattern.language.as_ref(), pattern.combined) {
1126 if let Some(language) = language_registry
1127 .language_for_name_or_extension(language_name)
1128 .now_or_never()
1129 .and_then(|language| language.ok())
1130 {
1131 combined_injection_ranges.insert(language, Vec::new());
1132 }
1133 }
1134 }
1135
1136 for query_range in changed_ranges {
1137 query_cursor.set_byte_range(query_range.start.saturating_sub(1)..query_range.end + 1);
1138 for mat in query_cursor.matches(&config.query, node, TextProvider(text.as_rope())) {
1139 let content_ranges = mat
1140 .nodes_for_capture_index(config.content_capture_ix)
1141 .map(|node| node.range())
1142 .collect::<Vec<_>>();
1143 if content_ranges.is_empty() {
1144 continue;
1145 }
1146
1147 // Avoid duplicate matches if two changed ranges intersect the same injection.
1148 let content_range =
1149 content_ranges.first().unwrap().start_byte..content_ranges.last().unwrap().end_byte;
1150 if let Some((last_pattern_ix, last_range)) = &prev_match {
1151 if mat.pattern_index == *last_pattern_ix && content_range == *last_range {
1152 continue;
1153 }
1154 }
1155 prev_match = Some((mat.pattern_index, content_range.clone()));
1156
1157 let combined = config.patterns[mat.pattern_index].combined;
1158
1159 let mut language_name = None;
1160 let mut step_range = content_range.clone();
1161 if let Some(name) = config.patterns[mat.pattern_index].language.as_ref() {
1162 language_name = Some(Cow::Borrowed(name.as_ref()))
1163 } else if let Some(language_node) = config
1164 .language_capture_ix
1165 .and_then(|ix| mat.nodes_for_capture_index(ix).next())
1166 {
1167 step_range.start = cmp::min(content_range.start, language_node.start_byte());
1168 step_range.end = cmp::max(content_range.end, language_node.end_byte());
1169 language_name = Some(Cow::Owned(
1170 text.text_for_range(language_node.byte_range()).collect(),
1171 ))
1172 };
1173
1174 if let Some(language_name) = language_name {
1175 let language = language_registry
1176 .language_for_name_or_extension(&language_name)
1177 .now_or_never()
1178 .and_then(|language| language.ok());
1179 let range = text.anchor_before(step_range.start)..text.anchor_after(step_range.end);
1180 if let Some(language) = language {
1181 if combined {
1182 combined_injection_ranges
1183 .entry(language.clone())
1184 .or_default()
1185 .extend(content_ranges);
1186 } else {
1187 queue.push(ParseStep {
1188 depth,
1189 language: ParseStepLanguage::Loaded { language },
1190 included_ranges: content_ranges,
1191 range,
1192 mode: ParseMode::Single,
1193 });
1194 }
1195 } else {
1196 queue.push(ParseStep {
1197 depth,
1198 language: ParseStepLanguage::Pending {
1199 name: language_name.into(),
1200 },
1201 included_ranges: content_ranges,
1202 range,
1203 mode: ParseMode::Single,
1204 });
1205 }
1206 }
1207 }
1208 }
1209
1210 for (language, mut included_ranges) in combined_injection_ranges.drain() {
1211 included_ranges.sort_unstable();
1212 let range = text.anchor_before(node.start_byte())..text.anchor_after(node.end_byte());
1213 queue.push(ParseStep {
1214 depth,
1215 language: ParseStepLanguage::Loaded { language },
1216 range,
1217 included_ranges,
1218 mode: ParseMode::Combined {
1219 parent_layer_range: node.start_byte()..node.end_byte(),
1220 parent_layer_changed_ranges: changed_ranges.to_vec(),
1221 },
1222 })
1223 }
1224}
1225
1226pub(crate) fn splice_included_ranges(
1227 mut ranges: Vec<tree_sitter::Range>,
1228 changed_ranges: &[Range<usize>],
1229 new_ranges: &[tree_sitter::Range],
1230) -> Vec<tree_sitter::Range> {
1231 let mut changed_ranges = changed_ranges.into_iter().peekable();
1232 let mut new_ranges = new_ranges.into_iter().peekable();
1233 let mut ranges_ix = 0;
1234 loop {
1235 let new_range = new_ranges.peek();
1236 let mut changed_range = changed_ranges.peek();
1237
1238 // Remove ranges that have changed before inserting any new ranges
1239 // into those ranges.
1240 if let Some((changed, new)) = changed_range.zip(new_range) {
1241 if new.end_byte < changed.start {
1242 changed_range = None;
1243 }
1244 }
1245
1246 if let Some(changed) = changed_range {
1247 let mut start_ix = ranges_ix
1248 + match ranges[ranges_ix..].binary_search_by_key(&changed.start, |r| r.end_byte) {
1249 Ok(ix) | Err(ix) => ix,
1250 };
1251 let mut end_ix = ranges_ix
1252 + match ranges[ranges_ix..].binary_search_by_key(&changed.end, |r| r.start_byte) {
1253 Ok(ix) => ix + 1,
1254 Err(ix) => ix,
1255 };
1256
1257 // If there are empty ranges, then there may be multiple ranges with the same
1258 // start or end. Expand the splice to include any adjacent ranges that touch
1259 // the changed range.
1260 while start_ix > 0 {
1261 if ranges[start_ix - 1].end_byte == changed.start {
1262 start_ix -= 1;
1263 } else {
1264 break;
1265 }
1266 }
1267 while let Some(range) = ranges.get(end_ix) {
1268 if range.start_byte == changed.end {
1269 end_ix += 1;
1270 } else {
1271 break;
1272 }
1273 }
1274
1275 if end_ix > start_ix {
1276 ranges.splice(start_ix..end_ix, []);
1277 }
1278 changed_ranges.next();
1279 ranges_ix = start_ix;
1280 } else if let Some(new_range) = new_range {
1281 let ix = ranges_ix
1282 + match ranges[ranges_ix..]
1283 .binary_search_by_key(&new_range.start_byte, |r| r.start_byte)
1284 {
1285 Ok(ix) | Err(ix) => ix,
1286 };
1287 ranges.insert(ix, **new_range);
1288 new_ranges.next();
1289 ranges_ix = ix + 1;
1290 } else {
1291 break;
1292 }
1293 }
1294 ranges
1295}
1296
1297impl OwnedSyntaxLayerInfo {
1298 pub fn node(&self) -> Node {
1299 self.tree
1300 .root_node_with_offset(self.offset.0, self.offset.1)
1301 }
1302}
1303
1304impl<'a> SyntaxLayerInfo<'a> {
1305 pub fn to_owned(&self) -> OwnedSyntaxLayerInfo {
1306 OwnedSyntaxLayerInfo {
1307 tree: self.tree.clone(),
1308 offset: self.offset,
1309 depth: self.depth,
1310 language: self.language.clone(),
1311 }
1312 }
1313
1314 pub fn node(&self) -> Node<'a> {
1315 self.tree
1316 .root_node_with_offset(self.offset.0, self.offset.1)
1317 }
1318
1319 pub(crate) fn override_id(&self, offset: usize, text: &text::BufferSnapshot) -> Option<u32> {
1320 let text = TextProvider(text.as_rope());
1321 let config = self.language.grammar.as_ref()?.override_config.as_ref()?;
1322
1323 let mut query_cursor = QueryCursorHandle::new();
1324 query_cursor.set_byte_range(offset..offset);
1325
1326 let mut smallest_match: Option<(u32, Range<usize>)> = None;
1327 for mat in query_cursor.matches(&config.query, self.node(), text) {
1328 for capture in mat.captures {
1329 if !config.values.contains_key(&capture.index) {
1330 continue;
1331 }
1332
1333 let range = capture.node.byte_range();
1334 if offset <= range.start || offset >= range.end {
1335 continue;
1336 }
1337
1338 if let Some((_, smallest_range)) = &smallest_match {
1339 if range.len() < smallest_range.len() {
1340 smallest_match = Some((capture.index, range))
1341 }
1342 continue;
1343 }
1344
1345 smallest_match = Some((capture.index, range));
1346 }
1347 }
1348
1349 smallest_match.map(|(index, _)| index)
1350 }
1351}
1352
1353impl std::ops::Deref for SyntaxMap {
1354 type Target = SyntaxSnapshot;
1355
1356 fn deref(&self) -> &Self::Target {
1357 &self.snapshot
1358 }
1359}
1360
1361impl PartialEq for ParseStep {
1362 fn eq(&self, _: &Self) -> bool {
1363 false
1364 }
1365}
1366
1367impl Eq for ParseStep {}
1368
1369impl PartialOrd for ParseStep {
1370 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
1371 Some(self.cmp(&other))
1372 }
1373}
1374
1375impl Ord for ParseStep {
1376 fn cmp(&self, other: &Self) -> Ordering {
1377 let range_a = self.range();
1378 let range_b = other.range();
1379 Ord::cmp(&other.depth, &self.depth)
1380 .then_with(|| Ord::cmp(&range_b.start, &range_a.start))
1381 .then_with(|| Ord::cmp(&range_a.end, &range_b.end))
1382 .then_with(|| self.language.id().cmp(&other.language.id()))
1383 }
1384}
1385
1386impl ParseStep {
1387 fn range(&self) -> Range<usize> {
1388 if let ParseMode::Combined {
1389 parent_layer_range, ..
1390 } = &self.mode
1391 {
1392 parent_layer_range.clone()
1393 } else {
1394 let start = self.included_ranges.first().map_or(0, |r| r.start_byte);
1395 let end = self.included_ranges.last().map_or(0, |r| r.end_byte);
1396 start..end
1397 }
1398 }
1399}
1400
1401impl ChangedRegion {
1402 fn cmp(&self, other: &Self, buffer: &BufferSnapshot) -> Ordering {
1403 let range_a = &self.range;
1404 let range_b = &other.range;
1405 Ord::cmp(&self.depth, &other.depth)
1406 .then_with(|| range_a.start.cmp(&range_b.start, buffer))
1407 .then_with(|| range_b.end.cmp(&range_a.end, buffer))
1408 }
1409}
1410
1411impl ChangeRegionSet {
1412 fn start_position(&self) -> ChangeStartPosition {
1413 self.0.first().map_or(
1414 ChangeStartPosition {
1415 depth: usize::MAX,
1416 position: Anchor::MAX,
1417 },
1418 |region| ChangeStartPosition {
1419 depth: region.depth,
1420 position: region.range.start,
1421 },
1422 )
1423 }
1424
1425 fn intersects(&self, layer: &SyntaxLayer, text: &BufferSnapshot) -> bool {
1426 for region in &self.0 {
1427 if region.depth < layer.depth {
1428 continue;
1429 }
1430 if region.depth > layer.depth {
1431 break;
1432 }
1433 if region.range.end.cmp(&layer.range.start, text).is_le() {
1434 continue;
1435 }
1436 if region.range.start.cmp(&layer.range.end, text).is_ge() {
1437 break;
1438 }
1439 return true;
1440 }
1441 false
1442 }
1443
1444 fn insert(&mut self, region: ChangedRegion, text: &BufferSnapshot) {
1445 if let Err(ix) = self.0.binary_search_by(|probe| probe.cmp(®ion, text)) {
1446 self.0.insert(ix, region);
1447 }
1448 }
1449
1450 fn prune(&mut self, summary: SyntaxLayerSummary, text: &BufferSnapshot) -> bool {
1451 let prev_len = self.0.len();
1452 self.0.retain(|region| {
1453 region.depth > summary.max_depth
1454 || (region.depth == summary.max_depth
1455 && region
1456 .range
1457 .end
1458 .cmp(&summary.last_layer_range.start, text)
1459 .is_gt())
1460 });
1461 self.0.len() < prev_len
1462 }
1463}
1464
1465impl Default for SyntaxLayerSummary {
1466 fn default() -> Self {
1467 Self {
1468 max_depth: 0,
1469 min_depth: 0,
1470 range: Anchor::MAX..Anchor::MIN,
1471 last_layer_range: Anchor::MIN..Anchor::MAX,
1472 last_layer_language: None,
1473 contains_unknown_injections: false,
1474 }
1475 }
1476}
1477
1478impl sum_tree::Summary for SyntaxLayerSummary {
1479 type Context = BufferSnapshot;
1480
1481 fn add_summary(&mut self, other: &Self, buffer: &Self::Context) {
1482 if other.max_depth > self.max_depth {
1483 self.max_depth = other.max_depth;
1484 self.range = other.range.clone();
1485 } else {
1486 if self.range == (Anchor::MAX..Anchor::MAX) {
1487 self.range.start = other.range.start;
1488 }
1489 if other.range.end.cmp(&self.range.end, buffer).is_gt() {
1490 self.range.end = other.range.end;
1491 }
1492 }
1493 self.last_layer_range = other.last_layer_range.clone();
1494 self.last_layer_language = other.last_layer_language;
1495 self.contains_unknown_injections |= other.contains_unknown_injections;
1496 }
1497}
1498
1499impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary> for SyntaxLayerPosition {
1500 fn cmp(&self, cursor_location: &SyntaxLayerSummary, buffer: &BufferSnapshot) -> Ordering {
1501 Ord::cmp(&self.depth, &cursor_location.max_depth)
1502 .then_with(|| {
1503 self.range
1504 .start
1505 .cmp(&cursor_location.last_layer_range.start, buffer)
1506 })
1507 .then_with(|| {
1508 cursor_location
1509 .last_layer_range
1510 .end
1511 .cmp(&self.range.end, buffer)
1512 })
1513 .then_with(|| self.language.cmp(&cursor_location.last_layer_language))
1514 }
1515}
1516
1517impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary> for ChangeStartPosition {
1518 fn cmp(&self, cursor_location: &SyntaxLayerSummary, text: &BufferSnapshot) -> Ordering {
1519 Ord::cmp(&self.depth, &cursor_location.max_depth)
1520 .then_with(|| self.position.cmp(&cursor_location.range.end, text))
1521 }
1522}
1523
1524impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary>
1525 for SyntaxLayerPositionBeforeChange
1526{
1527 fn cmp(&self, cursor_location: &SyntaxLayerSummary, buffer: &BufferSnapshot) -> Ordering {
1528 if self.change.cmp(cursor_location, buffer).is_le() {
1529 return Ordering::Less;
1530 } else {
1531 self.position.cmp(cursor_location, buffer)
1532 }
1533 }
1534}
1535
1536impl sum_tree::Item for SyntaxLayer {
1537 type Summary = SyntaxLayerSummary;
1538
1539 fn summary(&self) -> Self::Summary {
1540 SyntaxLayerSummary {
1541 min_depth: self.depth,
1542 max_depth: self.depth,
1543 range: self.range.clone(),
1544 last_layer_range: self.range.clone(),
1545 last_layer_language: self.content.language_id(),
1546 contains_unknown_injections: matches!(self.content, SyntaxLayerContent::Pending { .. }),
1547 }
1548 }
1549}
1550
1551impl std::fmt::Debug for SyntaxLayer {
1552 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1553 f.debug_struct("SyntaxLayer")
1554 .field("depth", &self.depth)
1555 .field("range", &self.range)
1556 .field("tree", &self.content.tree())
1557 .finish()
1558 }
1559}
1560
1561impl<'a> tree_sitter::TextProvider<'a> for TextProvider<'a> {
1562 type I = ByteChunks<'a>;
1563
1564 fn text(&mut self, node: tree_sitter::Node) -> Self::I {
1565 ByteChunks(self.0.chunks_in_range(node.byte_range()))
1566 }
1567}
1568
1569impl<'a> Iterator for ByteChunks<'a> {
1570 type Item = &'a [u8];
1571
1572 fn next(&mut self) -> Option<Self::Item> {
1573 self.0.next().map(str::as_bytes)
1574 }
1575}
1576
1577impl QueryCursorHandle {
1578 pub(crate) fn new() -> Self {
1579 let mut cursor = QUERY_CURSORS.lock().pop().unwrap_or_else(QueryCursor::new);
1580 cursor.set_match_limit(64);
1581 QueryCursorHandle(Some(cursor))
1582 }
1583}
1584
1585impl Deref for QueryCursorHandle {
1586 type Target = QueryCursor;
1587
1588 fn deref(&self) -> &Self::Target {
1589 self.0.as_ref().unwrap()
1590 }
1591}
1592
1593impl DerefMut for QueryCursorHandle {
1594 fn deref_mut(&mut self) -> &mut Self::Target {
1595 self.0.as_mut().unwrap()
1596 }
1597}
1598
1599impl Drop for QueryCursorHandle {
1600 fn drop(&mut self) {
1601 let mut cursor = self.0.take().unwrap();
1602 cursor.set_byte_range(0..usize::MAX);
1603 cursor.set_point_range(Point::zero().to_ts_point()..Point::MAX.to_ts_point());
1604 QUERY_CURSORS.lock().push(cursor)
1605 }
1606}
1607
1608pub(crate) trait ToTreeSitterPoint {
1609 fn to_ts_point(self) -> tree_sitter::Point;
1610 fn from_ts_point(point: tree_sitter::Point) -> Self;
1611}
1612
1613impl ToTreeSitterPoint for Point {
1614 fn to_ts_point(self) -> tree_sitter::Point {
1615 tree_sitter::Point::new(self.row as usize, self.column as usize)
1616 }
1617
1618 fn from_ts_point(point: tree_sitter::Point) -> Self {
1619 Point::new(point.row as u32, point.column as u32)
1620 }
1621}