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