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::{self, 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
1008 let mut language_name = None;
1009 let mut step_range = content_range.clone();
1010 if let Some(name) = config.patterns[mat.pattern_index].language.as_ref() {
1011 language_name = Some(Cow::Borrowed(name.as_ref()))
1012 } else if let Some(language_node) = config
1013 .language_capture_ix
1014 .and_then(|ix| mat.nodes_for_capture_index(ix).next())
1015 {
1016 step_range.start = cmp::min(content_range.start, language_node.start_byte());
1017 step_range.end = cmp::max(content_range.end, language_node.end_byte());
1018 language_name = Some(Cow::Owned(
1019 text.text_for_range(language_node.byte_range()).collect(),
1020 ))
1021 };
1022
1023 if let Some(language_name) = language_name {
1024 let language = language_registry
1025 .language_for_name(&language_name)
1026 .or_else(|| language_registry.language_for_extension(&language_name));
1027 if let Some(language) = language {
1028 result = true;
1029 let range =
1030 text.anchor_before(step_range.start)..text.anchor_after(step_range.end);
1031 if combined {
1032 combined_injection_ranges
1033 .get_mut(&language.clone())
1034 .unwrap()
1035 .extend(content_ranges);
1036 } else {
1037 queue.push(ParseStep {
1038 depth,
1039 language,
1040 included_ranges: content_ranges,
1041 range,
1042 mode: ParseMode::Single,
1043 });
1044 }
1045 }
1046 }
1047 }
1048 }
1049
1050 for (language, mut included_ranges) in combined_injection_ranges.drain() {
1051 included_ranges.sort_unstable();
1052 let range = text.anchor_before(node.start_byte())..text.anchor_after(node.end_byte());
1053 queue.push(ParseStep {
1054 depth,
1055 language,
1056 range,
1057 included_ranges,
1058 mode: ParseMode::Combined {
1059 parent_layer_range: node.start_byte()..node.end_byte(),
1060 parent_layer_changed_ranges: changed_ranges.to_vec(),
1061 },
1062 })
1063 }
1064
1065 result
1066}
1067
1068fn splice_included_ranges(
1069 mut ranges: Vec<tree_sitter::Range>,
1070 changed_ranges: &[Range<usize>],
1071 new_ranges: &[tree_sitter::Range],
1072) -> Vec<tree_sitter::Range> {
1073 let mut changed_ranges = changed_ranges.into_iter().peekable();
1074 let mut new_ranges = new_ranges.into_iter().peekable();
1075 let mut ranges_ix = 0;
1076 loop {
1077 let new_range = new_ranges.peek();
1078 let mut changed_range = changed_ranges.peek();
1079
1080 // Remove ranges that have changed before inserting any new ranges
1081 // into those ranges.
1082 if let Some((changed, new)) = changed_range.zip(new_range) {
1083 if new.end_byte < changed.start {
1084 changed_range = None;
1085 }
1086 }
1087
1088 if let Some(changed) = changed_range {
1089 let mut start_ix = ranges_ix
1090 + match ranges[ranges_ix..].binary_search_by_key(&changed.start, |r| r.end_byte) {
1091 Ok(ix) | Err(ix) => ix,
1092 };
1093 let mut end_ix = ranges_ix
1094 + match ranges[ranges_ix..].binary_search_by_key(&changed.end, |r| r.start_byte) {
1095 Ok(ix) => ix + 1,
1096 Err(ix) => ix,
1097 };
1098
1099 // If there are empty ranges, then there may be multiple ranges with the same
1100 // start or end. Expand the splice to include any adjacent ranges that touch
1101 // the changed range.
1102 while start_ix > 0 {
1103 if ranges[start_ix - 1].end_byte == changed.start {
1104 start_ix -= 1;
1105 } else {
1106 break;
1107 }
1108 }
1109 while let Some(range) = ranges.get(end_ix) {
1110 if range.start_byte == changed.end {
1111 end_ix += 1;
1112 } else {
1113 break;
1114 }
1115 }
1116
1117 if end_ix > start_ix {
1118 ranges.splice(start_ix..end_ix, []);
1119 }
1120 changed_ranges.next();
1121 ranges_ix = start_ix;
1122 } else if let Some(new_range) = new_range {
1123 let ix = ranges_ix
1124 + match ranges[ranges_ix..]
1125 .binary_search_by_key(&new_range.start_byte, |r| r.start_byte)
1126 {
1127 Ok(ix) | Err(ix) => ix,
1128 };
1129 ranges.insert(ix, **new_range);
1130 new_ranges.next();
1131 ranges_ix = ix + 1;
1132 } else {
1133 break;
1134 }
1135 }
1136 ranges
1137}
1138
1139impl<'a> SyntaxLayerInfo<'a> {
1140 pub(crate) fn override_id(&self, offset: usize, text: &text::BufferSnapshot) -> Option<u32> {
1141 let text = TextProvider(text.as_rope());
1142 let config = self.language.grammar.as_ref()?.override_config.as_ref()?;
1143
1144 let mut query_cursor = QueryCursorHandle::new();
1145 query_cursor.set_byte_range(offset..offset);
1146
1147 let mut smallest_match: Option<(u32, Range<usize>)> = None;
1148 for mat in query_cursor.matches(&config.query, self.node, text) {
1149 for capture in mat.captures {
1150 if !config.values.contains_key(&capture.index) {
1151 continue;
1152 }
1153
1154 let range = capture.node.byte_range();
1155 if offset <= range.start || offset >= range.end {
1156 continue;
1157 }
1158
1159 if let Some((_, smallest_range)) = &smallest_match {
1160 if range.len() < smallest_range.len() {
1161 smallest_match = Some((capture.index, range))
1162 }
1163 continue;
1164 }
1165
1166 smallest_match = Some((capture.index, range));
1167 }
1168 }
1169
1170 smallest_match.map(|(index, _)| index)
1171 }
1172}
1173
1174impl std::ops::Deref for SyntaxMap {
1175 type Target = SyntaxSnapshot;
1176
1177 fn deref(&self) -> &Self::Target {
1178 &self.snapshot
1179 }
1180}
1181
1182impl PartialEq for ParseStep {
1183 fn eq(&self, _: &Self) -> bool {
1184 false
1185 }
1186}
1187
1188impl Eq for ParseStep {}
1189
1190impl PartialOrd for ParseStep {
1191 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
1192 Some(self.cmp(&other))
1193 }
1194}
1195
1196impl Ord for ParseStep {
1197 fn cmp(&self, other: &Self) -> Ordering {
1198 let range_a = self.range();
1199 let range_b = other.range();
1200 Ord::cmp(&other.depth, &self.depth)
1201 .then_with(|| Ord::cmp(&range_b.start, &range_a.start))
1202 .then_with(|| Ord::cmp(&range_a.end, &range_b.end))
1203 .then_with(|| self.language.id().cmp(&other.language.id()))
1204 }
1205}
1206
1207impl ParseStep {
1208 fn range(&self) -> Range<usize> {
1209 if let ParseMode::Combined {
1210 parent_layer_range, ..
1211 } = &self.mode
1212 {
1213 parent_layer_range.clone()
1214 } else {
1215 let start = self.included_ranges.first().map_or(0, |r| r.start_byte);
1216 let end = self.included_ranges.last().map_or(0, |r| r.end_byte);
1217 start..end
1218 }
1219 }
1220}
1221
1222impl ChangedRegion {
1223 fn cmp(&self, other: &Self, buffer: &BufferSnapshot) -> Ordering {
1224 let range_a = &self.range;
1225 let range_b = &other.range;
1226 Ord::cmp(&self.depth, &other.depth)
1227 .then_with(|| range_a.start.cmp(&range_b.start, buffer))
1228 .then_with(|| range_b.end.cmp(&range_a.end, buffer))
1229 }
1230}
1231
1232impl ChangeRegionSet {
1233 fn start_position(&self) -> ChangeStartPosition {
1234 self.0.first().map_or(
1235 ChangeStartPosition {
1236 depth: usize::MAX,
1237 position: Anchor::MAX,
1238 },
1239 |region| ChangeStartPosition {
1240 depth: region.depth,
1241 position: region.range.start,
1242 },
1243 )
1244 }
1245
1246 fn intersects(&self, layer: &SyntaxLayer, text: &BufferSnapshot) -> bool {
1247 for region in &self.0 {
1248 if region.depth < layer.depth {
1249 continue;
1250 }
1251 if region.depth > layer.depth {
1252 break;
1253 }
1254 if region.range.end.cmp(&layer.range.start, text).is_le() {
1255 continue;
1256 }
1257 if region.range.start.cmp(&layer.range.end, text).is_ge() {
1258 break;
1259 }
1260 return true;
1261 }
1262 false
1263 }
1264
1265 fn insert(&mut self, region: ChangedRegion, text: &BufferSnapshot) {
1266 if let Err(ix) = self.0.binary_search_by(|probe| probe.cmp(®ion, text)) {
1267 self.0.insert(ix, region);
1268 }
1269 }
1270
1271 fn prune(&mut self, summary: SyntaxLayerSummary, text: &BufferSnapshot) -> bool {
1272 let prev_len = self.0.len();
1273 self.0.retain(|region| {
1274 region.depth > summary.max_depth
1275 || (region.depth == summary.max_depth
1276 && region
1277 .range
1278 .end
1279 .cmp(&summary.last_layer_range.start, text)
1280 .is_gt())
1281 });
1282 self.0.len() < prev_len
1283 }
1284}
1285
1286impl Default for SyntaxLayerSummary {
1287 fn default() -> Self {
1288 Self {
1289 max_depth: 0,
1290 min_depth: 0,
1291 range: Anchor::MAX..Anchor::MIN,
1292 last_layer_range: Anchor::MIN..Anchor::MAX,
1293 last_layer_language: None,
1294 }
1295 }
1296}
1297
1298impl sum_tree::Summary for SyntaxLayerSummary {
1299 type Context = BufferSnapshot;
1300
1301 fn add_summary(&mut self, other: &Self, buffer: &Self::Context) {
1302 if other.max_depth > self.max_depth {
1303 self.max_depth = other.max_depth;
1304 self.range = other.range.clone();
1305 } else {
1306 if other.range.start.cmp(&self.range.start, buffer).is_lt() {
1307 self.range.start = other.range.start;
1308 }
1309 if other.range.end.cmp(&self.range.end, buffer).is_gt() {
1310 self.range.end = other.range.end;
1311 }
1312 }
1313 self.last_layer_range = other.last_layer_range.clone();
1314 self.last_layer_language = other.last_layer_language;
1315 }
1316}
1317
1318impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary> for SyntaxLayerPosition {
1319 fn cmp(&self, cursor_location: &SyntaxLayerSummary, buffer: &BufferSnapshot) -> Ordering {
1320 Ord::cmp(&self.depth, &cursor_location.max_depth)
1321 .then_with(|| {
1322 self.range
1323 .start
1324 .cmp(&cursor_location.last_layer_range.start, buffer)
1325 })
1326 .then_with(|| {
1327 cursor_location
1328 .last_layer_range
1329 .end
1330 .cmp(&self.range.end, buffer)
1331 })
1332 .then_with(|| self.language.cmp(&cursor_location.last_layer_language))
1333 }
1334}
1335
1336impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary> for ChangeStartPosition {
1337 fn cmp(&self, cursor_location: &SyntaxLayerSummary, text: &BufferSnapshot) -> Ordering {
1338 Ord::cmp(&self.depth, &cursor_location.max_depth)
1339 .then_with(|| self.position.cmp(&cursor_location.range.end, text))
1340 }
1341}
1342
1343impl<'a> SeekTarget<'a, SyntaxLayerSummary, SyntaxLayerSummary>
1344 for SyntaxLayerPositionBeforeChange
1345{
1346 fn cmp(&self, cursor_location: &SyntaxLayerSummary, buffer: &BufferSnapshot) -> Ordering {
1347 if self.change.cmp(cursor_location, buffer).is_le() {
1348 return Ordering::Less;
1349 } else {
1350 self.position.cmp(cursor_location, buffer)
1351 }
1352 }
1353}
1354
1355impl sum_tree::Item for SyntaxLayer {
1356 type Summary = SyntaxLayerSummary;
1357
1358 fn summary(&self) -> Self::Summary {
1359 SyntaxLayerSummary {
1360 min_depth: self.depth,
1361 max_depth: self.depth,
1362 range: self.range.clone(),
1363 last_layer_range: self.range.clone(),
1364 last_layer_language: self.language.id(),
1365 }
1366 }
1367}
1368
1369impl std::fmt::Debug for SyntaxLayer {
1370 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1371 f.debug_struct("SyntaxLayer")
1372 .field("depth", &self.depth)
1373 .field("range", &self.range)
1374 .field("tree", &self.tree)
1375 .finish()
1376 }
1377}
1378
1379impl<'a> tree_sitter::TextProvider<'a> for TextProvider<'a> {
1380 type I = ByteChunks<'a>;
1381
1382 fn text(&mut self, node: tree_sitter::Node) -> Self::I {
1383 ByteChunks(self.0.chunks_in_range(node.byte_range()))
1384 }
1385}
1386
1387impl<'a> Iterator for ByteChunks<'a> {
1388 type Item = &'a [u8];
1389
1390 fn next(&mut self) -> Option<Self::Item> {
1391 self.0.next().map(str::as_bytes)
1392 }
1393}
1394
1395impl QueryCursorHandle {
1396 pub(crate) fn new() -> Self {
1397 let mut cursor = QUERY_CURSORS.lock().pop().unwrap_or_else(QueryCursor::new);
1398 cursor.set_match_limit(64);
1399 QueryCursorHandle(Some(cursor))
1400 }
1401}
1402
1403impl Deref for QueryCursorHandle {
1404 type Target = QueryCursor;
1405
1406 fn deref(&self) -> &Self::Target {
1407 self.0.as_ref().unwrap()
1408 }
1409}
1410
1411impl DerefMut for QueryCursorHandle {
1412 fn deref_mut(&mut self) -> &mut Self::Target {
1413 self.0.as_mut().unwrap()
1414 }
1415}
1416
1417impl Drop for QueryCursorHandle {
1418 fn drop(&mut self) {
1419 let mut cursor = self.0.take().unwrap();
1420 cursor.set_byte_range(0..usize::MAX);
1421 cursor.set_point_range(Point::zero().to_ts_point()..Point::MAX.to_ts_point());
1422 QUERY_CURSORS.lock().push(cursor)
1423 }
1424}
1425
1426pub(crate) trait ToTreeSitterPoint {
1427 fn to_ts_point(self) -> tree_sitter::Point;
1428 fn from_ts_point(point: tree_sitter::Point) -> Self;
1429}
1430
1431impl ToTreeSitterPoint for Point {
1432 fn to_ts_point(self) -> tree_sitter::Point {
1433 tree_sitter::Point::new(self.row as usize, self.column as usize)
1434 }
1435
1436 fn from_ts_point(point: tree_sitter::Point) -> Self {
1437 Point::new(point.row as u32, point.column as u32)
1438 }
1439}
1440
1441#[cfg(test)]
1442mod tests {
1443 use super::*;
1444 use crate::LanguageConfig;
1445 use rand::rngs::StdRng;
1446 use std::env;
1447 use text::Buffer;
1448 use unindent::Unindent as _;
1449 use util::test::marked_text_ranges;
1450
1451 #[test]
1452 fn test_splice_included_ranges() {
1453 let ranges = vec![ts_range(20..30), ts_range(50..60), ts_range(80..90)];
1454
1455 let new_ranges = splice_included_ranges(
1456 ranges.clone(),
1457 &[54..56, 58..68],
1458 &[ts_range(50..54), ts_range(59..67)],
1459 );
1460 assert_eq!(
1461 new_ranges,
1462 &[
1463 ts_range(20..30),
1464 ts_range(50..54),
1465 ts_range(59..67),
1466 ts_range(80..90),
1467 ]
1468 );
1469
1470 let new_ranges = splice_included_ranges(ranges.clone(), &[70..71, 91..100], &[]);
1471 assert_eq!(
1472 new_ranges,
1473 &[ts_range(20..30), ts_range(50..60), ts_range(80..90)]
1474 );
1475
1476 let new_ranges =
1477 splice_included_ranges(ranges.clone(), &[], &[ts_range(0..2), ts_range(70..75)]);
1478 assert_eq!(
1479 new_ranges,
1480 &[
1481 ts_range(0..2),
1482 ts_range(20..30),
1483 ts_range(50..60),
1484 ts_range(70..75),
1485 ts_range(80..90)
1486 ]
1487 );
1488
1489 let new_ranges = splice_included_ranges(ranges.clone(), &[30..50], &[ts_range(25..55)]);
1490 assert_eq!(new_ranges, &[ts_range(25..55), ts_range(80..90)]);
1491
1492 fn ts_range(range: Range<usize>) -> tree_sitter::Range {
1493 tree_sitter::Range {
1494 start_byte: range.start,
1495 start_point: tree_sitter::Point {
1496 row: 0,
1497 column: range.start,
1498 },
1499 end_byte: range.end,
1500 end_point: tree_sitter::Point {
1501 row: 0,
1502 column: range.end,
1503 },
1504 }
1505 }
1506 }
1507
1508 #[gpui::test]
1509 fn test_syntax_map_layers_for_range() {
1510 let registry = Arc::new(LanguageRegistry::test());
1511 let language = Arc::new(rust_lang());
1512 registry.add(language.clone());
1513
1514 let mut buffer = Buffer::new(
1515 0,
1516 0,
1517 r#"
1518 fn a() {
1519 assert_eq!(
1520 b(vec![C {}]),
1521 vec![d.e],
1522 );
1523 println!("{}", f(|_| true));
1524 }
1525 "#
1526 .unindent(),
1527 );
1528
1529 let mut syntax_map = SyntaxMap::new();
1530 syntax_map.set_language_registry(registry.clone());
1531 syntax_map.reparse(language.clone(), &buffer);
1532
1533 assert_layers_for_range(
1534 &syntax_map,
1535 &buffer,
1536 Point::new(2, 0)..Point::new(2, 0),
1537 &[
1538 "...(function_item ... (block (expression_statement (macro_invocation...",
1539 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1540 ],
1541 );
1542 assert_layers_for_range(
1543 &syntax_map,
1544 &buffer,
1545 Point::new(2, 14)..Point::new(2, 16),
1546 &[
1547 "...(function_item ...",
1548 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1549 "...(array_expression (struct_expression ...",
1550 ],
1551 );
1552 assert_layers_for_range(
1553 &syntax_map,
1554 &buffer,
1555 Point::new(3, 14)..Point::new(3, 16),
1556 &[
1557 "...(function_item ...",
1558 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1559 "...(array_expression (field_expression ...",
1560 ],
1561 );
1562 assert_layers_for_range(
1563 &syntax_map,
1564 &buffer,
1565 Point::new(5, 12)..Point::new(5, 16),
1566 &[
1567 "...(function_item ...",
1568 "...(call_expression ... (arguments (closure_expression ...",
1569 ],
1570 );
1571
1572 // Replace a vec! macro invocation with a plain slice, removing a syntactic layer.
1573 let macro_name_range = range_for_text(&buffer, "vec!");
1574 buffer.edit([(macro_name_range, "&")]);
1575 syntax_map.interpolate(&buffer);
1576 syntax_map.reparse(language.clone(), &buffer);
1577
1578 assert_layers_for_range(
1579 &syntax_map,
1580 &buffer,
1581 Point::new(2, 14)..Point::new(2, 16),
1582 &[
1583 "...(function_item ...",
1584 "...(tuple_expression (call_expression ... arguments: (arguments (reference_expression value: (array_expression...",
1585 ],
1586 );
1587
1588 // Put the vec! macro back, adding back the syntactic layer.
1589 buffer.undo();
1590 syntax_map.interpolate(&buffer);
1591 syntax_map.reparse(language.clone(), &buffer);
1592
1593 assert_layers_for_range(
1594 &syntax_map,
1595 &buffer,
1596 Point::new(2, 14)..Point::new(2, 16),
1597 &[
1598 "...(function_item ...",
1599 "...(tuple_expression (call_expression ... arguments: (arguments (macro_invocation...",
1600 "...(array_expression (struct_expression ...",
1601 ],
1602 );
1603 }
1604
1605 #[gpui::test]
1606 fn test_dynamic_language_injection() {
1607 let registry = Arc::new(LanguageRegistry::test());
1608 let markdown = Arc::new(markdown_lang());
1609 registry.add(markdown.clone());
1610 registry.add(Arc::new(rust_lang()));
1611 registry.add(Arc::new(ruby_lang()));
1612
1613 let mut buffer = Buffer::new(
1614 0,
1615 0,
1616 r#"
1617 This is a code block:
1618
1619 ```rs
1620 fn foo() {}
1621 ```
1622 "#
1623 .unindent(),
1624 );
1625
1626 let mut syntax_map = SyntaxMap::new();
1627 syntax_map.set_language_registry(registry.clone());
1628 syntax_map.reparse(markdown.clone(), &buffer);
1629 assert_layers_for_range(
1630 &syntax_map,
1631 &buffer,
1632 Point::new(3, 0)..Point::new(3, 0),
1633 &[
1634 "...(fenced_code_block (fenced_code_block_delimiter) (info_string (language)) (code_fence_content) (fenced_code_block_delimiter...",
1635 "...(function_item name: (identifier) parameters: (parameters) body: (block)...",
1636 ],
1637 );
1638
1639 // Replace Rust with Ruby in code block.
1640 let macro_name_range = range_for_text(&buffer, "rs");
1641 buffer.edit([(macro_name_range, "ruby")]);
1642 syntax_map.interpolate(&buffer);
1643 syntax_map.reparse(markdown.clone(), &buffer);
1644 assert_layers_for_range(
1645 &syntax_map,
1646 &buffer,
1647 Point::new(3, 0)..Point::new(3, 0),
1648 &[
1649 "...(fenced_code_block (fenced_code_block_delimiter) (info_string (language)) (code_fence_content) (fenced_code_block_delimiter...",
1650 "...(call method: (identifier) arguments: (argument_list (call method: (identifier) arguments: (argument_list) block: (block)...",
1651 ],
1652 );
1653 }
1654
1655 #[gpui::test]
1656 fn test_typing_multiple_new_injections() {
1657 let (buffer, syntax_map) = test_edit_sequence(
1658 "Rust",
1659 &[
1660 "fn a() { dbg }",
1661 "fn a() { dbg«!» }",
1662 "fn a() { dbg!«()» }",
1663 "fn a() { dbg!(«b») }",
1664 "fn a() { dbg!(b«.») }",
1665 "fn a() { dbg!(b.«c») }",
1666 "fn a() { dbg!(b.c«()») }",
1667 "fn a() { dbg!(b.c(«vec»)) }",
1668 "fn a() { dbg!(b.c(vec«!»)) }",
1669 "fn a() { dbg!(b.c(vec!«[]»)) }",
1670 "fn a() { dbg!(b.c(vec![«d»])) }",
1671 "fn a() { dbg!(b.c(vec![d«.»])) }",
1672 "fn a() { dbg!(b.c(vec![d.«e»])) }",
1673 ],
1674 );
1675
1676 assert_capture_ranges(
1677 &syntax_map,
1678 &buffer,
1679 &["field"],
1680 "fn a() { dbg!(b.«c»(vec![d.«e»])) }",
1681 );
1682 }
1683
1684 #[gpui::test]
1685 fn test_pasting_new_injection_line_between_others() {
1686 let (buffer, syntax_map) = test_edit_sequence(
1687 "Rust",
1688 &[
1689 "
1690 fn a() {
1691 b!(B {});
1692 c!(C {});
1693 d!(D {});
1694 e!(E {});
1695 f!(F {});
1696 g!(G {});
1697 }
1698 ",
1699 "
1700 fn a() {
1701 b!(B {});
1702 c!(C {});
1703 d!(D {});
1704 « h!(H {});
1705 » e!(E {});
1706 f!(F {});
1707 g!(G {});
1708 }
1709 ",
1710 ],
1711 );
1712
1713 assert_capture_ranges(
1714 &syntax_map,
1715 &buffer,
1716 &["struct"],
1717 "
1718 fn a() {
1719 b!(«B {}»);
1720 c!(«C {}»);
1721 d!(«D {}»);
1722 h!(«H {}»);
1723 e!(«E {}»);
1724 f!(«F {}»);
1725 g!(«G {}»);
1726 }
1727 ",
1728 );
1729 }
1730
1731 #[gpui::test]
1732 fn test_joining_injections_with_child_injections() {
1733 let (buffer, syntax_map) = test_edit_sequence(
1734 "Rust",
1735 &[
1736 "
1737 fn a() {
1738 b!(
1739 c![one.two.three],
1740 d![four.five.six],
1741 );
1742 e!(
1743 f![seven.eight],
1744 );
1745 }
1746 ",
1747 "
1748 fn a() {
1749 b!(
1750 c![one.two.three],
1751 d![four.five.six],
1752 ˇ f![seven.eight],
1753 );
1754 }
1755 ",
1756 ],
1757 );
1758
1759 assert_capture_ranges(
1760 &syntax_map,
1761 &buffer,
1762 &["field"],
1763 "
1764 fn a() {
1765 b!(
1766 c![one.«two».«three»],
1767 d![four.«five».«six»],
1768 f![seven.«eight»],
1769 );
1770 }
1771 ",
1772 );
1773 }
1774
1775 #[gpui::test]
1776 fn test_editing_edges_of_injection() {
1777 test_edit_sequence(
1778 "Rust",
1779 &[
1780 "
1781 fn a() {
1782 b!(c!())
1783 }
1784 ",
1785 "
1786 fn a() {
1787 «d»!(c!())
1788 }
1789 ",
1790 "
1791 fn a() {
1792 «e»d!(c!())
1793 }
1794 ",
1795 "
1796 fn a() {
1797 ed!«[»c!()«]»
1798 }
1799 ",
1800 ],
1801 );
1802 }
1803
1804 #[gpui::test]
1805 fn test_edits_preceding_and_intersecting_injection() {
1806 test_edit_sequence(
1807 "Rust",
1808 &[
1809 //
1810 "const aaaaaaaaaaaa: B = c!(d(e.f));",
1811 "const aˇa: B = c!(d(eˇ));",
1812 ],
1813 );
1814 }
1815
1816 #[gpui::test]
1817 fn test_non_local_changes_create_injections() {
1818 test_edit_sequence(
1819 "Rust",
1820 &[
1821 "
1822 // a! {
1823 static B: C = d;
1824 // }
1825 ",
1826 "
1827 ˇa! {
1828 static B: C = d;
1829 ˇ}
1830 ",
1831 ],
1832 );
1833 }
1834
1835 #[gpui::test]
1836 fn test_creating_many_injections_in_one_edit() {
1837 test_edit_sequence(
1838 "Rust",
1839 &[
1840 "
1841 fn a() {
1842 one(Two::three(3));
1843 four(Five::six(6));
1844 seven(Eight::nine(9));
1845 }
1846 ",
1847 "
1848 fn a() {
1849 one«!»(Two::three(3));
1850 four«!»(Five::six(6));
1851 seven«!»(Eight::nine(9));
1852 }
1853 ",
1854 "
1855 fn a() {
1856 one!(Two::three«!»(3));
1857 four!(Five::six«!»(6));
1858 seven!(Eight::nine«!»(9));
1859 }
1860 ",
1861 ],
1862 );
1863 }
1864
1865 #[gpui::test]
1866 fn test_editing_across_injection_boundary() {
1867 test_edit_sequence(
1868 "Rust",
1869 &[
1870 "
1871 fn one() {
1872 two();
1873 three!(
1874 three.four,
1875 five.six,
1876 );
1877 }
1878 ",
1879 "
1880 fn one() {
1881 two();
1882 th«irty_five![»
1883 three.four,
1884 five.six,
1885 « seven.eight,
1886 ];»
1887 }
1888 ",
1889 ],
1890 );
1891 }
1892
1893 #[gpui::test]
1894 fn test_removing_injection_by_replacing_across_boundary() {
1895 test_edit_sequence(
1896 "Rust",
1897 &[
1898 "
1899 fn one() {
1900 two!(
1901 three.four,
1902 );
1903 }
1904 ",
1905 "
1906 fn one() {
1907 t«en
1908 .eleven(
1909 twelve,
1910 »
1911 three.four,
1912 );
1913 }
1914 ",
1915 ],
1916 );
1917 }
1918
1919 #[gpui::test]
1920 fn test_combined_injections() {
1921 let (buffer, syntax_map) = test_edit_sequence(
1922 "ERB",
1923 &[
1924 "
1925 <body>
1926 <% if @one %>
1927 <div class=one>
1928 <% else %>
1929 <div class=two>
1930 <% end %>
1931 </div>
1932 </body>
1933 ",
1934 "
1935 <body>
1936 <% if @one %>
1937 <div class=one>
1938 ˇ else ˇ
1939 <div class=two>
1940 <% end %>
1941 </div>
1942 </body>
1943 ",
1944 "
1945 <body>
1946 <% if @one «;» end %>
1947 </div>
1948 </body>
1949 ",
1950 ],
1951 );
1952
1953 assert_capture_ranges(
1954 &syntax_map,
1955 &buffer,
1956 &["tag", "ivar"],
1957 "
1958 <«body»>
1959 <% if «@one» ; end %>
1960 </«div»>
1961 </«body»>
1962 ",
1963 );
1964 }
1965
1966 #[gpui::test]
1967 fn test_combined_injections_empty_ranges() {
1968 test_edit_sequence(
1969 "ERB",
1970 &[
1971 "
1972 <% if @one %>
1973 <% else %>
1974 <% end %>
1975 ",
1976 "
1977 <% if @one %>
1978 ˇ<% end %>
1979 ",
1980 ],
1981 );
1982 }
1983
1984 #[gpui::test]
1985 fn test_combined_injections_edit_edges_of_ranges() {
1986 let (buffer, syntax_map) = test_edit_sequence(
1987 "ERB",
1988 &[
1989 "
1990 <%= one @two %>
1991 <%= three @four %>
1992 ",
1993 "
1994 <%= one @two %ˇ
1995 <%= three @four %>
1996 ",
1997 "
1998 <%= one @two %«>»
1999 <%= three @four %>
2000 ",
2001 ],
2002 );
2003
2004 assert_capture_ranges(
2005 &syntax_map,
2006 &buffer,
2007 &["tag", "ivar"],
2008 "
2009 <%= one «@two» %>
2010 <%= three «@four» %>
2011 ",
2012 );
2013 }
2014
2015 #[gpui::test]
2016 fn test_combined_injections_splitting_some_injections() {
2017 let (_buffer, _syntax_map) = test_edit_sequence(
2018 "ERB",
2019 &[
2020 r#"
2021 <%A if b(:c) %>
2022 d
2023 <% end %>
2024 eee
2025 <% f %>
2026 "#,
2027 r#"
2028 <%« AAAAAAA %>
2029 hhhhhhh
2030 <%=» if b(:c) %>
2031 d
2032 <% end %>
2033 eee
2034 <% f %>
2035 "#,
2036 ],
2037 );
2038 }
2039
2040 #[gpui::test(iterations = 50)]
2041 fn test_random_syntax_map_edits(mut rng: StdRng) {
2042 let operations = env::var("OPERATIONS")
2043 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
2044 .unwrap_or(10);
2045
2046 let text = r#"
2047 fn test_something() {
2048 let vec = vec![5, 1, 3, 8];
2049 assert_eq!(
2050 vec
2051 .into_iter()
2052 .map(|i| i * 2)
2053 .collect::<Vec<usize>>(),
2054 vec![
2055 5 * 2, 1 * 2, 3 * 2, 8 * 2
2056 ],
2057 );
2058 }
2059 "#
2060 .unindent()
2061 .repeat(2);
2062
2063 let registry = Arc::new(LanguageRegistry::test());
2064 let language = Arc::new(rust_lang());
2065 registry.add(language.clone());
2066 let mut buffer = Buffer::new(0, 0, text);
2067
2068 let mut syntax_map = SyntaxMap::new();
2069 syntax_map.set_language_registry(registry.clone());
2070 syntax_map.reparse(language.clone(), &buffer);
2071
2072 let mut reference_syntax_map = SyntaxMap::new();
2073 reference_syntax_map.set_language_registry(registry.clone());
2074
2075 log::info!("initial text:\n{}", buffer.text());
2076
2077 for _ in 0..operations {
2078 let prev_buffer = buffer.snapshot();
2079 let prev_syntax_map = syntax_map.snapshot();
2080
2081 buffer.randomly_edit(&mut rng, 3);
2082 log::info!("text:\n{}", buffer.text());
2083
2084 syntax_map.interpolate(&buffer);
2085 check_interpolation(&prev_syntax_map, &syntax_map, &prev_buffer, &buffer);
2086
2087 syntax_map.reparse(language.clone(), &buffer);
2088
2089 reference_syntax_map.clear();
2090 reference_syntax_map.reparse(language.clone(), &buffer);
2091 }
2092
2093 for i in 0..operations {
2094 let i = operations - i - 1;
2095 buffer.undo();
2096 log::info!("undoing operation {}", i);
2097 log::info!("text:\n{}", buffer.text());
2098
2099 syntax_map.interpolate(&buffer);
2100 syntax_map.reparse(language.clone(), &buffer);
2101
2102 reference_syntax_map.clear();
2103 reference_syntax_map.reparse(language.clone(), &buffer);
2104 assert_eq!(
2105 syntax_map.layers(&buffer).len(),
2106 reference_syntax_map.layers(&buffer).len(),
2107 "wrong number of layers after undoing edit {i}"
2108 );
2109 }
2110
2111 let layers = syntax_map.layers(&buffer);
2112 let reference_layers = reference_syntax_map.layers(&buffer);
2113 for (edited_layer, reference_layer) in layers.into_iter().zip(reference_layers.into_iter())
2114 {
2115 assert_eq!(edited_layer.node.to_sexp(), reference_layer.node.to_sexp());
2116 assert_eq!(edited_layer.node.range(), reference_layer.node.range());
2117 }
2118 }
2119
2120 #[gpui::test(iterations = 50)]
2121 fn test_random_syntax_map_edits_with_combined_injections(mut rng: StdRng) {
2122 let operations = env::var("OPERATIONS")
2123 .map(|i| i.parse().expect("invalid `OPERATIONS` variable"))
2124 .unwrap_or(10);
2125
2126 let text = r#"
2127 <div id="main">
2128 <% if one?(:two) %>
2129 <p class="three" four>
2130 <%= yield :five %>
2131 </p>
2132 <% elsif Six.seven(8) %>
2133 <p id="three" four>
2134 <%= yield :five %>
2135 </p>
2136 <% else %>
2137 <span>Ok</span>
2138 <% end %>
2139 </div>
2140 "#
2141 .unindent()
2142 .repeat(8);
2143
2144 let registry = Arc::new(LanguageRegistry::test());
2145 let language = Arc::new(erb_lang());
2146 registry.add(language.clone());
2147 registry.add(Arc::new(ruby_lang()));
2148 registry.add(Arc::new(html_lang()));
2149 let mut buffer = Buffer::new(0, 0, text);
2150
2151 let mut syntax_map = SyntaxMap::new();
2152 syntax_map.set_language_registry(registry.clone());
2153 syntax_map.reparse(language.clone(), &buffer);
2154
2155 let mut reference_syntax_map = SyntaxMap::new();
2156 reference_syntax_map.set_language_registry(registry.clone());
2157
2158 log::info!("initial text:\n{}", buffer.text());
2159
2160 for _ in 0..operations {
2161 let prev_buffer = buffer.snapshot();
2162 let prev_syntax_map = syntax_map.snapshot();
2163
2164 buffer.randomly_edit(&mut rng, 3);
2165 log::info!("text:\n{}", buffer.text());
2166
2167 syntax_map.interpolate(&buffer);
2168 check_interpolation(&prev_syntax_map, &syntax_map, &prev_buffer, &buffer);
2169
2170 syntax_map.reparse(language.clone(), &buffer);
2171
2172 reference_syntax_map.clear();
2173 reference_syntax_map.reparse(language.clone(), &buffer);
2174 }
2175
2176 for i in 0..operations {
2177 let i = operations - i - 1;
2178 buffer.undo();
2179 log::info!("undoing operation {}", i);
2180 log::info!("text:\n{}", buffer.text());
2181
2182 syntax_map.interpolate(&buffer);
2183 syntax_map.reparse(language.clone(), &buffer);
2184
2185 reference_syntax_map.clear();
2186 reference_syntax_map.reparse(language.clone(), &buffer);
2187 assert_eq!(
2188 syntax_map.layers(&buffer).len(),
2189 reference_syntax_map.layers(&buffer).len(),
2190 "wrong number of layers after undoing edit {i}"
2191 );
2192 }
2193
2194 let layers = syntax_map.layers(&buffer);
2195 let reference_layers = reference_syntax_map.layers(&buffer);
2196 for (edited_layer, reference_layer) in layers.into_iter().zip(reference_layers.into_iter())
2197 {
2198 assert_eq!(edited_layer.node.to_sexp(), reference_layer.node.to_sexp());
2199 assert_eq!(edited_layer.node.range(), reference_layer.node.range());
2200 }
2201 }
2202
2203 fn check_interpolation(
2204 old_syntax_map: &SyntaxSnapshot,
2205 new_syntax_map: &SyntaxSnapshot,
2206 old_buffer: &BufferSnapshot,
2207 new_buffer: &BufferSnapshot,
2208 ) {
2209 let edits = new_buffer
2210 .edits_since::<usize>(&old_buffer.version())
2211 .collect::<Vec<_>>();
2212
2213 for (old_layer, new_layer) in old_syntax_map
2214 .layers
2215 .iter()
2216 .zip(new_syntax_map.layers.iter())
2217 {
2218 assert_eq!(old_layer.range, new_layer.range);
2219 let old_start_byte = old_layer.range.start.to_offset(old_buffer);
2220 let new_start_byte = new_layer.range.start.to_offset(new_buffer);
2221 let old_start_point = old_layer.range.start.to_point(old_buffer).to_ts_point();
2222 let new_start_point = new_layer.range.start.to_point(new_buffer).to_ts_point();
2223 let old_node = old_layer
2224 .tree
2225 .root_node_with_offset(old_start_byte, old_start_point);
2226 let new_node = new_layer
2227 .tree
2228 .root_node_with_offset(new_start_byte, new_start_point);
2229 check_node_edits(
2230 old_layer.depth,
2231 &old_layer.range,
2232 old_node,
2233 new_node,
2234 old_buffer,
2235 new_buffer,
2236 &edits,
2237 );
2238 }
2239
2240 fn check_node_edits(
2241 depth: usize,
2242 range: &Range<Anchor>,
2243 old_node: Node,
2244 new_node: Node,
2245 old_buffer: &BufferSnapshot,
2246 new_buffer: &BufferSnapshot,
2247 edits: &[text::Edit<usize>],
2248 ) {
2249 assert_eq!(old_node.kind(), new_node.kind());
2250
2251 let old_range = old_node.byte_range();
2252 let new_range = new_node.byte_range();
2253
2254 let is_edited = edits
2255 .iter()
2256 .any(|edit| edit.new.start < new_range.end && edit.new.end > new_range.start);
2257 if is_edited {
2258 assert!(
2259 new_node.has_changes(),
2260 concat!(
2261 "failed to mark node as edited.\n",
2262 "layer depth: {}, old layer range: {:?}, new layer range: {:?},\n",
2263 "node kind: {}, old node range: {:?}, new node range: {:?}",
2264 ),
2265 depth,
2266 range.to_offset(old_buffer),
2267 range.to_offset(new_buffer),
2268 new_node.kind(),
2269 old_range,
2270 new_range,
2271 );
2272 }
2273
2274 if !new_node.has_changes() {
2275 assert_eq!(
2276 old_buffer
2277 .text_for_range(old_range.clone())
2278 .collect::<String>(),
2279 new_buffer
2280 .text_for_range(new_range.clone())
2281 .collect::<String>(),
2282 concat!(
2283 "mismatched text for node\n",
2284 "layer depth: {}, old layer range: {:?}, new layer range: {:?},\n",
2285 "node kind: {}, old node range:{:?}, new node range:{:?}",
2286 ),
2287 depth,
2288 range.to_offset(old_buffer),
2289 range.to_offset(new_buffer),
2290 new_node.kind(),
2291 old_range,
2292 new_range,
2293 );
2294 }
2295
2296 for i in 0..new_node.child_count() {
2297 check_node_edits(
2298 depth,
2299 range,
2300 old_node.child(i).unwrap(),
2301 new_node.child(i).unwrap(),
2302 old_buffer,
2303 new_buffer,
2304 edits,
2305 )
2306 }
2307 }
2308 }
2309
2310 fn test_edit_sequence(language_name: &str, steps: &[&str]) -> (Buffer, SyntaxMap) {
2311 let registry = Arc::new(LanguageRegistry::test());
2312 registry.add(Arc::new(rust_lang()));
2313 registry.add(Arc::new(ruby_lang()));
2314 registry.add(Arc::new(html_lang()));
2315 registry.add(Arc::new(erb_lang()));
2316 registry.add(Arc::new(markdown_lang()));
2317 let language = registry.language_for_name(language_name).unwrap();
2318 let mut buffer = Buffer::new(0, 0, Default::default());
2319
2320 let mut mutated_syntax_map = SyntaxMap::new();
2321 mutated_syntax_map.set_language_registry(registry.clone());
2322 mutated_syntax_map.reparse(language.clone(), &buffer);
2323
2324 for (i, marked_string) in steps.into_iter().enumerate() {
2325 buffer.edit_via_marked_text(&marked_string.unindent());
2326
2327 // Reparse the syntax map
2328 mutated_syntax_map.interpolate(&buffer);
2329 mutated_syntax_map.reparse(language.clone(), &buffer);
2330
2331 // Create a second syntax map from scratch
2332 let mut reference_syntax_map = SyntaxMap::new();
2333 reference_syntax_map.set_language_registry(registry.clone());
2334 reference_syntax_map.reparse(language.clone(), &buffer);
2335
2336 // Compare the mutated syntax map to the new syntax map
2337 let mutated_layers = mutated_syntax_map.layers(&buffer);
2338 let reference_layers = reference_syntax_map.layers(&buffer);
2339 assert_eq!(
2340 mutated_layers.len(),
2341 reference_layers.len(),
2342 "wrong number of layers at step {i}"
2343 );
2344 for (edited_layer, reference_layer) in
2345 mutated_layers.into_iter().zip(reference_layers.into_iter())
2346 {
2347 assert_eq!(
2348 edited_layer.node.to_sexp(),
2349 reference_layer.node.to_sexp(),
2350 "different layer at step {i}"
2351 );
2352 assert_eq!(
2353 edited_layer.node.range(),
2354 reference_layer.node.range(),
2355 "different layer at step {i}"
2356 );
2357 }
2358 }
2359
2360 (buffer, mutated_syntax_map)
2361 }
2362
2363 fn html_lang() -> Language {
2364 Language::new(
2365 LanguageConfig {
2366 name: "HTML".into(),
2367 path_suffixes: vec!["html".to_string()],
2368 ..Default::default()
2369 },
2370 Some(tree_sitter_html::language()),
2371 )
2372 .with_highlights_query(
2373 r#"
2374 (tag_name) @tag
2375 (erroneous_end_tag_name) @tag
2376 (attribute_name) @property
2377 "#,
2378 )
2379 .unwrap()
2380 }
2381
2382 fn ruby_lang() -> Language {
2383 Language::new(
2384 LanguageConfig {
2385 name: "Ruby".into(),
2386 path_suffixes: vec!["rb".to_string()],
2387 ..Default::default()
2388 },
2389 Some(tree_sitter_ruby::language()),
2390 )
2391 .with_highlights_query(
2392 r#"
2393 ["if" "do" "else" "end"] @keyword
2394 (instance_variable) @ivar
2395 "#,
2396 )
2397 .unwrap()
2398 }
2399
2400 fn erb_lang() -> Language {
2401 Language::new(
2402 LanguageConfig {
2403 name: "ERB".into(),
2404 path_suffixes: vec!["erb".to_string()],
2405 ..Default::default()
2406 },
2407 Some(tree_sitter_embedded_template::language()),
2408 )
2409 .with_highlights_query(
2410 r#"
2411 ["<%" "%>"] @keyword
2412 "#,
2413 )
2414 .unwrap()
2415 .with_injection_query(
2416 r#"
2417 ((code) @content
2418 (#set! "language" "ruby")
2419 (#set! "combined"))
2420
2421 ((content) @content
2422 (#set! "language" "html")
2423 (#set! "combined"))
2424 "#,
2425 )
2426 .unwrap()
2427 }
2428
2429 fn rust_lang() -> Language {
2430 Language::new(
2431 LanguageConfig {
2432 name: "Rust".into(),
2433 path_suffixes: vec!["rs".to_string()],
2434 ..Default::default()
2435 },
2436 Some(tree_sitter_rust::language()),
2437 )
2438 .with_highlights_query(
2439 r#"
2440 (field_identifier) @field
2441 (struct_expression) @struct
2442 "#,
2443 )
2444 .unwrap()
2445 .with_injection_query(
2446 r#"
2447 (macro_invocation
2448 (token_tree) @content
2449 (#set! "language" "rust"))
2450 "#,
2451 )
2452 .unwrap()
2453 }
2454
2455 fn markdown_lang() -> Language {
2456 Language::new(
2457 LanguageConfig {
2458 name: "Markdown".into(),
2459 path_suffixes: vec!["md".into()],
2460 ..Default::default()
2461 },
2462 Some(tree_sitter_markdown::language()),
2463 )
2464 .with_injection_query(
2465 r#"
2466 (fenced_code_block
2467 (info_string
2468 (language) @language)
2469 (code_fence_content) @content)
2470 "#,
2471 )
2472 .unwrap()
2473 }
2474
2475 fn range_for_text(buffer: &Buffer, text: &str) -> Range<usize> {
2476 let start = buffer.as_rope().to_string().find(text).unwrap();
2477 start..start + text.len()
2478 }
2479
2480 fn assert_layers_for_range(
2481 syntax_map: &SyntaxMap,
2482 buffer: &BufferSnapshot,
2483 range: Range<Point>,
2484 expected_layers: &[&str],
2485 ) {
2486 let layers = syntax_map
2487 .layers_for_range(range, &buffer)
2488 .collect::<Vec<_>>();
2489 assert_eq!(
2490 layers.len(),
2491 expected_layers.len(),
2492 "wrong number of layers"
2493 );
2494 for (i, (SyntaxLayerInfo { node, .. }, expected_s_exp)) in
2495 layers.iter().zip(expected_layers.iter()).enumerate()
2496 {
2497 let actual_s_exp = node.to_sexp();
2498 assert!(
2499 string_contains_sequence(
2500 &actual_s_exp,
2501 &expected_s_exp.split("...").collect::<Vec<_>>()
2502 ),
2503 "layer {i}:\n\nexpected: {expected_s_exp}\nactual: {actual_s_exp}",
2504 );
2505 }
2506 }
2507
2508 fn assert_capture_ranges(
2509 syntax_map: &SyntaxMap,
2510 buffer: &BufferSnapshot,
2511 highlight_query_capture_names: &[&str],
2512 marked_string: &str,
2513 ) {
2514 let mut actual_ranges = Vec::<Range<usize>>::new();
2515 let captures = syntax_map.captures(0..buffer.len(), buffer, |grammar| {
2516 grammar.highlights_query.as_ref()
2517 });
2518 let queries = captures
2519 .grammars()
2520 .iter()
2521 .map(|grammar| grammar.highlights_query.as_ref().unwrap())
2522 .collect::<Vec<_>>();
2523 for capture in captures {
2524 let name = &queries[capture.grammar_index].capture_names()[capture.index as usize];
2525 if highlight_query_capture_names.contains(&name.as_str()) {
2526 actual_ranges.push(capture.node.byte_range());
2527 }
2528 }
2529
2530 let (text, expected_ranges) = marked_text_ranges(&marked_string.unindent(), false);
2531 assert_eq!(text, buffer.text());
2532 assert_eq!(actual_ranges, expected_ranges);
2533 }
2534
2535 pub fn string_contains_sequence(text: &str, parts: &[&str]) -> bool {
2536 let mut last_part_end = 0;
2537 for part in parts {
2538 if let Some(start_ix) = text[last_part_end..].find(part) {
2539 last_part_end = start_ix + part.len();
2540 } else {
2541 return false;
2542 }
2543 }
2544 true
2545 }
2546}