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