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