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