1mod highlight_map;
   2mod language;
   3#[cfg(test)]
   4mod tests;
   5
   6pub use self::{
   7    highlight_map::{HighlightId, HighlightMap},
   8    language::{BracketPair, Language, LanguageConfig, LanguageRegistry},
   9};
  10use anyhow::{anyhow, Result};
  11pub use buffer::{Buffer as TextBuffer, *};
  12use clock::ReplicaId;
  13use futures::FutureExt as _;
  14use gpui::{AppContext, Entity, ModelContext, MutableAppContext, Task};
  15use lazy_static::lazy_static;
  16use parking_lot::Mutex;
  17use rpc::proto;
  18use similar::{ChangeTag, TextDiff};
  19use smol::future::yield_now;
  20use std::{
  21    any::Any,
  22    cell::RefCell,
  23    cmp,
  24    collections::{BTreeMap, HashMap, HashSet},
  25    ffi::OsString,
  26    future::Future,
  27    iter::Iterator,
  28    ops::{Deref, DerefMut, Range},
  29    path::{Path, PathBuf},
  30    str,
  31    sync::Arc,
  32    time::{Duration, Instant, SystemTime, UNIX_EPOCH},
  33};
  34use tree_sitter::{InputEdit, Parser, QueryCursor, Tree};
  35use util::TryFutureExt as _;
  36
  37thread_local! {
  38    static PARSER: RefCell<Parser> = RefCell::new(Parser::new());
  39}
  40
  41lazy_static! {
  42    static ref QUERY_CURSORS: Mutex<Vec<QueryCursor>> = Default::default();
  43}
  44
  45// TODO - Make this configurable
  46const INDENT_SIZE: u32 = 4;
  47
  48pub struct Buffer {
  49    text: TextBuffer,
  50    file: Option<Box<dyn File>>,
  51    saved_version: clock::Global,
  52    saved_mtime: SystemTime,
  53    language: Option<Arc<Language>>,
  54    autoindent_requests: Vec<Arc<AutoindentRequest>>,
  55    pending_autoindent: Option<Task<()>>,
  56    sync_parse_timeout: Duration,
  57    syntax_tree: Mutex<Option<SyntaxTree>>,
  58    parsing_in_background: bool,
  59    parse_count: usize,
  60    #[cfg(test)]
  61    operations: Vec<Operation>,
  62}
  63
  64pub struct Snapshot {
  65    text: buffer::Snapshot,
  66    tree: Option<Tree>,
  67    is_parsing: bool,
  68    language: Option<Arc<Language>>,
  69    query_cursor: QueryCursorHandle,
  70}
  71
  72#[derive(Clone, Debug, Eq, PartialEq)]
  73pub enum Event {
  74    Edited,
  75    Dirtied,
  76    Saved,
  77    FileHandleChanged,
  78    Reloaded,
  79    Reparsed,
  80    Closed,
  81}
  82
  83pub trait File {
  84    fn worktree_id(&self) -> usize;
  85
  86    fn entry_id(&self) -> Option<usize>;
  87
  88    fn mtime(&self) -> SystemTime;
  89
  90    fn path(&self) -> &Arc<Path>;
  91
  92    fn full_path(&self, cx: &AppContext) -> PathBuf;
  93
  94    /// Returns the last component of this handle's absolute path. If this handle refers to the root
  95    /// of its worktree, then this method will return the name of the worktree itself.
  96    fn file_name<'a>(&'a self, cx: &'a AppContext) -> Option<OsString>;
  97
  98    fn is_deleted(&self) -> bool;
  99
 100    fn save(
 101        &self,
 102        buffer_id: u64,
 103        text: Rope,
 104        version: clock::Global,
 105        cx: &mut MutableAppContext,
 106    ) -> Task<Result<(clock::Global, SystemTime)>>;
 107
 108    fn load_local(&self, cx: &AppContext) -> Option<Task<Result<String>>>;
 109
 110    fn buffer_updated(&self, buffer_id: u64, operation: Operation, cx: &mut MutableAppContext);
 111
 112    fn buffer_removed(&self, buffer_id: u64, cx: &mut MutableAppContext);
 113
 114    fn boxed_clone(&self) -> Box<dyn File>;
 115
 116    fn as_any(&self) -> &dyn Any;
 117}
 118
 119struct QueryCursorHandle(Option<QueryCursor>);
 120
 121#[derive(Clone)]
 122struct SyntaxTree {
 123    tree: Tree,
 124    version: clock::Global,
 125}
 126
 127#[derive(Clone)]
 128struct AutoindentRequest {
 129    selection_set_ids: HashSet<SelectionSetId>,
 130    before_edit: Snapshot,
 131    edited: AnchorSet,
 132    inserted: Option<AnchorRangeSet>,
 133}
 134
 135#[derive(Debug)]
 136struct IndentSuggestion {
 137    basis_row: u32,
 138    indent: bool,
 139}
 140
 141struct TextProvider<'a>(&'a Rope);
 142
 143struct Highlights<'a> {
 144    captures: tree_sitter::QueryCaptures<'a, 'a, TextProvider<'a>>,
 145    next_capture: Option<(tree_sitter::QueryMatch<'a, 'a>, usize)>,
 146    stack: Vec<(usize, HighlightId)>,
 147    highlight_map: HighlightMap,
 148}
 149
 150pub struct HighlightedChunks<'a> {
 151    range: Range<usize>,
 152    chunks: Chunks<'a>,
 153    highlights: Option<Highlights<'a>>,
 154}
 155
 156struct Diff {
 157    base_version: clock::Global,
 158    new_text: Arc<str>,
 159    changes: Vec<(ChangeTag, usize)>,
 160}
 161
 162impl Buffer {
 163    pub fn new<T: Into<Arc<str>>>(
 164        replica_id: ReplicaId,
 165        base_text: T,
 166        cx: &mut ModelContext<Self>,
 167    ) -> Self {
 168        Self::build(
 169            TextBuffer::new(
 170                replica_id,
 171                cx.model_id() as u64,
 172                History::new(base_text.into()),
 173            ),
 174            None,
 175            None,
 176            cx,
 177        )
 178    }
 179
 180    pub fn from_history(
 181        replica_id: ReplicaId,
 182        history: History,
 183        file: Option<Box<dyn File>>,
 184        language: Option<Arc<Language>>,
 185        cx: &mut ModelContext<Self>,
 186    ) -> Self {
 187        Self::build(
 188            TextBuffer::new(replica_id, cx.model_id() as u64, history),
 189            file,
 190            language,
 191            cx,
 192        )
 193    }
 194
 195    pub fn from_proto(
 196        replica_id: ReplicaId,
 197        message: proto::Buffer,
 198        file: Option<Box<dyn File>>,
 199        language: Option<Arc<Language>>,
 200        cx: &mut ModelContext<Self>,
 201    ) -> Result<Self> {
 202        Ok(Self::build(
 203            TextBuffer::from_proto(replica_id, message)?,
 204            file,
 205            language,
 206            cx,
 207        ))
 208    }
 209
 210    fn build(
 211        buffer: TextBuffer,
 212        file: Option<Box<dyn File>>,
 213        language: Option<Arc<Language>>,
 214        cx: &mut ModelContext<Self>,
 215    ) -> Self {
 216        let saved_mtime;
 217        if let Some(file) = file.as_ref() {
 218            saved_mtime = file.mtime();
 219        } else {
 220            saved_mtime = UNIX_EPOCH;
 221        }
 222
 223        let mut result = Self {
 224            text: buffer,
 225            saved_mtime,
 226            saved_version: clock::Global::new(),
 227            file,
 228            syntax_tree: Mutex::new(None),
 229            parsing_in_background: false,
 230            parse_count: 0,
 231            sync_parse_timeout: Duration::from_millis(1),
 232            autoindent_requests: Default::default(),
 233            pending_autoindent: Default::default(),
 234            language,
 235
 236            #[cfg(test)]
 237            operations: Default::default(),
 238        };
 239        result.reparse(cx);
 240        result
 241    }
 242
 243    pub fn snapshot(&self) -> Snapshot {
 244        Snapshot {
 245            text: self.text.snapshot(),
 246            tree: self.syntax_tree(),
 247            is_parsing: self.parsing_in_background,
 248            language: self.language.clone(),
 249            query_cursor: QueryCursorHandle::new(),
 250        }
 251    }
 252
 253    pub fn file(&self) -> Option<&dyn File> {
 254        self.file.as_deref()
 255    }
 256
 257    pub fn save(
 258        &mut self,
 259        cx: &mut ModelContext<Self>,
 260    ) -> Result<Task<Result<(clock::Global, SystemTime)>>> {
 261        let file = self
 262            .file
 263            .as_ref()
 264            .ok_or_else(|| anyhow!("buffer has no file"))?;
 265        let text = self.as_rope().clone();
 266        let version = self.version.clone();
 267        let save = file.save(self.remote_id(), text, version, cx.as_mut());
 268        Ok(cx.spawn(|this, mut cx| async move {
 269            let (version, mtime) = save.await?;
 270            this.update(&mut cx, |this, cx| {
 271                this.did_save(version.clone(), mtime, None, cx);
 272            });
 273            Ok((version, mtime))
 274        }))
 275    }
 276
 277    pub fn set_language(&mut self, language: Option<Arc<Language>>, cx: &mut ModelContext<Self>) {
 278        self.language = language;
 279        self.reparse(cx);
 280    }
 281
 282    pub fn did_save(
 283        &mut self,
 284        version: clock::Global,
 285        mtime: SystemTime,
 286        new_file: Option<Box<dyn File>>,
 287        cx: &mut ModelContext<Self>,
 288    ) {
 289        self.saved_mtime = mtime;
 290        self.saved_version = version;
 291        if let Some(new_file) = new_file {
 292            self.file = Some(new_file);
 293        }
 294        cx.emit(Event::Saved);
 295    }
 296
 297    pub fn file_updated(
 298        &mut self,
 299        new_file: Box<dyn File>,
 300        cx: &mut ModelContext<Self>,
 301    ) -> Option<Task<()>> {
 302        let old_file = self.file.as_ref()?;
 303        let mut file_changed = false;
 304        let mut task = None;
 305
 306        if new_file.path() != old_file.path() {
 307            file_changed = true;
 308        }
 309
 310        if new_file.is_deleted() {
 311            if !old_file.is_deleted() {
 312                file_changed = true;
 313                if !self.is_dirty() {
 314                    cx.emit(Event::Dirtied);
 315                }
 316            }
 317        } else {
 318            let new_mtime = new_file.mtime();
 319            if new_mtime != old_file.mtime() {
 320                file_changed = true;
 321
 322                if !self.is_dirty() {
 323                    task = Some(cx.spawn(|this, mut cx| {
 324                        async move {
 325                            let new_text = this.read_with(&cx, |this, cx| {
 326                                this.file.as_ref().and_then(|file| file.load_local(cx))
 327                            });
 328                            if let Some(new_text) = new_text {
 329                                let new_text = new_text.await?;
 330                                let diff = this
 331                                    .read_with(&cx, |this, cx| this.diff(new_text.into(), cx))
 332                                    .await;
 333                                this.update(&mut cx, |this, cx| {
 334                                    if this.apply_diff(diff, cx) {
 335                                        this.saved_version = this.version.clone();
 336                                        this.saved_mtime = new_mtime;
 337                                        cx.emit(Event::Reloaded);
 338                                    }
 339                                });
 340                            }
 341                            Ok(())
 342                        }
 343                        .log_err()
 344                        .map(drop)
 345                    }));
 346                }
 347            }
 348        }
 349
 350        if file_changed {
 351            cx.emit(Event::FileHandleChanged);
 352        }
 353        self.file = Some(new_file);
 354        task
 355    }
 356
 357    pub fn close(&mut self, cx: &mut ModelContext<Self>) {
 358        cx.emit(Event::Closed);
 359    }
 360
 361    pub fn language(&self) -> Option<&Arc<Language>> {
 362        self.language.as_ref()
 363    }
 364
 365    pub fn parse_count(&self) -> usize {
 366        self.parse_count
 367    }
 368
 369    fn syntax_tree(&self) -> Option<Tree> {
 370        if let Some(syntax_tree) = self.syntax_tree.lock().as_mut() {
 371            self.interpolate_tree(syntax_tree);
 372            Some(syntax_tree.tree.clone())
 373        } else {
 374            None
 375        }
 376    }
 377
 378    #[cfg(any(test, feature = "test-support"))]
 379    pub fn is_parsing(&self) -> bool {
 380        self.parsing_in_background
 381    }
 382
 383    #[cfg(test)]
 384    pub fn set_sync_parse_timeout(&mut self, timeout: Duration) {
 385        self.sync_parse_timeout = timeout;
 386    }
 387
 388    fn reparse(&mut self, cx: &mut ModelContext<Self>) -> bool {
 389        if self.parsing_in_background {
 390            return false;
 391        }
 392
 393        if let Some(language) = self.language.clone() {
 394            let old_tree = self.syntax_tree();
 395            let text = self.as_rope().clone();
 396            let parsed_version = self.version();
 397            let parse_task = cx.background().spawn({
 398                let language = language.clone();
 399                async move { Self::parse_text(&text, old_tree, &language) }
 400            });
 401
 402            match cx
 403                .background()
 404                .block_with_timeout(self.sync_parse_timeout, parse_task)
 405            {
 406                Ok(new_tree) => {
 407                    self.did_finish_parsing(new_tree, parsed_version, cx);
 408                    return true;
 409                }
 410                Err(parse_task) => {
 411                    self.parsing_in_background = true;
 412                    cx.spawn(move |this, mut cx| async move {
 413                        let new_tree = parse_task.await;
 414                        this.update(&mut cx, move |this, cx| {
 415                            let language_changed =
 416                                this.language.as_ref().map_or(true, |curr_language| {
 417                                    !Arc::ptr_eq(curr_language, &language)
 418                                });
 419                            let parse_again = this.version > parsed_version || language_changed;
 420                            this.parsing_in_background = false;
 421                            this.did_finish_parsing(new_tree, parsed_version, cx);
 422
 423                            if parse_again && this.reparse(cx) {
 424                                return;
 425                            }
 426                        });
 427                    })
 428                    .detach();
 429                }
 430            }
 431        }
 432        false
 433    }
 434
 435    fn parse_text(text: &Rope, old_tree: Option<Tree>, language: &Language) -> Tree {
 436        PARSER.with(|parser| {
 437            let mut parser = parser.borrow_mut();
 438            parser
 439                .set_language(language.grammar)
 440                .expect("incompatible grammar");
 441            let mut chunks = text.chunks_in_range(0..text.len());
 442            let tree = parser
 443                .parse_with(
 444                    &mut move |offset, _| {
 445                        chunks.seek(offset);
 446                        chunks.next().unwrap_or("").as_bytes()
 447                    },
 448                    old_tree.as_ref(),
 449                )
 450                .unwrap();
 451            tree
 452        })
 453    }
 454
 455    fn interpolate_tree(&self, tree: &mut SyntaxTree) {
 456        let mut delta = 0_isize;
 457        for edit in self.edits_since(tree.version.clone()) {
 458            let start_offset = (edit.old_bytes.start as isize + delta) as usize;
 459            let start_point = self.as_rope().to_point(start_offset);
 460            tree.tree.edit(&InputEdit {
 461                start_byte: start_offset,
 462                old_end_byte: start_offset + edit.deleted_bytes(),
 463                new_end_byte: start_offset + edit.inserted_bytes(),
 464                start_position: start_point.to_ts_point(),
 465                old_end_position: (start_point + edit.deleted_lines()).to_ts_point(),
 466                new_end_position: self
 467                    .as_rope()
 468                    .to_point(start_offset + edit.inserted_bytes())
 469                    .to_ts_point(),
 470            });
 471            delta += edit.inserted_bytes() as isize - edit.deleted_bytes() as isize;
 472        }
 473        tree.version = self.version();
 474    }
 475
 476    fn did_finish_parsing(
 477        &mut self,
 478        tree: Tree,
 479        version: clock::Global,
 480        cx: &mut ModelContext<Self>,
 481    ) {
 482        self.parse_count += 1;
 483        *self.syntax_tree.lock() = Some(SyntaxTree { tree, version });
 484        self.request_autoindent(cx);
 485        cx.emit(Event::Reparsed);
 486        cx.notify();
 487    }
 488
 489    fn request_autoindent(&mut self, cx: &mut ModelContext<Self>) {
 490        if let Some(indent_columns) = self.compute_autoindents() {
 491            let indent_columns = cx.background().spawn(indent_columns);
 492            match cx
 493                .background()
 494                .block_with_timeout(Duration::from_micros(500), indent_columns)
 495            {
 496                Ok(indent_columns) => self.apply_autoindents(indent_columns, cx),
 497                Err(indent_columns) => {
 498                    self.pending_autoindent = Some(cx.spawn(|this, mut cx| async move {
 499                        let indent_columns = indent_columns.await;
 500                        this.update(&mut cx, |this, cx| {
 501                            this.apply_autoindents(indent_columns, cx);
 502                        });
 503                    }));
 504                }
 505            }
 506        }
 507    }
 508
 509    fn compute_autoindents(&self) -> Option<impl Future<Output = BTreeMap<u32, u32>>> {
 510        let max_rows_between_yields = 100;
 511        let snapshot = self.snapshot();
 512        if snapshot.language.is_none()
 513            || snapshot.tree.is_none()
 514            || self.autoindent_requests.is_empty()
 515        {
 516            return None;
 517        }
 518
 519        let autoindent_requests = self.autoindent_requests.clone();
 520        Some(async move {
 521            let mut indent_columns = BTreeMap::new();
 522            for request in autoindent_requests {
 523                let old_to_new_rows = request
 524                    .edited
 525                    .to_points(&request.before_edit)
 526                    .map(|point| point.row)
 527                    .zip(request.edited.to_points(&snapshot).map(|point| point.row))
 528                    .collect::<BTreeMap<u32, u32>>();
 529
 530                let mut old_suggestions = HashMap::<u32, u32>::default();
 531                let old_edited_ranges =
 532                    contiguous_ranges(old_to_new_rows.keys().copied(), max_rows_between_yields);
 533                for old_edited_range in old_edited_ranges {
 534                    let suggestions = request
 535                        .before_edit
 536                        .suggest_autoindents(old_edited_range.clone())
 537                        .into_iter()
 538                        .flatten();
 539                    for (old_row, suggestion) in old_edited_range.zip(suggestions) {
 540                        let indentation_basis = old_to_new_rows
 541                            .get(&suggestion.basis_row)
 542                            .and_then(|from_row| old_suggestions.get(from_row).copied())
 543                            .unwrap_or_else(|| {
 544                                request
 545                                    .before_edit
 546                                    .indent_column_for_line(suggestion.basis_row)
 547                            });
 548                        let delta = if suggestion.indent { INDENT_SIZE } else { 0 };
 549                        old_suggestions.insert(
 550                            *old_to_new_rows.get(&old_row).unwrap(),
 551                            indentation_basis + delta,
 552                        );
 553                    }
 554                    yield_now().await;
 555                }
 556
 557                // At this point, old_suggestions contains the suggested indentation for all edited lines with respect to the state of the
 558                // buffer before the edit, but keyed by the row for these lines after the edits were applied.
 559                let new_edited_row_ranges =
 560                    contiguous_ranges(old_to_new_rows.values().copied(), max_rows_between_yields);
 561                for new_edited_row_range in new_edited_row_ranges {
 562                    let suggestions = snapshot
 563                        .suggest_autoindents(new_edited_row_range.clone())
 564                        .into_iter()
 565                        .flatten();
 566                    for (new_row, suggestion) in new_edited_row_range.zip(suggestions) {
 567                        let delta = if suggestion.indent { INDENT_SIZE } else { 0 };
 568                        let new_indentation = indent_columns
 569                            .get(&suggestion.basis_row)
 570                            .copied()
 571                            .unwrap_or_else(|| {
 572                                snapshot.indent_column_for_line(suggestion.basis_row)
 573                            })
 574                            + delta;
 575                        if old_suggestions
 576                            .get(&new_row)
 577                            .map_or(true, |old_indentation| new_indentation != *old_indentation)
 578                        {
 579                            indent_columns.insert(new_row, new_indentation);
 580                        }
 581                    }
 582                    yield_now().await;
 583                }
 584
 585                if let Some(inserted) = request.inserted.as_ref() {
 586                    let inserted_row_ranges = contiguous_ranges(
 587                        inserted
 588                            .to_point_ranges(&snapshot)
 589                            .flat_map(|range| range.start.row..range.end.row + 1),
 590                        max_rows_between_yields,
 591                    );
 592                    for inserted_row_range in inserted_row_ranges {
 593                        let suggestions = snapshot
 594                            .suggest_autoindents(inserted_row_range.clone())
 595                            .into_iter()
 596                            .flatten();
 597                        for (row, suggestion) in inserted_row_range.zip(suggestions) {
 598                            let delta = if suggestion.indent { INDENT_SIZE } else { 0 };
 599                            let new_indentation = indent_columns
 600                                .get(&suggestion.basis_row)
 601                                .copied()
 602                                .unwrap_or_else(|| {
 603                                    snapshot.indent_column_for_line(suggestion.basis_row)
 604                                })
 605                                + delta;
 606                            indent_columns.insert(row, new_indentation);
 607                        }
 608                        yield_now().await;
 609                    }
 610                }
 611            }
 612            indent_columns
 613        })
 614    }
 615
 616    fn apply_autoindents(
 617        &mut self,
 618        indent_columns: BTreeMap<u32, u32>,
 619        cx: &mut ModelContext<Self>,
 620    ) {
 621        let selection_set_ids = self
 622            .autoindent_requests
 623            .drain(..)
 624            .flat_map(|req| req.selection_set_ids.clone())
 625            .collect::<HashSet<_>>();
 626
 627        self.start_transaction(selection_set_ids.iter().copied())
 628            .unwrap();
 629        for (row, indent_column) in &indent_columns {
 630            self.set_indent_column_for_line(*row, *indent_column, cx);
 631        }
 632
 633        for selection_set_id in &selection_set_ids {
 634            if let Ok(set) = self.selection_set(*selection_set_id) {
 635                let new_selections = set
 636                    .selections
 637                    .iter()
 638                    .map(|selection| {
 639                        let start_point = selection.start.to_point(&self.text);
 640                        if start_point.column == 0 {
 641                            let end_point = selection.end.to_point(&self.text);
 642                            let delta = Point::new(
 643                                0,
 644                                indent_columns.get(&start_point.row).copied().unwrap_or(0),
 645                            );
 646                            if delta.column > 0 {
 647                                return Selection {
 648                                    id: selection.id,
 649                                    goal: selection.goal,
 650                                    reversed: selection.reversed,
 651                                    start: self
 652                                        .anchor_at(start_point + delta, selection.start.bias),
 653                                    end: self.anchor_at(end_point + delta, selection.end.bias),
 654                                };
 655                            }
 656                        }
 657                        selection.clone()
 658                    })
 659                    .collect::<Arc<[_]>>();
 660                self.update_selection_set(*selection_set_id, new_selections, cx)
 661                    .unwrap();
 662            }
 663        }
 664
 665        self.end_transaction(selection_set_ids.iter().copied(), cx)
 666            .unwrap();
 667    }
 668
 669    pub fn indent_column_for_line(&self, row: u32) -> u32 {
 670        self.content().indent_column_for_line(row)
 671    }
 672
 673    fn set_indent_column_for_line(&mut self, row: u32, column: u32, cx: &mut ModelContext<Self>) {
 674        let current_column = self.indent_column_for_line(row);
 675        if column > current_column {
 676            let offset = Point::new(row, 0).to_offset(&*self);
 677            self.edit(
 678                [offset..offset],
 679                " ".repeat((column - current_column) as usize),
 680                cx,
 681            );
 682        } else if column < current_column {
 683            self.edit(
 684                [Point::new(row, 0)..Point::new(row, current_column - column)],
 685                "",
 686                cx,
 687            );
 688        }
 689    }
 690
 691    pub fn range_for_syntax_ancestor<T: ToOffset>(&self, range: Range<T>) -> Option<Range<usize>> {
 692        if let Some(tree) = self.syntax_tree() {
 693            let root = tree.root_node();
 694            let range = range.start.to_offset(self)..range.end.to_offset(self);
 695            let mut node = root.descendant_for_byte_range(range.start, range.end);
 696            while node.map_or(false, |n| n.byte_range() == range) {
 697                node = node.unwrap().parent();
 698            }
 699            node.map(|n| n.byte_range())
 700        } else {
 701            None
 702        }
 703    }
 704
 705    pub fn enclosing_bracket_ranges<T: ToOffset>(
 706        &self,
 707        range: Range<T>,
 708    ) -> Option<(Range<usize>, Range<usize>)> {
 709        let (lang, tree) = self.language.as_ref().zip(self.syntax_tree())?;
 710        let open_capture_ix = lang.brackets_query.capture_index_for_name("open")?;
 711        let close_capture_ix = lang.brackets_query.capture_index_for_name("close")?;
 712
 713        // Find bracket pairs that *inclusively* contain the given range.
 714        let range = range.start.to_offset(self).saturating_sub(1)..range.end.to_offset(self) + 1;
 715        let mut cursor = QueryCursorHandle::new();
 716        let matches = cursor.set_byte_range(range).matches(
 717            &lang.brackets_query,
 718            tree.root_node(),
 719            TextProvider(self.as_rope()),
 720        );
 721
 722        // Get the ranges of the innermost pair of brackets.
 723        matches
 724            .filter_map(|mat| {
 725                let open = mat.nodes_for_capture_index(open_capture_ix).next()?;
 726                let close = mat.nodes_for_capture_index(close_capture_ix).next()?;
 727                Some((open.byte_range(), close.byte_range()))
 728            })
 729            .min_by_key(|(open_range, close_range)| close_range.end - open_range.start)
 730    }
 731
 732    fn diff(&self, new_text: Arc<str>, cx: &AppContext) -> Task<Diff> {
 733        // TODO: it would be nice to not allocate here.
 734        let old_text = self.text();
 735        let base_version = self.version();
 736        cx.background().spawn(async move {
 737            let changes = TextDiff::from_lines(old_text.as_str(), new_text.as_ref())
 738                .iter_all_changes()
 739                .map(|c| (c.tag(), c.value().len()))
 740                .collect::<Vec<_>>();
 741            Diff {
 742                base_version,
 743                new_text,
 744                changes,
 745            }
 746        })
 747    }
 748
 749    fn apply_diff(&mut self, diff: Diff, cx: &mut ModelContext<Self>) -> bool {
 750        if self.version == diff.base_version {
 751            self.start_transaction(None).unwrap();
 752            let mut offset = 0;
 753            for (tag, len) in diff.changes {
 754                let range = offset..(offset + len);
 755                match tag {
 756                    ChangeTag::Equal => offset += len,
 757                    ChangeTag::Delete => self.edit(Some(range), "", cx),
 758                    ChangeTag::Insert => {
 759                        self.edit(Some(offset..offset), &diff.new_text[range], cx);
 760                        offset += len;
 761                    }
 762                }
 763            }
 764            self.end_transaction(None, cx).unwrap();
 765            true
 766        } else {
 767            false
 768        }
 769    }
 770
 771    pub fn is_dirty(&self) -> bool {
 772        self.version > self.saved_version
 773            || self.file.as_ref().map_or(false, |file| file.is_deleted())
 774    }
 775
 776    pub fn has_conflict(&self) -> bool {
 777        self.version > self.saved_version
 778            && self
 779                .file
 780                .as_ref()
 781                .map_or(false, |file| file.mtime() > self.saved_mtime)
 782    }
 783
 784    pub fn start_transaction(
 785        &mut self,
 786        selection_set_ids: impl IntoIterator<Item = SelectionSetId>,
 787    ) -> Result<()> {
 788        self.start_transaction_at(selection_set_ids, Instant::now())
 789    }
 790
 791    fn start_transaction_at(
 792        &mut self,
 793        selection_set_ids: impl IntoIterator<Item = SelectionSetId>,
 794        now: Instant,
 795    ) -> Result<()> {
 796        self.text.start_transaction_at(selection_set_ids, now)
 797    }
 798
 799    pub fn end_transaction(
 800        &mut self,
 801        selection_set_ids: impl IntoIterator<Item = SelectionSetId>,
 802        cx: &mut ModelContext<Self>,
 803    ) -> Result<()> {
 804        self.end_transaction_at(selection_set_ids, Instant::now(), cx)
 805    }
 806
 807    fn end_transaction_at(
 808        &mut self,
 809        selection_set_ids: impl IntoIterator<Item = SelectionSetId>,
 810        now: Instant,
 811        cx: &mut ModelContext<Self>,
 812    ) -> Result<()> {
 813        if let Some(start_version) = self.text.end_transaction_at(selection_set_ids, now) {
 814            cx.notify();
 815            let was_dirty = start_version != self.saved_version;
 816            let edited = self.edits_since(start_version).next().is_some();
 817            if edited {
 818                self.did_edit(was_dirty, cx);
 819                self.reparse(cx);
 820            }
 821        }
 822        Ok(())
 823    }
 824
 825    pub fn edit<I, S, T>(&mut self, ranges_iter: I, new_text: T, cx: &mut ModelContext<Self>)
 826    where
 827        I: IntoIterator<Item = Range<S>>,
 828        S: ToOffset,
 829        T: Into<String>,
 830    {
 831        self.edit_internal(ranges_iter, new_text, false, cx)
 832    }
 833
 834    pub fn edit_with_autoindent<I, S, T>(
 835        &mut self,
 836        ranges_iter: I,
 837        new_text: T,
 838        cx: &mut ModelContext<Self>,
 839    ) where
 840        I: IntoIterator<Item = Range<S>>,
 841        S: ToOffset,
 842        T: Into<String>,
 843    {
 844        self.edit_internal(ranges_iter, new_text, true, cx)
 845    }
 846
 847    pub fn edit_internal<I, S, T>(
 848        &mut self,
 849        ranges_iter: I,
 850        new_text: T,
 851        autoindent: bool,
 852        cx: &mut ModelContext<Self>,
 853    ) where
 854        I: IntoIterator<Item = Range<S>>,
 855        S: ToOffset,
 856        T: Into<String>,
 857    {
 858        let new_text = new_text.into();
 859
 860        // Skip invalid ranges and coalesce contiguous ones.
 861        let mut ranges: Vec<Range<usize>> = Vec::new();
 862        for range in ranges_iter {
 863            let range = range.start.to_offset(&*self)..range.end.to_offset(&*self);
 864            if !new_text.is_empty() || !range.is_empty() {
 865                if let Some(prev_range) = ranges.last_mut() {
 866                    if prev_range.end >= range.start {
 867                        prev_range.end = cmp::max(prev_range.end, range.end);
 868                    } else {
 869                        ranges.push(range);
 870                    }
 871                } else {
 872                    ranges.push(range);
 873                }
 874            }
 875        }
 876        if ranges.is_empty() {
 877            return;
 878        }
 879
 880        self.start_transaction(None).unwrap();
 881        self.pending_autoindent.take();
 882        let autoindent_request = if autoindent && self.language.is_some() {
 883            let before_edit = self.snapshot();
 884            let edited = self.content().anchor_set(ranges.iter().filter_map(|range| {
 885                let start = range.start.to_point(&*self);
 886                if new_text.starts_with('\n') && start.column == self.line_len(start.row) {
 887                    None
 888                } else {
 889                    Some((range.start, Bias::Left))
 890                }
 891            }));
 892            Some((before_edit, edited))
 893        } else {
 894            None
 895        };
 896
 897        let first_newline_ix = new_text.find('\n');
 898        let new_text_len = new_text.len();
 899
 900        let edit = self.text.edit(ranges.iter().cloned(), new_text);
 901
 902        if let Some((before_edit, edited)) = autoindent_request {
 903            let mut inserted = None;
 904            if let Some(first_newline_ix) = first_newline_ix {
 905                let mut delta = 0isize;
 906                inserted = Some(self.content().anchor_range_set(ranges.iter().map(|range| {
 907                    let start = (delta + range.start as isize) as usize + first_newline_ix + 1;
 908                    let end = (delta + range.start as isize) as usize + new_text_len;
 909                    delta += (range.end as isize - range.start as isize) + new_text_len as isize;
 910                    (start, Bias::Left)..(end, Bias::Right)
 911                })));
 912            }
 913
 914            let selection_set_ids = self
 915                .text
 916                .peek_undo_stack()
 917                .unwrap()
 918                .starting_selection_set_ids()
 919                .collect();
 920            self.autoindent_requests.push(Arc::new(AutoindentRequest {
 921                selection_set_ids,
 922                before_edit,
 923                edited,
 924                inserted,
 925            }));
 926        }
 927
 928        self.end_transaction(None, cx).unwrap();
 929        self.send_operation(Operation::Edit(edit), cx);
 930    }
 931
 932    fn did_edit(&self, was_dirty: bool, cx: &mut ModelContext<Self>) {
 933        cx.emit(Event::Edited);
 934        if !was_dirty {
 935            cx.emit(Event::Dirtied);
 936        }
 937    }
 938
 939    pub fn add_selection_set(
 940        &mut self,
 941        selections: impl Into<Arc<[Selection]>>,
 942        cx: &mut ModelContext<Self>,
 943    ) -> SelectionSetId {
 944        let operation = self.text.add_selection_set(selections);
 945        if let Operation::UpdateSelections { set_id, .. } = &operation {
 946            let set_id = *set_id;
 947            cx.notify();
 948            self.send_operation(operation, cx);
 949            set_id
 950        } else {
 951            unreachable!()
 952        }
 953    }
 954
 955    pub fn update_selection_set(
 956        &mut self,
 957        set_id: SelectionSetId,
 958        selections: impl Into<Arc<[Selection]>>,
 959        cx: &mut ModelContext<Self>,
 960    ) -> Result<()> {
 961        let operation = self.text.update_selection_set(set_id, selections)?;
 962        cx.notify();
 963        self.send_operation(operation, cx);
 964        Ok(())
 965    }
 966
 967    pub fn set_active_selection_set(
 968        &mut self,
 969        set_id: Option<SelectionSetId>,
 970        cx: &mut ModelContext<Self>,
 971    ) -> Result<()> {
 972        let operation = self.text.set_active_selection_set(set_id)?;
 973        self.send_operation(operation, cx);
 974        Ok(())
 975    }
 976
 977    pub fn remove_selection_set(
 978        &mut self,
 979        set_id: SelectionSetId,
 980        cx: &mut ModelContext<Self>,
 981    ) -> Result<()> {
 982        let operation = self.text.remove_selection_set(set_id)?;
 983        cx.notify();
 984        self.send_operation(operation, cx);
 985        Ok(())
 986    }
 987
 988    pub fn apply_ops<I: IntoIterator<Item = Operation>>(
 989        &mut self,
 990        ops: I,
 991        cx: &mut ModelContext<Self>,
 992    ) -> Result<()> {
 993        self.pending_autoindent.take();
 994
 995        let was_dirty = self.is_dirty();
 996        let old_version = self.version.clone();
 997
 998        self.text.apply_ops(ops)?;
 999
1000        cx.notify();
1001        if self.edits_since(old_version).next().is_some() {
1002            self.did_edit(was_dirty, cx);
1003            self.reparse(cx);
1004        }
1005
1006        Ok(())
1007    }
1008
1009    #[cfg(not(test))]
1010    pub fn send_operation(&mut self, operation: Operation, cx: &mut ModelContext<Self>) {
1011        if let Some(file) = &self.file {
1012            file.buffer_updated(self.remote_id(), operation, cx.as_mut());
1013        }
1014    }
1015
1016    #[cfg(test)]
1017    pub fn send_operation(&mut self, operation: Operation, _: &mut ModelContext<Self>) {
1018        self.operations.push(operation);
1019    }
1020
1021    pub fn remove_peer(&mut self, replica_id: ReplicaId, cx: &mut ModelContext<Self>) {
1022        self.text.remove_peer(replica_id);
1023        cx.notify();
1024    }
1025
1026    pub fn undo(&mut self, cx: &mut ModelContext<Self>) {
1027        let was_dirty = self.is_dirty();
1028        let old_version = self.version.clone();
1029
1030        for operation in self.text.undo() {
1031            self.send_operation(operation, cx);
1032        }
1033
1034        cx.notify();
1035        if self.edits_since(old_version).next().is_some() {
1036            self.did_edit(was_dirty, cx);
1037            self.reparse(cx);
1038        }
1039    }
1040
1041    pub fn redo(&mut self, cx: &mut ModelContext<Self>) {
1042        let was_dirty = self.is_dirty();
1043        let old_version = self.version.clone();
1044
1045        for operation in self.text.redo() {
1046            self.send_operation(operation, cx);
1047        }
1048
1049        cx.notify();
1050        if self.edits_since(old_version).next().is_some() {
1051            self.did_edit(was_dirty, cx);
1052            self.reparse(cx);
1053        }
1054    }
1055}
1056
1057#[cfg(any(test, feature = "test-support"))]
1058impl Buffer {
1059    pub fn randomly_edit<T>(&mut self, rng: &mut T, old_range_count: usize)
1060    where
1061        T: rand::Rng,
1062    {
1063        self.text.randomly_edit(rng, old_range_count);
1064    }
1065
1066    pub fn randomly_mutate<T>(&mut self, rng: &mut T)
1067    where
1068        T: rand::Rng,
1069    {
1070        self.text.randomly_mutate(rng);
1071    }
1072}
1073
1074impl Entity for Buffer {
1075    type Event = Event;
1076
1077    fn release(&mut self, cx: &mut gpui::MutableAppContext) {
1078        if let Some(file) = self.file.as_ref() {
1079            file.buffer_removed(self.remote_id(), cx);
1080        }
1081    }
1082}
1083
1084impl Clone for Buffer {
1085    fn clone(&self) -> Self {
1086        Self {
1087            text: self.text.clone(),
1088            saved_version: self.saved_version.clone(),
1089            saved_mtime: self.saved_mtime,
1090            file: self.file.as_ref().map(|f| f.boxed_clone()),
1091            language: self.language.clone(),
1092            syntax_tree: Mutex::new(self.syntax_tree.lock().clone()),
1093            parsing_in_background: false,
1094            sync_parse_timeout: self.sync_parse_timeout,
1095            parse_count: self.parse_count,
1096            autoindent_requests: Default::default(),
1097            pending_autoindent: Default::default(),
1098
1099            #[cfg(test)]
1100            operations: self.operations.clone(),
1101        }
1102    }
1103}
1104
1105impl Deref for Buffer {
1106    type Target = TextBuffer;
1107
1108    fn deref(&self) -> &Self::Target {
1109        &self.text
1110    }
1111}
1112
1113impl<'a> From<&'a Buffer> for Content<'a> {
1114    fn from(buffer: &'a Buffer) -> Self {
1115        Self::from(&buffer.text)
1116    }
1117}
1118
1119impl<'a> From<&'a mut Buffer> for Content<'a> {
1120    fn from(buffer: &'a mut Buffer) -> Self {
1121        Self::from(&buffer.text)
1122    }
1123}
1124
1125impl<'a> From<&'a Snapshot> for Content<'a> {
1126    fn from(snapshot: &'a Snapshot) -> Self {
1127        Self::from(&snapshot.text)
1128    }
1129}
1130
1131impl Snapshot {
1132    fn suggest_autoindents<'a>(
1133        &'a self,
1134        row_range: Range<u32>,
1135    ) -> Option<impl Iterator<Item = IndentSuggestion> + 'a> {
1136        let mut query_cursor = QueryCursorHandle::new();
1137        if let Some((language, tree)) = self.language.as_ref().zip(self.tree.as_ref()) {
1138            let prev_non_blank_row = self.prev_non_blank_row(row_range.start);
1139
1140            // Get the "indentation ranges" that intersect this row range.
1141            let indent_capture_ix = language.indents_query.capture_index_for_name("indent");
1142            let end_capture_ix = language.indents_query.capture_index_for_name("end");
1143            query_cursor.set_point_range(
1144                Point::new(prev_non_blank_row.unwrap_or(row_range.start), 0).to_ts_point()
1145                    ..Point::new(row_range.end, 0).to_ts_point(),
1146            );
1147            let mut indentation_ranges = Vec::<(Range<Point>, &'static str)>::new();
1148            for mat in query_cursor.matches(
1149                &language.indents_query,
1150                tree.root_node(),
1151                TextProvider(self.as_rope()),
1152            ) {
1153                let mut node_kind = "";
1154                let mut start: Option<Point> = None;
1155                let mut end: Option<Point> = None;
1156                for capture in mat.captures {
1157                    if Some(capture.index) == indent_capture_ix {
1158                        node_kind = capture.node.kind();
1159                        start.get_or_insert(Point::from_ts_point(capture.node.start_position()));
1160                        end.get_or_insert(Point::from_ts_point(capture.node.end_position()));
1161                    } else if Some(capture.index) == end_capture_ix {
1162                        end = Some(Point::from_ts_point(capture.node.start_position().into()));
1163                    }
1164                }
1165
1166                if let Some((start, end)) = start.zip(end) {
1167                    if start.row == end.row {
1168                        continue;
1169                    }
1170
1171                    let range = start..end;
1172                    match indentation_ranges.binary_search_by_key(&range.start, |r| r.0.start) {
1173                        Err(ix) => indentation_ranges.insert(ix, (range, node_kind)),
1174                        Ok(ix) => {
1175                            let prev_range = &mut indentation_ranges[ix];
1176                            prev_range.0.end = prev_range.0.end.max(range.end);
1177                        }
1178                    }
1179                }
1180            }
1181
1182            let mut prev_row = prev_non_blank_row.unwrap_or(0);
1183            Some(row_range.map(move |row| {
1184                let row_start = Point::new(row, self.indent_column_for_line(row));
1185
1186                let mut indent_from_prev_row = false;
1187                let mut outdent_to_row = u32::MAX;
1188                for (range, _node_kind) in &indentation_ranges {
1189                    if range.start.row >= row {
1190                        break;
1191                    }
1192
1193                    if range.start.row == prev_row && range.end > row_start {
1194                        indent_from_prev_row = true;
1195                    }
1196                    if range.end.row >= prev_row && range.end <= row_start {
1197                        outdent_to_row = outdent_to_row.min(range.start.row);
1198                    }
1199                }
1200
1201                let suggestion = if outdent_to_row == prev_row {
1202                    IndentSuggestion {
1203                        basis_row: prev_row,
1204                        indent: false,
1205                    }
1206                } else if indent_from_prev_row {
1207                    IndentSuggestion {
1208                        basis_row: prev_row,
1209                        indent: true,
1210                    }
1211                } else if outdent_to_row < prev_row {
1212                    IndentSuggestion {
1213                        basis_row: outdent_to_row,
1214                        indent: false,
1215                    }
1216                } else {
1217                    IndentSuggestion {
1218                        basis_row: prev_row,
1219                        indent: false,
1220                    }
1221                };
1222
1223                prev_row = row;
1224                suggestion
1225            }))
1226        } else {
1227            None
1228        }
1229    }
1230
1231    fn prev_non_blank_row(&self, mut row: u32) -> Option<u32> {
1232        while row > 0 {
1233            row -= 1;
1234            if !self.is_line_blank(row) {
1235                return Some(row);
1236            }
1237        }
1238        None
1239    }
1240
1241    fn is_line_blank(&self, row: u32) -> bool {
1242        self.text_for_range(Point::new(row, 0)..Point::new(row, self.line_len(row)))
1243            .all(|chunk| chunk.matches(|c: char| !c.is_whitespace()).next().is_none())
1244    }
1245
1246    pub fn highlighted_text_for_range<T: ToOffset>(
1247        &mut self,
1248        range: Range<T>,
1249    ) -> HighlightedChunks {
1250        let range = range.start.to_offset(&*self)..range.end.to_offset(&*self);
1251        let chunks = self.text.as_rope().chunks_in_range(range.clone());
1252        if let Some((language, tree)) = self.language.as_ref().zip(self.tree.as_ref()) {
1253            let captures = self.query_cursor.set_byte_range(range.clone()).captures(
1254                &language.highlights_query,
1255                tree.root_node(),
1256                TextProvider(self.text.as_rope()),
1257            );
1258
1259            HighlightedChunks {
1260                range,
1261                chunks,
1262                highlights: Some(Highlights {
1263                    captures,
1264                    next_capture: None,
1265                    stack: Default::default(),
1266                    highlight_map: language.highlight_map(),
1267                }),
1268            }
1269        } else {
1270            HighlightedChunks {
1271                range,
1272                chunks,
1273                highlights: None,
1274            }
1275        }
1276    }
1277}
1278
1279impl Clone for Snapshot {
1280    fn clone(&self) -> Self {
1281        Self {
1282            text: self.text.clone(),
1283            tree: self.tree.clone(),
1284            is_parsing: self.is_parsing,
1285            language: self.language.clone(),
1286            query_cursor: QueryCursorHandle::new(),
1287        }
1288    }
1289}
1290
1291impl Deref for Snapshot {
1292    type Target = buffer::Snapshot;
1293
1294    fn deref(&self) -> &Self::Target {
1295        &self.text
1296    }
1297}
1298
1299impl<'a> tree_sitter::TextProvider<'a> for TextProvider<'a> {
1300    type I = ByteChunks<'a>;
1301
1302    fn text(&mut self, node: tree_sitter::Node) -> Self::I {
1303        ByteChunks(self.0.chunks_in_range(node.byte_range()))
1304    }
1305}
1306
1307struct ByteChunks<'a>(rope::Chunks<'a>);
1308
1309impl<'a> Iterator for ByteChunks<'a> {
1310    type Item = &'a [u8];
1311
1312    fn next(&mut self) -> Option<Self::Item> {
1313        self.0.next().map(str::as_bytes)
1314    }
1315}
1316
1317impl<'a> HighlightedChunks<'a> {
1318    pub fn seek(&mut self, offset: usize) {
1319        self.range.start = offset;
1320        self.chunks.seek(self.range.start);
1321        if let Some(highlights) = self.highlights.as_mut() {
1322            highlights
1323                .stack
1324                .retain(|(end_offset, _)| *end_offset > offset);
1325            if let Some((mat, capture_ix)) = &highlights.next_capture {
1326                let capture = mat.captures[*capture_ix as usize];
1327                if offset >= capture.node.start_byte() {
1328                    let next_capture_end = capture.node.end_byte();
1329                    if offset < next_capture_end {
1330                        highlights.stack.push((
1331                            next_capture_end,
1332                            highlights.highlight_map.get(capture.index),
1333                        ));
1334                    }
1335                    highlights.next_capture.take();
1336                }
1337            }
1338            highlights.captures.set_byte_range(self.range.clone());
1339        }
1340    }
1341
1342    pub fn offset(&self) -> usize {
1343        self.range.start
1344    }
1345}
1346
1347impl<'a> Iterator for HighlightedChunks<'a> {
1348    type Item = (&'a str, HighlightId);
1349
1350    fn next(&mut self) -> Option<Self::Item> {
1351        let mut next_capture_start = usize::MAX;
1352
1353        if let Some(highlights) = self.highlights.as_mut() {
1354            while let Some((parent_capture_end, _)) = highlights.stack.last() {
1355                if *parent_capture_end <= self.range.start {
1356                    highlights.stack.pop();
1357                } else {
1358                    break;
1359                }
1360            }
1361
1362            if highlights.next_capture.is_none() {
1363                highlights.next_capture = highlights.captures.next();
1364            }
1365
1366            while let Some((mat, capture_ix)) = highlights.next_capture.as_ref() {
1367                let capture = mat.captures[*capture_ix as usize];
1368                if self.range.start < capture.node.start_byte() {
1369                    next_capture_start = capture.node.start_byte();
1370                    break;
1371                } else {
1372                    let style_id = highlights.highlight_map.get(capture.index);
1373                    highlights.stack.push((capture.node.end_byte(), style_id));
1374                    highlights.next_capture = highlights.captures.next();
1375                }
1376            }
1377        }
1378
1379        if let Some(chunk) = self.chunks.peek() {
1380            let chunk_start = self.range.start;
1381            let mut chunk_end = (self.chunks.offset() + chunk.len()).min(next_capture_start);
1382            let mut style_id = HighlightId::default();
1383            if let Some((parent_capture_end, parent_style_id)) =
1384                self.highlights.as_ref().and_then(|h| h.stack.last())
1385            {
1386                chunk_end = chunk_end.min(*parent_capture_end);
1387                style_id = *parent_style_id;
1388            }
1389
1390            let slice =
1391                &chunk[chunk_start - self.chunks.offset()..chunk_end - self.chunks.offset()];
1392            self.range.start = chunk_end;
1393            if self.range.start == self.chunks.offset() + chunk.len() {
1394                self.chunks.next().unwrap();
1395            }
1396
1397            Some((slice, style_id))
1398        } else {
1399            None
1400        }
1401    }
1402}
1403
1404impl QueryCursorHandle {
1405    fn new() -> Self {
1406        QueryCursorHandle(Some(
1407            QUERY_CURSORS
1408                .lock()
1409                .pop()
1410                .unwrap_or_else(|| QueryCursor::new()),
1411        ))
1412    }
1413}
1414
1415impl Deref for QueryCursorHandle {
1416    type Target = QueryCursor;
1417
1418    fn deref(&self) -> &Self::Target {
1419        self.0.as_ref().unwrap()
1420    }
1421}
1422
1423impl DerefMut for QueryCursorHandle {
1424    fn deref_mut(&mut self) -> &mut Self::Target {
1425        self.0.as_mut().unwrap()
1426    }
1427}
1428
1429impl Drop for QueryCursorHandle {
1430    fn drop(&mut self) {
1431        let mut cursor = self.0.take().unwrap();
1432        cursor.set_byte_range(0..usize::MAX);
1433        cursor.set_point_range(Point::zero().to_ts_point()..Point::MAX.to_ts_point());
1434        QUERY_CURSORS.lock().push(cursor)
1435    }
1436}
1437
1438trait ToTreeSitterPoint {
1439    fn to_ts_point(self) -> tree_sitter::Point;
1440    fn from_ts_point(point: tree_sitter::Point) -> Self;
1441}
1442
1443impl ToTreeSitterPoint for Point {
1444    fn to_ts_point(self) -> tree_sitter::Point {
1445        tree_sitter::Point::new(self.row as usize, self.column as usize)
1446    }
1447
1448    fn from_ts_point(point: tree_sitter::Point) -> Self {
1449        Point::new(point.row as u32, point.column as u32)
1450    }
1451}
1452
1453fn contiguous_ranges(
1454    values: impl IntoIterator<Item = u32>,
1455    max_len: usize,
1456) -> impl Iterator<Item = Range<u32>> {
1457    let mut values = values.into_iter();
1458    let mut current_range: Option<Range<u32>> = None;
1459    std::iter::from_fn(move || loop {
1460        if let Some(value) = values.next() {
1461            if let Some(range) = &mut current_range {
1462                if value == range.end && range.len() < max_len {
1463                    range.end += 1;
1464                    continue;
1465                }
1466            }
1467
1468            let prev_range = current_range.clone();
1469            current_range = Some(value..(value + 1));
1470            if prev_range.is_some() {
1471                return prev_range;
1472            }
1473        } else {
1474            return current_range.take();
1475        }
1476    })
1477}