1use crate::{Grammar, InjectionConfig, Language, LanguageRegistry};
2use collections::HashMap;
3use lazy_static::lazy_static;
4use parking_lot::Mutex;
5use std::{
6 borrow::Cow,
7 cell::RefCell,
8 cmp::{Ordering, Reverse},
9 collections::BinaryHeap,
10 ops::{Deref, DerefMut, Range},
11 sync::Arc,
12};
13use sum_tree::{Bias, SeekTarget, SumTree};
14use text::{Anchor, BufferSnapshot, OffsetRangeExt, Point, Rope, ToOffset, ToPoint};
15use tree_sitter::{
16 Node, Parser, Query, QueryCapture, QueryCaptures, QueryCursor, QueryMatches, Tree,
17};
18
19thread_local! {
20 static PARSER: RefCell<Parser> = RefCell::new(Parser::new());
21}
22
23lazy_static! {
24 static ref QUERY_CURSORS: Mutex<Vec<QueryCursor>> = Default::default();
25}
26
27#[derive(Default)]
28pub struct SyntaxMap {
29 parsed_version: clock::Global,
30 interpolated_version: clock::Global,
31 snapshot: SyntaxSnapshot,
32 language_registry: Option<Arc<LanguageRegistry>>,
33}
34
35#[derive(Clone, Default)]
36pub struct SyntaxSnapshot {
37 layers: SumTree<SyntaxLayer>,
38}
39
40#[derive(Default)]
41pub struct SyntaxMapCaptures<'a> {
42 layers: Vec<SyntaxMapCapturesLayer<'a>>,
43 active_layer_count: usize,
44 grammars: Vec<&'a Grammar>,
45}
46
47#[derive(Default)]
48pub struct SyntaxMapMatches<'a> {
49 layers: Vec<SyntaxMapMatchesLayer<'a>>,
50 active_layer_count: usize,
51 grammars: Vec<&'a Grammar>,
52}
53
54#[derive(Debug)]
55pub struct SyntaxMapCapture<'a> {
56 pub depth: usize,
57 pub node: Node<'a>,
58 pub index: u32,
59 pub grammar_index: usize,
60}
61
62#[derive(Debug)]
63pub struct SyntaxMapMatch<'a> {
64 pub depth: usize,
65 pub pattern_index: usize,
66 pub captures: &'a [QueryCapture<'a>],
67 pub grammar_index: usize,
68}
69
70struct SyntaxMapCapturesLayer<'a> {
71 depth: usize,
72 captures: QueryCaptures<'a, 'a, TextProvider<'a>>,
73 next_capture: Option<QueryCapture<'a>>,
74 grammar_index: usize,
75 _query_cursor: QueryCursorHandle,
76}
77
78struct SyntaxMapMatchesLayer<'a> {
79 depth: usize,
80 next_pattern_index: usize,
81 next_captures: Vec<QueryCapture<'a>>,
82 has_next: bool,
83 matches: QueryMatches<'a, 'a, TextProvider<'a>>,
84 grammar_index: usize,
85 _query_cursor: QueryCursorHandle,
86}
87
88#[derive(Clone)]
89struct SyntaxLayer {
90 depth: usize,
91 range: Range<Anchor>,
92 tree: tree_sitter::Tree,
93 language: Arc<Language>,
94}
95
96#[derive(Debug)]
97pub struct SyntaxLayerInfo<'a> {
98 pub depth: usize,
99 pub node: Node<'a>,
100 pub language: &'a Arc<Language>,
101}
102
103#[derive(Debug, Clone)]
104struct SyntaxLayerSummary {
105 min_depth: usize,
106 max_depth: usize,
107 range: Range<Anchor>,
108 last_layer_range: Range<Anchor>,
109 last_layer_language: Option<usize>,
110}
111
112#[derive(Clone, Debug)]
113struct SyntaxLayerPosition {
114 depth: usize,
115 range: Range<Anchor>,
116 language: Option<usize>,
117}
118
119#[derive(Clone, Debug)]
120struct ChangeStartPosition {
121 depth: usize,
122 position: Anchor,
123}
124
125#[derive(Clone, Debug)]
126struct SyntaxLayerPositionBeforeChange {
127 position: SyntaxLayerPosition,
128 change: ChangeStartPosition,
129}
130
131struct ParseStep {
132 depth: usize,
133 language: Arc<Language>,
134 range: Range<Anchor>,
135 included_ranges: Vec<tree_sitter::Range>,
136 mode: ParseMode,
137}
138
139enum ParseMode {
140 Single,
141 Combined {
142 parent_layer_range: Range<usize>,
143 parent_layer_changed_ranges: Vec<Range<usize>>,
144 },
145}
146
147#[derive(Debug, PartialEq, Eq)]
148struct ChangedRegion {
149 depth: usize,
150 range: Range<Anchor>,
151}
152
153#[derive(Default)]
154struct ChangeRegionSet(Vec<ChangedRegion>);
155
156struct TextProvider<'a>(&'a Rope);
157
158struct ByteChunks<'a>(text::Chunks<'a>);
159
160struct QueryCursorHandle(Option<QueryCursor>);
161
162impl SyntaxMap {
163 pub fn new() -> Self {
164 Self::default()
165 }
166
167 pub fn set_language_registry(&mut self, registry: Arc<LanguageRegistry>) {
168 self.language_registry = Some(registry);
169 }
170
171 pub fn snapshot(&self) -> SyntaxSnapshot {
172 self.snapshot.clone()
173 }
174
175 pub fn language_registry(&self) -> Option<Arc<LanguageRegistry>> {
176 self.language_registry.clone()
177 }
178
179 pub fn parsed_version(&self) -> clock::Global {
180 self.parsed_version.clone()
181 }
182
183 pub fn interpolate(&mut self, text: &BufferSnapshot) {
184 self.snapshot.interpolate(&self.interpolated_version, text);
185 self.interpolated_version = text.version.clone();
186 }
187
188 #[cfg(test)]
189 pub fn reparse(&mut self, language: Arc<Language>, text: &BufferSnapshot) {
190 self.snapshot.reparse(
191 &self.parsed_version,
192 text,
193 self.language_registry.clone(),
194 language,
195 );
196 self.parsed_version = text.version.clone();
197 self.interpolated_version = text.version.clone();
198 }
199
200 pub fn did_parse(&mut self, snapshot: SyntaxSnapshot, version: clock::Global) {
201 self.interpolated_version = version.clone();
202 self.parsed_version = version;
203 self.snapshot = snapshot;
204 }
205
206 pub fn clear(&mut self) {
207 self.snapshot = SyntaxSnapshot::default();
208 }
209}
210
211impl SyntaxSnapshot {
212 pub fn is_empty(&self) -> bool {
213 self.layers.is_empty()
214 }
215
216 pub fn interpolate(&mut self, from_version: &clock::Global, text: &BufferSnapshot) {
217 let edits = text
218 .anchored_edits_since::<(usize, Point)>(&from_version)
219 .collect::<Vec<_>>();
220 if edits.is_empty() {
221 return;
222 }
223
224 let mut layers = SumTree::new();
225 let mut first_edit_ix_for_depth = 0;
226 let mut prev_depth = 0;
227 let mut cursor = self.layers.cursor::<SyntaxLayerSummary>();
228 cursor.next(text);
229
230 'outer: loop {
231 let depth = cursor.end(text).max_depth;
232 if depth > prev_depth {
233 first_edit_ix_for_depth = 0;
234 prev_depth = depth;
235 }
236
237 // Preserve any layers at this depth that precede the first edit.
238 if let Some((_, edit_range)) = edits.get(first_edit_ix_for_depth) {
239 let target = ChangeStartPosition {
240 depth,
241 position: edit_range.start,
242 };
243 if target.cmp(&cursor.start(), text).is_gt() {
244 let slice = cursor.slice(&target, Bias::Left, text);
245 layers.push_tree(slice, text);
246 }
247 }
248 // If this layer follows all of the edits, then preserve it and any
249 // subsequent layers at this same depth.
250 else if cursor.item().is_some() {
251 let slice = cursor.slice(
252 &SyntaxLayerPosition {
253 depth: depth + 1,
254 range: Anchor::MIN..Anchor::MAX,
255 language: None,
256 },
257 Bias::Left,
258 text,
259 );
260 layers.push_tree(slice, text);
261 continue;
262 };
263
264 let Some(layer) = cursor.item() else { break };
265 let (start_byte, start_point) = layer.range.start.summary::<(usize, Point)>(text);
266
267 // Ignore edits that end before the start of this layer, and don't consider them
268 // for any subsequent layers at this same depth.
269 loop {
270 let Some((_, edit_range)) = edits.get(first_edit_ix_for_depth) else { continue 'outer };
271 if edit_range.end.cmp(&layer.range.start, text).is_le() {
272 first_edit_ix_for_depth += 1;
273 } else {
274 break;
275 }
276 }
277
278 let mut layer = layer.clone();
279 for (edit, edit_range) in &edits[first_edit_ix_for_depth..] {
280 // Ignore any edits that follow this layer.
281 if edit_range.start.cmp(&layer.range.end, text).is_ge() {
282 break;
283 }
284
285 // Apply any edits that intersect this layer to the layer's syntax tree.
286 let tree_edit = if edit_range.start.cmp(&layer.range.start, text).is_ge() {
287 tree_sitter::InputEdit {
288 start_byte: edit.new.start.0 - start_byte,
289 old_end_byte: edit.new.start.0 - start_byte
290 + (edit.old.end.0 - edit.old.start.0),
291 new_end_byte: edit.new.end.0 - start_byte,
292 start_position: (edit.new.start.1 - start_point).to_ts_point(),
293 old_end_position: (edit.new.start.1 - start_point
294 + (edit.old.end.1 - edit.old.start.1))
295 .to_ts_point(),
296 new_end_position: (edit.new.end.1 - start_point).to_ts_point(),
297 }
298 } else {
299 let node = layer.tree.root_node();
300 tree_sitter::InputEdit {
301 start_byte: 0,
302 old_end_byte: node.end_byte(),
303 new_end_byte: 0,
304 start_position: Default::default(),
305 old_end_position: node.end_position(),
306 new_end_position: Default::default(),
307 }
308 };
309
310 layer.tree.edit(&tree_edit);
311 }
312
313 debug_assert!(
314 layer.tree.root_node().end_byte() <= text.len(),
315 "tree's size {}, is larger than text size {}",
316 layer.tree.root_node().end_byte(),
317 text.len(),
318 );
319
320 layers.push(layer, text);
321 cursor.next(text);
322 }
323
324 layers.push_tree(cursor.suffix(&text), &text);
325 drop(cursor);
326 self.layers = layers;
327 }
328
329 pub fn reparse(
330 &mut self,
331 from_version: &clock::Global,
332 text: &BufferSnapshot,
333 registry: Option<Arc<LanguageRegistry>>,
334 root_language: Arc<Language>,
335 ) {
336 let edits = text.edits_since::<usize>(from_version).collect::<Vec<_>>();
337 let max_depth = self.layers.summary().max_depth;
338 let mut cursor = self.layers.cursor::<SyntaxLayerSummary>();
339 cursor.next(&text);
340 let mut layers = SumTree::new();
341
342 let mut changed_regions = ChangeRegionSet::default();
343 let mut queue = BinaryHeap::new();
344 let mut combined_injection_ranges = HashMap::default();
345 queue.push(ParseStep {
346 depth: 0,
347 language: root_language.clone(),
348 included_ranges: vec![tree_sitter::Range {
349 start_byte: 0,
350 end_byte: text.len(),
351 start_point: Point::zero().to_ts_point(),
352 end_point: text.max_point().to_ts_point(),
353 }],
354 range: Anchor::MIN..Anchor::MAX,
355 mode: ParseMode::Single,
356 });
357
358 loop {
359 let step = queue.pop();
360 let position = if let Some(step) = &step {
361 SyntaxLayerPosition {
362 depth: step.depth,
363 range: step.range.clone(),
364 language: step.language.id(),
365 }
366 } else {
367 SyntaxLayerPosition {
368 depth: max_depth + 1,
369 range: Anchor::MAX..Anchor::MAX,
370 language: None,
371 }
372 };
373
374 let mut done = cursor.item().is_none();
375 while !done && position.cmp(&cursor.end(text), &text).is_gt() {
376 done = true;
377
378 let bounded_position = SyntaxLayerPositionBeforeChange {
379 position: position.clone(),
380 change: changed_regions.start_position(),
381 };
382 if bounded_position.cmp(&cursor.start(), &text).is_gt() {
383 let slice = cursor.slice(&bounded_position, Bias::Left, text);
384 if !slice.is_empty() {
385 layers.push_tree(slice, &text);
386 if changed_regions.prune(cursor.end(text), text) {
387 done = false;
388 }
389 }
390 }
391
392 while position.cmp(&cursor.end(text), text).is_gt() {
393 let Some(layer) = cursor.item() else { break };
394
395 if changed_regions.intersects(&layer, text) {
396 changed_regions.insert(
397 ChangedRegion {
398 depth: layer.depth + 1,
399 range: layer.range.clone(),
400 },
401 text,
402 );
403 } else {
404 layers.push(layer.clone(), text);
405 }
406
407 cursor.next(text);
408 if changed_regions.prune(cursor.end(text), text) {
409 done = false;
410 }
411 }
412 }
413
414 let Some(step) = step else { break };
415 let (step_start_byte, step_start_point) =
416 step.range.start.summary::<(usize, Point)>(text);
417 let step_end_byte = step.range.end.to_offset(text);
418 let Some(grammar) = step.language.grammar.as_deref() else { continue };
419
420 let mut old_layer = cursor.item();
421 if let Some(layer) = old_layer {
422 if layer.range.to_offset(text) == (step_start_byte..step_end_byte)
423 && layer.language.id() == step.language.id()
424 {
425 cursor.next(&text);
426 } else {
427 old_layer = None;
428 }
429 }
430
431 let tree;
432 let changed_ranges;
433 let mut included_ranges = step.included_ranges;
434 if let Some(old_layer) = old_layer {
435 if let ParseMode::Combined {
436 parent_layer_changed_ranges,
437 ..
438 } = step.mode
439 {
440 included_ranges = splice_included_ranges(
441 old_layer.tree.included_ranges(),
442 &parent_layer_changed_ranges,
443 &included_ranges,
444 );
445 }
446
447 tree = parse_text(
448 grammar,
449 text.as_rope(),
450 step_start_byte,
451 step_start_point,
452 included_ranges,
453 Some(old_layer.tree.clone()),
454 );
455 changed_ranges = join_ranges(
456 edits.iter().map(|e| e.new.clone()).filter(|range| {
457 range.start <= step_end_byte && range.end >= step_start_byte
458 }),
459 old_layer
460 .tree
461 .changed_ranges(&tree)
462 .map(|r| step_start_byte + r.start_byte..step_start_byte + r.end_byte),
463 );
464 } else {
465 tree = parse_text(
466 grammar,
467 text.as_rope(),
468 step_start_byte,
469 step_start_point,
470 included_ranges,
471 None,
472 );
473 changed_ranges = vec![step_start_byte..step_end_byte];
474 }
475
476 layers.push(
477 SyntaxLayer {
478 depth: step.depth,
479 range: step.range,
480 tree: tree.clone(),
481 language: step.language.clone(),
482 },
483 &text,
484 );
485
486 if let (Some((config, registry)), false) = (
487 grammar.injection_config.as_ref().zip(registry.as_ref()),
488 changed_ranges.is_empty(),
489 ) {
490 for range in &changed_ranges {
491 changed_regions.insert(
492 ChangedRegion {
493 depth: step.depth + 1,
494 range: text.anchor_before(range.start)..text.anchor_after(range.end),
495 },
496 text,
497 );
498 }
499 get_injections(
500 config,
501 text,
502 tree.root_node_with_offset(step_start_byte, step_start_point.to_ts_point()),
503 registry,
504 step.depth + 1,
505 &changed_ranges,
506 &mut combined_injection_ranges,
507 &mut queue,
508 );
509 }
510 }
511
512 drop(cursor);
513 self.layers = layers;
514 }
515
516 pub fn single_tree_captures<'a>(
517 range: Range<usize>,
518 text: &'a Rope,
519 tree: &'a Tree,
520 language: &'a Arc<Language>,
521 query: fn(&Grammar) -> Option<&Query>,
522 ) -> SyntaxMapCaptures<'a> {
523 SyntaxMapCaptures::new(
524 range.clone(),
525 text,
526 [SyntaxLayerInfo {
527 language,
528 depth: 0,
529 node: tree.root_node(),
530 }]
531 .into_iter(),
532 query,
533 )
534 }
535
536 pub fn captures<'a>(
537 &'a self,
538 range: Range<usize>,
539 buffer: &'a BufferSnapshot,
540 query: fn(&Grammar) -> Option<&Query>,
541 ) -> SyntaxMapCaptures {
542 SyntaxMapCaptures::new(
543 range.clone(),
544 buffer.as_rope(),
545 self.layers_for_range(range, buffer).into_iter(),
546 query,
547 )
548 }
549
550 pub fn matches<'a>(
551 &'a self,
552 range: Range<usize>,
553 buffer: &'a BufferSnapshot,
554 query: fn(&Grammar) -> Option<&Query>,
555 ) -> SyntaxMapMatches {
556 SyntaxMapMatches::new(
557 range.clone(),
558 buffer.as_rope(),
559 self.layers_for_range(range, buffer).into_iter(),
560 query,
561 )
562 }
563
564 #[cfg(test)]
565 pub fn layers<'a>(&'a self, buffer: &'a BufferSnapshot) -> Vec<SyntaxLayerInfo> {
566 self.layers_for_range(0..buffer.len(), buffer).collect()
567 }
568
569 pub fn layers_for_range<'a, T: ToOffset>(
570 &'a self,
571 range: Range<T>,
572 buffer: &'a BufferSnapshot,
573 ) -> impl 'a + Iterator<Item = SyntaxLayerInfo> {
574 let start = buffer.anchor_before(range.start.to_offset(buffer));
575 let end = buffer.anchor_after(range.end.to_offset(buffer));
576
577 let mut cursor = self.layers.filter::<_, ()>(move |summary| {
578 if summary.max_depth > summary.min_depth {
579 true
580 } else {
581 let is_before_start = summary.range.end.cmp(&start, buffer).is_lt();
582 let is_after_end = summary.range.start.cmp(&end, buffer).is_gt();
583 !is_before_start && !is_after_end
584 }
585 });
586
587 cursor.next(buffer);
588 std::iter::from_fn(move || {
589 if let Some(layer) = cursor.item() {
590 let info = SyntaxLayerInfo {
591 language: &layer.language,
592 depth: layer.depth,
593 node: layer.tree.root_node_with_offset(
594 layer.range.start.to_offset(buffer),
595 layer.range.start.to_point(buffer).to_ts_point(),
596 ),
597 };
598 cursor.next(buffer);
599 Some(info)
600 } else {
601 None
602 }
603 })
604 }
605}
606
607impl<'a> SyntaxMapCaptures<'a> {
608 fn new(
609 range: Range<usize>,
610 text: &'a Rope,
611 layers: impl Iterator<Item = SyntaxLayerInfo<'a>>,
612 query: fn(&Grammar) -> Option<&Query>,
613 ) -> Self {
614 let mut result = Self {
615 layers: Vec::new(),
616 grammars: Vec::new(),
617 active_layer_count: 0,
618 };
619 for SyntaxLayerInfo {
620 language,
621 depth,
622 node,
623 } in layers
624 {
625 let grammar = match &language.grammar {
626 Some(grammer) => grammer,
627 None => continue,
628 };
629 let query = match query(&grammar) {
630 Some(query) => query,
631 None => continue,
632 };
633
634 let mut query_cursor = QueryCursorHandle::new();
635
636 // TODO - add a Tree-sitter API to remove the need for this.
637 let cursor = unsafe {
638 std::mem::transmute::<_, &'static mut QueryCursor>(query_cursor.deref_mut())
639 };
640
641 cursor.set_byte_range(range.clone());
642 let captures = cursor.captures(query, node, TextProvider(text));
643 let grammar_index = result
644 .grammars
645 .iter()
646 .position(|g| g.id == grammar.id())
647 .unwrap_or_else(|| {
648 result.grammars.push(grammar);
649 result.grammars.len() - 1
650 });
651 let mut layer = SyntaxMapCapturesLayer {
652 depth,
653 grammar_index,
654 next_capture: None,
655 captures,
656 _query_cursor: query_cursor,
657 };
658
659 layer.advance();
660 if layer.next_capture.is_some() {
661 let key = layer.sort_key();
662 let ix = match result.layers[..result.active_layer_count]
663 .binary_search_by_key(&key, |layer| layer.sort_key())
664 {
665 Ok(ix) | Err(ix) => ix,
666 };
667 result.layers.insert(ix, layer);
668 result.active_layer_count += 1;
669 } else {
670 result.layers.push(layer);
671 }
672 }
673
674 result
675 }
676
677 pub fn grammars(&self) -> &[&'a Grammar] {
678 &self.grammars
679 }
680
681 pub fn peek(&self) -> Option<SyntaxMapCapture<'a>> {
682 let layer = self.layers[..self.active_layer_count].first()?;
683 let capture = layer.next_capture?;
684 Some(SyntaxMapCapture {
685 depth: layer.depth,
686 grammar_index: layer.grammar_index,
687 index: capture.index,
688 node: capture.node,
689 })
690 }
691
692 pub fn advance(&mut self) -> bool {
693 let layer = if let Some(layer) = self.layers[..self.active_layer_count].first_mut() {
694 layer
695 } else {
696 return false;
697 };
698
699 layer.advance();
700 if layer.next_capture.is_some() {
701 let key = layer.sort_key();
702 let i = 1 + self.layers[1..self.active_layer_count]
703 .iter()
704 .position(|later_layer| key < later_layer.sort_key())
705 .unwrap_or(self.active_layer_count - 1);
706 self.layers[0..i].rotate_left(1);
707 } else {
708 self.layers[0..self.active_layer_count].rotate_left(1);
709 self.active_layer_count -= 1;
710 }
711
712 true
713 }
714
715 pub fn set_byte_range(&mut self, range: Range<usize>) {
716 for layer in &mut self.layers {
717 layer.captures.set_byte_range(range.clone());
718 if let Some(capture) = &layer.next_capture {
719 if capture.node.end_byte() > range.start {
720 continue;
721 }
722 }
723 layer.advance();
724 }
725 self.layers.sort_unstable_by_key(|layer| layer.sort_key());
726 self.active_layer_count = self
727 .layers
728 .iter()
729 .position(|layer| layer.next_capture.is_none())
730 .unwrap_or(self.layers.len());
731 }
732}
733
734impl<'a> SyntaxMapMatches<'a> {
735 fn new(
736 range: Range<usize>,
737 text: &'a Rope,
738 layers: impl Iterator<Item = SyntaxLayerInfo<'a>>,
739 query: fn(&Grammar) -> Option<&Query>,
740 ) -> Self {
741 let mut result = Self::default();
742 for SyntaxLayerInfo {
743 language,
744 depth,
745 node,
746 } in layers
747 {
748 let grammar = match &language.grammar {
749 Some(grammer) => grammer,
750 None => continue,
751 };
752 let query = match query(&grammar) {
753 Some(query) => query,
754 None => continue,
755 };
756
757 let mut query_cursor = QueryCursorHandle::new();
758
759 // TODO - add a Tree-sitter API to remove the need for this.
760 let cursor = unsafe {
761 std::mem::transmute::<_, &'static mut QueryCursor>(query_cursor.deref_mut())
762 };
763
764 cursor.set_byte_range(range.clone());
765 let matches = cursor.matches(query, node, TextProvider(text));
766 let grammar_index = result
767 .grammars
768 .iter()
769 .position(|g| g.id == grammar.id())
770 .unwrap_or_else(|| {
771 result.grammars.push(grammar);
772 result.grammars.len() - 1
773 });
774 let mut layer = SyntaxMapMatchesLayer {
775 depth,
776 grammar_index,
777 matches,
778 next_pattern_index: 0,
779 next_captures: Vec::new(),
780 has_next: false,
781 _query_cursor: query_cursor,
782 };
783
784 layer.advance();
785 if layer.has_next {
786 let key = layer.sort_key();
787 let ix = match result.layers[..result.active_layer_count]
788 .binary_search_by_key(&key, |layer| layer.sort_key())
789 {
790 Ok(ix) | Err(ix) => ix,
791 };
792 result.layers.insert(ix, layer);
793 result.active_layer_count += 1;
794 } else {
795 result.layers.push(layer);
796 }
797 }
798 result
799 }
800
801 pub fn grammars(&self) -> &[&'a Grammar] {
802 &self.grammars
803 }
804
805 pub fn peek(&self) -> Option<SyntaxMapMatch> {
806 let layer = self.layers.first()?;
807 if !layer.has_next {
808 return None;
809 }
810 Some(SyntaxMapMatch {
811 depth: layer.depth,
812 grammar_index: layer.grammar_index,
813 pattern_index: layer.next_pattern_index,
814 captures: &layer.next_captures,
815 })
816 }
817
818 pub fn advance(&mut self) -> bool {
819 let layer = if let Some(layer) = self.layers.first_mut() {
820 layer
821 } else {
822 return false;
823 };
824
825 layer.advance();
826 if layer.has_next {
827 let key = layer.sort_key();
828 let i = 1 + self.layers[1..self.active_layer_count]
829 .iter()
830 .position(|later_layer| key < later_layer.sort_key())
831 .unwrap_or(self.active_layer_count - 1);
832 self.layers[0..i].rotate_left(1);
833 } else {
834 self.layers[0..self.active_layer_count].rotate_left(1);
835 self.active_layer_count -= 1;
836 }
837
838 true
839 }
840}
841
842impl<'a> SyntaxMapCapturesLayer<'a> {
843 fn advance(&mut self) {
844 self.next_capture = self.captures.next().map(|(mat, ix)| mat.captures[ix]);
845 }
846
847 fn sort_key(&self) -> (usize, Reverse<usize>, usize) {
848 if let Some(capture) = &self.next_capture {
849 let range = capture.node.byte_range();
850 (range.start, Reverse(range.end), self.depth)
851 } else {
852 (usize::MAX, Reverse(0), usize::MAX)
853 }
854 }
855}
856
857impl<'a> SyntaxMapMatchesLayer<'a> {
858 fn advance(&mut self) {
859 if let Some(mat) = self.matches.next() {
860 self.next_captures.clear();
861 self.next_captures.extend_from_slice(&mat.captures);
862 self.next_pattern_index = mat.pattern_index;
863 self.has_next = true;
864 } else {
865 self.has_next = false;
866 }
867 }
868
869 fn sort_key(&self) -> (usize, Reverse<usize>, usize) {
870 if self.has_next {
871 let captures = &self.next_captures;
872 if let Some((first, last)) = captures.first().zip(captures.last()) {
873 return (
874 first.node.start_byte(),
875 Reverse(last.node.end_byte()),
876 self.depth,
877 );
878 }
879 }
880 (usize::MAX, Reverse(0), usize::MAX)
881 }
882}
883
884impl<'a> Iterator for SyntaxMapCaptures<'a> {
885 type Item = SyntaxMapCapture<'a>;
886
887 fn next(&mut self) -> Option<Self::Item> {
888 let result = self.peek();
889 self.advance();
890 result
891 }
892}
893
894fn join_ranges(
895 a: impl Iterator<Item = Range<usize>>,
896 b: impl Iterator<Item = Range<usize>>,
897) -> Vec<Range<usize>> {
898 let mut result = Vec::<Range<usize>>::new();
899 let mut a = a.peekable();
900 let mut b = b.peekable();
901 loop {
902 let range = match (a.peek(), b.peek()) {
903 (Some(range_a), Some(range_b)) => {
904 if range_a.start < range_b.start {
905 a.next().unwrap()
906 } else {
907 b.next().unwrap()
908 }
909 }
910 (None, Some(_)) => b.next().unwrap(),
911 (Some(_), None) => a.next().unwrap(),
912 (None, None) => break,
913 };
914
915 if let Some(last) = result.last_mut() {
916 if range.start <= last.end {
917 last.end = last.end.max(range.end);
918 continue;
919 }
920 }
921 result.push(range);
922 }
923 result
924}
925
926fn parse_text(
927 grammar: &Grammar,
928 text: &Rope,
929 start_byte: usize,
930 start_point: Point,
931 mut ranges: Vec<tree_sitter::Range>,
932 old_tree: Option<Tree>,
933) -> Tree {
934 for range in &mut ranges {
935 range.start_byte -= start_byte;
936 range.end_byte -= start_byte;
937 range.start_point = (Point::from_ts_point(range.start_point) - start_point).to_ts_point();
938 range.end_point = (Point::from_ts_point(range.end_point) - start_point).to_ts_point();
939 }
940
941 PARSER.with(|parser| {
942 let mut parser = parser.borrow_mut();
943 let mut chunks = text.chunks_in_range(start_byte..text.len());
944 parser
945 .set_included_ranges(&ranges)
946 .expect("overlapping ranges");
947 parser
948 .set_language(grammar.ts_language)
949 .expect("incompatible grammar");
950 parser
951 .parse_with(
952 &mut move |offset, _| {
953 chunks.seek(start_byte + offset);
954 chunks.next().unwrap_or("").as_bytes()
955 },
956 old_tree.as_ref(),
957 )
958 .expect("invalid language")
959 })
960}
961
962fn get_injections(
963 config: &InjectionConfig,
964 text: &BufferSnapshot,
965 node: Node,
966 language_registry: &LanguageRegistry,
967 depth: usize,
968 changed_ranges: &[Range<usize>],
969 combined_injection_ranges: &mut HashMap<Arc<Language>, Vec<tree_sitter::Range>>,
970 queue: &mut BinaryHeap<ParseStep>,
971) -> bool {
972 let mut result = false;
973 let mut query_cursor = QueryCursorHandle::new();
974 let mut prev_match = None;
975
976 combined_injection_ranges.clear();
977 for pattern in &config.patterns {
978 if let (Some(language_name), true) = (pattern.language.as_ref(), pattern.combined) {
979 if let Some(language) = language_registry.language_for_name(language_name) {
980 combined_injection_ranges.insert(language, Vec::new());
981 }
982 }
983 }
984
985 for query_range in changed_ranges {
986 query_cursor.set_byte_range(query_range.start.saturating_sub(1)..query_range.end + 1);
987 for mat in query_cursor.matches(&config.query, node, TextProvider(text.as_rope())) {
988 let content_ranges = mat
989 .nodes_for_capture_index(config.content_capture_ix)
990 .map(|node| node.range())
991 .collect::<Vec<_>>();
992 if content_ranges.is_empty() {
993 continue;
994 }
995
996 // Avoid duplicate matches if two changed ranges intersect the same injection.
997 let content_range =
998 content_ranges.first().unwrap().start_byte..content_ranges.last().unwrap().end_byte;
999 if let Some((last_pattern_ix, last_range)) = &prev_match {
1000 if mat.pattern_index == *last_pattern_ix && content_range == *last_range {
1001 continue;
1002 }
1003 }
1004 prev_match = Some((mat.pattern_index, content_range.clone()));
1005
1006 let combined = config.patterns[mat.pattern_index].combined;
1007 let language_name = config.patterns[mat.pattern_index]
1008 .language
1009 .as_ref()
1010 .map(|s| Cow::Borrowed(s.as_ref()))
1011 .or_else(|| {
1012 let ix = config.language_capture_ix?;
1013 let node = mat.nodes_for_capture_index(ix).next()?;
1014 Some(Cow::Owned(text.text_for_range(node.byte_range()).collect()))
1015 });
1016
1017 if let Some(language_name) = language_name {
1018 let language = language_registry
1019 .language_for_name(&language_name)
1020 .or_else(|| language_registry.language_for_extension(&language_name));
1021 if let Some(language) = language {
1022 result = true;
1023 let range = text.anchor_before(content_range.start)
1024 ..text.anchor_after(content_range.end);
1025 if combined {
1026 combined_injection_ranges
1027 .get_mut(&language.clone())
1028 .unwrap()
1029 .extend(content_ranges);
1030 } else {
1031 queue.push(ParseStep {
1032 depth,
1033 language,
1034 included_ranges: content_ranges,
1035 range,
1036 mode: ParseMode::Single,
1037 });
1038 }
1039 }
1040 }
1041 }
1042 }
1043
1044 for (language, mut included_ranges) in combined_injection_ranges.drain() {
1045 included_ranges.sort_unstable();
1046 let range = text.anchor_before(node.start_byte())..text.anchor_after(node.end_byte());
1047 queue.push(ParseStep {
1048 depth,
1049 language,
1050 range,
1051 included_ranges,
1052 mode: ParseMode::Combined {
1053 parent_layer_range: node.start_byte()..node.end_byte(),
1054 parent_layer_changed_ranges: changed_ranges.to_vec(),
1055 },
1056 })
1057 }
1058
1059 result
1060}
1061
1062fn splice_included_ranges(
1063 mut ranges: Vec<tree_sitter::Range>,
1064 changed_ranges: &[Range<usize>],
1065 new_ranges: &[tree_sitter::Range],
1066) -> Vec<tree_sitter::Range> {
1067 let mut changed_ranges = changed_ranges.into_iter().peekable();
1068 let mut new_ranges = new_ranges.into_iter().peekable();
1069 let mut ranges_ix = 0;
1070 loop {
1071 let new_range = new_ranges.peek();
1072 let mut changed_range = changed_ranges.peek();
1073
1074 // Remove ranges that have changed before inserting any new ranges
1075 // into those ranges.
1076 if let Some((changed, new)) = changed_range.zip(new_range) {
1077 if new.end_byte < changed.start {
1078 changed_range = None;
1079 }
1080 }
1081
1082 if let Some(changed) = changed_range {
1083 let mut start_ix = ranges_ix
1084 + match ranges[ranges_ix..].binary_search_by_key(&changed.start, |r| r.end_byte) {
1085 Ok(ix) | Err(ix) => ix,
1086 };
1087 let mut end_ix = ranges_ix
1088 + match ranges[ranges_ix..].binary_search_by_key(&changed.end, |r| r.start_byte) {
1089 Ok(ix) => ix + 1,
1090 Err(ix) => ix,
1091 };
1092
1093 // If there are empty ranges, then there may be multiple ranges with the same
1094 // start or end. Expand the splice to include any adjacent ranges that touch
1095 // the changed range.
1096 while start_ix > 0 {
1097 if ranges[start_ix - 1].end_byte == changed.start {
1098 start_ix -= 1;
1099 } else {
1100 break;
1101 }
1102 }
1103 while let Some(range) = ranges.get(end_ix) {
1104 if range.start_byte == changed.end {
1105 end_ix += 1;
1106 } else {
1107 break;
1108 }
1109 }
1110
1111 if end_ix > start_ix {
1112 ranges.splice(start_ix..end_ix, []);
1113 }
1114 changed_ranges.next();
1115 ranges_ix = start_ix;
1116 } else if let Some(new_range) = new_range {
1117 let ix = ranges_ix
1118 + match ranges[ranges_ix..]
1119 .binary_search_by_key(&new_range.start_byte, |r| r.start_byte)
1120 {
1121 Ok(ix) | Err(ix) => ix,
1122 };
1123 ranges.insert(ix, **new_range);
1124 new_ranges.next();
1125 ranges_ix = ix + 1;
1126 } else {
1127 break;
1128 }
1129 }
1130 ranges
1131}
1132
1133impl<'a> SyntaxLayerInfo<'a> {
1134 pub(crate) fn override_id(&self, offset: usize, text: &text::BufferSnapshot) -> Option<u32> {
1135 let text = TextProvider(text.as_rope());
1136 let config = self.language.grammar.as_ref()?.override_config.as_ref()?;
1137
1138 let mut query_cursor = QueryCursorHandle::new();
1139 query_cursor.set_byte_range(offset..offset);
1140
1141 let mut smallest_match: Option<(u32, Range<usize>)> = None;
1142 for mat in query_cursor.matches(&config.query, self.node, text) {
1143 for capture in mat.captures {
1144 if !config.values.contains_key(&capture.index) {
1145 continue;
1146 }
1147
1148 let range = capture.node.byte_range();
1149 if offset <= range.start || offset >= range.end {
1150 continue;
1151 }
1152
1153 if let Some((_, smallest_range)) = &smallest_match {
1154 if range.len() < smallest_range.len() {
1155 smallest_match = Some((capture.index, range))
1156 }
1157 continue;
1158 }
1159
1160 smallest_match = Some((capture.index, range));
1161 }
1162 }
1163
1164 smallest_match.map(|(index, _)| index)
1165 }
1166}
1167
1168impl std::ops::Deref for SyntaxMap {
1169 type Target = SyntaxSnapshot;
1170
1171 fn deref(&self) -> &Self::Target {
1172 &self.snapshot
1173 }
1174}
1175
1176impl PartialEq for ParseStep {
1177 fn eq(&self, _: &Self) -> bool {
1178 false
1179 }
1180}
1181
1182impl Eq for ParseStep {}
1183
1184impl PartialOrd for ParseStep {
1185 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
1186 Some(self.cmp(&other))
1187 }
1188}
1189
1190impl Ord for ParseStep {
1191 fn cmp(&self, other: &Self) -> Ordering {
1192 let range_a = self.range();
1193 let range_b = other.range();
1194 Ord::cmp(&other.depth, &self.depth)
1195 .then_with(|| Ord::cmp(&range_b.start, &range_a.start))
1196 .then_with(|| Ord::cmp(&range_a.end, &range_b.end))
1197 .then_with(|| self.language.id().cmp(&other.language.id()))
1198 }
1199}
1200
1201impl ParseStep {
1202 fn range(&self) -> Range<usize> {
1203 if let ParseMode::Combined {
1204 parent_layer_range, ..
1205 } = &self.mode
1206 {
1207 parent_layer_range.clone()
1208 } else {
1209 let start = self.included_ranges.first().map_or(0, |r| r.start_byte);
1210 let end = self.included_ranges.last().map_or(0, |r| r.end_byte);
1211 start..end
1212 }
1213 }
1214}
1215
1216impl ChangedRegion {
1217 fn cmp(&self, other: &Self, buffer: &BufferSnapshot) -> Ordering {
1218 let range_a = &self.range;
1219 let range_b = &other.range;
1220 Ord::cmp(&self.depth, &other.depth)
1221 .then_with(|| range_a.start.cmp(&range_b.start, buffer))
1222 .then_with(|| range_b.end.cmp(&range_a.end, buffer))
1223 }
1224}
1225
1226impl ChangeRegionSet {
1227 fn start_position(&self) -> ChangeStartPosition {
1228 self.0.first().map_or(
1229 ChangeStartPosition {
1230 depth: usize::MAX,
1231 position: Anchor::MAX,
1232 },
1233 |region| ChangeStartPosition {
1234 depth: region.depth,
1235 position: region.range.start,
1236 },
1237 )
1238 }
1239
1240 fn intersects(&self, layer: &SyntaxLayer, text: &BufferSnapshot) -> bool {
1241 for region in &self.0 {
1242 if region.depth < layer.depth {
1243 continue;
1244 }
1245 if region.depth > layer.depth {
1246 break;
1247 }
1248 if region.range.end.cmp(&layer.range.start, text).is_le() {
1249 continue;
1250 }
1251 if region.range.start.cmp(&layer.range.end, text).is_ge() {
1252 break;
1253 }
1254 return true;
1255 }
1256 false
1257 }
1258
1259 fn insert(&mut self, region: ChangedRegion, text: &BufferSnapshot) {
1260 if let Err(ix) = self.0.binary_search_by(|probe| probe.cmp(®ion, text)) {
1261 self.0.insert(ix, region);
1262 }
1263 }
1264
1265 fn prune(&mut self, summary: SyntaxLayerSummary, text: &BufferSnapshot) -> bool {
1266 let prev_len = self.0.len();
1267 self.0.retain(|region| {
1268 region.depth > summary.max_depth
1269 || (region.depth == summary.max_depth
1270 && region
1271 .range
1272 .end
1273 .cmp(&summary.last_layer_range.start, text)
1274 .is_gt())
1275 });
1276 self.0.len() < prev_len
1277 }
1278}
1279
1280impl Default for SyntaxLayerSummary {
1281 fn default() -> Self {
1282 Self {
1283 max_depth: 0,
1284 min_depth: 0,
1285 range: Anchor::MAX..Anchor::MIN,
1286 last_layer_range: Anchor::MIN..Anchor::MAX,
1287 last_layer_language: None,
1288 }
1289 }
1290}
1291
1292impl sum_tree::Summary for SyntaxLayerSummary {
1293 type Context = BufferSnapshot;
1294
1295 fn add_summary(&mut self, other: &Self, buffer: &Self::Context) {
1296 if other.max_depth > self.max_depth {
1297 self.max_depth = other.max_depth;
1298 self.range = other.range.clone();
1299 } else {
1300 if other.range.start.cmp(&self.range.start, buffer).is_lt() {
1301 self.range.start = other.range.start;
1302 }
1303 if other.range.end.cmp(&self.range.end, buffer).is_gt() {
1304 self.range.end = other.range.end;
1305 }
1306 }
1307 self.last_layer_range = other.last_layer_range.clone();
1308 self.last_layer_language = other.last_layer_language;
1309 }
1310}
1311
1312impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary> for SyntaxLayerPosition {
1313 fn cmp(&self, cursor_location: &SyntaxLayerSummary, buffer: &BufferSnapshot) -> Ordering {
1314 Ord::cmp(&self.depth, &cursor_location.max_depth)
1315 .then_with(|| {
1316 self.range
1317 .start
1318 .cmp(&cursor_location.last_layer_range.start, buffer)
1319 })
1320 .then_with(|| {
1321 cursor_location
1322 .last_layer_range
1323 .end
1324 .cmp(&self.range.end, buffer)
1325 })
1326 .then_with(|| self.language.cmp(&cursor_location.last_layer_language))
1327 }
1328}
1329
1330impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary> for ChangeStartPosition {
1331 fn cmp(&self, cursor_location: &SyntaxLayerSummary, text: &BufferSnapshot) -> Ordering {
1332 Ord::cmp(&self.depth, &cursor_location.max_depth)
1333 .then_with(|| self.position.cmp(&cursor_location.range.end, text))
1334 }
1335}
1336
1337impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary>
1338 for SyntaxLayerPositionBeforeChange
1339{
1340 fn cmp(&self, cursor_location: &SyntaxLayerSummary, buffer: &BufferSnapshot) -> Ordering {
1341 if self.change.cmp(cursor_location, buffer).is_le() {
1342 return Ordering::Less;
1343 } else {
1344 self.position.cmp(cursor_location, buffer)
1345 }
1346 }
1347}
1348
1349impl sum_tree::Item for SyntaxLayer {
1350 type Summary = SyntaxLayerSummary;
1351
1352 fn summary(&self) -> Self::Summary {
1353 SyntaxLayerSummary {
1354 min_depth: self.depth,
1355 max_depth: self.depth,
1356 range: self.range.clone(),
1357 last_layer_range: self.range.clone(),
1358 last_layer_language: self.language.id(),
1359 }
1360 }
1361}
1362
1363impl std::fmt::Debug for SyntaxLayer {
1364 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1365 f.debug_struct("SyntaxLayer")
1366 .field("depth", &self.depth)
1367 .field("range", &self.range)
1368 .field("tree", &self.tree)
1369 .finish()
1370 }
1371}
1372
1373impl<'a> tree_sitter::TextProvider<'a> for TextProvider<'a> {
1374 type I = ByteChunks<'a>;
1375
1376 fn text(&mut self, node: tree_sitter::Node) -> Self::I {
1377 ByteChunks(self.0.chunks_in_range(node.byte_range()))
1378 }
1379}
1380
1381impl<'a> Iterator for ByteChunks<'a> {
1382 type Item = &'a [u8];
1383
1384 fn next(&mut self) -> Option<Self::Item> {
1385 self.0.next().map(str::as_bytes)
1386 }
1387}
1388
1389impl QueryCursorHandle {
1390 pub(crate) fn new() -> Self {
1391 let mut cursor = QUERY_CURSORS.lock().pop().unwrap_or_else(QueryCursor::new);
1392 cursor.set_match_limit(64);
1393 QueryCursorHandle(Some(cursor))
1394 }
1395}
1396
1397impl Deref for QueryCursorHandle {
1398 type Target = QueryCursor;
1399
1400 fn deref(&self) -> &Self::Target {
1401 self.0.as_ref().unwrap()
1402 }
1403}
1404
1405impl DerefMut for QueryCursorHandle {
1406 fn deref_mut(&mut self) -> &mut Self::Target {
1407 self.0.as_mut().unwrap()
1408 }
1409}
1410
1411impl Drop for QueryCursorHandle {
1412 fn drop(&mut self) {
1413 let mut cursor = self.0.take().unwrap();
1414 cursor.set_byte_range(0..usize::MAX);
1415 cursor.set_point_range(Point::zero().to_ts_point()..Point::MAX.to_ts_point());
1416 QUERY_CURSORS.lock().push(cursor)
1417 }
1418}
1419
1420pub(crate) trait ToTreeSitterPoint {
1421 fn to_ts_point(self) -> tree_sitter::Point;
1422 fn from_ts_point(point: tree_sitter::Point) -> Self;
1423}
1424
1425impl ToTreeSitterPoint for Point {
1426 fn to_ts_point(self) -> tree_sitter::Point {
1427 tree_sitter::Point::new(self.row as usize, self.column as usize)
1428 }
1429
1430 fn from_ts_point(point: tree_sitter::Point) -> Self {
1431 Point::new(point.row as u32, point.column as u32)
1432 }
1433}
1434
1435#[cfg(test)]
1436mod tests {
1437 use super::*;
1438 use crate::LanguageConfig;
1439 use rand::rngs::StdRng;
1440 use std::env;
1441 use text::Buffer;
1442 use unindent::Unindent as _;
1443 use util::test::marked_text_ranges;
1444
1445 #[test]
1446 fn test_splice_included_ranges() {
1447 let ranges = vec![ts_range(20..30), ts_range(50..60), ts_range(80..90)];
1448
1449 let new_ranges = splice_included_ranges(
1450 ranges.clone(),
1451 &[54..56, 58..68],
1452 &[ts_range(50..54), ts_range(59..67)],
1453 );
1454 assert_eq!(
1455 new_ranges,
1456 &[
1457 ts_range(20..30),
1458 ts_range(50..54),
1459 ts_range(59..67),
1460 ts_range(80..90),
1461 ]
1462 );
1463
1464 let new_ranges = splice_included_ranges(ranges.clone(), &[70..71, 91..100], &[]);
1465 assert_eq!(
1466 new_ranges,
1467 &[ts_range(20..30), ts_range(50..60), ts_range(80..90)]
1468 );
1469
1470 let new_ranges =
1471 splice_included_ranges(ranges.clone(), &[], &[ts_range(0..2), ts_range(70..75)]);
1472 assert_eq!(
1473 new_ranges,
1474 &[
1475 ts_range(0..2),
1476 ts_range(20..30),
1477 ts_range(50..60),
1478 ts_range(70..75),
1479 ts_range(80..90)
1480 ]
1481 );
1482
1483 let new_ranges = splice_included_ranges(ranges.clone(), &[30..50], &[ts_range(25..55)]);
1484 assert_eq!(new_ranges, &[ts_range(25..55), ts_range(80..90)]);
1485
1486 fn ts_range(range: Range<usize>) -> tree_sitter::Range {
1487 tree_sitter::Range {
1488 start_byte: range.start,
1489 start_point: tree_sitter::Point {
1490 row: 0,
1491 column: range.start,
1492 },
1493 end_byte: range.end,
1494 end_point: tree_sitter::Point {
1495 row: 0,
1496 column: range.end,
1497 },
1498 }
1499 }
1500 }
1501
1502 #[gpui::test]
1503 fn test_syntax_map_layers_for_range() {
1504 let registry = Arc::new(LanguageRegistry::test());
1505 let language = Arc::new(rust_lang());
1506 registry.add(language.clone());
1507
1508 let mut buffer = Buffer::new(
1509 0,
1510 0,
1511 r#"
1512 fn a() {
1513 assert_eq!(
1514 b(vec![C {}]),
1515 vec![d.e],
1516 );
1517 println!("{}", f(|_| true));
1518 }
1519 "#
1520 .unindent(),
1521 );
1522
1523 let mut syntax_map = SyntaxMap::new();
1524 syntax_map.set_language_registry(registry.clone());
1525 syntax_map.reparse(language.clone(), &buffer);
1526
1527 assert_layers_for_range(
1528 &syntax_map,
1529 &buffer,
1530 Point::new(2, 0)..Point::new(2, 0),
1531 &[
1532 "...(function_item ... (block (expression_statement (macro_invocation...",
1533 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1534 ],
1535 );
1536 assert_layers_for_range(
1537 &syntax_map,
1538 &buffer,
1539 Point::new(2, 14)..Point::new(2, 16),
1540 &[
1541 "...(function_item ...",
1542 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1543 "...(array_expression (struct_expression ...",
1544 ],
1545 );
1546 assert_layers_for_range(
1547 &syntax_map,
1548 &buffer,
1549 Point::new(3, 14)..Point::new(3, 16),
1550 &[
1551 "...(function_item ...",
1552 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1553 "...(array_expression (field_expression ...",
1554 ],
1555 );
1556 assert_layers_for_range(
1557 &syntax_map,
1558 &buffer,
1559 Point::new(5, 12)..Point::new(5, 16),
1560 &[
1561 "...(function_item ...",
1562 "...(call_expression ... (arguments (closure_expression ...",
1563 ],
1564 );
1565
1566 // Replace a vec! macro invocation with a plain slice, removing a syntactic layer.
1567 let macro_name_range = range_for_text(&buffer, "vec!");
1568 buffer.edit([(macro_name_range, "&")]);
1569 syntax_map.interpolate(&buffer);
1570 syntax_map.reparse(language.clone(), &buffer);
1571
1572 assert_layers_for_range(
1573 &syntax_map,
1574 &buffer,
1575 Point::new(2, 14)..Point::new(2, 16),
1576 &[
1577 "...(function_item ...",
1578 "...(tuple_expression (call_expression ... arguments: (arguments (reference_expression value: (array_expression...",
1579 ],
1580 );
1581
1582 // Put the vec! macro back, adding back the syntactic layer.
1583 buffer.undo();
1584 syntax_map.interpolate(&buffer);
1585 syntax_map.reparse(language.clone(), &buffer);
1586
1587 assert_layers_for_range(
1588 &syntax_map,
1589 &buffer,
1590 Point::new(2, 14)..Point::new(2, 16),
1591 &[
1592 "...(function_item ...",
1593 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1594 "...(array_expression (struct_expression ...",
1595 ],
1596 );
1597 }
1598
1599 #[gpui::test]
1600 fn test_dynamic_language_injection() {
1601 let registry = Arc::new(LanguageRegistry::test());
1602 let markdown = Arc::new(markdown_lang());
1603 registry.add(markdown.clone());
1604 registry.add(Arc::new(rust_lang()));
1605 registry.add(Arc::new(ruby_lang()));
1606
1607 let mut buffer = Buffer::new(
1608 0,
1609 0,
1610 r#"
1611 This is a code block:
1612
1613 ```rs
1614 fn foo() {}
1615 ```
1616 "#
1617 .unindent(),
1618 );
1619
1620 let mut syntax_map = SyntaxMap::new();
1621 syntax_map.set_language_registry(registry.clone());
1622 syntax_map.reparse(markdown.clone(), &buffer);
1623 assert_layers_for_range(
1624 &syntax_map,
1625 &buffer,
1626 Point::new(3, 0)..Point::new(3, 0),
1627 &[
1628 "...(fenced_code_block (fenced_code_block_delimiter) (info_string (language)) (code_fence_content) (fenced_code_block_delimiter...",
1629 "...(function_item name: (identifier) parameters: (parameters) body: (block)...",
1630 ],
1631 );
1632
1633 // Replace Rust with Ruby in code block.
1634 let macro_name_range = range_for_text(&buffer, "rs");
1635 buffer.edit([(macro_name_range, "ruby")]);
1636 syntax_map.interpolate(&buffer);
1637 syntax_map.reparse(markdown.clone(), &buffer);
1638 assert_layers_for_range(
1639 &syntax_map,
1640 &buffer,
1641 Point::new(3, 0)..Point::new(3, 0),
1642 &[
1643 "...(fenced_code_block (fenced_code_block_delimiter) (info_string (language)) (code_fence_content) (fenced_code_block_delimiter...",
1644 "...(call method: (identifier) arguments: (argument_list (call method: (identifier) arguments: (argument_list) block: (block)...",
1645 ],
1646 );
1647 }
1648
1649 #[gpui::test]
1650 fn test_typing_multiple_new_injections() {
1651 let (buffer, syntax_map) = test_edit_sequence(
1652 "Rust",
1653 &[
1654 "fn a() { dbg }",
1655 "fn a() { dbg«!» }",
1656 "fn a() { dbg!«()» }",
1657 "fn a() { dbg!(«b») }",
1658 "fn a() { dbg!(b«.») }",
1659 "fn a() { dbg!(b.«c») }",
1660 "fn a() { dbg!(b.c«()») }",
1661 "fn a() { dbg!(b.c(«vec»)) }",
1662 "fn a() { dbg!(b.c(vec«!»)) }",
1663 "fn a() { dbg!(b.c(vec!«[]»)) }",
1664 "fn a() { dbg!(b.c(vec![«d»])) }",
1665 "fn a() { dbg!(b.c(vec![d«.»])) }",
1666 "fn a() { dbg!(b.c(vec![d.«e»])) }",
1667 ],
1668 );
1669
1670 assert_capture_ranges(
1671 &syntax_map,
1672 &buffer,
1673 &["field"],
1674 "fn a() { dbg!(b.«c»(vec![d.«e»])) }",
1675 );
1676 }
1677
1678 #[gpui::test]
1679 fn test_pasting_new_injection_line_between_others() {
1680 let (buffer, syntax_map) = test_edit_sequence(
1681 "Rust",
1682 &[
1683 "
1684 fn a() {
1685 b!(B {});
1686 c!(C {});
1687 d!(D {});
1688 e!(E {});
1689 f!(F {});
1690 g!(G {});
1691 }
1692 ",
1693 "
1694 fn a() {
1695 b!(B {});
1696 c!(C {});
1697 d!(D {});
1698 « h!(H {});
1699 » e!(E {});
1700 f!(F {});
1701 g!(G {});
1702 }
1703 ",
1704 ],
1705 );
1706
1707 assert_capture_ranges(
1708 &syntax_map,
1709 &buffer,
1710 &["struct"],
1711 "
1712 fn a() {
1713 b!(«B {}»);
1714 c!(«C {}»);
1715 d!(«D {}»);
1716 h!(«H {}»);
1717 e!(«E {}»);
1718 f!(«F {}»);
1719 g!(«G {}»);
1720 }
1721 ",
1722 );
1723 }
1724
1725 #[gpui::test]
1726 fn test_joining_injections_with_child_injections() {
1727 let (buffer, syntax_map) = test_edit_sequence(
1728 "Rust",
1729 &[
1730 "
1731 fn a() {
1732 b!(
1733 c![one.two.three],
1734 d![four.five.six],
1735 );
1736 e!(
1737 f![seven.eight],
1738 );
1739 }
1740 ",
1741 "
1742 fn a() {
1743 b!(
1744 c![one.two.three],
1745 d![four.five.six],
1746 ˇ f![seven.eight],
1747 );
1748 }
1749 ",
1750 ],
1751 );
1752
1753 assert_capture_ranges(
1754 &syntax_map,
1755 &buffer,
1756 &["field"],
1757 "
1758 fn a() {
1759 b!(
1760 c![one.«two».«three»],
1761 d![four.«five».«six»],
1762 f![seven.«eight»],
1763 );
1764 }
1765 ",
1766 );
1767 }
1768
1769 #[gpui::test]
1770 fn test_editing_edges_of_injection() {
1771 test_edit_sequence(
1772 "Rust",
1773 &[
1774 "
1775 fn a() {
1776 b!(c!())
1777 }
1778 ",
1779 "
1780 fn a() {
1781 «d»!(c!())
1782 }
1783 ",
1784 "
1785 fn a() {
1786 «e»d!(c!())
1787 }
1788 ",
1789 "
1790 fn a() {
1791 ed!«[»c!()«]»
1792 }
1793 ",
1794 ],
1795 );
1796 }
1797
1798 #[gpui::test]
1799 fn test_edits_preceding_and_intersecting_injection() {
1800 test_edit_sequence(
1801 "Rust",
1802 &[
1803 //
1804 "const aaaaaaaaaaaa: B = c!(d(e.f));",
1805 "const aˇa: B = c!(d(eˇ));",
1806 ],
1807 );
1808 }
1809
1810 #[gpui::test]
1811 fn test_non_local_changes_create_injections() {
1812 test_edit_sequence(
1813 "Rust",
1814 &[
1815 "
1816 // a! {
1817 static B: C = d;
1818 // }
1819 ",
1820 "
1821 ˇa! {
1822 static B: C = d;
1823 ˇ}
1824 ",
1825 ],
1826 );
1827 }
1828
1829 #[gpui::test]
1830 fn test_creating_many_injections_in_one_edit() {
1831 test_edit_sequence(
1832 "Rust",
1833 &[
1834 "
1835 fn a() {
1836 one(Two::three(3));
1837 four(Five::six(6));
1838 seven(Eight::nine(9));
1839 }
1840 ",
1841 "
1842 fn a() {
1843 one«!»(Two::three(3));
1844 four«!»(Five::six(6));
1845 seven«!»(Eight::nine(9));
1846 }
1847 ",
1848 "
1849 fn a() {
1850 one!(Two::three«!»(3));
1851 four!(Five::six«!»(6));
1852 seven!(Eight::nine«!»(9));
1853 }
1854 ",
1855 ],
1856 );
1857 }
1858
1859 #[gpui::test]
1860 fn test_editing_across_injection_boundary() {
1861 test_edit_sequence(
1862 "Rust",
1863 &[
1864 "
1865 fn one() {
1866 two();
1867 three!(
1868 three.four,
1869 five.six,
1870 );
1871 }
1872 ",
1873 "
1874 fn one() {
1875 two();
1876 th«irty_five![»
1877 three.four,
1878 five.six,
1879 « seven.eight,
1880 ];»
1881 }
1882 ",
1883 ],
1884 );
1885 }
1886
1887 #[gpui::test]
1888 fn test_removing_injection_by_replacing_across_boundary() {
1889 test_edit_sequence(
1890 "Rust",
1891 &[
1892 "
1893 fn one() {
1894 two!(
1895 three.four,
1896 );
1897 }
1898 ",
1899 "
1900 fn one() {
1901 t«en
1902 .eleven(
1903 twelve,
1904 »
1905 three.four,
1906 );
1907 }
1908 ",
1909 ],
1910 );
1911 }
1912
1913 #[gpui::test]
1914 fn test_combined_injections() {
1915 let (buffer, syntax_map) = test_edit_sequence(
1916 "ERB",
1917 &[
1918 "
1919 <body>
1920 <% if @one %>
1921 <div class=one>
1922 <% else %>
1923 <div class=two>
1924 <% end %>
1925 </div>
1926 </body>
1927 ",
1928 "
1929 <body>
1930 <% if @one %>
1931 <div class=one>
1932 ˇ else ˇ
1933 <div class=two>
1934 <% end %>
1935 </div>
1936 </body>
1937 ",
1938 "
1939 <body>
1940 <% if @one «;» end %>
1941 </div>
1942 </body>
1943 ",
1944 ],
1945 );
1946
1947 assert_capture_ranges(
1948 &syntax_map,
1949 &buffer,
1950 &["tag", "ivar"],
1951 "
1952 <«body»>
1953 <% if «@one» ; end %>
1954 </«div»>
1955 </«body»>
1956 ",
1957 );
1958 }
1959
1960 #[gpui::test]
1961 fn test_combined_injections_empty_ranges() {
1962 test_edit_sequence(
1963 "ERB",
1964 &[
1965 "
1966 <% if @one %>
1967 <% else %>
1968 <% end %>
1969 ",
1970 "
1971 <% if @one %>
1972 ˇ<% end %>
1973 ",
1974 ],
1975 );
1976 }
1977
1978 #[gpui::test]
1979 fn test_combined_injections_edit_edges_of_ranges() {
1980 let (buffer, syntax_map) = test_edit_sequence(
1981 "ERB",
1982 &[
1983 "
1984 <%= one @two %>
1985 <%= three @four %>
1986 ",
1987 "
1988 <%= one @two %ˇ
1989 <%= three @four %>
1990 ",
1991 "
1992 <%= one @two %«>»
1993 <%= three @four %>
1994 ",
1995 ],
1996 );
1997
1998 assert_capture_ranges(
1999 &syntax_map,
2000 &buffer,
2001 &["tag", "ivar"],
2002 "
2003 <%= one «@two» %>
2004 <%= three «@four» %>
2005 ",
2006 );
2007 }
2008
2009 #[gpui::test]
2010 fn test_combined_injections_splitting_some_injections() {
2011 let (_buffer, _syntax_map) = test_edit_sequence(
2012 "ERB",
2013 &[
2014 r#"
2015 <%A if b(:c) %>
2016 d
2017 <% end %>
2018 eee
2019 <% f %>
2020 "#,
2021 r#"
2022 <%« AAAAAAA %>
2023 hhhhhhh
2024 <%=» if b(:c) %>
2025 d
2026 <% end %>
2027 eee
2028 <% f %>
2029 "#,
2030 ],
2031 );
2032 }
2033
2034 #[gpui::test(iterations = 50)]
2035 fn test_random_syntax_map_edits(mut rng: StdRng) {
2036 let operations = env::var("OPERATIONS")
2037 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
2038 .unwrap_or(10);
2039
2040 let text = r#"
2041 fn test_something() {
2042 let vec = vec![5, 1, 3, 8];
2043 assert_eq!(
2044 vec
2045 .into_iter()
2046 .map(|i| i * 2)
2047 .collect::<Vec<usize>>(),
2048 vec![
2049 5 * 2, 1 * 2, 3 * 2, 8 * 2
2050 ],
2051 );
2052 }
2053 "#
2054 .unindent()
2055 .repeat(2);
2056
2057 let registry = Arc::new(LanguageRegistry::test());
2058 let language = Arc::new(rust_lang());
2059 registry.add(language.clone());
2060 let mut buffer = Buffer::new(0, 0, text);
2061
2062 let mut syntax_map = SyntaxMap::new();
2063 syntax_map.set_language_registry(registry.clone());
2064 syntax_map.reparse(language.clone(), &buffer);
2065
2066 let mut reference_syntax_map = SyntaxMap::new();
2067 reference_syntax_map.set_language_registry(registry.clone());
2068
2069 log::info!("initial text:\n{}", buffer.text());
2070
2071 for _ in 0..operations {
2072 let prev_buffer = buffer.snapshot();
2073 let prev_syntax_map = syntax_map.snapshot();
2074
2075 buffer.randomly_edit(&mut rng, 3);
2076 log::info!("text:\n{}", buffer.text());
2077
2078 syntax_map.interpolate(&buffer);
2079 check_interpolation(&prev_syntax_map, &syntax_map, &prev_buffer, &buffer);
2080
2081 syntax_map.reparse(language.clone(), &buffer);
2082
2083 reference_syntax_map.clear();
2084 reference_syntax_map.reparse(language.clone(), &buffer);
2085 }
2086
2087 for i in 0..operations {
2088 let i = operations - i - 1;
2089 buffer.undo();
2090 log::info!("undoing operation {}", i);
2091 log::info!("text:\n{}", buffer.text());
2092
2093 syntax_map.interpolate(&buffer);
2094 syntax_map.reparse(language.clone(), &buffer);
2095
2096 reference_syntax_map.clear();
2097 reference_syntax_map.reparse(language.clone(), &buffer);
2098 assert_eq!(
2099 syntax_map.layers(&buffer).len(),
2100 reference_syntax_map.layers(&buffer).len(),
2101 "wrong number of layers after undoing edit {i}"
2102 );
2103 }
2104
2105 let layers = syntax_map.layers(&buffer);
2106 let reference_layers = reference_syntax_map.layers(&buffer);
2107 for (edited_layer, reference_layer) in layers.into_iter().zip(reference_layers.into_iter())
2108 {
2109 assert_eq!(edited_layer.node.to_sexp(), reference_layer.node.to_sexp());
2110 assert_eq!(edited_layer.node.range(), reference_layer.node.range());
2111 }
2112 }
2113
2114 #[gpui::test(iterations = 50)]
2115 fn test_random_syntax_map_edits_with_combined_injections(mut rng: StdRng) {
2116 let operations = env::var("OPERATIONS")
2117 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
2118 .unwrap_or(10);
2119
2120 let text = r#"
2121 <div id="main">
2122 <% if one?(:two) %>
2123 <p class="three" four>
2124 <%= yield :five %>
2125 </p>
2126 <% elsif Six.seven(8) %>
2127 <p id="three" four>
2128 <%= yield :five %>
2129 </p>
2130 <% else %>
2131 <span>Ok</span>
2132 <% end %>
2133 </div>
2134 "#
2135 .unindent()
2136 .repeat(8);
2137
2138 let registry = Arc::new(LanguageRegistry::test());
2139 let language = Arc::new(erb_lang());
2140 registry.add(language.clone());
2141 registry.add(Arc::new(ruby_lang()));
2142 registry.add(Arc::new(html_lang()));
2143 let mut buffer = Buffer::new(0, 0, text);
2144
2145 let mut syntax_map = SyntaxMap::new();
2146 syntax_map.set_language_registry(registry.clone());
2147 syntax_map.reparse(language.clone(), &buffer);
2148
2149 let mut reference_syntax_map = SyntaxMap::new();
2150 reference_syntax_map.set_language_registry(registry.clone());
2151
2152 log::info!("initial text:\n{}", buffer.text());
2153
2154 for _ in 0..operations {
2155 let prev_buffer = buffer.snapshot();
2156 let prev_syntax_map = syntax_map.snapshot();
2157
2158 buffer.randomly_edit(&mut rng, 3);
2159 log::info!("text:\n{}", buffer.text());
2160
2161 syntax_map.interpolate(&buffer);
2162 check_interpolation(&prev_syntax_map, &syntax_map, &prev_buffer, &buffer);
2163
2164 syntax_map.reparse(language.clone(), &buffer);
2165
2166 reference_syntax_map.clear();
2167 reference_syntax_map.reparse(language.clone(), &buffer);
2168 }
2169
2170 for i in 0..operations {
2171 let i = operations - i - 1;
2172 buffer.undo();
2173 log::info!("undoing operation {}", i);
2174 log::info!("text:\n{}", buffer.text());
2175
2176 syntax_map.interpolate(&buffer);
2177 syntax_map.reparse(language.clone(), &buffer);
2178
2179 reference_syntax_map.clear();
2180 reference_syntax_map.reparse(language.clone(), &buffer);
2181 assert_eq!(
2182 syntax_map.layers(&buffer).len(),
2183 reference_syntax_map.layers(&buffer).len(),
2184 "wrong number of layers after undoing edit {i}"
2185 );
2186 }
2187
2188 let layers = syntax_map.layers(&buffer);
2189 let reference_layers = reference_syntax_map.layers(&buffer);
2190 for (edited_layer, reference_layer) in layers.into_iter().zip(reference_layers.into_iter())
2191 {
2192 assert_eq!(edited_layer.node.to_sexp(), reference_layer.node.to_sexp());
2193 assert_eq!(edited_layer.node.range(), reference_layer.node.range());
2194 }
2195 }
2196
2197 fn check_interpolation(
2198 old_syntax_map: &SyntaxSnapshot,
2199 new_syntax_map: &SyntaxSnapshot,
2200 old_buffer: &BufferSnapshot,
2201 new_buffer: &BufferSnapshot,
2202 ) {
2203 let edits = new_buffer
2204 .edits_since::<usize>(&old_buffer.version())
2205 .collect::<Vec<_>>();
2206
2207 for (old_layer, new_layer) in old_syntax_map
2208 .layers
2209 .iter()
2210 .zip(new_syntax_map.layers.iter())
2211 {
2212 assert_eq!(old_layer.range, new_layer.range);
2213 let old_start_byte = old_layer.range.start.to_offset(old_buffer);
2214 let new_start_byte = new_layer.range.start.to_offset(new_buffer);
2215 let old_start_point = old_layer.range.start.to_point(old_buffer).to_ts_point();
2216 let new_start_point = new_layer.range.start.to_point(new_buffer).to_ts_point();
2217 let old_node = old_layer
2218 .tree
2219 .root_node_with_offset(old_start_byte, old_start_point);
2220 let new_node = new_layer
2221 .tree
2222 .root_node_with_offset(new_start_byte, new_start_point);
2223 check_node_edits(
2224 old_layer.depth,
2225 &old_layer.range,
2226 old_node,
2227 new_node,
2228 old_buffer,
2229 new_buffer,
2230 &edits,
2231 );
2232 }
2233
2234 fn check_node_edits(
2235 depth: usize,
2236 range: &Range<Anchor>,
2237 old_node: Node,
2238 new_node: Node,
2239 old_buffer: &BufferSnapshot,
2240 new_buffer: &BufferSnapshot,
2241 edits: &[text::Edit<usize>],
2242 ) {
2243 assert_eq!(old_node.kind(), new_node.kind());
2244
2245 let old_range = old_node.byte_range();
2246 let new_range = new_node.byte_range();
2247
2248 let is_edited = edits
2249 .iter()
2250 .any(|edit| edit.new.start < new_range.end && edit.new.end > new_range.start);
2251 if is_edited {
2252 assert!(
2253 new_node.has_changes(),
2254 concat!(
2255 "failed to mark node as edited.\n",
2256 "layer depth: {}, old layer range: {:?}, new layer range: {:?},\n",
2257 "node kind: {}, old node range: {:?}, new node range: {:?}",
2258 ),
2259 depth,
2260 range.to_offset(old_buffer),
2261 range.to_offset(new_buffer),
2262 new_node.kind(),
2263 old_range,
2264 new_range,
2265 );
2266 }
2267
2268 if !new_node.has_changes() {
2269 assert_eq!(
2270 old_buffer
2271 .text_for_range(old_range.clone())
2272 .collect::<String>(),
2273 new_buffer
2274 .text_for_range(new_range.clone())
2275 .collect::<String>(),
2276 concat!(
2277 "mismatched text for node\n",
2278 "layer depth: {}, old layer range: {:?}, new layer range: {:?},\n",
2279 "node kind: {}, old node range:{:?}, new node range:{:?}",
2280 ),
2281 depth,
2282 range.to_offset(old_buffer),
2283 range.to_offset(new_buffer),
2284 new_node.kind(),
2285 old_range,
2286 new_range,
2287 );
2288 }
2289
2290 for i in 0..new_node.child_count() {
2291 check_node_edits(
2292 depth,
2293 range,
2294 old_node.child(i).unwrap(),
2295 new_node.child(i).unwrap(),
2296 old_buffer,
2297 new_buffer,
2298 edits,
2299 )
2300 }
2301 }
2302 }
2303
2304 fn test_edit_sequence(language_name: &str, steps: &[&str]) -> (Buffer, SyntaxMap) {
2305 let registry = Arc::new(LanguageRegistry::test());
2306 registry.add(Arc::new(rust_lang()));
2307 registry.add(Arc::new(ruby_lang()));
2308 registry.add(Arc::new(html_lang()));
2309 registry.add(Arc::new(erb_lang()));
2310 registry.add(Arc::new(markdown_lang()));
2311 let language = registry.language_for_name(language_name).unwrap();
2312 let mut buffer = Buffer::new(0, 0, Default::default());
2313
2314 let mut mutated_syntax_map = SyntaxMap::new();
2315 mutated_syntax_map.set_language_registry(registry.clone());
2316 mutated_syntax_map.reparse(language.clone(), &buffer);
2317
2318 for (i, marked_string) in steps.into_iter().enumerate() {
2319 buffer.edit_via_marked_text(&marked_string.unindent());
2320
2321 // Reparse the syntax map
2322 mutated_syntax_map.interpolate(&buffer);
2323 mutated_syntax_map.reparse(language.clone(), &buffer);
2324
2325 // Create a second syntax map from scratch
2326 let mut reference_syntax_map = SyntaxMap::new();
2327 reference_syntax_map.set_language_registry(registry.clone());
2328 reference_syntax_map.reparse(language.clone(), &buffer);
2329
2330 // Compare the mutated syntax map to the new syntax map
2331 let mutated_layers = mutated_syntax_map.layers(&buffer);
2332 let reference_layers = reference_syntax_map.layers(&buffer);
2333 assert_eq!(
2334 mutated_layers.len(),
2335 reference_layers.len(),
2336 "wrong number of layers at step {i}"
2337 );
2338 for (edited_layer, reference_layer) in
2339 mutated_layers.into_iter().zip(reference_layers.into_iter())
2340 {
2341 assert_eq!(
2342 edited_layer.node.to_sexp(),
2343 reference_layer.node.to_sexp(),
2344 "different layer at step {i}"
2345 );
2346 assert_eq!(
2347 edited_layer.node.range(),
2348 reference_layer.node.range(),
2349 "different layer at step {i}"
2350 );
2351 }
2352 }
2353
2354 (buffer, mutated_syntax_map)
2355 }
2356
2357 fn html_lang() -> Language {
2358 Language::new(
2359 LanguageConfig {
2360 name: "HTML".into(),
2361 path_suffixes: vec!["html".to_string()],
2362 ..Default::default()
2363 },
2364 Some(tree_sitter_html::language()),
2365 )
2366 .with_highlights_query(
2367 r#"
2368 (tag_name) @tag
2369 (erroneous_end_tag_name) @tag
2370 (attribute_name) @property
2371 "#,
2372 )
2373 .unwrap()
2374 }
2375
2376 fn ruby_lang() -> Language {
2377 Language::new(
2378 LanguageConfig {
2379 name: "Ruby".into(),
2380 path_suffixes: vec!["rb".to_string()],
2381 ..Default::default()
2382 },
2383 Some(tree_sitter_ruby::language()),
2384 )
2385 .with_highlights_query(
2386 r#"
2387 ["if" "do" "else" "end"] @keyword
2388 (instance_variable) @ivar
2389 "#,
2390 )
2391 .unwrap()
2392 }
2393
2394 fn erb_lang() -> Language {
2395 Language::new(
2396 LanguageConfig {
2397 name: "ERB".into(),
2398 path_suffixes: vec!["erb".to_string()],
2399 ..Default::default()
2400 },
2401 Some(tree_sitter_embedded_template::language()),
2402 )
2403 .with_highlights_query(
2404 r#"
2405 ["<%" "%>"] @keyword
2406 "#,
2407 )
2408 .unwrap()
2409 .with_injection_query(
2410 r#"
2411 ((code) @content
2412 (#set! "language" "ruby")
2413 (#set! "combined"))
2414
2415 ((content) @content
2416 (#set! "language" "html")
2417 (#set! "combined"))
2418 "#,
2419 )
2420 .unwrap()
2421 }
2422
2423 fn rust_lang() -> Language {
2424 Language::new(
2425 LanguageConfig {
2426 name: "Rust".into(),
2427 path_suffixes: vec!["rs".to_string()],
2428 ..Default::default()
2429 },
2430 Some(tree_sitter_rust::language()),
2431 )
2432 .with_highlights_query(
2433 r#"
2434 (field_identifier) @field
2435 (struct_expression) @struct
2436 "#,
2437 )
2438 .unwrap()
2439 .with_injection_query(
2440 r#"
2441 (macro_invocation
2442 (token_tree) @content
2443 (#set! "language" "rust"))
2444 "#,
2445 )
2446 .unwrap()
2447 }
2448
2449 fn markdown_lang() -> Language {
2450 Language::new(
2451 LanguageConfig {
2452 name: "Markdown".into(),
2453 path_suffixes: vec!["md".into()],
2454 ..Default::default()
2455 },
2456 Some(tree_sitter_markdown::language()),
2457 )
2458 .with_injection_query(
2459 r#"
2460 (fenced_code_block
2461 (info_string
2462 (language) @language)
2463 (code_fence_content) @content)
2464 "#,
2465 )
2466 .unwrap()
2467 }
2468
2469 fn range_for_text(buffer: &Buffer, text: &str) -> Range<usize> {
2470 let start = buffer.as_rope().to_string().find(text).unwrap();
2471 start..start + text.len()
2472 }
2473
2474 fn assert_layers_for_range(
2475 syntax_map: &SyntaxMap,
2476 buffer: &BufferSnapshot,
2477 range: Range<Point>,
2478 expected_layers: &[&str],
2479 ) {
2480 let layers = syntax_map
2481 .layers_for_range(range, &buffer)
2482 .collect::<Vec<_>>();
2483 assert_eq!(
2484 layers.len(),
2485 expected_layers.len(),
2486 "wrong number of layers"
2487 );
2488 for (i, (SyntaxLayerInfo { node, .. }, expected_s_exp)) in
2489 layers.iter().zip(expected_layers.iter()).enumerate()
2490 {
2491 let actual_s_exp = node.to_sexp();
2492 assert!(
2493 string_contains_sequence(
2494 &actual_s_exp,
2495 &expected_s_exp.split("...").collect::<Vec<_>>()
2496 ),
2497 "layer {i}:\n\nexpected: {expected_s_exp}\nactual: {actual_s_exp}",
2498 );
2499 }
2500 }
2501
2502 fn assert_capture_ranges(
2503 syntax_map: &SyntaxMap,
2504 buffer: &BufferSnapshot,
2505 highlight_query_capture_names: &[&str],
2506 marked_string: &str,
2507 ) {
2508 let mut actual_ranges = Vec::<Range<usize>>::new();
2509 let captures = syntax_map.captures(0..buffer.len(), buffer, |grammar| {
2510 grammar.highlights_query.as_ref()
2511 });
2512 let queries = captures
2513 .grammars()
2514 .iter()
2515 .map(|grammar| grammar.highlights_query.as_ref().unwrap())
2516 .collect::<Vec<_>>();
2517 for capture in captures {
2518 let name = &queries[capture.grammar_index].capture_names()[capture.index as usize];
2519 if highlight_query_capture_names.contains(&name.as_str()) {
2520 actual_ranges.push(capture.node.byte_range());
2521 }
2522 }
2523
2524 let (text, expected_ranges) = marked_text_ranges(&marked_string.unindent(), false);
2525 assert_eq!(text, buffer.text());
2526 assert_eq!(actual_ranges, expected_ranges);
2527 }
2528
2529 pub fn string_contains_sequence(text: &str, parts: &[&str]) -> bool {
2530 let mut last_part_end = 0;
2531 for part in parts {
2532 if let Some(start_ix) = text[last_part_end..].find(part) {
2533 last_part_end = start_ix + part.len();
2534 } else {
2535 return false;
2536 }
2537 }
2538 true
2539 }
2540}