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