1mod anchor;
   2#[cfg(test)]
   3mod multi_buffer_tests;
   4mod position;
   5
   6pub use anchor::{Anchor, AnchorRangeExt, Offset};
   7pub use position::{TypedOffset, TypedPoint, TypedRow};
   8
   9use anyhow::{anyhow, Result};
  10use buffer_diff::{
  11    BufferDiff, BufferDiffEvent, BufferDiffSnapshot, DiffHunkSecondaryStatus, DiffHunkStatus,
  12    DiffHunkStatusKind,
  13};
  14use clock::ReplicaId;
  15use collections::{BTreeMap, Bound, HashMap, HashSet};
  16use futures::{channel::mpsc, SinkExt};
  17use gpui::{App, AppContext as _, Context, Entity, EntityId, EventEmitter, Task};
  18use itertools::Itertools;
  19use language::{
  20    language_settings::{language_settings, IndentGuideSettings, LanguageSettings},
  21    AutoindentMode, Buffer, BufferChunks, BufferRow, BufferSnapshot, Capability, CharClassifier,
  22    CharKind, Chunk, CursorShape, DiagnosticEntry, DiskState, File, IndentSize, Language,
  23    LanguageScope, OffsetRangeExt, OffsetUtf16, Outline, OutlineItem, Point, PointUtf16, Selection,
  24    TextDimension, TextObject, ToOffset as _, ToPoint as _, TransactionId, TreeSitterOptions,
  25    Unclipped,
  26};
  27
  28use rope::DimensionPair;
  29use smallvec::SmallVec;
  30use smol::future::yield_now;
  31use std::{
  32    any::type_name,
  33    borrow::Cow,
  34    cell::{Ref, RefCell},
  35    cmp, fmt,
  36    future::Future,
  37    io,
  38    iter::{self, FromIterator},
  39    mem,
  40    ops::{Range, RangeBounds, Sub},
  41    path::Path,
  42    str,
  43    sync::Arc,
  44    time::{Duration, Instant},
  45};
  46use sum_tree::{Bias, Cursor, SumTree, TreeMap};
  47use text::{
  48    locator::Locator,
  49    subscription::{Subscription, Topic},
  50    BufferId, Edit, LineIndent, TextSummary,
  51};
  52use theme::SyntaxTheme;
  53use util::post_inc;
  54
  55const NEWLINES: &[u8] = &[b'\n'; u8::MAX as usize];
  56
  57#[derive(Debug, Default, Clone, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
  58pub struct ExcerptId(usize);
  59
  60/// One or more [`Buffers`](Buffer) being edited in a single view.
  61///
  62/// See <https://zed.dev/features#multi-buffers>
  63pub struct MultiBuffer {
  64    /// A snapshot of the [`Excerpt`]s in the MultiBuffer.
  65    /// Use [`MultiBuffer::snapshot`] to get a up-to-date snapshot.
  66    snapshot: RefCell<MultiBufferSnapshot>,
  67    /// Contains the state of the buffers being edited
  68    buffers: RefCell<HashMap<BufferId, BufferState>>,
  69    // only used by consumers using `set_excerpts_for_buffer`
  70    buffers_by_path: BTreeMap<PathKey, Vec<ExcerptId>>,
  71    diffs: HashMap<BufferId, DiffState>,
  72    // all_diff_hunks_expanded: bool,
  73    subscriptions: Topic,
  74    /// If true, the multi-buffer only contains a single [`Buffer`] and a single [`Excerpt`]
  75    singleton: bool,
  76    history: History,
  77    title: Option<String>,
  78    capability: Capability,
  79}
  80
  81#[derive(Clone, Debug, PartialEq, Eq)]
  82pub enum MultiOrSingleBufferOffsetRange {
  83    Single(Range<usize>),
  84    Multi(Range<usize>),
  85}
  86
  87#[derive(Clone, Debug, PartialEq, Eq)]
  88pub enum Event {
  89    ExcerptsAdded {
  90        buffer: Entity<Buffer>,
  91        predecessor: ExcerptId,
  92        excerpts: Vec<(ExcerptId, ExcerptRange<language::Anchor>)>,
  93    },
  94    ExcerptsRemoved {
  95        ids: Vec<ExcerptId>,
  96    },
  97    ExcerptsExpanded {
  98        ids: Vec<ExcerptId>,
  99    },
 100    ExcerptsEdited {
 101        excerpt_ids: Vec<ExcerptId>,
 102        buffer_ids: Vec<BufferId>,
 103    },
 104    DiffHunksToggled,
 105    Edited {
 106        singleton_buffer_edited: bool,
 107        edited_buffer: Option<Entity<Buffer>>,
 108    },
 109    TransactionUndone {
 110        transaction_id: TransactionId,
 111    },
 112    Reloaded,
 113    ReloadNeeded,
 114
 115    LanguageChanged(BufferId),
 116    CapabilityChanged,
 117    Reparsed(BufferId),
 118    Saved,
 119    FileHandleChanged,
 120    Closed,
 121    Discarded,
 122    DirtyChanged,
 123    DiagnosticsUpdated,
 124}
 125
 126/// A diff hunk, representing a range of consequent lines in a multibuffer.
 127#[derive(Debug, Clone, PartialEq, Eq)]
 128pub struct MultiBufferDiffHunk {
 129    /// The row range in the multibuffer where this diff hunk appears.
 130    pub row_range: Range<MultiBufferRow>,
 131    /// The buffer ID that this hunk belongs to.
 132    pub buffer_id: BufferId,
 133    /// The range of the underlying buffer that this hunk corresponds to.
 134    pub buffer_range: Range<text::Anchor>,
 135    /// The excerpt that contains the diff hunk.
 136    pub excerpt_id: ExcerptId,
 137    /// The range within the buffer's diff base that this hunk corresponds to.
 138    pub diff_base_byte_range: Range<usize>,
 139    /// Whether or not this hunk also appears in the 'secondary diff'.
 140    pub secondary_status: DiffHunkSecondaryStatus,
 141}
 142
 143impl MultiBufferDiffHunk {
 144    pub fn status(&self) -> DiffHunkStatus {
 145        let kind = if self.buffer_range.start == self.buffer_range.end {
 146            DiffHunkStatusKind::Deleted
 147        } else if self.diff_base_byte_range.is_empty() {
 148            DiffHunkStatusKind::Added
 149        } else {
 150            DiffHunkStatusKind::Modified
 151        };
 152        DiffHunkStatus {
 153            kind,
 154            secondary: self.secondary_status,
 155        }
 156    }
 157}
 158
 159#[derive(PartialEq, Eq, Ord, PartialOrd, Clone, Hash, Debug)]
 160pub struct PathKey {
 161    namespace: &'static str,
 162    path: Arc<Path>,
 163}
 164
 165impl PathKey {
 166    pub fn namespaced(namespace: &'static str, path: Arc<Path>) -> Self {
 167        Self { namespace, path }
 168    }
 169
 170    pub fn path(&self) -> &Arc<Path> {
 171        &self.path
 172    }
 173}
 174
 175pub type MultiBufferPoint = Point;
 176type ExcerptOffset = TypedOffset<Excerpt>;
 177type ExcerptPoint = TypedPoint<Excerpt>;
 178
 179#[derive(Copy, Clone, Debug, Default, Eq, Ord, PartialOrd, PartialEq, Hash, serde::Deserialize)]
 180#[serde(transparent)]
 181pub struct MultiBufferRow(pub u32);
 182
 183impl MultiBufferRow {
 184    pub const MIN: Self = Self(0);
 185    pub const MAX: Self = Self(u32::MAX);
 186}
 187
 188impl std::ops::Add<usize> for MultiBufferRow {
 189    type Output = Self;
 190
 191    fn add(self, rhs: usize) -> Self::Output {
 192        MultiBufferRow(self.0 + rhs as u32)
 193    }
 194}
 195
 196#[derive(Clone)]
 197struct History {
 198    next_transaction_id: TransactionId,
 199    undo_stack: Vec<Transaction>,
 200    redo_stack: Vec<Transaction>,
 201    transaction_depth: usize,
 202    group_interval: Duration,
 203}
 204
 205#[derive(Clone)]
 206struct Transaction {
 207    id: TransactionId,
 208    buffer_transactions: HashMap<BufferId, text::TransactionId>,
 209    first_edit_at: Instant,
 210    last_edit_at: Instant,
 211    suppress_grouping: bool,
 212}
 213
 214pub trait ToOffset: 'static + fmt::Debug {
 215    fn to_offset(&self, snapshot: &MultiBufferSnapshot) -> usize;
 216}
 217
 218pub trait ToOffsetUtf16: 'static + fmt::Debug {
 219    fn to_offset_utf16(&self, snapshot: &MultiBufferSnapshot) -> OffsetUtf16;
 220}
 221
 222pub trait ToPoint: 'static + fmt::Debug {
 223    fn to_point(&self, snapshot: &MultiBufferSnapshot) -> Point;
 224}
 225
 226pub trait ToPointUtf16: 'static + fmt::Debug {
 227    fn to_point_utf16(&self, snapshot: &MultiBufferSnapshot) -> PointUtf16;
 228}
 229
 230struct BufferState {
 231    buffer: Entity<Buffer>,
 232    last_version: clock::Global,
 233    last_non_text_state_update_count: usize,
 234    excerpts: Vec<Locator>,
 235    _subscriptions: [gpui::Subscription; 2],
 236}
 237
 238struct DiffState {
 239    diff: Entity<BufferDiff>,
 240    _subscription: gpui::Subscription,
 241}
 242
 243impl DiffState {
 244    fn new(diff: Entity<BufferDiff>, cx: &mut Context<MultiBuffer>) -> Self {
 245        DiffState {
 246            _subscription: cx.subscribe(&diff, |this, diff, event, cx| match event {
 247                BufferDiffEvent::DiffChanged { changed_range } => {
 248                    if let Some(changed_range) = changed_range.clone() {
 249                        this.buffer_diff_changed(diff, changed_range, cx)
 250                    }
 251                }
 252                BufferDiffEvent::LanguageChanged => this.buffer_diff_language_changed(diff, cx),
 253            }),
 254            diff,
 255        }
 256    }
 257}
 258
 259/// The contents of a [`MultiBuffer`] at a single point in time.
 260#[derive(Clone, Default)]
 261pub struct MultiBufferSnapshot {
 262    singleton: bool,
 263    excerpts: SumTree<Excerpt>,
 264    excerpt_ids: SumTree<ExcerptIdMapping>,
 265    diffs: TreeMap<BufferId, BufferDiffSnapshot>,
 266    diff_transforms: SumTree<DiffTransform>,
 267    trailing_excerpt_update_count: usize,
 268    all_diff_hunks_expanded: bool,
 269    non_text_state_update_count: usize,
 270    edit_count: usize,
 271    is_dirty: bool,
 272    has_deleted_file: bool,
 273    has_conflict: bool,
 274    show_headers: bool,
 275}
 276
 277#[derive(Debug, Clone)]
 278enum DiffTransform {
 279    BufferContent {
 280        summary: TextSummary,
 281        inserted_hunk_info: Option<DiffTransformHunkInfo>,
 282    },
 283    DeletedHunk {
 284        summary: TextSummary,
 285        buffer_id: BufferId,
 286        hunk_info: DiffTransformHunkInfo,
 287        base_text_byte_range: Range<usize>,
 288        has_trailing_newline: bool,
 289    },
 290}
 291
 292#[derive(Clone, Copy, Debug)]
 293struct DiffTransformHunkInfo {
 294    excerpt_id: ExcerptId,
 295    hunk_start_anchor: text::Anchor,
 296    hunk_secondary_status: DiffHunkSecondaryStatus,
 297}
 298
 299impl Eq for DiffTransformHunkInfo {}
 300
 301impl PartialEq for DiffTransformHunkInfo {
 302    fn eq(&self, other: &DiffTransformHunkInfo) -> bool {
 303        self.excerpt_id == other.excerpt_id && self.hunk_start_anchor == other.hunk_start_anchor
 304    }
 305}
 306
 307impl std::hash::Hash for DiffTransformHunkInfo {
 308    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
 309        self.excerpt_id.hash(state);
 310        self.hunk_start_anchor.hash(state);
 311    }
 312}
 313
 314#[derive(Clone)]
 315pub struct ExcerptInfo {
 316    pub id: ExcerptId,
 317    pub buffer: BufferSnapshot,
 318    pub buffer_id: BufferId,
 319    pub range: ExcerptRange<text::Anchor>,
 320    pub end_row: MultiBufferRow,
 321}
 322
 323impl std::fmt::Debug for ExcerptInfo {
 324    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 325        f.debug_struct(type_name::<Self>())
 326            .field("id", &self.id)
 327            .field("buffer_id", &self.buffer_id)
 328            .field("path", &self.buffer.file().map(|f| f.path()))
 329            .field("range", &self.range)
 330            .finish()
 331    }
 332}
 333
 334/// A boundary between `Excerpt`s in a [`MultiBuffer`]
 335#[derive(Debug)]
 336pub struct ExcerptBoundary {
 337    pub prev: Option<ExcerptInfo>,
 338    pub next: Option<ExcerptInfo>,
 339    /// The row in the `MultiBuffer` where the boundary is located
 340    pub row: MultiBufferRow,
 341}
 342
 343impl ExcerptBoundary {
 344    pub fn starts_new_buffer(&self) -> bool {
 345        match (self.prev.as_ref(), self.next.as_ref()) {
 346            (None, _) => true,
 347            (Some(_), None) => false,
 348            (Some(prev), Some(next)) => prev.buffer_id != next.buffer_id,
 349        }
 350    }
 351}
 352
 353#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
 354pub struct RowInfo {
 355    pub buffer_id: Option<BufferId>,
 356    pub buffer_row: Option<u32>,
 357    pub multibuffer_row: Option<MultiBufferRow>,
 358    pub diff_status: Option<buffer_diff::DiffHunkStatus>,
 359}
 360
 361/// A slice into a [`Buffer`] that is being edited in a [`MultiBuffer`].
 362#[derive(Clone)]
 363struct Excerpt {
 364    /// The unique identifier for this excerpt
 365    id: ExcerptId,
 366    /// The location of the excerpt in the [`MultiBuffer`]
 367    locator: Locator,
 368    /// The buffer being excerpted
 369    buffer_id: BufferId,
 370    /// A snapshot of the buffer being excerpted
 371    buffer: BufferSnapshot,
 372    /// The range of the buffer to be shown in the excerpt
 373    range: ExcerptRange<text::Anchor>,
 374    /// The last row in the excerpted slice of the buffer
 375    max_buffer_row: BufferRow,
 376    /// A summary of the text in the excerpt
 377    text_summary: TextSummary,
 378    has_trailing_newline: bool,
 379}
 380
 381/// A public view into an `Excerpt` in a [`MultiBuffer`].
 382///
 383/// Contains methods for getting the [`Buffer`] of the excerpt,
 384/// as well as mapping offsets to/from buffer and multibuffer coordinates.
 385#[derive(Clone)]
 386pub struct MultiBufferExcerpt<'a> {
 387    excerpt: &'a Excerpt,
 388    diff_transforms:
 389        sum_tree::Cursor<'a, DiffTransform, (OutputDimension<usize>, ExcerptDimension<usize>)>,
 390    offset: usize,
 391    excerpt_offset: ExcerptDimension<usize>,
 392    buffer_offset: usize,
 393}
 394
 395#[derive(Clone, Debug)]
 396struct ExcerptIdMapping {
 397    id: ExcerptId,
 398    locator: Locator,
 399}
 400
 401/// A range of text from a single [`Buffer`], to be shown as an `Excerpt`.
 402/// These ranges are relative to the buffer itself
 403#[derive(Clone, Debug, Eq, PartialEq, Hash)]
 404pub struct ExcerptRange<T> {
 405    /// The full range of text to be shown in the excerpt.
 406    pub context: Range<T>,
 407    /// The primary range of text to be highlighted in the excerpt.
 408    /// In a multi-buffer search, this would be the text that matched the search
 409    pub primary: Option<Range<T>>,
 410}
 411
 412#[derive(Clone, Debug, Default)]
 413pub struct ExcerptSummary {
 414    excerpt_id: ExcerptId,
 415    /// The location of the last [`Excerpt`] being summarized
 416    excerpt_locator: Locator,
 417    widest_line_number: u32,
 418    text: TextSummary,
 419}
 420
 421#[derive(Debug, Clone)]
 422pub struct DiffTransformSummary {
 423    input: TextSummary,
 424    output: TextSummary,
 425}
 426
 427#[derive(Clone)]
 428pub struct MultiBufferRows<'a> {
 429    point: Point,
 430    is_empty: bool,
 431    cursor: MultiBufferCursor<'a, Point>,
 432}
 433
 434pub struct MultiBufferChunks<'a> {
 435    excerpts: Cursor<'a, Excerpt, ExcerptOffset>,
 436    diff_transforms: Cursor<'a, DiffTransform, (usize, ExcerptOffset)>,
 437    diffs: &'a TreeMap<BufferId, BufferDiffSnapshot>,
 438    diff_base_chunks: Option<(BufferId, BufferChunks<'a>)>,
 439    buffer_chunk: Option<Chunk<'a>>,
 440    range: Range<usize>,
 441    excerpt_offset_range: Range<ExcerptOffset>,
 442    excerpt_chunks: Option<ExcerptChunks<'a>>,
 443    language_aware: bool,
 444}
 445
 446pub struct ReversedMultiBufferChunks<'a> {
 447    cursor: MultiBufferCursor<'a, usize>,
 448    current_chunks: Option<rope::Chunks<'a>>,
 449    start: usize,
 450    offset: usize,
 451}
 452
 453pub struct MultiBufferBytes<'a> {
 454    range: Range<usize>,
 455    cursor: MultiBufferCursor<'a, usize>,
 456    excerpt_bytes: Option<text::Bytes<'a>>,
 457    has_trailing_newline: bool,
 458    chunk: &'a [u8],
 459}
 460
 461pub struct ReversedMultiBufferBytes<'a> {
 462    range: Range<usize>,
 463    chunks: ReversedMultiBufferChunks<'a>,
 464    chunk: &'a [u8],
 465}
 466
 467#[derive(Clone)]
 468struct MultiBufferCursor<'a, D: TextDimension> {
 469    excerpts: Cursor<'a, Excerpt, ExcerptDimension<D>>,
 470    diff_transforms: Cursor<'a, DiffTransform, (OutputDimension<D>, ExcerptDimension<D>)>,
 471    diffs: &'a TreeMap<BufferId, BufferDiffSnapshot>,
 472    cached_region: Option<MultiBufferRegion<'a, D>>,
 473}
 474
 475#[derive(Clone)]
 476struct MultiBufferRegion<'a, D: TextDimension> {
 477    buffer: &'a BufferSnapshot,
 478    is_main_buffer: bool,
 479    diff_hunk_status: Option<DiffHunkStatus>,
 480    excerpt: &'a Excerpt,
 481    buffer_range: Range<D>,
 482    range: Range<D>,
 483    has_trailing_newline: bool,
 484}
 485
 486struct ExcerptChunks<'a> {
 487    excerpt_id: ExcerptId,
 488    content_chunks: BufferChunks<'a>,
 489    footer_height: usize,
 490}
 491
 492#[derive(Debug)]
 493struct BufferEdit {
 494    range: Range<usize>,
 495    new_text: Arc<str>,
 496    is_insertion: bool,
 497    original_start_column: u32,
 498    excerpt_id: ExcerptId,
 499}
 500
 501#[derive(Clone, Copy, Debug, PartialEq)]
 502enum DiffChangeKind {
 503    BufferEdited,
 504    DiffUpdated { base_changed: bool },
 505    ExpandOrCollapseHunks { expand: bool },
 506}
 507
 508#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 509pub enum ExpandExcerptDirection {
 510    Up,
 511    Down,
 512    UpAndDown,
 513}
 514
 515impl ExpandExcerptDirection {
 516    pub fn should_expand_up(&self) -> bool {
 517        match self {
 518            ExpandExcerptDirection::Up => true,
 519            ExpandExcerptDirection::Down => false,
 520            ExpandExcerptDirection::UpAndDown => true,
 521        }
 522    }
 523
 524    pub fn should_expand_down(&self) -> bool {
 525        match self {
 526            ExpandExcerptDirection::Up => false,
 527            ExpandExcerptDirection::Down => true,
 528            ExpandExcerptDirection::UpAndDown => true,
 529        }
 530    }
 531}
 532
 533#[derive(Clone, Debug, PartialEq)]
 534pub struct IndentGuide {
 535    pub buffer_id: BufferId,
 536    pub start_row: MultiBufferRow,
 537    pub end_row: MultiBufferRow,
 538    pub depth: u32,
 539    pub tab_size: u32,
 540    pub settings: IndentGuideSettings,
 541}
 542
 543impl IndentGuide {
 544    pub fn indent_level(&self) -> u32 {
 545        self.depth * self.tab_size
 546    }
 547}
 548
 549impl MultiBuffer {
 550    pub fn new(capability: Capability) -> Self {
 551        Self {
 552            snapshot: RefCell::new(MultiBufferSnapshot {
 553                show_headers: true,
 554                ..MultiBufferSnapshot::default()
 555            }),
 556            buffers: RefCell::default(),
 557            diffs: HashMap::default(),
 558            subscriptions: Topic::default(),
 559            singleton: false,
 560            capability,
 561            title: None,
 562            buffers_by_path: Default::default(),
 563            history: History {
 564                next_transaction_id: clock::Lamport::default(),
 565                undo_stack: Vec::new(),
 566                redo_stack: Vec::new(),
 567                transaction_depth: 0,
 568                group_interval: Duration::from_millis(300),
 569            },
 570        }
 571    }
 572
 573    pub fn without_headers(capability: Capability) -> Self {
 574        Self {
 575            snapshot: Default::default(),
 576            buffers: Default::default(),
 577            buffers_by_path: Default::default(),
 578            diffs: HashMap::default(),
 579            subscriptions: Default::default(),
 580            singleton: false,
 581            capability,
 582            history: History {
 583                next_transaction_id: Default::default(),
 584                undo_stack: Default::default(),
 585                redo_stack: Default::default(),
 586                transaction_depth: 0,
 587                group_interval: Duration::from_millis(300),
 588            },
 589            title: Default::default(),
 590        }
 591    }
 592
 593    pub fn clone(&self, new_cx: &mut Context<Self>) -> Self {
 594        let mut buffers = HashMap::default();
 595        for (buffer_id, buffer_state) in self.buffers.borrow().iter() {
 596            buffers.insert(
 597                *buffer_id,
 598                BufferState {
 599                    buffer: buffer_state.buffer.clone(),
 600                    last_version: buffer_state.last_version.clone(),
 601                    last_non_text_state_update_count: buffer_state.last_non_text_state_update_count,
 602                    excerpts: buffer_state.excerpts.clone(),
 603                    _subscriptions: [
 604                        new_cx.observe(&buffer_state.buffer, |_, _, cx| cx.notify()),
 605                        new_cx.subscribe(&buffer_state.buffer, Self::on_buffer_event),
 606                    ],
 607                },
 608            );
 609        }
 610        let mut diff_bases = HashMap::default();
 611        for (buffer_id, diff) in self.diffs.iter() {
 612            diff_bases.insert(*buffer_id, DiffState::new(diff.diff.clone(), new_cx));
 613        }
 614        Self {
 615            snapshot: RefCell::new(self.snapshot.borrow().clone()),
 616            buffers: RefCell::new(buffers),
 617            buffers_by_path: Default::default(),
 618            diffs: diff_bases,
 619            subscriptions: Default::default(),
 620            singleton: self.singleton,
 621            capability: self.capability,
 622            history: self.history.clone(),
 623            title: self.title.clone(),
 624        }
 625    }
 626
 627    pub fn with_title(mut self, title: String) -> Self {
 628        self.title = Some(title);
 629        self
 630    }
 631
 632    pub fn read_only(&self) -> bool {
 633        self.capability == Capability::ReadOnly
 634    }
 635
 636    pub fn singleton(buffer: Entity<Buffer>, cx: &mut Context<Self>) -> Self {
 637        let mut this = Self::new(buffer.read(cx).capability());
 638        this.singleton = true;
 639        this.push_excerpts(
 640            buffer,
 641            [ExcerptRange {
 642                context: text::Anchor::MIN..text::Anchor::MAX,
 643                primary: None,
 644            }],
 645            cx,
 646        );
 647        this.snapshot.borrow_mut().singleton = true;
 648        this
 649    }
 650
 651    /// Returns an up-to-date snapshot of the MultiBuffer.
 652    pub fn snapshot(&self, cx: &App) -> MultiBufferSnapshot {
 653        self.sync(cx);
 654        self.snapshot.borrow().clone()
 655    }
 656
 657    pub fn read(&self, cx: &App) -> Ref<MultiBufferSnapshot> {
 658        self.sync(cx);
 659        self.snapshot.borrow()
 660    }
 661
 662    pub fn as_singleton(&self) -> Option<Entity<Buffer>> {
 663        if self.singleton {
 664            return Some(
 665                self.buffers
 666                    .borrow()
 667                    .values()
 668                    .next()
 669                    .unwrap()
 670                    .buffer
 671                    .clone(),
 672            );
 673        } else {
 674            None
 675        }
 676    }
 677
 678    pub fn is_singleton(&self) -> bool {
 679        self.singleton
 680    }
 681
 682    pub fn subscribe(&mut self) -> Subscription {
 683        self.subscriptions.subscribe()
 684    }
 685
 686    pub fn is_dirty(&self, cx: &App) -> bool {
 687        self.read(cx).is_dirty()
 688    }
 689
 690    pub fn has_deleted_file(&self, cx: &App) -> bool {
 691        self.read(cx).has_deleted_file()
 692    }
 693
 694    pub fn has_conflict(&self, cx: &App) -> bool {
 695        self.read(cx).has_conflict()
 696    }
 697
 698    // The `is_empty` signature doesn't match what clippy expects
 699    #[allow(clippy::len_without_is_empty)]
 700    pub fn len(&self, cx: &App) -> usize {
 701        self.read(cx).len()
 702    }
 703
 704    pub fn is_empty(&self) -> bool {
 705        self.buffers.borrow().is_empty()
 706    }
 707
 708    pub fn symbols_containing<T: ToOffset>(
 709        &self,
 710        offset: T,
 711        theme: Option<&SyntaxTheme>,
 712        cx: &App,
 713    ) -> Option<(BufferId, Vec<OutlineItem<Anchor>>)> {
 714        self.read(cx).symbols_containing(offset, theme)
 715    }
 716
 717    pub fn edit<I, S, T>(
 718        &self,
 719        edits: I,
 720        autoindent_mode: Option<AutoindentMode>,
 721        cx: &mut Context<Self>,
 722    ) where
 723        I: IntoIterator<Item = (Range<S>, T)>,
 724        S: ToOffset,
 725        T: Into<Arc<str>>,
 726    {
 727        let snapshot = self.read(cx);
 728        let edits = edits
 729            .into_iter()
 730            .map(|(range, new_text)| {
 731                let mut range = range.start.to_offset(&snapshot)..range.end.to_offset(&snapshot);
 732                if range.start > range.end {
 733                    mem::swap(&mut range.start, &mut range.end);
 734                }
 735                (range, new_text.into())
 736            })
 737            .collect::<Vec<_>>();
 738
 739        return edit_internal(self, snapshot, edits, autoindent_mode, cx);
 740
 741        // Non-generic part of edit, hoisted out to avoid blowing up LLVM IR.
 742        fn edit_internal(
 743            this: &MultiBuffer,
 744            snapshot: Ref<MultiBufferSnapshot>,
 745            edits: Vec<(Range<usize>, Arc<str>)>,
 746            mut autoindent_mode: Option<AutoindentMode>,
 747            cx: &mut Context<MultiBuffer>,
 748        ) {
 749            if this.read_only() || this.buffers.borrow().is_empty() {
 750                return;
 751            }
 752
 753            let original_start_columns = match &mut autoindent_mode {
 754                Some(AutoindentMode::Block {
 755                    original_start_columns,
 756                }) => mem::take(original_start_columns),
 757                _ => Default::default(),
 758            };
 759
 760            let (buffer_edits, edited_excerpt_ids) =
 761                this.convert_edits_to_buffer_edits(edits, &snapshot, &original_start_columns);
 762            drop(snapshot);
 763
 764            let mut buffer_ids = Vec::new();
 765            for (buffer_id, mut edits) in buffer_edits {
 766                buffer_ids.push(buffer_id);
 767                edits.sort_by_key(|edit| edit.range.start);
 768                this.buffers.borrow()[&buffer_id]
 769                    .buffer
 770                    .update(cx, |buffer, cx| {
 771                        let mut edits = edits.into_iter().peekable();
 772                        let mut insertions = Vec::new();
 773                        let mut original_indent_columns = Vec::new();
 774                        let mut deletions = Vec::new();
 775                        let empty_str: Arc<str> = Arc::default();
 776                        while let Some(BufferEdit {
 777                            mut range,
 778                            mut new_text,
 779                            mut is_insertion,
 780                            original_start_column: original_indent_column,
 781                            excerpt_id,
 782                        }) = edits.next()
 783                        {
 784                            while let Some(BufferEdit {
 785                                range: next_range,
 786                                is_insertion: next_is_insertion,
 787                                new_text: next_new_text,
 788                                excerpt_id: next_excerpt_id,
 789                                ..
 790                            }) = edits.peek()
 791                            {
 792                                if range.end >= next_range.start {
 793                                    range.end = cmp::max(next_range.end, range.end);
 794                                    is_insertion |= *next_is_insertion;
 795                                    if excerpt_id == *next_excerpt_id {
 796                                        new_text = format!("{new_text}{next_new_text}").into();
 797                                    }
 798                                    edits.next();
 799                                } else {
 800                                    break;
 801                                }
 802                            }
 803
 804                            if is_insertion {
 805                                original_indent_columns.push(original_indent_column);
 806                                insertions.push((
 807                                    buffer.anchor_before(range.start)
 808                                        ..buffer.anchor_before(range.end),
 809                                    new_text.clone(),
 810                                ));
 811                            } else if !range.is_empty() {
 812                                deletions.push((
 813                                    buffer.anchor_before(range.start)
 814                                        ..buffer.anchor_before(range.end),
 815                                    empty_str.clone(),
 816                                ));
 817                            }
 818                        }
 819
 820                        let deletion_autoindent_mode =
 821                            if let Some(AutoindentMode::Block { .. }) = autoindent_mode {
 822                                Some(AutoindentMode::Block {
 823                                    original_start_columns: Default::default(),
 824                                })
 825                            } else {
 826                                autoindent_mode.clone()
 827                            };
 828                        let insertion_autoindent_mode =
 829                            if let Some(AutoindentMode::Block { .. }) = autoindent_mode {
 830                                Some(AutoindentMode::Block {
 831                                    original_start_columns: original_indent_columns,
 832                                })
 833                            } else {
 834                                autoindent_mode.clone()
 835                            };
 836
 837                        buffer.edit(deletions, deletion_autoindent_mode, cx);
 838                        buffer.edit(insertions, insertion_autoindent_mode, cx);
 839                    })
 840            }
 841
 842            cx.emit(Event::ExcerptsEdited {
 843                excerpt_ids: edited_excerpt_ids,
 844                buffer_ids,
 845            });
 846        }
 847    }
 848
 849    fn convert_edits_to_buffer_edits(
 850        &self,
 851        edits: Vec<(Range<usize>, Arc<str>)>,
 852        snapshot: &MultiBufferSnapshot,
 853        original_start_columns: &[u32],
 854    ) -> (HashMap<BufferId, Vec<BufferEdit>>, Vec<ExcerptId>) {
 855        let mut buffer_edits: HashMap<BufferId, Vec<BufferEdit>> = Default::default();
 856        let mut edited_excerpt_ids = Vec::new();
 857        let mut cursor = snapshot.cursor::<usize>();
 858        for (ix, (range, new_text)) in edits.into_iter().enumerate() {
 859            let original_start_column = original_start_columns.get(ix).copied().unwrap_or(0);
 860
 861            cursor.seek(&range.start);
 862            let mut start_region = cursor.region().expect("start offset out of bounds");
 863            if !start_region.is_main_buffer {
 864                cursor.next();
 865                if let Some(region) = cursor.region() {
 866                    start_region = region;
 867                } else {
 868                    continue;
 869                }
 870            }
 871
 872            if range.end < start_region.range.start {
 873                continue;
 874            }
 875
 876            if range.end > start_region.range.end {
 877                cursor.seek_forward(&range.end);
 878            }
 879            let mut end_region = cursor.region().expect("end offset out of bounds");
 880            if !end_region.is_main_buffer {
 881                cursor.prev();
 882                if let Some(region) = cursor.region() {
 883                    end_region = region;
 884                } else {
 885                    continue;
 886                }
 887            }
 888
 889            if range.start > end_region.range.end {
 890                continue;
 891            }
 892
 893            let start_overshoot = range.start.saturating_sub(start_region.range.start);
 894            let end_overshoot = range.end.saturating_sub(end_region.range.start);
 895            let buffer_start = (start_region.buffer_range.start + start_overshoot)
 896                .min(start_region.buffer_range.end);
 897            let buffer_end =
 898                (end_region.buffer_range.start + end_overshoot).min(end_region.buffer_range.end);
 899
 900            if start_region.excerpt.id == end_region.excerpt.id {
 901                if start_region.is_main_buffer {
 902                    edited_excerpt_ids.push(start_region.excerpt.id);
 903                    buffer_edits
 904                        .entry(start_region.buffer.remote_id())
 905                        .or_default()
 906                        .push(BufferEdit {
 907                            range: buffer_start..buffer_end,
 908                            new_text,
 909                            is_insertion: true,
 910                            original_start_column,
 911                            excerpt_id: start_region.excerpt.id,
 912                        });
 913                }
 914            } else {
 915                let start_excerpt_range = buffer_start..start_region.buffer_range.end;
 916                let end_excerpt_range = end_region.buffer_range.start..buffer_end;
 917                if start_region.is_main_buffer {
 918                    edited_excerpt_ids.push(start_region.excerpt.id);
 919                    buffer_edits
 920                        .entry(start_region.buffer.remote_id())
 921                        .or_default()
 922                        .push(BufferEdit {
 923                            range: start_excerpt_range,
 924                            new_text: new_text.clone(),
 925                            is_insertion: true,
 926                            original_start_column,
 927                            excerpt_id: start_region.excerpt.id,
 928                        });
 929                }
 930                if end_region.is_main_buffer {
 931                    edited_excerpt_ids.push(end_region.excerpt.id);
 932                    buffer_edits
 933                        .entry(end_region.buffer.remote_id())
 934                        .or_default()
 935                        .push(BufferEdit {
 936                            range: end_excerpt_range,
 937                            new_text: new_text.clone(),
 938                            is_insertion: false,
 939                            original_start_column,
 940                            excerpt_id: end_region.excerpt.id,
 941                        });
 942                }
 943
 944                cursor.seek(&range.start);
 945                cursor.next_excerpt();
 946                while let Some(region) = cursor.region() {
 947                    if region.excerpt.id == end_region.excerpt.id {
 948                        break;
 949                    }
 950                    if region.is_main_buffer {
 951                        edited_excerpt_ids.push(region.excerpt.id);
 952                        buffer_edits
 953                            .entry(region.buffer.remote_id())
 954                            .or_default()
 955                            .push(BufferEdit {
 956                                range: region.buffer_range,
 957                                new_text: new_text.clone(),
 958                                is_insertion: false,
 959                                original_start_column,
 960                                excerpt_id: region.excerpt.id,
 961                            });
 962                    }
 963                    cursor.next_excerpt();
 964                }
 965            }
 966        }
 967        (buffer_edits, edited_excerpt_ids)
 968    }
 969
 970    pub fn autoindent_ranges<I, S>(&self, ranges: I, cx: &mut Context<Self>)
 971    where
 972        I: IntoIterator<Item = Range<S>>,
 973        S: ToOffset,
 974    {
 975        let snapshot = self.read(cx);
 976        let empty = Arc::<str>::from("");
 977        let edits = ranges
 978            .into_iter()
 979            .map(|range| {
 980                let mut range = range.start.to_offset(&snapshot)..range.end.to_offset(&snapshot);
 981                if range.start > range.end {
 982                    mem::swap(&mut range.start, &mut range.end);
 983                }
 984                (range, empty.clone())
 985            })
 986            .collect::<Vec<_>>();
 987
 988        return autoindent_ranges_internal(self, snapshot, edits, cx);
 989
 990        fn autoindent_ranges_internal(
 991            this: &MultiBuffer,
 992            snapshot: Ref<MultiBufferSnapshot>,
 993            edits: Vec<(Range<usize>, Arc<str>)>,
 994            cx: &mut Context<MultiBuffer>,
 995        ) {
 996            if this.read_only() || this.buffers.borrow().is_empty() {
 997                return;
 998            }
 999
1000            let (buffer_edits, edited_excerpt_ids) =
1001                this.convert_edits_to_buffer_edits(edits, &snapshot, &[]);
1002            drop(snapshot);
1003
1004            let mut buffer_ids = Vec::new();
1005            for (buffer_id, mut edits) in buffer_edits {
1006                buffer_ids.push(buffer_id);
1007                edits.sort_unstable_by_key(|edit| edit.range.start);
1008
1009                let mut ranges: Vec<Range<usize>> = Vec::new();
1010                for edit in edits {
1011                    if let Some(last_range) = ranges.last_mut() {
1012                        if edit.range.start <= last_range.end {
1013                            last_range.end = last_range.end.max(edit.range.end);
1014                            continue;
1015                        }
1016                    }
1017                    ranges.push(edit.range);
1018                }
1019
1020                this.buffers.borrow()[&buffer_id]
1021                    .buffer
1022                    .update(cx, |buffer, cx| {
1023                        buffer.autoindent_ranges(ranges, cx);
1024                    })
1025            }
1026
1027            cx.emit(Event::ExcerptsEdited {
1028                excerpt_ids: edited_excerpt_ids,
1029                buffer_ids,
1030            });
1031        }
1032    }
1033
1034    // Inserts newlines at the given position to create an empty line, returning the start of the new line.
1035    // You can also request the insertion of empty lines above and below the line starting at the returned point.
1036    // Panics if the given position is invalid.
1037    pub fn insert_empty_line(
1038        &mut self,
1039        position: impl ToPoint,
1040        space_above: bool,
1041        space_below: bool,
1042        cx: &mut Context<Self>,
1043    ) -> Point {
1044        let multibuffer_point = position.to_point(&self.read(cx));
1045        let (buffer, buffer_point, _) = self.point_to_buffer_point(multibuffer_point, cx).unwrap();
1046        self.start_transaction(cx);
1047        let empty_line_start = buffer.update(cx, |buffer, cx| {
1048            buffer.insert_empty_line(buffer_point, space_above, space_below, cx)
1049        });
1050        self.end_transaction(cx);
1051        multibuffer_point + (empty_line_start - buffer_point)
1052    }
1053
1054    pub fn start_transaction(&mut self, cx: &mut Context<Self>) -> Option<TransactionId> {
1055        self.start_transaction_at(Instant::now(), cx)
1056    }
1057
1058    pub fn start_transaction_at(
1059        &mut self,
1060        now: Instant,
1061        cx: &mut Context<Self>,
1062    ) -> Option<TransactionId> {
1063        if let Some(buffer) = self.as_singleton() {
1064            return buffer.update(cx, |buffer, _| buffer.start_transaction_at(now));
1065        }
1066
1067        for BufferState { buffer, .. } in self.buffers.borrow().values() {
1068            buffer.update(cx, |buffer, _| buffer.start_transaction_at(now));
1069        }
1070        self.history.start_transaction(now)
1071    }
1072
1073    pub fn end_transaction(&mut self, cx: &mut Context<Self>) -> Option<TransactionId> {
1074        self.end_transaction_at(Instant::now(), cx)
1075    }
1076
1077    pub fn end_transaction_at(
1078        &mut self,
1079        now: Instant,
1080        cx: &mut Context<Self>,
1081    ) -> Option<TransactionId> {
1082        if let Some(buffer) = self.as_singleton() {
1083            return buffer.update(cx, |buffer, cx| buffer.end_transaction_at(now, cx));
1084        }
1085
1086        let mut buffer_transactions = HashMap::default();
1087        for BufferState { buffer, .. } in self.buffers.borrow().values() {
1088            if let Some(transaction_id) =
1089                buffer.update(cx, |buffer, cx| buffer.end_transaction_at(now, cx))
1090            {
1091                buffer_transactions.insert(buffer.read(cx).remote_id(), transaction_id);
1092            }
1093        }
1094
1095        if self.history.end_transaction(now, buffer_transactions) {
1096            let transaction_id = self.history.group().unwrap();
1097            Some(transaction_id)
1098        } else {
1099            None
1100        }
1101    }
1102
1103    pub fn edited_ranges_for_transaction<D>(
1104        &self,
1105        transaction_id: TransactionId,
1106        cx: &App,
1107    ) -> Vec<Range<D>>
1108    where
1109        D: TextDimension + Ord + Sub<D, Output = D>,
1110    {
1111        let Some(transaction) = self.history.transaction(transaction_id) else {
1112            return Vec::new();
1113        };
1114
1115        let mut ranges = Vec::new();
1116        let snapshot = self.read(cx);
1117        let buffers = self.buffers.borrow();
1118        let mut cursor = snapshot.excerpts.cursor::<ExcerptSummary>(&());
1119
1120        for (buffer_id, buffer_transaction) in &transaction.buffer_transactions {
1121            let Some(buffer_state) = buffers.get(buffer_id) else {
1122                continue;
1123            };
1124
1125            let buffer = buffer_state.buffer.read(cx);
1126            for range in buffer.edited_ranges_for_transaction_id::<D>(*buffer_transaction) {
1127                for excerpt_id in &buffer_state.excerpts {
1128                    cursor.seek(excerpt_id, Bias::Left, &());
1129                    if let Some(excerpt) = cursor.item() {
1130                        if excerpt.locator == *excerpt_id {
1131                            let excerpt_buffer_start =
1132                                excerpt.range.context.start.summary::<D>(buffer);
1133                            let excerpt_buffer_end = excerpt.range.context.end.summary::<D>(buffer);
1134                            let excerpt_range = excerpt_buffer_start..excerpt_buffer_end;
1135                            if excerpt_range.contains(&range.start)
1136                                && excerpt_range.contains(&range.end)
1137                            {
1138                                let excerpt_start = D::from_text_summary(&cursor.start().text);
1139
1140                                let mut start = excerpt_start;
1141                                start.add_assign(&(range.start - excerpt_buffer_start));
1142                                let mut end = excerpt_start;
1143                                end.add_assign(&(range.end - excerpt_buffer_start));
1144
1145                                ranges.push(start..end);
1146                                break;
1147                            }
1148                        }
1149                    }
1150                }
1151            }
1152        }
1153
1154        ranges.sort_by_key(|range| range.start);
1155        ranges
1156    }
1157
1158    pub fn merge_transactions(
1159        &mut self,
1160        transaction: TransactionId,
1161        destination: TransactionId,
1162        cx: &mut Context<Self>,
1163    ) {
1164        if let Some(buffer) = self.as_singleton() {
1165            buffer.update(cx, |buffer, _| {
1166                buffer.merge_transactions(transaction, destination)
1167            });
1168        } else if let Some(transaction) = self.history.forget(transaction) {
1169            if let Some(destination) = self.history.transaction_mut(destination) {
1170                for (buffer_id, buffer_transaction_id) in transaction.buffer_transactions {
1171                    if let Some(destination_buffer_transaction_id) =
1172                        destination.buffer_transactions.get(&buffer_id)
1173                    {
1174                        if let Some(state) = self.buffers.borrow().get(&buffer_id) {
1175                            state.buffer.update(cx, |buffer, _| {
1176                                buffer.merge_transactions(
1177                                    buffer_transaction_id,
1178                                    *destination_buffer_transaction_id,
1179                                )
1180                            });
1181                        }
1182                    } else {
1183                        destination
1184                            .buffer_transactions
1185                            .insert(buffer_id, buffer_transaction_id);
1186                    }
1187                }
1188            }
1189        }
1190    }
1191
1192    pub fn finalize_last_transaction(&mut self, cx: &mut Context<Self>) {
1193        self.history.finalize_last_transaction();
1194        for BufferState { buffer, .. } in self.buffers.borrow().values() {
1195            buffer.update(cx, |buffer, _| {
1196                buffer.finalize_last_transaction();
1197            });
1198        }
1199    }
1200
1201    pub fn push_transaction<'a, T>(&mut self, buffer_transactions: T, cx: &Context<Self>)
1202    where
1203        T: IntoIterator<Item = (&'a Entity<Buffer>, &'a language::Transaction)>,
1204    {
1205        self.history
1206            .push_transaction(buffer_transactions, Instant::now(), cx);
1207        self.history.finalize_last_transaction();
1208    }
1209
1210    pub fn group_until_transaction(
1211        &mut self,
1212        transaction_id: TransactionId,
1213        cx: &mut Context<Self>,
1214    ) {
1215        if let Some(buffer) = self.as_singleton() {
1216            buffer.update(cx, |buffer, _| {
1217                buffer.group_until_transaction(transaction_id)
1218            });
1219        } else {
1220            self.history.group_until(transaction_id);
1221        }
1222    }
1223
1224    pub fn set_active_selections(
1225        &self,
1226        selections: &[Selection<Anchor>],
1227        line_mode: bool,
1228        cursor_shape: CursorShape,
1229        cx: &mut Context<Self>,
1230    ) {
1231        let mut selections_by_buffer: HashMap<BufferId, Vec<Selection<text::Anchor>>> =
1232            Default::default();
1233        let snapshot = self.read(cx);
1234        let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>(&());
1235        for selection in selections {
1236            let start_locator = snapshot.excerpt_locator_for_id(selection.start.excerpt_id);
1237            let end_locator = snapshot.excerpt_locator_for_id(selection.end.excerpt_id);
1238
1239            cursor.seek(&Some(start_locator), Bias::Left, &());
1240            while let Some(excerpt) = cursor.item() {
1241                if excerpt.locator > *end_locator {
1242                    break;
1243                }
1244
1245                let mut start = excerpt.range.context.start;
1246                let mut end = excerpt.range.context.end;
1247                if excerpt.id == selection.start.excerpt_id {
1248                    start = selection.start.text_anchor;
1249                }
1250                if excerpt.id == selection.end.excerpt_id {
1251                    end = selection.end.text_anchor;
1252                }
1253                selections_by_buffer
1254                    .entry(excerpt.buffer_id)
1255                    .or_default()
1256                    .push(Selection {
1257                        id: selection.id,
1258                        start,
1259                        end,
1260                        reversed: selection.reversed,
1261                        goal: selection.goal,
1262                    });
1263
1264                cursor.next(&());
1265            }
1266        }
1267
1268        for (buffer_id, buffer_state) in self.buffers.borrow().iter() {
1269            if !selections_by_buffer.contains_key(buffer_id) {
1270                buffer_state
1271                    .buffer
1272                    .update(cx, |buffer, cx| buffer.remove_active_selections(cx));
1273            }
1274        }
1275
1276        for (buffer_id, mut selections) in selections_by_buffer {
1277            self.buffers.borrow()[&buffer_id]
1278                .buffer
1279                .update(cx, |buffer, cx| {
1280                    selections.sort_unstable_by(|a, b| a.start.cmp(&b.start, buffer));
1281                    let mut selections = selections.into_iter().peekable();
1282                    let merged_selections = Arc::from_iter(iter::from_fn(|| {
1283                        let mut selection = selections.next()?;
1284                        while let Some(next_selection) = selections.peek() {
1285                            if selection.end.cmp(&next_selection.start, buffer).is_ge() {
1286                                let next_selection = selections.next().unwrap();
1287                                if next_selection.end.cmp(&selection.end, buffer).is_ge() {
1288                                    selection.end = next_selection.end;
1289                                }
1290                            } else {
1291                                break;
1292                            }
1293                        }
1294                        Some(selection)
1295                    }));
1296                    buffer.set_active_selections(merged_selections, line_mode, cursor_shape, cx);
1297                });
1298        }
1299    }
1300
1301    pub fn remove_active_selections(&self, cx: &mut Context<Self>) {
1302        for buffer in self.buffers.borrow().values() {
1303            buffer
1304                .buffer
1305                .update(cx, |buffer, cx| buffer.remove_active_selections(cx));
1306        }
1307    }
1308
1309    pub fn undo(&mut self, cx: &mut Context<Self>) -> Option<TransactionId> {
1310        let mut transaction_id = None;
1311        if let Some(buffer) = self.as_singleton() {
1312            transaction_id = buffer.update(cx, |buffer, cx| buffer.undo(cx));
1313        } else {
1314            while let Some(transaction) = self.history.pop_undo() {
1315                let mut undone = false;
1316                for (buffer_id, buffer_transaction_id) in &mut transaction.buffer_transactions {
1317                    if let Some(BufferState { buffer, .. }) = self.buffers.borrow().get(buffer_id) {
1318                        undone |= buffer.update(cx, |buffer, cx| {
1319                            let undo_to = *buffer_transaction_id;
1320                            if let Some(entry) = buffer.peek_undo_stack() {
1321                                *buffer_transaction_id = entry.transaction_id();
1322                            }
1323                            buffer.undo_to_transaction(undo_to, cx)
1324                        });
1325                    }
1326                }
1327
1328                if undone {
1329                    transaction_id = Some(transaction.id);
1330                    break;
1331                }
1332            }
1333        }
1334
1335        if let Some(transaction_id) = transaction_id {
1336            cx.emit(Event::TransactionUndone { transaction_id });
1337        }
1338
1339        transaction_id
1340    }
1341
1342    pub fn redo(&mut self, cx: &mut Context<Self>) -> Option<TransactionId> {
1343        if let Some(buffer) = self.as_singleton() {
1344            return buffer.update(cx, |buffer, cx| buffer.redo(cx));
1345        }
1346
1347        while let Some(transaction) = self.history.pop_redo() {
1348            let mut redone = false;
1349            for (buffer_id, buffer_transaction_id) in &mut transaction.buffer_transactions {
1350                if let Some(BufferState { buffer, .. }) = self.buffers.borrow().get(buffer_id) {
1351                    redone |= buffer.update(cx, |buffer, cx| {
1352                        let redo_to = *buffer_transaction_id;
1353                        if let Some(entry) = buffer.peek_redo_stack() {
1354                            *buffer_transaction_id = entry.transaction_id();
1355                        }
1356                        buffer.redo_to_transaction(redo_to, cx)
1357                    });
1358                }
1359            }
1360
1361            if redone {
1362                return Some(transaction.id);
1363            }
1364        }
1365
1366        None
1367    }
1368
1369    pub fn undo_transaction(&mut self, transaction_id: TransactionId, cx: &mut Context<Self>) {
1370        if let Some(buffer) = self.as_singleton() {
1371            buffer.update(cx, |buffer, cx| buffer.undo_transaction(transaction_id, cx));
1372        } else if let Some(transaction) = self.history.remove_from_undo(transaction_id) {
1373            for (buffer_id, transaction_id) in &transaction.buffer_transactions {
1374                if let Some(BufferState { buffer, .. }) = self.buffers.borrow().get(buffer_id) {
1375                    buffer.update(cx, |buffer, cx| {
1376                        buffer.undo_transaction(*transaction_id, cx)
1377                    });
1378                }
1379            }
1380        }
1381    }
1382
1383    pub fn forget_transaction(&mut self, transaction_id: TransactionId, cx: &mut Context<Self>) {
1384        if let Some(buffer) = self.as_singleton() {
1385            buffer.update(cx, |buffer, _| {
1386                buffer.forget_transaction(transaction_id);
1387            });
1388        } else if let Some(transaction) = self.history.forget(transaction_id) {
1389            for (buffer_id, buffer_transaction_id) in transaction.buffer_transactions {
1390                if let Some(state) = self.buffers.borrow_mut().get_mut(&buffer_id) {
1391                    state.buffer.update(cx, |buffer, _| {
1392                        buffer.forget_transaction(buffer_transaction_id);
1393                    });
1394                }
1395            }
1396        }
1397    }
1398
1399    pub fn push_excerpts<O>(
1400        &mut self,
1401        buffer: Entity<Buffer>,
1402        ranges: impl IntoIterator<Item = ExcerptRange<O>>,
1403        cx: &mut Context<Self>,
1404    ) -> Vec<ExcerptId>
1405    where
1406        O: text::ToOffset,
1407    {
1408        self.insert_excerpts_after(ExcerptId::max(), buffer, ranges, cx)
1409    }
1410
1411    pub fn push_excerpts_with_context_lines<O>(
1412        &mut self,
1413        buffer: Entity<Buffer>,
1414        ranges: Vec<Range<O>>,
1415        context_line_count: u32,
1416        cx: &mut Context<Self>,
1417    ) -> Vec<Range<Anchor>>
1418    where
1419        O: text::ToPoint + text::ToOffset,
1420    {
1421        let buffer_id = buffer.read(cx).remote_id();
1422        let buffer_snapshot = buffer.read(cx).snapshot();
1423        let (excerpt_ranges, range_counts) =
1424            build_excerpt_ranges(&buffer_snapshot, &ranges, context_line_count);
1425
1426        let excerpt_ids = self.push_excerpts(buffer, excerpt_ranges, cx);
1427
1428        let mut anchor_ranges = Vec::new();
1429        let mut ranges = ranges.into_iter();
1430        for (excerpt_id, range_count) in excerpt_ids.into_iter().zip(range_counts.into_iter()) {
1431            anchor_ranges.extend(ranges.by_ref().take(range_count).map(|range| {
1432                let start = Anchor {
1433                    buffer_id: Some(buffer_id),
1434                    excerpt_id,
1435                    text_anchor: buffer_snapshot.anchor_after(range.start),
1436                    diff_base_anchor: None,
1437                };
1438                let end = Anchor {
1439                    buffer_id: Some(buffer_id),
1440                    excerpt_id,
1441                    text_anchor: buffer_snapshot.anchor_after(range.end),
1442                    diff_base_anchor: None,
1443                };
1444                start..end
1445            }))
1446        }
1447        anchor_ranges
1448    }
1449
1450    pub fn location_for_path(&self, path: &PathKey, cx: &App) -> Option<Anchor> {
1451        let excerpt_id = self.buffers_by_path.get(path)?.first()?;
1452        let snapshot = self.snapshot(cx);
1453        let excerpt = snapshot.excerpt(*excerpt_id)?;
1454        Some(Anchor::in_buffer(
1455            *excerpt_id,
1456            excerpt.buffer_id,
1457            excerpt.range.context.start,
1458        ))
1459    }
1460
1461    pub fn excerpt_paths(&self) -> impl Iterator<Item = &PathKey> {
1462        self.buffers_by_path.keys()
1463    }
1464
1465    /// Sets excerpts, returns `true` if at least one new excerpt was added.
1466    pub fn set_excerpts_for_path(
1467        &mut self,
1468        path: PathKey,
1469        buffer: Entity<Buffer>,
1470        ranges: Vec<Range<Point>>,
1471        context_line_count: u32,
1472        cx: &mut Context<Self>,
1473    ) -> bool {
1474        let buffer_snapshot = buffer.update(cx, |buffer, _| buffer.snapshot());
1475
1476        let mut insert_after = self
1477            .buffers_by_path
1478            .range(..path.clone())
1479            .next_back()
1480            .map(|(_, value)| *value.last().unwrap())
1481            .unwrap_or(ExcerptId::min());
1482        let existing = self.buffers_by_path.get(&path).cloned().unwrap_or_default();
1483
1484        let (new, _) = build_excerpt_ranges(&buffer_snapshot, &ranges, context_line_count);
1485
1486        let mut new_iter = new.into_iter().peekable();
1487        let mut existing_iter = existing.into_iter().peekable();
1488
1489        let mut new_excerpt_ids = Vec::new();
1490        let mut to_remove = Vec::new();
1491        let mut to_insert = Vec::new();
1492        let mut added_a_new_excerpt = false;
1493        let snapshot = self.snapshot(cx);
1494
1495        let mut excerpts_cursor = snapshot.excerpts.cursor::<Option<&Locator>>(&());
1496        excerpts_cursor.next(&());
1497
1498        loop {
1499            let (new, existing) = match (new_iter.peek(), existing_iter.peek()) {
1500                (Some(new), Some(existing)) => (new, existing),
1501                (None, None) => break,
1502                (None, Some(_)) => {
1503                    to_remove.push(existing_iter.next().unwrap());
1504                    continue;
1505                }
1506                (Some(_), None) => {
1507                    added_a_new_excerpt = true;
1508                    to_insert.push(new_iter.next().unwrap());
1509                    continue;
1510                }
1511            };
1512            let locator = snapshot.excerpt_locator_for_id(*existing);
1513            excerpts_cursor.seek_forward(&Some(locator), Bias::Left, &());
1514            let existing_excerpt = excerpts_cursor.item().unwrap();
1515            if existing_excerpt.buffer_id != buffer_snapshot.remote_id() {
1516                to_remove.push(existing_iter.next().unwrap());
1517                to_insert.push(new_iter.next().unwrap());
1518                continue;
1519            }
1520
1521            let existing_start = existing_excerpt
1522                .range
1523                .context
1524                .start
1525                .to_point(&buffer_snapshot);
1526            let existing_end = existing_excerpt
1527                .range
1528                .context
1529                .end
1530                .to_point(&buffer_snapshot);
1531
1532            if existing_end < new.context.start {
1533                to_remove.push(existing_iter.next().unwrap());
1534                continue;
1535            } else if existing_start > new.context.end {
1536                to_insert.push(new_iter.next().unwrap());
1537                continue;
1538            }
1539
1540            // maybe merge overlapping excerpts?
1541            // it's hard to distinguish between a manually expanded excerpt, and one that
1542            // got smaller because of a missing diff.
1543            if existing_start == new.context.start && existing_end == new.context.end {
1544                new_excerpt_ids.append(&mut self.insert_excerpts_after(
1545                    insert_after,
1546                    buffer.clone(),
1547                    mem::take(&mut to_insert),
1548                    cx,
1549                ));
1550                insert_after = existing_iter.next().unwrap();
1551                new_excerpt_ids.push(insert_after);
1552                new_iter.next();
1553            } else {
1554                to_remove.push(existing_iter.next().unwrap());
1555                to_insert.push(new_iter.next().unwrap());
1556            }
1557        }
1558
1559        new_excerpt_ids.append(&mut self.insert_excerpts_after(
1560            insert_after,
1561            buffer,
1562            to_insert,
1563            cx,
1564        ));
1565        self.remove_excerpts(to_remove, cx);
1566        if new_excerpt_ids.is_empty() {
1567            self.buffers_by_path.remove(&path);
1568        } else {
1569            self.buffers_by_path.insert(path, new_excerpt_ids);
1570        }
1571
1572        added_a_new_excerpt
1573    }
1574
1575    pub fn paths(&self) -> impl Iterator<Item = PathKey> + '_ {
1576        self.buffers_by_path.keys().cloned()
1577    }
1578
1579    pub fn remove_excerpts_for_path(&mut self, path: PathKey, cx: &mut Context<Self>) {
1580        if let Some(to_remove) = self.buffers_by_path.remove(&path) {
1581            self.remove_excerpts(to_remove, cx)
1582        }
1583    }
1584
1585    pub fn push_multiple_excerpts_with_context_lines(
1586        &self,
1587        buffers_with_ranges: Vec<(Entity<Buffer>, Vec<Range<text::Anchor>>)>,
1588        context_line_count: u32,
1589        cx: &mut Context<Self>,
1590    ) -> Task<Vec<Range<Anchor>>> {
1591        use futures::StreamExt;
1592
1593        let (excerpt_ranges_tx, mut excerpt_ranges_rx) = mpsc::channel(256);
1594
1595        let mut buffer_ids = Vec::with_capacity(buffers_with_ranges.len());
1596
1597        for (buffer, ranges) in buffers_with_ranges {
1598            let (buffer_id, buffer_snapshot) =
1599                buffer.update(cx, |buffer, _| (buffer.remote_id(), buffer.snapshot()));
1600
1601            buffer_ids.push(buffer_id);
1602
1603            cx.background_spawn({
1604                let mut excerpt_ranges_tx = excerpt_ranges_tx.clone();
1605
1606                async move {
1607                    let (excerpt_ranges, counts) =
1608                        build_excerpt_ranges(&buffer_snapshot, &ranges, context_line_count);
1609                    excerpt_ranges_tx
1610                        .send((buffer_id, buffer.clone(), ranges, excerpt_ranges, counts))
1611                        .await
1612                        .ok();
1613                }
1614            })
1615            .detach()
1616        }
1617
1618        cx.spawn(move |this, mut cx| async move {
1619            let mut results_by_buffer_id = HashMap::default();
1620            while let Some((buffer_id, buffer, ranges, excerpt_ranges, range_counts)) =
1621                excerpt_ranges_rx.next().await
1622            {
1623                results_by_buffer_id
1624                    .insert(buffer_id, (buffer, ranges, excerpt_ranges, range_counts));
1625            }
1626
1627            let mut multi_buffer_ranges = Vec::default();
1628            'outer: for buffer_id in buffer_ids {
1629                let Some((buffer, ranges, excerpt_ranges, range_counts)) =
1630                    results_by_buffer_id.remove(&buffer_id)
1631                else {
1632                    continue;
1633                };
1634
1635                let mut ranges = ranges.into_iter();
1636                let mut range_counts = range_counts.into_iter();
1637                for excerpt_ranges in excerpt_ranges.chunks(100) {
1638                    let excerpt_ids = match this.update(&mut cx, |this, cx| {
1639                        this.push_excerpts(buffer.clone(), excerpt_ranges.iter().cloned(), cx)
1640                    }) {
1641                        Ok(excerpt_ids) => excerpt_ids,
1642                        Err(_) => continue 'outer,
1643                    };
1644
1645                    for (excerpt_id, range_count) in
1646                        excerpt_ids.into_iter().zip(range_counts.by_ref())
1647                    {
1648                        for range in ranges.by_ref().take(range_count) {
1649                            let start = Anchor {
1650                                buffer_id: Some(buffer_id),
1651                                excerpt_id,
1652                                text_anchor: range.start,
1653                                diff_base_anchor: None,
1654                            };
1655                            let end = Anchor {
1656                                buffer_id: Some(buffer_id),
1657                                excerpt_id,
1658                                text_anchor: range.end,
1659                                diff_base_anchor: None,
1660                            };
1661                            multi_buffer_ranges.push(start..end);
1662                        }
1663                    }
1664                }
1665            }
1666
1667            multi_buffer_ranges
1668        })
1669    }
1670
1671    pub fn insert_excerpts_after<O>(
1672        &mut self,
1673        prev_excerpt_id: ExcerptId,
1674        buffer: Entity<Buffer>,
1675        ranges: impl IntoIterator<Item = ExcerptRange<O>>,
1676        cx: &mut Context<Self>,
1677    ) -> Vec<ExcerptId>
1678    where
1679        O: text::ToOffset,
1680    {
1681        let mut ids = Vec::new();
1682        let mut next_excerpt_id =
1683            if let Some(last_entry) = self.snapshot.borrow().excerpt_ids.last() {
1684                last_entry.id.0 + 1
1685            } else {
1686                1
1687            };
1688        self.insert_excerpts_with_ids_after(
1689            prev_excerpt_id,
1690            buffer,
1691            ranges.into_iter().map(|range| {
1692                let id = ExcerptId(post_inc(&mut next_excerpt_id));
1693                ids.push(id);
1694                (id, range)
1695            }),
1696            cx,
1697        );
1698        ids
1699    }
1700
1701    pub fn insert_excerpts_with_ids_after<O>(
1702        &mut self,
1703        prev_excerpt_id: ExcerptId,
1704        buffer: Entity<Buffer>,
1705        ranges: impl IntoIterator<Item = (ExcerptId, ExcerptRange<O>)>,
1706        cx: &mut Context<Self>,
1707    ) where
1708        O: text::ToOffset,
1709    {
1710        assert_eq!(self.history.transaction_depth, 0);
1711        let mut ranges = ranges.into_iter().peekable();
1712        if ranges.peek().is_none() {
1713            return Default::default();
1714        }
1715
1716        self.sync(cx);
1717
1718        let buffer_id = buffer.read(cx).remote_id();
1719        let buffer_snapshot = buffer.read(cx).snapshot();
1720
1721        let mut buffers = self.buffers.borrow_mut();
1722        let buffer_state = buffers.entry(buffer_id).or_insert_with(|| BufferState {
1723            last_version: buffer_snapshot.version().clone(),
1724            last_non_text_state_update_count: buffer_snapshot.non_text_state_update_count(),
1725            excerpts: Default::default(),
1726            _subscriptions: [
1727                cx.observe(&buffer, |_, _, cx| cx.notify()),
1728                cx.subscribe(&buffer, Self::on_buffer_event),
1729            ],
1730            buffer: buffer.clone(),
1731        });
1732
1733        let mut snapshot = self.snapshot.borrow_mut();
1734
1735        let mut prev_locator = snapshot.excerpt_locator_for_id(prev_excerpt_id).clone();
1736        let mut new_excerpt_ids = mem::take(&mut snapshot.excerpt_ids);
1737        let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>(&());
1738        let mut new_excerpts = cursor.slice(&prev_locator, Bias::Right, &());
1739        prev_locator = cursor.start().unwrap_or(Locator::min_ref()).clone();
1740
1741        let edit_start = ExcerptOffset::new(new_excerpts.summary().text.len);
1742        new_excerpts.update_last(
1743            |excerpt| {
1744                excerpt.has_trailing_newline = true;
1745            },
1746            &(),
1747        );
1748
1749        let next_locator = if let Some(excerpt) = cursor.item() {
1750            excerpt.locator.clone()
1751        } else {
1752            Locator::max()
1753        };
1754
1755        let mut excerpts = Vec::new();
1756        while let Some((id, range)) = ranges.next() {
1757            let locator = Locator::between(&prev_locator, &next_locator);
1758            if let Err(ix) = buffer_state.excerpts.binary_search(&locator) {
1759                buffer_state.excerpts.insert(ix, locator.clone());
1760            }
1761            let range = ExcerptRange {
1762                context: buffer_snapshot.anchor_before(&range.context.start)
1763                    ..buffer_snapshot.anchor_after(&range.context.end),
1764                primary: range.primary.map(|primary| {
1765                    buffer_snapshot.anchor_before(&primary.start)
1766                        ..buffer_snapshot.anchor_after(&primary.end)
1767                }),
1768            };
1769            excerpts.push((id, range.clone()));
1770            let excerpt = Excerpt::new(
1771                id,
1772                locator.clone(),
1773                buffer_id,
1774                buffer_snapshot.clone(),
1775                range,
1776                ranges.peek().is_some() || cursor.item().is_some(),
1777            );
1778            new_excerpts.push(excerpt, &());
1779            prev_locator = locator.clone();
1780
1781            if let Some(last_mapping_entry) = new_excerpt_ids.last() {
1782                assert!(id > last_mapping_entry.id, "excerpt ids must be increasing");
1783            }
1784            new_excerpt_ids.push(ExcerptIdMapping { id, locator }, &());
1785        }
1786
1787        let edit_end = ExcerptOffset::new(new_excerpts.summary().text.len);
1788
1789        let suffix = cursor.suffix(&());
1790        let changed_trailing_excerpt = suffix.is_empty();
1791        new_excerpts.append(suffix, &());
1792        drop(cursor);
1793        snapshot.excerpts = new_excerpts;
1794        snapshot.excerpt_ids = new_excerpt_ids;
1795        if changed_trailing_excerpt {
1796            snapshot.trailing_excerpt_update_count += 1;
1797        }
1798
1799        self.sync_diff_transforms(
1800            &mut snapshot,
1801            vec![Edit {
1802                old: edit_start..edit_start,
1803                new: edit_start..edit_end,
1804            }],
1805            DiffChangeKind::BufferEdited,
1806        );
1807        cx.emit(Event::Edited {
1808            singleton_buffer_edited: false,
1809            edited_buffer: None,
1810        });
1811        cx.emit(Event::ExcerptsAdded {
1812            buffer,
1813            predecessor: prev_excerpt_id,
1814            excerpts,
1815        });
1816        cx.notify();
1817    }
1818
1819    pub fn clear(&mut self, cx: &mut Context<Self>) {
1820        self.sync(cx);
1821        let ids = self.excerpt_ids();
1822        self.buffers.borrow_mut().clear();
1823        let mut snapshot = self.snapshot.borrow_mut();
1824        let start = ExcerptOffset::new(0);
1825        let prev_len = ExcerptOffset::new(snapshot.excerpts.summary().text.len);
1826        snapshot.excerpts = Default::default();
1827        snapshot.trailing_excerpt_update_count += 1;
1828        snapshot.is_dirty = false;
1829        snapshot.has_deleted_file = false;
1830        snapshot.has_conflict = false;
1831
1832        self.sync_diff_transforms(
1833            &mut snapshot,
1834            vec![Edit {
1835                old: start..prev_len,
1836                new: start..start,
1837            }],
1838            DiffChangeKind::BufferEdited,
1839        );
1840        cx.emit(Event::Edited {
1841            singleton_buffer_edited: false,
1842            edited_buffer: None,
1843        });
1844        cx.emit(Event::ExcerptsRemoved { ids });
1845        cx.notify();
1846    }
1847
1848    pub fn excerpts_for_buffer(
1849        &self,
1850        buffer_id: BufferId,
1851        cx: &App,
1852    ) -> Vec<(ExcerptId, ExcerptRange<text::Anchor>)> {
1853        let mut excerpts = Vec::new();
1854        let snapshot = self.read(cx);
1855        let buffers = self.buffers.borrow();
1856        let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>(&());
1857        for locator in buffers
1858            .get(&buffer_id)
1859            .map(|state| &state.excerpts)
1860            .into_iter()
1861            .flatten()
1862        {
1863            cursor.seek_forward(&Some(locator), Bias::Left, &());
1864            if let Some(excerpt) = cursor.item() {
1865                if excerpt.locator == *locator {
1866                    excerpts.push((excerpt.id, excerpt.range.clone()));
1867                }
1868            }
1869        }
1870
1871        excerpts
1872    }
1873
1874    pub fn excerpt_ranges_for_buffer(&self, buffer_id: BufferId, cx: &App) -> Vec<Range<Point>> {
1875        let snapshot = self.read(cx);
1876        let buffers = self.buffers.borrow();
1877        let mut excerpts = snapshot
1878            .excerpts
1879            .cursor::<(Option<&Locator>, ExcerptDimension<Point>)>(&());
1880        let mut diff_transforms = snapshot
1881            .diff_transforms
1882            .cursor::<(ExcerptDimension<Point>, OutputDimension<Point>)>(&());
1883        diff_transforms.next(&());
1884        let locators = buffers
1885            .get(&buffer_id)
1886            .into_iter()
1887            .flat_map(|state| &state.excerpts);
1888        let mut result = Vec::new();
1889        for locator in locators {
1890            excerpts.seek_forward(&Some(locator), Bias::Left, &());
1891            if let Some(excerpt) = excerpts.item() {
1892                if excerpt.locator == *locator {
1893                    let excerpt_start = excerpts.start().1.clone();
1894                    let excerpt_end =
1895                        ExcerptDimension(excerpt_start.0 + excerpt.text_summary.lines);
1896
1897                    diff_transforms.seek_forward(&excerpt_start, Bias::Left, &());
1898                    let overshoot = excerpt_start.0 - diff_transforms.start().0 .0;
1899                    let start = diff_transforms.start().1 .0 + overshoot;
1900
1901                    diff_transforms.seek_forward(&excerpt_end, Bias::Right, &());
1902                    let overshoot = excerpt_end.0 - diff_transforms.start().0 .0;
1903                    let end = diff_transforms.start().1 .0 + overshoot;
1904
1905                    result.push(start..end)
1906                }
1907            }
1908        }
1909        result
1910    }
1911
1912    pub fn excerpt_buffer_ids(&self) -> Vec<BufferId> {
1913        self.snapshot
1914            .borrow()
1915            .excerpts
1916            .iter()
1917            .map(|entry| entry.buffer_id)
1918            .collect()
1919    }
1920
1921    pub fn excerpt_ids(&self) -> Vec<ExcerptId> {
1922        self.snapshot
1923            .borrow()
1924            .excerpts
1925            .iter()
1926            .map(|entry| entry.id)
1927            .collect()
1928    }
1929
1930    pub fn excerpt_containing(
1931        &self,
1932        position: impl ToOffset,
1933        cx: &App,
1934    ) -> Option<(ExcerptId, Entity<Buffer>, Range<text::Anchor>)> {
1935        let snapshot = self.read(cx);
1936        let offset = position.to_offset(&snapshot);
1937
1938        let mut cursor = snapshot.cursor::<usize>();
1939        cursor.seek(&offset);
1940        cursor
1941            .excerpt()
1942            .or_else(|| snapshot.excerpts.last())
1943            .map(|excerpt| {
1944                (
1945                    excerpt.id,
1946                    self.buffers
1947                        .borrow()
1948                        .get(&excerpt.buffer_id)
1949                        .unwrap()
1950                        .buffer
1951                        .clone(),
1952                    excerpt.range.context.clone(),
1953                )
1954            })
1955    }
1956
1957    // If point is at the end of the buffer, the last excerpt is returned
1958    pub fn point_to_buffer_offset<T: ToOffset>(
1959        &self,
1960        point: T,
1961        cx: &App,
1962    ) -> Option<(Entity<Buffer>, usize)> {
1963        let snapshot = self.read(cx);
1964        let (buffer, offset) = snapshot.point_to_buffer_offset(point)?;
1965        Some((
1966            self.buffers
1967                .borrow()
1968                .get(&buffer.remote_id())?
1969                .buffer
1970                .clone(),
1971            offset,
1972        ))
1973    }
1974
1975    // If point is at the end of the buffer, the last excerpt is returned
1976    pub fn point_to_buffer_point<T: ToPoint>(
1977        &self,
1978        point: T,
1979        cx: &App,
1980    ) -> Option<(Entity<Buffer>, Point, ExcerptId)> {
1981        let snapshot = self.read(cx);
1982        let point = point.to_point(&snapshot);
1983        let mut cursor = snapshot.cursor::<Point>();
1984        cursor.seek(&point);
1985
1986        cursor.region().and_then(|region| {
1987            if !region.is_main_buffer {
1988                return None;
1989            }
1990
1991            let overshoot = point - region.range.start;
1992            let buffer_point = region.buffer_range.start + overshoot;
1993            let buffer = self.buffers.borrow()[&region.buffer.remote_id()]
1994                .buffer
1995                .clone();
1996            Some((buffer, buffer_point, region.excerpt.id))
1997        })
1998    }
1999
2000    pub fn buffer_point_to_anchor(
2001        &self,
2002        buffer: &Entity<Buffer>,
2003        point: Point,
2004        cx: &App,
2005    ) -> Option<Anchor> {
2006        let mut found = None;
2007        let snapshot = buffer.read(cx).snapshot();
2008        for (excerpt_id, range) in self.excerpts_for_buffer(snapshot.remote_id(), cx) {
2009            let start = range.context.start.to_point(&snapshot);
2010            let end = range.context.end.to_point(&snapshot);
2011            if start <= point && point < end {
2012                found = Some((snapshot.clip_point(point, Bias::Left), excerpt_id));
2013                break;
2014            }
2015            if point < start {
2016                found = Some((start, excerpt_id));
2017            }
2018            if point > end {
2019                found = Some((end, excerpt_id));
2020            }
2021        }
2022
2023        found.map(|(point, excerpt_id)| {
2024            let text_anchor = snapshot.anchor_after(point);
2025            Anchor::in_buffer(excerpt_id, snapshot.remote_id(), text_anchor)
2026        })
2027    }
2028
2029    pub fn remove_excerpts(
2030        &mut self,
2031        excerpt_ids: impl IntoIterator<Item = ExcerptId>,
2032        cx: &mut Context<Self>,
2033    ) {
2034        self.sync(cx);
2035        let ids = excerpt_ids.into_iter().collect::<Vec<_>>();
2036        if ids.is_empty() {
2037            return;
2038        }
2039
2040        let mut buffers = self.buffers.borrow_mut();
2041        let mut snapshot = self.snapshot.borrow_mut();
2042        let mut new_excerpts = SumTree::default();
2043        let mut cursor = snapshot
2044            .excerpts
2045            .cursor::<(Option<&Locator>, ExcerptOffset)>(&());
2046        let mut edits = Vec::new();
2047        let mut excerpt_ids = ids.iter().copied().peekable();
2048        let mut removed_buffer_ids = Vec::new();
2049
2050        while let Some(excerpt_id) = excerpt_ids.next() {
2051            // Seek to the next excerpt to remove, preserving any preceding excerpts.
2052            let locator = snapshot.excerpt_locator_for_id(excerpt_id);
2053            new_excerpts.append(cursor.slice(&Some(locator), Bias::Left, &()), &());
2054
2055            if let Some(mut excerpt) = cursor.item() {
2056                if excerpt.id != excerpt_id {
2057                    continue;
2058                }
2059                let mut old_start = cursor.start().1;
2060
2061                // Skip over the removed excerpt.
2062                'remove_excerpts: loop {
2063                    if let Some(buffer_state) = buffers.get_mut(&excerpt.buffer_id) {
2064                        buffer_state.excerpts.retain(|l| l != &excerpt.locator);
2065                        if buffer_state.excerpts.is_empty() {
2066                            log::debug!(
2067                                "removing buffer and diff for buffer {}",
2068                                excerpt.buffer_id
2069                            );
2070                            buffers.remove(&excerpt.buffer_id);
2071                            removed_buffer_ids.push(excerpt.buffer_id);
2072                        }
2073                    }
2074                    cursor.next(&());
2075
2076                    // Skip over any subsequent excerpts that are also removed.
2077                    if let Some(&next_excerpt_id) = excerpt_ids.peek() {
2078                        let next_locator = snapshot.excerpt_locator_for_id(next_excerpt_id);
2079                        if let Some(next_excerpt) = cursor.item() {
2080                            if next_excerpt.locator == *next_locator {
2081                                excerpt_ids.next();
2082                                excerpt = next_excerpt;
2083                                continue 'remove_excerpts;
2084                            }
2085                        }
2086                    }
2087
2088                    break;
2089                }
2090
2091                // When removing the last excerpt, remove the trailing newline from
2092                // the previous excerpt.
2093                if cursor.item().is_none() && old_start.value > 0 {
2094                    old_start.value -= 1;
2095                    new_excerpts.update_last(|e| e.has_trailing_newline = false, &());
2096                }
2097
2098                // Push an edit for the removal of this run of excerpts.
2099                let old_end = cursor.start().1;
2100                let new_start = ExcerptOffset::new(new_excerpts.summary().text.len);
2101                edits.push(Edit {
2102                    old: old_start..old_end,
2103                    new: new_start..new_start,
2104                });
2105            }
2106        }
2107        let suffix = cursor.suffix(&());
2108        let changed_trailing_excerpt = suffix.is_empty();
2109        new_excerpts.append(suffix, &());
2110        drop(cursor);
2111        snapshot.excerpts = new_excerpts;
2112        for buffer_id in removed_buffer_ids {
2113            self.diffs.remove(&buffer_id);
2114            snapshot.diffs.remove(&buffer_id);
2115        }
2116
2117        if changed_trailing_excerpt {
2118            snapshot.trailing_excerpt_update_count += 1;
2119        }
2120
2121        self.sync_diff_transforms(&mut snapshot, edits, DiffChangeKind::BufferEdited);
2122        cx.emit(Event::Edited {
2123            singleton_buffer_edited: false,
2124            edited_buffer: None,
2125        });
2126        cx.emit(Event::ExcerptsRemoved { ids });
2127        cx.notify();
2128    }
2129
2130    pub fn wait_for_anchors<'a>(
2131        &self,
2132        anchors: impl 'a + Iterator<Item = Anchor>,
2133        cx: &mut Context<Self>,
2134    ) -> impl 'static + Future<Output = Result<()>> {
2135        let borrow = self.buffers.borrow();
2136        let mut error = None;
2137        let mut futures = Vec::new();
2138        for anchor in anchors {
2139            if let Some(buffer_id) = anchor.buffer_id {
2140                if let Some(buffer) = borrow.get(&buffer_id) {
2141                    buffer.buffer.update(cx, |buffer, _| {
2142                        futures.push(buffer.wait_for_anchors([anchor.text_anchor]))
2143                    });
2144                } else {
2145                    error = Some(anyhow!(
2146                        "buffer {buffer_id} is not part of this multi-buffer"
2147                    ));
2148                    break;
2149                }
2150            }
2151        }
2152        async move {
2153            if let Some(error) = error {
2154                Err(error)?;
2155            }
2156            for future in futures {
2157                future.await?;
2158            }
2159            Ok(())
2160        }
2161    }
2162
2163    pub fn text_anchor_for_position<T: ToOffset>(
2164        &self,
2165        position: T,
2166        cx: &App,
2167    ) -> Option<(Entity<Buffer>, language::Anchor)> {
2168        let snapshot = self.read(cx);
2169        let anchor = snapshot.anchor_before(position);
2170        let buffer = self
2171            .buffers
2172            .borrow()
2173            .get(&anchor.buffer_id?)?
2174            .buffer
2175            .clone();
2176        Some((buffer, anchor.text_anchor))
2177    }
2178
2179    fn on_buffer_event(
2180        &mut self,
2181        buffer: Entity<Buffer>,
2182        event: &language::BufferEvent,
2183        cx: &mut Context<Self>,
2184    ) {
2185        cx.emit(match event {
2186            language::BufferEvent::Edited => Event::Edited {
2187                singleton_buffer_edited: true,
2188                edited_buffer: Some(buffer.clone()),
2189            },
2190            language::BufferEvent::DirtyChanged => Event::DirtyChanged,
2191            language::BufferEvent::Saved => Event::Saved,
2192            language::BufferEvent::FileHandleChanged => Event::FileHandleChanged,
2193            language::BufferEvent::Reloaded => Event::Reloaded,
2194            language::BufferEvent::ReloadNeeded => Event::ReloadNeeded,
2195            language::BufferEvent::LanguageChanged => {
2196                Event::LanguageChanged(buffer.read(cx).remote_id())
2197            }
2198            language::BufferEvent::Reparsed => Event::Reparsed(buffer.read(cx).remote_id()),
2199            language::BufferEvent::DiagnosticsUpdated => Event::DiagnosticsUpdated,
2200            language::BufferEvent::Closed => Event::Closed,
2201            language::BufferEvent::Discarded => Event::Discarded,
2202            language::BufferEvent::CapabilityChanged => {
2203                self.capability = buffer.read(cx).capability();
2204                Event::CapabilityChanged
2205            }
2206            language::BufferEvent::Operation { .. } => return,
2207        });
2208    }
2209
2210    fn buffer_diff_language_changed(&mut self, diff: Entity<BufferDiff>, cx: &mut Context<Self>) {
2211        self.sync(cx);
2212        let mut snapshot = self.snapshot.borrow_mut();
2213        let diff = diff.read(cx);
2214        let buffer_id = diff.buffer_id;
2215        let diff = diff.snapshot(cx);
2216        snapshot.diffs.insert(buffer_id, diff);
2217    }
2218
2219    fn buffer_diff_changed(
2220        &mut self,
2221        diff: Entity<BufferDiff>,
2222        range: Range<text::Anchor>,
2223        cx: &mut Context<Self>,
2224    ) {
2225        self.sync(cx);
2226
2227        let diff = diff.read(cx);
2228        let buffer_id = diff.buffer_id;
2229        let buffers = self.buffers.borrow();
2230        let Some(buffer_state) = buffers.get(&buffer_id) else {
2231            return;
2232        };
2233
2234        let buffer = buffer_state.buffer.read(cx);
2235        let diff_change_range = range.to_offset(buffer);
2236
2237        let new_diff = diff.snapshot(cx);
2238        let mut snapshot = self.snapshot.borrow_mut();
2239        let base_text_changed = snapshot
2240            .diffs
2241            .get(&buffer_id)
2242            .map_or(true, |old_diff| !new_diff.base_texts_eq(old_diff));
2243
2244        snapshot.diffs.insert(buffer_id, new_diff);
2245
2246        let mut excerpt_edits = Vec::new();
2247        for locator in &buffer_state.excerpts {
2248            let mut cursor = snapshot
2249                .excerpts
2250                .cursor::<(Option<&Locator>, ExcerptOffset)>(&());
2251            cursor.seek_forward(&Some(locator), Bias::Left, &());
2252            if let Some(excerpt) = cursor.item() {
2253                if excerpt.locator == *locator {
2254                    let excerpt_buffer_range = excerpt.range.context.to_offset(&excerpt.buffer);
2255                    if diff_change_range.end < excerpt_buffer_range.start
2256                        || diff_change_range.start > excerpt_buffer_range.end
2257                    {
2258                        continue;
2259                    }
2260                    let excerpt_start = cursor.start().1;
2261                    let excerpt_len = ExcerptOffset::new(excerpt.text_summary.len);
2262                    let diff_change_start_in_excerpt = ExcerptOffset::new(
2263                        diff_change_range
2264                            .start
2265                            .saturating_sub(excerpt_buffer_range.start),
2266                    );
2267                    let diff_change_end_in_excerpt = ExcerptOffset::new(
2268                        diff_change_range
2269                            .end
2270                            .saturating_sub(excerpt_buffer_range.start),
2271                    );
2272                    let edit_start = excerpt_start + diff_change_start_in_excerpt.min(excerpt_len);
2273                    let edit_end = excerpt_start + diff_change_end_in_excerpt.min(excerpt_len);
2274                    excerpt_edits.push(Edit {
2275                        old: edit_start..edit_end,
2276                        new: edit_start..edit_end,
2277                    });
2278                }
2279            }
2280        }
2281
2282        self.sync_diff_transforms(
2283            &mut snapshot,
2284            excerpt_edits,
2285            DiffChangeKind::DiffUpdated {
2286                base_changed: base_text_changed,
2287            },
2288        );
2289        cx.emit(Event::Edited {
2290            singleton_buffer_edited: false,
2291            edited_buffer: None,
2292        });
2293    }
2294
2295    pub fn all_buffers(&self) -> HashSet<Entity<Buffer>> {
2296        self.buffers
2297            .borrow()
2298            .values()
2299            .map(|state| state.buffer.clone())
2300            .collect()
2301    }
2302
2303    pub fn buffer(&self, buffer_id: BufferId) -> Option<Entity<Buffer>> {
2304        self.buffers
2305            .borrow()
2306            .get(&buffer_id)
2307            .map(|state| state.buffer.clone())
2308    }
2309
2310    pub fn language_at<T: ToOffset>(&self, point: T, cx: &App) -> Option<Arc<Language>> {
2311        self.point_to_buffer_offset(point, cx)
2312            .and_then(|(buffer, offset)| buffer.read(cx).language_at(offset))
2313    }
2314
2315    pub fn language_settings<'a>(&'a self, cx: &'a App) -> Cow<'a, LanguageSettings> {
2316        let buffer_id = self
2317            .snapshot
2318            .borrow()
2319            .excerpts
2320            .first()
2321            .map(|excerpt| excerpt.buffer.remote_id());
2322        buffer_id
2323            .and_then(|buffer_id| self.buffer(buffer_id))
2324            .map(|buffer| {
2325                let buffer = buffer.read(cx);
2326                language_settings(buffer.language().map(|l| l.name()), buffer.file(), cx)
2327            })
2328            .unwrap_or_else(move || self.language_settings_at(0, cx))
2329    }
2330
2331    pub fn language_settings_at<'a, T: ToOffset>(
2332        &'a self,
2333        point: T,
2334        cx: &'a App,
2335    ) -> Cow<'a, LanguageSettings> {
2336        let mut language = None;
2337        let mut file = None;
2338        if let Some((buffer, offset)) = self.point_to_buffer_offset(point, cx) {
2339            let buffer = buffer.read(cx);
2340            language = buffer.language_at(offset);
2341            file = buffer.file();
2342        }
2343        language_settings(language.map(|l| l.name()), file, cx)
2344    }
2345
2346    pub fn for_each_buffer(&self, mut f: impl FnMut(&Entity<Buffer>)) {
2347        self.buffers
2348            .borrow()
2349            .values()
2350            .for_each(|state| f(&state.buffer))
2351    }
2352
2353    pub fn title<'a>(&'a self, cx: &'a App) -> Cow<'a, str> {
2354        if let Some(title) = self.title.as_ref() {
2355            return title.into();
2356        }
2357
2358        if let Some(buffer) = self.as_singleton() {
2359            if let Some(file) = buffer.read(cx).file() {
2360                return file.file_name(cx).to_string_lossy();
2361            }
2362        }
2363
2364        "untitled".into()
2365    }
2366
2367    pub fn set_title(&mut self, title: String, cx: &mut Context<Self>) {
2368        self.title = Some(title);
2369        cx.notify();
2370    }
2371
2372    /// Preserve preview tabs containing this multibuffer until additional edits occur.
2373    pub fn refresh_preview(&self, cx: &mut Context<Self>) {
2374        for buffer_state in self.buffers.borrow().values() {
2375            buffer_state
2376                .buffer
2377                .update(cx, |buffer, _cx| buffer.refresh_preview());
2378        }
2379    }
2380
2381    /// Whether we should preserve the preview status of a tab containing this multi-buffer.
2382    pub fn preserve_preview(&self, cx: &App) -> bool {
2383        self.buffers
2384            .borrow()
2385            .values()
2386            .all(|state| state.buffer.read(cx).preserve_preview())
2387    }
2388
2389    #[cfg(any(test, feature = "test-support"))]
2390    pub fn is_parsing(&self, cx: &App) -> bool {
2391        self.as_singleton().unwrap().read(cx).is_parsing()
2392    }
2393
2394    pub fn add_diff(&mut self, diff: Entity<BufferDiff>, cx: &mut Context<Self>) {
2395        let buffer_id = diff.read(cx).buffer_id;
2396        self.buffer_diff_changed(diff.clone(), text::Anchor::MIN..text::Anchor::MAX, cx);
2397        self.diffs.insert(buffer_id, DiffState::new(diff, cx));
2398    }
2399
2400    pub fn diff_for(&self, buffer_id: BufferId) -> Option<Entity<BufferDiff>> {
2401        self.diffs.get(&buffer_id).map(|state| state.diff.clone())
2402    }
2403
2404    pub fn expand_diff_hunks(&mut self, ranges: Vec<Range<Anchor>>, cx: &mut Context<Self>) {
2405        self.expand_or_collapse_diff_hunks(ranges, true, cx);
2406    }
2407
2408    pub fn collapse_diff_hunks(&mut self, ranges: Vec<Range<Anchor>>, cx: &mut Context<Self>) {
2409        self.expand_or_collapse_diff_hunks(ranges, false, cx);
2410    }
2411
2412    pub fn set_all_diff_hunks_expanded(&mut self, cx: &mut Context<Self>) {
2413        self.snapshot.borrow_mut().all_diff_hunks_expanded = true;
2414        self.expand_or_collapse_diff_hunks(vec![Anchor::min()..Anchor::max()], true, cx);
2415    }
2416
2417    pub fn all_diff_hunks_expanded(&self) -> bool {
2418        self.snapshot.borrow().all_diff_hunks_expanded
2419    }
2420
2421    pub fn has_multiple_hunks(&self, cx: &App) -> bool {
2422        self.read(cx)
2423            .diff_hunks_in_range(Anchor::min()..Anchor::max())
2424            .nth(1)
2425            .is_some()
2426    }
2427
2428    pub fn single_hunk_is_expanded(&self, range: Range<Anchor>, cx: &App) -> bool {
2429        let snapshot = self.read(cx);
2430        let mut cursor = snapshot.diff_transforms.cursor::<usize>(&());
2431        let offset_range = range.to_offset(&snapshot);
2432        cursor.seek(&offset_range.start, Bias::Left, &());
2433        while let Some(item) = cursor.item() {
2434            if *cursor.start() >= offset_range.end && *cursor.start() > offset_range.start {
2435                break;
2436            }
2437            if item.hunk_info().is_some() {
2438                return true;
2439            }
2440            cursor.next(&());
2441        }
2442        false
2443    }
2444
2445    pub fn has_expanded_diff_hunks_in_ranges(&self, ranges: &[Range<Anchor>], cx: &App) -> bool {
2446        let snapshot = self.read(cx);
2447        let mut cursor = snapshot.diff_transforms.cursor::<usize>(&());
2448        for range in ranges {
2449            let range = range.to_point(&snapshot);
2450            let start = snapshot.point_to_offset(Point::new(range.start.row, 0));
2451            let end = snapshot.point_to_offset(Point::new(range.end.row + 1, 0));
2452            let start = start.saturating_sub(1);
2453            let end = snapshot.len().min(end + 1);
2454            cursor.seek(&start, Bias::Right, &());
2455            while let Some(item) = cursor.item() {
2456                if *cursor.start() >= end {
2457                    break;
2458                }
2459                if item.hunk_info().is_some() {
2460                    return true;
2461                }
2462                cursor.next(&());
2463            }
2464        }
2465        false
2466    }
2467
2468    pub fn expand_or_collapse_diff_hunks_inner(
2469        &mut self,
2470        ranges: impl IntoIterator<Item = (Range<Point>, ExcerptId)>,
2471        expand: bool,
2472        cx: &mut Context<Self>,
2473    ) {
2474        if self.snapshot.borrow().all_diff_hunks_expanded && !expand {
2475            return;
2476        }
2477        self.sync(cx);
2478        let mut snapshot = self.snapshot.borrow_mut();
2479        let mut excerpt_edits = Vec::new();
2480        for (range, end_excerpt_id) in ranges {
2481            for diff_hunk in snapshot.diff_hunks_in_range(range) {
2482                if diff_hunk.excerpt_id.cmp(&end_excerpt_id, &snapshot).is_gt() {
2483                    continue;
2484                }
2485                let start = Anchor::in_buffer(
2486                    diff_hunk.excerpt_id,
2487                    diff_hunk.buffer_id,
2488                    diff_hunk.buffer_range.start,
2489                );
2490                let end = Anchor::in_buffer(
2491                    diff_hunk.excerpt_id,
2492                    diff_hunk.buffer_id,
2493                    diff_hunk.buffer_range.end,
2494                );
2495                let start = snapshot.excerpt_offset_for_anchor(&start);
2496                let end = snapshot.excerpt_offset_for_anchor(&end);
2497                excerpt_edits.push(text::Edit {
2498                    old: start..end,
2499                    new: start..end,
2500                });
2501            }
2502        }
2503
2504        self.sync_diff_transforms(
2505            &mut snapshot,
2506            excerpt_edits,
2507            DiffChangeKind::ExpandOrCollapseHunks { expand },
2508        );
2509        cx.emit(Event::DiffHunksToggled);
2510        cx.emit(Event::Edited {
2511            singleton_buffer_edited: false,
2512            edited_buffer: None,
2513        });
2514    }
2515
2516    pub fn expand_or_collapse_diff_hunks(
2517        &mut self,
2518        ranges: Vec<Range<Anchor>>,
2519        expand: bool,
2520        cx: &mut Context<Self>,
2521    ) {
2522        let snapshot = self.snapshot.borrow().clone();
2523        let ranges = ranges.iter().map(move |range| {
2524            let end_excerpt_id = range.end.excerpt_id;
2525            let range = range.to_point(&snapshot);
2526            let mut peek_end = range.end;
2527            if range.end.row < snapshot.max_row().0 {
2528                peek_end = Point::new(range.end.row + 1, 0);
2529            };
2530            (range.start..peek_end, end_excerpt_id)
2531        });
2532        self.expand_or_collapse_diff_hunks_inner(ranges, expand, cx);
2533    }
2534
2535    pub fn resize_excerpt(
2536        &mut self,
2537        id: ExcerptId,
2538        range: Range<text::Anchor>,
2539        cx: &mut Context<Self>,
2540    ) {
2541        self.sync(cx);
2542
2543        let mut snapshot = self.snapshot.borrow_mut();
2544        let locator = snapshot.excerpt_locator_for_id(id);
2545        let mut new_excerpts = SumTree::default();
2546        let mut cursor = snapshot
2547            .excerpts
2548            .cursor::<(Option<&Locator>, ExcerptOffset)>(&());
2549        let mut edits = Vec::<Edit<ExcerptOffset>>::new();
2550
2551        let prefix = cursor.slice(&Some(locator), Bias::Left, &());
2552        new_excerpts.append(prefix, &());
2553
2554        let mut excerpt = cursor.item().unwrap().clone();
2555        let old_text_len = ExcerptOffset::new(excerpt.text_summary.len);
2556
2557        excerpt.range.context.start = range.start;
2558        excerpt.range.context.end = range.end;
2559        excerpt.max_buffer_row = range.end.to_point(&excerpt.buffer).row;
2560
2561        excerpt.text_summary = excerpt
2562            .buffer
2563            .text_summary_for_range(excerpt.range.context.clone());
2564
2565        let new_start_offset = ExcerptOffset::new(new_excerpts.summary().text.len);
2566        let old_start_offset = cursor.start().1;
2567        let new_text_len = ExcerptOffset::new(excerpt.text_summary.len);
2568        let edit = Edit {
2569            old: old_start_offset..old_start_offset + old_text_len,
2570            new: new_start_offset..new_start_offset + new_text_len,
2571        };
2572
2573        if let Some(last_edit) = edits.last_mut() {
2574            if last_edit.old.end == edit.old.start {
2575                last_edit.old.end = edit.old.end;
2576                last_edit.new.end = edit.new.end;
2577            } else {
2578                edits.push(edit);
2579            }
2580        } else {
2581            edits.push(edit);
2582        }
2583
2584        new_excerpts.push(excerpt, &());
2585
2586        cursor.next(&());
2587
2588        new_excerpts.append(cursor.suffix(&()), &());
2589
2590        drop(cursor);
2591        snapshot.excerpts = new_excerpts;
2592
2593        self.sync_diff_transforms(&mut snapshot, edits, DiffChangeKind::BufferEdited);
2594        cx.emit(Event::Edited {
2595            singleton_buffer_edited: false,
2596            edited_buffer: None,
2597        });
2598        cx.emit(Event::ExcerptsExpanded { ids: vec![id] });
2599        cx.notify();
2600    }
2601
2602    pub fn expand_excerpts(
2603        &mut self,
2604        ids: impl IntoIterator<Item = ExcerptId>,
2605        line_count: u32,
2606        direction: ExpandExcerptDirection,
2607        cx: &mut Context<Self>,
2608    ) {
2609        if line_count == 0 {
2610            return;
2611        }
2612        self.sync(cx);
2613        let mut snapshot = self.snapshot.borrow_mut();
2614
2615        let ids = ids.into_iter().collect::<Vec<_>>();
2616        let locators = snapshot.excerpt_locators_for_ids(ids.iter().copied());
2617        let mut new_excerpts = SumTree::default();
2618        let mut cursor = snapshot
2619            .excerpts
2620            .cursor::<(Option<&Locator>, ExcerptOffset)>(&());
2621        let mut edits = Vec::<Edit<ExcerptOffset>>::new();
2622
2623        for locator in &locators {
2624            let prefix = cursor.slice(&Some(locator), Bias::Left, &());
2625            new_excerpts.append(prefix, &());
2626
2627            let mut excerpt = cursor.item().unwrap().clone();
2628            let old_text_len = ExcerptOffset::new(excerpt.text_summary.len);
2629
2630            let up_line_count = if direction.should_expand_up() {
2631                line_count
2632            } else {
2633                0
2634            };
2635
2636            let start_row = excerpt
2637                .range
2638                .context
2639                .start
2640                .to_point(&excerpt.buffer)
2641                .row
2642                .saturating_sub(up_line_count);
2643            let start_point = Point::new(start_row, 0);
2644            excerpt.range.context.start = excerpt.buffer.anchor_before(start_point);
2645
2646            let down_line_count = if direction.should_expand_down() {
2647                line_count
2648            } else {
2649                0
2650            };
2651
2652            let mut end_point = excerpt.buffer.clip_point(
2653                excerpt.range.context.end.to_point(&excerpt.buffer)
2654                    + Point::new(down_line_count, 0),
2655                Bias::Left,
2656            );
2657            end_point.column = excerpt.buffer.line_len(end_point.row);
2658            excerpt.range.context.end = excerpt.buffer.anchor_after(end_point);
2659            excerpt.max_buffer_row = end_point.row;
2660
2661            excerpt.text_summary = excerpt
2662                .buffer
2663                .text_summary_for_range(excerpt.range.context.clone());
2664
2665            let new_start_offset = ExcerptOffset::new(new_excerpts.summary().text.len);
2666            let old_start_offset = cursor.start().1;
2667            let new_text_len = ExcerptOffset::new(excerpt.text_summary.len);
2668            let edit = Edit {
2669                old: old_start_offset..old_start_offset + old_text_len,
2670                new: new_start_offset..new_start_offset + new_text_len,
2671            };
2672
2673            if let Some(last_edit) = edits.last_mut() {
2674                if last_edit.old.end == edit.old.start {
2675                    last_edit.old.end = edit.old.end;
2676                    last_edit.new.end = edit.new.end;
2677                } else {
2678                    edits.push(edit);
2679                }
2680            } else {
2681                edits.push(edit);
2682            }
2683
2684            new_excerpts.push(excerpt, &());
2685
2686            cursor.next(&());
2687        }
2688
2689        new_excerpts.append(cursor.suffix(&()), &());
2690
2691        drop(cursor);
2692        snapshot.excerpts = new_excerpts;
2693
2694        self.sync_diff_transforms(&mut snapshot, edits, DiffChangeKind::BufferEdited);
2695        cx.emit(Event::Edited {
2696            singleton_buffer_edited: false,
2697            edited_buffer: None,
2698        });
2699        cx.emit(Event::ExcerptsExpanded { ids });
2700        cx.notify();
2701    }
2702
2703    fn sync(&self, cx: &App) {
2704        let mut snapshot = self.snapshot.borrow_mut();
2705        let mut excerpts_to_edit = Vec::new();
2706        let mut non_text_state_updated = false;
2707        let mut is_dirty = false;
2708        let mut has_deleted_file = false;
2709        let mut has_conflict = false;
2710        let mut edited = false;
2711        let mut buffers = self.buffers.borrow_mut();
2712        for buffer_state in buffers.values_mut() {
2713            let buffer = buffer_state.buffer.read(cx);
2714            let version = buffer.version();
2715            let non_text_state_update_count = buffer.non_text_state_update_count();
2716
2717            let buffer_edited = version.changed_since(&buffer_state.last_version);
2718            let buffer_non_text_state_updated =
2719                non_text_state_update_count > buffer_state.last_non_text_state_update_count;
2720            if buffer_edited || buffer_non_text_state_updated {
2721                buffer_state.last_version = version;
2722                buffer_state.last_non_text_state_update_count = non_text_state_update_count;
2723                excerpts_to_edit.extend(
2724                    buffer_state
2725                        .excerpts
2726                        .iter()
2727                        .map(|locator| (locator, buffer_state.buffer.clone(), buffer_edited)),
2728                );
2729            }
2730
2731            edited |= buffer_edited;
2732            non_text_state_updated |= buffer_non_text_state_updated;
2733            is_dirty |= buffer.is_dirty();
2734            has_deleted_file |= buffer
2735                .file()
2736                .map_or(false, |file| file.disk_state() == DiskState::Deleted);
2737            has_conflict |= buffer.has_conflict();
2738        }
2739        if edited {
2740            snapshot.edit_count += 1;
2741        }
2742        if non_text_state_updated {
2743            snapshot.non_text_state_update_count += 1;
2744        }
2745        snapshot.is_dirty = is_dirty;
2746        snapshot.has_deleted_file = has_deleted_file;
2747        snapshot.has_conflict = has_conflict;
2748
2749        for (id, diff) in self.diffs.iter() {
2750            if snapshot.diffs.get(&id).is_none() {
2751                snapshot.diffs.insert(*id, diff.diff.read(cx).snapshot(cx));
2752            }
2753        }
2754
2755        excerpts_to_edit.sort_unstable_by_key(|(locator, _, _)| *locator);
2756
2757        let mut edits = Vec::new();
2758        let mut new_excerpts = SumTree::default();
2759        let mut cursor = snapshot
2760            .excerpts
2761            .cursor::<(Option<&Locator>, ExcerptOffset)>(&());
2762
2763        for (locator, buffer, buffer_edited) in excerpts_to_edit {
2764            new_excerpts.append(cursor.slice(&Some(locator), Bias::Left, &()), &());
2765            let old_excerpt = cursor.item().unwrap();
2766            let buffer = buffer.read(cx);
2767            let buffer_id = buffer.remote_id();
2768
2769            let mut new_excerpt;
2770            if buffer_edited {
2771                edits.extend(
2772                    buffer
2773                        .edits_since_in_range::<usize>(
2774                            old_excerpt.buffer.version(),
2775                            old_excerpt.range.context.clone(),
2776                        )
2777                        .map(|edit| {
2778                            let excerpt_old_start = cursor.start().1;
2779                            let excerpt_new_start =
2780                                ExcerptOffset::new(new_excerpts.summary().text.len);
2781                            let old_start = excerpt_old_start + ExcerptOffset::new(edit.old.start);
2782                            let old_end = excerpt_old_start + ExcerptOffset::new(edit.old.end);
2783                            let new_start = excerpt_new_start + ExcerptOffset::new(edit.new.start);
2784                            let new_end = excerpt_new_start + ExcerptOffset::new(edit.new.end);
2785                            Edit {
2786                                old: old_start..old_end,
2787                                new: new_start..new_end,
2788                            }
2789                        }),
2790                );
2791
2792                new_excerpt = Excerpt::new(
2793                    old_excerpt.id,
2794                    locator.clone(),
2795                    buffer_id,
2796                    buffer.snapshot(),
2797                    old_excerpt.range.clone(),
2798                    old_excerpt.has_trailing_newline,
2799                );
2800            } else {
2801                new_excerpt = old_excerpt.clone();
2802                new_excerpt.buffer = buffer.snapshot();
2803            }
2804
2805            new_excerpts.push(new_excerpt, &());
2806            cursor.next(&());
2807        }
2808        new_excerpts.append(cursor.suffix(&()), &());
2809
2810        drop(cursor);
2811        snapshot.excerpts = new_excerpts;
2812
2813        self.sync_diff_transforms(&mut snapshot, edits, DiffChangeKind::BufferEdited);
2814    }
2815
2816    fn sync_diff_transforms(
2817        &self,
2818        snapshot: &mut MultiBufferSnapshot,
2819        excerpt_edits: Vec<text::Edit<ExcerptOffset>>,
2820        change_kind: DiffChangeKind,
2821    ) {
2822        if excerpt_edits.is_empty() {
2823            return;
2824        }
2825
2826        let mut excerpts = snapshot.excerpts.cursor::<ExcerptOffset>(&());
2827        let mut old_diff_transforms = snapshot
2828            .diff_transforms
2829            .cursor::<(ExcerptOffset, usize)>(&());
2830        let mut new_diff_transforms = SumTree::default();
2831        let mut old_expanded_hunks = HashSet::default();
2832        let mut output_edits = Vec::new();
2833        let mut output_delta = 0_isize;
2834        let mut at_transform_boundary = true;
2835        let mut end_of_current_insert = None;
2836
2837        let mut excerpt_edits = excerpt_edits.into_iter().peekable();
2838        while let Some(edit) = excerpt_edits.next() {
2839            excerpts.seek_forward(&edit.new.start, Bias::Right, &());
2840            if excerpts.item().is_none() && *excerpts.start() == edit.new.start {
2841                excerpts.prev(&());
2842            }
2843
2844            // Keep any transforms that are before the edit.
2845            if at_transform_boundary {
2846                at_transform_boundary = false;
2847                let transforms_before_edit =
2848                    old_diff_transforms.slice(&edit.old.start, Bias::Left, &());
2849                self.append_diff_transforms(&mut new_diff_transforms, transforms_before_edit);
2850                if let Some(transform) = old_diff_transforms.item() {
2851                    if old_diff_transforms.end(&()).0 == edit.old.start
2852                        && old_diff_transforms.start().0 < edit.old.start
2853                    {
2854                        self.push_diff_transform(&mut new_diff_transforms, transform.clone());
2855                        old_diff_transforms.next(&());
2856                    }
2857                }
2858            }
2859
2860            // Compute the start of the edit in output coordinates.
2861            let edit_start_overshoot = (edit.old.start - old_diff_transforms.start().0).value;
2862            let edit_old_start = old_diff_transforms.start().1 + edit_start_overshoot;
2863            let edit_new_start = (edit_old_start as isize + output_delta) as usize;
2864
2865            let changed_diff_hunks = self.recompute_diff_transforms_for_edit(
2866                &edit,
2867                &mut excerpts,
2868                &mut old_diff_transforms,
2869                &mut new_diff_transforms,
2870                &mut end_of_current_insert,
2871                &mut old_expanded_hunks,
2872                &snapshot,
2873                change_kind,
2874            );
2875
2876            // Compute the end of the edit in output coordinates.
2877            let edit_old_end_overshoot = edit.old.end - old_diff_transforms.start().0;
2878            let edit_new_end_overshoot = edit.new.end - new_diff_transforms.summary().excerpt_len();
2879            let edit_old_end = old_diff_transforms.start().1 + edit_old_end_overshoot.value;
2880            let edit_new_end =
2881                new_diff_transforms.summary().output.len + edit_new_end_overshoot.value;
2882            let output_edit = Edit {
2883                old: edit_old_start..edit_old_end,
2884                new: edit_new_start..edit_new_end,
2885            };
2886
2887            output_delta += (output_edit.new.end - output_edit.new.start) as isize;
2888            output_delta -= (output_edit.old.end - output_edit.old.start) as isize;
2889            if changed_diff_hunks || matches!(change_kind, DiffChangeKind::BufferEdited) {
2890                output_edits.push(output_edit);
2891            }
2892
2893            // If this is the last edit that intersects the current diff transform,
2894            // then recreate the content up to the end of this transform, to prepare
2895            // for reusing additional slices of the old transforms.
2896            if excerpt_edits.peek().map_or(true, |next_edit| {
2897                next_edit.old.start >= old_diff_transforms.end(&()).0
2898            }) {
2899                let keep_next_old_transform = (old_diff_transforms.start().0 >= edit.old.end)
2900                    && match old_diff_transforms.item() {
2901                        Some(DiffTransform::BufferContent {
2902                            inserted_hunk_info: Some(hunk),
2903                            ..
2904                        }) => excerpts.item().is_some_and(|excerpt| {
2905                            hunk.hunk_start_anchor.is_valid(&excerpt.buffer)
2906                        }),
2907                        _ => true,
2908                    };
2909
2910                let mut excerpt_offset = edit.new.end;
2911                if !keep_next_old_transform {
2912                    excerpt_offset += old_diff_transforms.end(&()).0 - edit.old.end;
2913                    old_diff_transforms.next(&());
2914                }
2915
2916                old_expanded_hunks.clear();
2917                self.push_buffer_content_transform(
2918                    &snapshot,
2919                    &mut new_diff_transforms,
2920                    excerpt_offset,
2921                    end_of_current_insert,
2922                );
2923                at_transform_boundary = true;
2924            }
2925        }
2926
2927        // Keep any transforms that are after the last edit.
2928        self.append_diff_transforms(&mut new_diff_transforms, old_diff_transforms.suffix(&()));
2929
2930        // Ensure there's always at least one buffer content transform.
2931        if new_diff_transforms.is_empty() {
2932            new_diff_transforms.push(
2933                DiffTransform::BufferContent {
2934                    summary: Default::default(),
2935                    inserted_hunk_info: None,
2936                },
2937                &(),
2938            );
2939        }
2940
2941        self.subscriptions.publish(output_edits);
2942        drop(old_diff_transforms);
2943        drop(excerpts);
2944        snapshot.diff_transforms = new_diff_transforms;
2945        snapshot.edit_count += 1;
2946
2947        #[cfg(any(test, feature = "test-support"))]
2948        snapshot.check_invariants();
2949    }
2950
2951    #[allow(clippy::too_many_arguments)]
2952    fn recompute_diff_transforms_for_edit(
2953        &self,
2954        edit: &Edit<TypedOffset<Excerpt>>,
2955        excerpts: &mut Cursor<Excerpt, TypedOffset<Excerpt>>,
2956        old_diff_transforms: &mut Cursor<DiffTransform, (TypedOffset<Excerpt>, usize)>,
2957        new_diff_transforms: &mut SumTree<DiffTransform>,
2958        end_of_current_insert: &mut Option<(TypedOffset<Excerpt>, DiffTransformHunkInfo)>,
2959        old_expanded_hunks: &mut HashSet<DiffTransformHunkInfo>,
2960        snapshot: &MultiBufferSnapshot,
2961        change_kind: DiffChangeKind,
2962    ) -> bool {
2963        log::trace!(
2964            "recomputing diff transform for edit {:?} => {:?}",
2965            edit.old.start.value..edit.old.end.value,
2966            edit.new.start.value..edit.new.end.value
2967        );
2968
2969        // Record which hunks were previously expanded.
2970        while let Some(item) = old_diff_transforms.item() {
2971            if let Some(hunk_info) = item.hunk_info() {
2972                log::trace!(
2973                    "previously expanded hunk at {}",
2974                    old_diff_transforms.start().0
2975                );
2976                old_expanded_hunks.insert(hunk_info);
2977            }
2978            if old_diff_transforms.end(&()).0 > edit.old.end {
2979                break;
2980            }
2981            old_diff_transforms.next(&());
2982        }
2983
2984        // Avoid querying diff hunks if there's no possibility of hunks being expanded.
2985        let all_diff_hunks_expanded = snapshot.all_diff_hunks_expanded;
2986        if old_expanded_hunks.is_empty()
2987            && change_kind == DiffChangeKind::BufferEdited
2988            && !all_diff_hunks_expanded
2989        {
2990            return false;
2991        }
2992
2993        // Visit each excerpt that intersects the edit.
2994        let mut did_expand_hunks = false;
2995        while let Some(excerpt) = excerpts.item() {
2996            // Recompute the expanded hunks in the portion of the excerpt that
2997            // intersects the edit.
2998            if let Some(diff) = snapshot.diffs.get(&excerpt.buffer_id) {
2999                let buffer = &excerpt.buffer;
3000                let excerpt_start = *excerpts.start();
3001                let excerpt_end = excerpt_start + ExcerptOffset::new(excerpt.text_summary.len);
3002                let excerpt_buffer_start = excerpt.range.context.start.to_offset(buffer);
3003                let excerpt_buffer_end = excerpt_buffer_start + excerpt.text_summary.len;
3004                let edit_buffer_start =
3005                    excerpt_buffer_start + edit.new.start.value.saturating_sub(excerpt_start.value);
3006                let edit_buffer_end =
3007                    excerpt_buffer_start + edit.new.end.value.saturating_sub(excerpt_start.value);
3008                let edit_buffer_end = edit_buffer_end.min(excerpt_buffer_end);
3009                let edit_anchor_range =
3010                    buffer.anchor_before(edit_buffer_start)..buffer.anchor_after(edit_buffer_end);
3011
3012                for hunk in diff.hunks_intersecting_range(edit_anchor_range, buffer) {
3013                    if hunk.is_created_file() && !all_diff_hunks_expanded {
3014                        continue;
3015                    }
3016
3017                    let hunk_buffer_range = hunk.buffer_range.to_offset(buffer);
3018                    if hunk_buffer_range.start < excerpt_buffer_start {
3019                        log::trace!("skipping hunk that starts before excerpt");
3020                        continue;
3021                    }
3022
3023                    let hunk_info = DiffTransformHunkInfo {
3024                        excerpt_id: excerpt.id,
3025                        hunk_start_anchor: hunk.buffer_range.start,
3026                        hunk_secondary_status: hunk.secondary_status,
3027                    };
3028
3029                    let hunk_excerpt_start = excerpt_start
3030                        + ExcerptOffset::new(
3031                            hunk_buffer_range.start.saturating_sub(excerpt_buffer_start),
3032                        );
3033                    let hunk_excerpt_end = excerpt_end.min(
3034                        excerpt_start
3035                            + ExcerptOffset::new(hunk_buffer_range.end - excerpt_buffer_start),
3036                    );
3037
3038                    self.push_buffer_content_transform(
3039                        snapshot,
3040                        new_diff_transforms,
3041                        hunk_excerpt_start,
3042                        *end_of_current_insert,
3043                    );
3044
3045                    // For every existing hunk, determine if it was previously expanded
3046                    // and if it should currently be expanded.
3047                    let was_previously_expanded = old_expanded_hunks.contains(&hunk_info);
3048                    let should_expand_hunk = match &change_kind {
3049                        DiffChangeKind::DiffUpdated { base_changed: true } => {
3050                            was_previously_expanded || all_diff_hunks_expanded
3051                        }
3052                        DiffChangeKind::ExpandOrCollapseHunks { expand } => {
3053                            let intersects = hunk_buffer_range.is_empty()
3054                                || hunk_buffer_range.end > edit_buffer_start;
3055                            if *expand {
3056                                intersects || was_previously_expanded || all_diff_hunks_expanded
3057                            } else {
3058                                !intersects && (was_previously_expanded || all_diff_hunks_expanded)
3059                            }
3060                        }
3061                        _ => was_previously_expanded || all_diff_hunks_expanded,
3062                    };
3063
3064                    if should_expand_hunk {
3065                        did_expand_hunks = true;
3066                        log::trace!(
3067                            "expanding hunk {:?}, excerpt:{:?}",
3068                            hunk_excerpt_start.value..hunk_excerpt_end.value,
3069                            excerpt.id
3070                        );
3071
3072                        if !hunk.diff_base_byte_range.is_empty()
3073                            && hunk_buffer_range.start >= edit_buffer_start
3074                            && hunk_buffer_range.start <= excerpt_buffer_end
3075                        {
3076                            let base_text = diff.base_text();
3077                            let mut text_cursor =
3078                                base_text.as_rope().cursor(hunk.diff_base_byte_range.start);
3079                            let mut base_text_summary =
3080                                text_cursor.summary::<TextSummary>(hunk.diff_base_byte_range.end);
3081
3082                            let mut has_trailing_newline = false;
3083                            if base_text_summary.last_line_chars > 0 {
3084                                base_text_summary += TextSummary::newline();
3085                                has_trailing_newline = true;
3086                            }
3087
3088                            new_diff_transforms.push(
3089                                DiffTransform::DeletedHunk {
3090                                    base_text_byte_range: hunk.diff_base_byte_range.clone(),
3091                                    summary: base_text_summary,
3092                                    buffer_id: excerpt.buffer_id,
3093                                    hunk_info,
3094                                    has_trailing_newline,
3095                                },
3096                                &(),
3097                            );
3098                        }
3099
3100                        if !hunk_buffer_range.is_empty() {
3101                            *end_of_current_insert =
3102                                Some((hunk_excerpt_end.min(excerpt_end), hunk_info));
3103                        }
3104                    }
3105                }
3106            }
3107
3108            if excerpts.end(&()) <= edit.new.end {
3109                excerpts.next(&());
3110            } else {
3111                break;
3112            }
3113        }
3114
3115        did_expand_hunks || !old_expanded_hunks.is_empty()
3116    }
3117
3118    fn append_diff_transforms(
3119        &self,
3120        new_transforms: &mut SumTree<DiffTransform>,
3121        subtree: SumTree<DiffTransform>,
3122    ) {
3123        if let Some(DiffTransform::BufferContent {
3124            inserted_hunk_info,
3125            summary,
3126        }) = subtree.first()
3127        {
3128            if self.extend_last_buffer_content_transform(
3129                new_transforms,
3130                *inserted_hunk_info,
3131                *summary,
3132            ) {
3133                let mut cursor = subtree.cursor::<()>(&());
3134                cursor.next(&());
3135                cursor.next(&());
3136                new_transforms.append(cursor.suffix(&()), &());
3137                return;
3138            }
3139        }
3140        new_transforms.append(subtree, &());
3141    }
3142
3143    fn push_diff_transform(
3144        &self,
3145        new_transforms: &mut SumTree<DiffTransform>,
3146        transform: DiffTransform,
3147    ) {
3148        if let DiffTransform::BufferContent {
3149            inserted_hunk_info: inserted_hunk_anchor,
3150            summary,
3151        } = transform
3152        {
3153            if self.extend_last_buffer_content_transform(
3154                new_transforms,
3155                inserted_hunk_anchor,
3156                summary,
3157            ) {
3158                return;
3159            }
3160        }
3161        new_transforms.push(transform, &());
3162    }
3163
3164    fn push_buffer_content_transform(
3165        &self,
3166        old_snapshot: &MultiBufferSnapshot,
3167        new_transforms: &mut SumTree<DiffTransform>,
3168        end_offset: ExcerptOffset,
3169        current_inserted_hunk: Option<(ExcerptOffset, DiffTransformHunkInfo)>,
3170    ) {
3171        let inserted_region = current_inserted_hunk.map(|(insertion_end_offset, hunk_info)| {
3172            (end_offset.min(insertion_end_offset), Some(hunk_info))
3173        });
3174        let unchanged_region = [(end_offset, None)];
3175
3176        for (end_offset, inserted_hunk_info) in inserted_region.into_iter().chain(unchanged_region)
3177        {
3178            let start_offset = new_transforms.summary().excerpt_len();
3179            if end_offset <= start_offset {
3180                continue;
3181            }
3182            let summary_to_add = old_snapshot
3183                .text_summary_for_excerpt_offset_range::<TextSummary>(start_offset..end_offset);
3184
3185            if !self.extend_last_buffer_content_transform(
3186                new_transforms,
3187                inserted_hunk_info,
3188                summary_to_add,
3189            ) {
3190                new_transforms.push(
3191                    DiffTransform::BufferContent {
3192                        summary: summary_to_add,
3193                        inserted_hunk_info,
3194                    },
3195                    &(),
3196                )
3197            }
3198        }
3199    }
3200
3201    fn extend_last_buffer_content_transform(
3202        &self,
3203        new_transforms: &mut SumTree<DiffTransform>,
3204        new_inserted_hunk_info: Option<DiffTransformHunkInfo>,
3205        summary_to_add: TextSummary,
3206    ) -> bool {
3207        let mut did_extend = false;
3208        new_transforms.update_last(
3209            |last_transform| {
3210                if let DiffTransform::BufferContent {
3211                    summary,
3212                    inserted_hunk_info: inserted_hunk_anchor,
3213                } = last_transform
3214                {
3215                    if *inserted_hunk_anchor == new_inserted_hunk_info {
3216                        *summary += summary_to_add;
3217                        did_extend = true;
3218                    }
3219                }
3220            },
3221            &(),
3222        );
3223        did_extend
3224    }
3225}
3226
3227#[cfg(any(test, feature = "test-support"))]
3228impl MultiBuffer {
3229    pub fn build_simple(text: &str, cx: &mut gpui::App) -> Entity<Self> {
3230        let buffer = cx.new(|cx| Buffer::local(text, cx));
3231        cx.new(|cx| Self::singleton(buffer, cx))
3232    }
3233
3234    pub fn build_multi<const COUNT: usize>(
3235        excerpts: [(&str, Vec<Range<Point>>); COUNT],
3236        cx: &mut gpui::App,
3237    ) -> Entity<Self> {
3238        let multi = cx.new(|_| Self::new(Capability::ReadWrite));
3239        for (text, ranges) in excerpts {
3240            let buffer = cx.new(|cx| Buffer::local(text, cx));
3241            let excerpt_ranges = ranges.into_iter().map(|range| ExcerptRange {
3242                context: range,
3243                primary: None,
3244            });
3245            multi.update(cx, |multi, cx| {
3246                multi.push_excerpts(buffer, excerpt_ranges, cx)
3247            });
3248        }
3249
3250        multi
3251    }
3252
3253    pub fn build_from_buffer(buffer: Entity<Buffer>, cx: &mut gpui::App) -> Entity<Self> {
3254        cx.new(|cx| Self::singleton(buffer, cx))
3255    }
3256
3257    pub fn build_random(rng: &mut impl rand::Rng, cx: &mut gpui::App) -> Entity<Self> {
3258        cx.new(|cx| {
3259            let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
3260            let mutation_count = rng.gen_range(1..=5);
3261            multibuffer.randomly_edit_excerpts(rng, mutation_count, cx);
3262            multibuffer
3263        })
3264    }
3265
3266    pub fn randomly_edit(
3267        &mut self,
3268        rng: &mut impl rand::Rng,
3269        edit_count: usize,
3270        cx: &mut Context<Self>,
3271    ) {
3272        use util::RandomCharIter;
3273
3274        let snapshot = self.read(cx);
3275        let mut edits: Vec<(Range<usize>, Arc<str>)> = Vec::new();
3276        let mut last_end = None;
3277        for _ in 0..edit_count {
3278            if last_end.map_or(false, |last_end| last_end >= snapshot.len()) {
3279                break;
3280            }
3281
3282            let new_start = last_end.map_or(0, |last_end| last_end + 1);
3283            let end = snapshot.clip_offset(rng.gen_range(new_start..=snapshot.len()), Bias::Right);
3284            let start = snapshot.clip_offset(rng.gen_range(new_start..=end), Bias::Right);
3285            last_end = Some(end);
3286
3287            let mut range = start..end;
3288            if rng.gen_bool(0.2) {
3289                mem::swap(&mut range.start, &mut range.end);
3290            }
3291
3292            let new_text_len = rng.gen_range(0..10);
3293            let new_text: String = RandomCharIter::new(&mut *rng).take(new_text_len).collect();
3294
3295            edits.push((range, new_text.into()));
3296        }
3297        log::info!("mutating multi-buffer with {:?}", edits);
3298        drop(snapshot);
3299
3300        self.edit(edits, None, cx);
3301    }
3302
3303    pub fn randomly_edit_excerpts(
3304        &mut self,
3305        rng: &mut impl rand::Rng,
3306        mutation_count: usize,
3307        cx: &mut Context<Self>,
3308    ) {
3309        use rand::prelude::*;
3310        use std::env;
3311        use util::RandomCharIter;
3312
3313        let max_excerpts = env::var("MAX_EXCERPTS")
3314            .map(|i| i.parse().expect("invalid `MAX_EXCERPTS` variable"))
3315            .unwrap_or(5);
3316
3317        let mut buffers = Vec::new();
3318        for _ in 0..mutation_count {
3319            if rng.gen_bool(0.05) {
3320                log::info!("Clearing multi-buffer");
3321                self.clear(cx);
3322                continue;
3323            } else if rng.gen_bool(0.1) && !self.excerpt_ids().is_empty() {
3324                let ids = self.excerpt_ids();
3325                let mut excerpts = HashSet::default();
3326                for _ in 0..rng.gen_range(0..ids.len()) {
3327                    excerpts.extend(ids.choose(rng).copied());
3328                }
3329
3330                let line_count = rng.gen_range(0..5);
3331
3332                log::info!("Expanding excerpts {excerpts:?} by {line_count} lines");
3333
3334                self.expand_excerpts(
3335                    excerpts.iter().cloned(),
3336                    line_count,
3337                    ExpandExcerptDirection::UpAndDown,
3338                    cx,
3339                );
3340                continue;
3341            }
3342
3343            let excerpt_ids = self.excerpt_ids();
3344            if excerpt_ids.is_empty() || (rng.gen() && excerpt_ids.len() < max_excerpts) {
3345                let buffer_handle = if rng.gen() || self.buffers.borrow().is_empty() {
3346                    let text = RandomCharIter::new(&mut *rng).take(10).collect::<String>();
3347                    buffers.push(cx.new(|cx| Buffer::local(text, cx)));
3348                    let buffer = buffers.last().unwrap().read(cx);
3349                    log::info!(
3350                        "Creating new buffer {} with text: {:?}",
3351                        buffer.remote_id(),
3352                        buffer.text()
3353                    );
3354                    buffers.last().unwrap().clone()
3355                } else {
3356                    self.buffers
3357                        .borrow()
3358                        .values()
3359                        .choose(rng)
3360                        .unwrap()
3361                        .buffer
3362                        .clone()
3363                };
3364
3365                let buffer = buffer_handle.read(cx);
3366                let buffer_text = buffer.text();
3367                let ranges = (0..rng.gen_range(0..5))
3368                    .map(|_| {
3369                        let end_ix =
3370                            buffer.clip_offset(rng.gen_range(0..=buffer.len()), Bias::Right);
3371                        let start_ix = buffer.clip_offset(rng.gen_range(0..=end_ix), Bias::Left);
3372                        ExcerptRange {
3373                            context: start_ix..end_ix,
3374                            primary: None,
3375                        }
3376                    })
3377                    .collect::<Vec<_>>();
3378                log::info!(
3379                    "Inserting excerpts from buffer {} and ranges {:?}: {:?}",
3380                    buffer_handle.read(cx).remote_id(),
3381                    ranges.iter().map(|r| &r.context).collect::<Vec<_>>(),
3382                    ranges
3383                        .iter()
3384                        .map(|r| &buffer_text[r.context.clone()])
3385                        .collect::<Vec<_>>()
3386                );
3387
3388                let excerpt_id = self.push_excerpts(buffer_handle.clone(), ranges, cx);
3389                log::info!("Inserted with ids: {:?}", excerpt_id);
3390            } else {
3391                let remove_count = rng.gen_range(1..=excerpt_ids.len());
3392                let mut excerpts_to_remove = excerpt_ids
3393                    .choose_multiple(rng, remove_count)
3394                    .cloned()
3395                    .collect::<Vec<_>>();
3396                let snapshot = self.snapshot.borrow();
3397                excerpts_to_remove.sort_unstable_by(|a, b| a.cmp(b, &snapshot));
3398                drop(snapshot);
3399                log::info!("Removing excerpts {:?}", excerpts_to_remove);
3400                self.remove_excerpts(excerpts_to_remove, cx);
3401            }
3402        }
3403    }
3404
3405    pub fn randomly_mutate(
3406        &mut self,
3407        rng: &mut impl rand::Rng,
3408        mutation_count: usize,
3409        cx: &mut Context<Self>,
3410    ) {
3411        use rand::prelude::*;
3412
3413        if rng.gen_bool(0.7) || self.singleton {
3414            let buffer = self
3415                .buffers
3416                .borrow()
3417                .values()
3418                .choose(rng)
3419                .map(|state| state.buffer.clone());
3420
3421            if let Some(buffer) = buffer {
3422                buffer.update(cx, |buffer, cx| {
3423                    if rng.gen() {
3424                        buffer.randomly_edit(rng, mutation_count, cx);
3425                    } else {
3426                        buffer.randomly_undo_redo(rng, cx);
3427                    }
3428                });
3429            } else {
3430                self.randomly_edit(rng, mutation_count, cx);
3431            }
3432        } else {
3433            self.randomly_edit_excerpts(rng, mutation_count, cx);
3434        }
3435
3436        self.check_invariants(cx);
3437    }
3438
3439    fn check_invariants(&self, cx: &App) {
3440        self.read(cx).check_invariants();
3441    }
3442}
3443
3444impl EventEmitter<Event> for MultiBuffer {}
3445
3446impl MultiBufferSnapshot {
3447    pub fn text(&self) -> String {
3448        self.chunks(0..self.len(), false)
3449            .map(|chunk| chunk.text)
3450            .collect()
3451    }
3452
3453    pub fn reversed_chars_at<T: ToOffset>(&self, position: T) -> impl Iterator<Item = char> + '_ {
3454        self.reversed_chunks_in_range(0..position.to_offset(self))
3455            .flat_map(|c| c.chars().rev())
3456    }
3457
3458    fn reversed_chunks_in_range(&self, range: Range<usize>) -> ReversedMultiBufferChunks {
3459        let mut cursor = self.cursor::<usize>();
3460        cursor.seek(&range.end);
3461        let current_chunks = cursor.region().as_ref().map(|region| {
3462            let start_overshoot = range.start.saturating_sub(region.range.start);
3463            let end_overshoot = range.end - region.range.start;
3464            let end = (region.buffer_range.start + end_overshoot).min(region.buffer_range.end);
3465            let start = region.buffer_range.start + start_overshoot;
3466            region.buffer.reversed_chunks_in_range(start..end)
3467        });
3468        ReversedMultiBufferChunks {
3469            cursor,
3470            current_chunks,
3471            start: range.start,
3472            offset: range.end,
3473        }
3474    }
3475
3476    pub fn chars_at<T: ToOffset>(&self, position: T) -> impl Iterator<Item = char> + '_ {
3477        let offset = position.to_offset(self);
3478        self.text_for_range(offset..self.len())
3479            .flat_map(|chunk| chunk.chars())
3480    }
3481
3482    pub fn text_for_range<T: ToOffset>(&self, range: Range<T>) -> impl Iterator<Item = &str> + '_ {
3483        self.chunks(range, false).map(|chunk| chunk.text)
3484    }
3485
3486    pub fn is_line_blank(&self, row: MultiBufferRow) -> bool {
3487        self.text_for_range(Point::new(row.0, 0)..Point::new(row.0, self.line_len(row)))
3488            .all(|chunk| chunk.matches(|c: char| !c.is_whitespace()).next().is_none())
3489    }
3490
3491    pub fn contains_str_at<T>(&self, position: T, needle: &str) -> bool
3492    where
3493        T: ToOffset,
3494    {
3495        let position = position.to_offset(self);
3496        position == self.clip_offset(position, Bias::Left)
3497            && self
3498                .bytes_in_range(position..self.len())
3499                .flatten()
3500                .copied()
3501                .take(needle.len())
3502                .eq(needle.bytes())
3503    }
3504
3505    pub fn diff_hunks(&self) -> impl Iterator<Item = MultiBufferDiffHunk> + '_ {
3506        self.diff_hunks_in_range(Anchor::min()..Anchor::max())
3507    }
3508
3509    pub fn diff_hunks_in_range<T: ToPoint>(
3510        &self,
3511        range: Range<T>,
3512    ) -> impl Iterator<Item = MultiBufferDiffHunk> + '_ {
3513        let query_range = range.start.to_point(self)..range.end.to_point(self);
3514        self.lift_buffer_metadata(query_range.clone(), move |buffer, buffer_range| {
3515            let Some(diff) = self.diffs.get(&buffer.remote_id()) else {
3516                log::debug!("no diff found for {:?}", buffer.remote_id());
3517                return None;
3518            };
3519            let buffer_start = buffer.anchor_before(buffer_range.start);
3520            let buffer_end = buffer.anchor_after(buffer_range.end);
3521            Some(
3522                diff.hunks_intersecting_range(buffer_start..buffer_end, buffer)
3523                    .filter_map(|hunk| {
3524                        if hunk.is_created_file() && !self.all_diff_hunks_expanded {
3525                            return None;
3526                        }
3527                        Some((hunk.range.clone(), hunk))
3528                    }),
3529            )
3530        })
3531        .filter_map(move |(range, hunk, excerpt)| {
3532            if range.start != range.end && range.end == query_range.start && !hunk.range.is_empty()
3533            {
3534                return None;
3535            }
3536            let end_row = if range.end.column == 0 {
3537                range.end.row
3538            } else {
3539                range.end.row + 1
3540            };
3541            Some(MultiBufferDiffHunk {
3542                row_range: MultiBufferRow(range.start.row)..MultiBufferRow(end_row),
3543                buffer_id: excerpt.buffer_id,
3544                excerpt_id: excerpt.id,
3545                buffer_range: hunk.buffer_range.clone(),
3546                diff_base_byte_range: hunk.diff_base_byte_range.clone(),
3547                secondary_status: hunk.secondary_status,
3548            })
3549        })
3550    }
3551
3552    pub fn excerpt_ids_for_range<T: ToOffset>(
3553        &self,
3554        range: Range<T>,
3555    ) -> impl Iterator<Item = ExcerptId> + '_ {
3556        let range = range.start.to_offset(self)..range.end.to_offset(self);
3557        let mut cursor = self.cursor::<usize>();
3558        cursor.seek(&range.start);
3559        std::iter::from_fn(move || {
3560            let region = cursor.region()?;
3561            if region.range.start >= range.end {
3562                return None;
3563            }
3564            cursor.next_excerpt();
3565            Some(region.excerpt.id)
3566        })
3567    }
3568
3569    pub fn buffer_ids_for_range<T: ToOffset>(
3570        &self,
3571        range: Range<T>,
3572    ) -> impl Iterator<Item = BufferId> + '_ {
3573        let range = range.start.to_offset(self)..range.end.to_offset(self);
3574        let mut cursor = self.cursor::<usize>();
3575        cursor.seek(&range.start);
3576        std::iter::from_fn(move || {
3577            let region = cursor.region()?;
3578            if region.range.start > range.end
3579                || region.range.start == range.end && region.range.start > range.start
3580            {
3581                return None;
3582            }
3583            cursor.next_excerpt();
3584            Some(region.excerpt.buffer_id)
3585        })
3586    }
3587
3588    pub fn ranges_to_buffer_ranges<T: ToOffset>(
3589        &self,
3590        ranges: impl Iterator<Item = Range<T>>,
3591    ) -> impl Iterator<Item = (&BufferSnapshot, Range<usize>, ExcerptId)> {
3592        ranges.flat_map(|range| self.range_to_buffer_ranges(range).into_iter())
3593    }
3594
3595    pub fn range_to_buffer_ranges<T: ToOffset>(
3596        &self,
3597        range: Range<T>,
3598    ) -> Vec<(&BufferSnapshot, Range<usize>, ExcerptId)> {
3599        let start = range.start.to_offset(&self);
3600        let end = range.end.to_offset(&self);
3601
3602        let mut cursor = self.cursor::<usize>();
3603        cursor.seek(&start);
3604
3605        let mut result: Vec<(&BufferSnapshot, Range<usize>, ExcerptId)> = Vec::new();
3606        while let Some(region) = cursor.region() {
3607            if region.range.start > end {
3608                break;
3609            }
3610            if region.is_main_buffer {
3611                let start_overshoot = start.saturating_sub(region.range.start);
3612                let end_overshoot = end.saturating_sub(region.range.start);
3613                let start = region
3614                    .buffer_range
3615                    .end
3616                    .min(region.buffer_range.start + start_overshoot);
3617                let end = region
3618                    .buffer_range
3619                    .end
3620                    .min(region.buffer_range.start + end_overshoot);
3621                if let Some(prev) = result.last_mut().filter(|(_, prev_range, excerpt_id)| {
3622                    *excerpt_id == region.excerpt.id && prev_range.end == start
3623                }) {
3624                    prev.1.end = end;
3625                } else {
3626                    result.push((region.buffer, start..end, region.excerpt.id));
3627                }
3628            }
3629            cursor.next();
3630        }
3631        result
3632    }
3633
3634    pub fn range_to_buffer_ranges_with_deleted_hunks<T: ToOffset>(
3635        &self,
3636        range: Range<T>,
3637    ) -> impl Iterator<Item = (&BufferSnapshot, Range<usize>, ExcerptId, Option<Anchor>)> + '_ {
3638        let start = range.start.to_offset(&self);
3639        let end = range.end.to_offset(&self);
3640
3641        let mut cursor = self.cursor::<usize>();
3642        cursor.seek(&start);
3643
3644        std::iter::from_fn(move || {
3645            let region = cursor.region()?;
3646            if region.range.start > end {
3647                return None;
3648            }
3649            let start_overshoot = start.saturating_sub(region.range.start);
3650            let end_overshoot = end.saturating_sub(region.range.start);
3651            let start = region
3652                .buffer_range
3653                .end
3654                .min(region.buffer_range.start + start_overshoot);
3655            let end = region
3656                .buffer_range
3657                .end
3658                .min(region.buffer_range.start + end_overshoot);
3659
3660            let region_excerpt_id = region.excerpt.id;
3661            let deleted_hunk_anchor = if region.is_main_buffer {
3662                None
3663            } else {
3664                Some(self.anchor_before(region.range.start))
3665            };
3666            let result = (
3667                region.buffer,
3668                start..end,
3669                region_excerpt_id,
3670                deleted_hunk_anchor,
3671            );
3672            cursor.next();
3673            Some(result)
3674        })
3675    }
3676
3677    /// Retrieves buffer metadata for the given range, and converts it into multi-buffer
3678    /// coordinates.
3679    ///
3680    /// The given callback will be called for every excerpt intersecting the given range. It will
3681    /// be passed the excerpt's buffer and the buffer range that the input range intersects.
3682    /// The callback should return an iterator of metadata items from that buffer, each paired
3683    /// with a buffer range.
3684    ///
3685    /// The returned iterator yields each of these metadata items, paired with its range in
3686    /// multi-buffer coordinates.
3687    fn lift_buffer_metadata<'a, D, M, I>(
3688        &'a self,
3689        query_range: Range<D>,
3690        get_buffer_metadata: impl 'a + Fn(&'a BufferSnapshot, Range<D>) -> Option<I>,
3691    ) -> impl Iterator<Item = (Range<D>, M, &'a Excerpt)> + 'a
3692    where
3693        I: Iterator<Item = (Range<D>, M)> + 'a,
3694        D: TextDimension + Ord + Sub<D, Output = D>,
3695    {
3696        let max_position = D::from_text_summary(&self.text_summary());
3697        let mut current_excerpt_metadata: Option<(ExcerptId, I)> = None;
3698        let mut cursor = self.cursor::<D>();
3699
3700        // Find the excerpt and buffer offset where the given range ends.
3701        cursor.seek(&query_range.end);
3702        let mut range_end = None;
3703        while let Some(region) = cursor.region() {
3704            if region.is_main_buffer {
3705                let mut buffer_end = region.buffer_range.start;
3706                let overshoot = if query_range.end > region.range.start {
3707                    query_range.end - region.range.start
3708                } else {
3709                    D::default()
3710                };
3711                buffer_end.add_assign(&overshoot);
3712                range_end = Some((region.excerpt.id, buffer_end));
3713                break;
3714            }
3715            cursor.next();
3716        }
3717
3718        cursor.seek(&query_range.start);
3719
3720        if let Some(region) = cursor.region().filter(|region| !region.is_main_buffer) {
3721            if region.range.start > D::zero(&()) {
3722                cursor.prev()
3723            }
3724        }
3725
3726        iter::from_fn(move || loop {
3727            let excerpt = cursor.excerpt()?;
3728
3729            // If we have already retrieved metadata for this excerpt, continue to use it.
3730            let metadata_iter = if let Some((_, metadata)) = current_excerpt_metadata
3731                .as_mut()
3732                .filter(|(excerpt_id, _)| *excerpt_id == excerpt.id)
3733            {
3734                Some(metadata)
3735            }
3736            // Otherwise, compute the intersection of the input range with the excerpt's range,
3737            // and retrieve the metadata for the resulting range.
3738            else {
3739                let region = cursor.region()?;
3740                let mut buffer_start;
3741                if region.is_main_buffer {
3742                    buffer_start = region.buffer_range.start;
3743                    if query_range.start > region.range.start {
3744                        let overshoot = query_range.start - region.range.start;
3745                        buffer_start.add_assign(&overshoot);
3746                    }
3747                    buffer_start = buffer_start.min(region.buffer_range.end);
3748                } else {
3749                    buffer_start = cursor.main_buffer_position()?;
3750                };
3751                let mut buffer_end = excerpt.range.context.end.summary::<D>(&excerpt.buffer);
3752                if let Some((end_excerpt_id, end_buffer_offset)) = range_end {
3753                    if excerpt.id == end_excerpt_id {
3754                        buffer_end = buffer_end.min(end_buffer_offset);
3755                    }
3756                }
3757
3758                if let Some(iterator) =
3759                    get_buffer_metadata(&excerpt.buffer, buffer_start..buffer_end)
3760                {
3761                    Some(&mut current_excerpt_metadata.insert((excerpt.id, iterator)).1)
3762                } else {
3763                    None
3764                }
3765            };
3766
3767            // Visit each metadata item.
3768            if let Some((metadata_buffer_range, metadata)) = metadata_iter.and_then(Iterator::next)
3769            {
3770                // Find the multibuffer regions that contain the start and end of
3771                // the metadata item's range.
3772                if metadata_buffer_range.start > D::default() {
3773                    while let Some(region) = cursor.region() {
3774                        if region.is_main_buffer
3775                            && (region.buffer_range.end >= metadata_buffer_range.start
3776                                || cursor.is_at_end_of_excerpt())
3777                        {
3778                            break;
3779                        }
3780                        cursor.next();
3781                    }
3782                }
3783                let start_region = cursor.region()?;
3784                while let Some(region) = cursor.region() {
3785                    if region.is_main_buffer
3786                        && (region.buffer_range.end > metadata_buffer_range.end
3787                            || cursor.is_at_end_of_excerpt())
3788                    {
3789                        break;
3790                    }
3791                    cursor.next();
3792                }
3793                let end_region = cursor.region();
3794
3795                // Convert the metadata item's range into multibuffer coordinates.
3796                let mut start_position = start_region.range.start;
3797                let region_buffer_start = start_region.buffer_range.start;
3798                if start_region.is_main_buffer && metadata_buffer_range.start > region_buffer_start
3799                {
3800                    start_position.add_assign(&(metadata_buffer_range.start - region_buffer_start));
3801                    start_position = start_position.min(start_region.range.end);
3802                }
3803
3804                let mut end_position = max_position;
3805                if let Some(end_region) = &end_region {
3806                    end_position = end_region.range.start;
3807                    debug_assert!(end_region.is_main_buffer);
3808                    let region_buffer_start = end_region.buffer_range.start;
3809                    if metadata_buffer_range.end > region_buffer_start {
3810                        end_position.add_assign(&(metadata_buffer_range.end - region_buffer_start));
3811                    }
3812                    end_position = end_position.min(end_region.range.end);
3813                }
3814
3815                if start_position <= query_range.end && end_position >= query_range.start {
3816                    return Some((start_position..end_position, metadata, excerpt));
3817                }
3818            }
3819            // When there are no more metadata items for this excerpt, move to the next excerpt.
3820            else {
3821                current_excerpt_metadata.take();
3822                cursor.next_excerpt();
3823            }
3824        })
3825    }
3826
3827    pub fn diff_hunk_before<T: ToOffset>(&self, position: T) -> Option<MultiBufferRow> {
3828        let offset = position.to_offset(self);
3829
3830        let mut cursor = self.cursor::<DimensionPair<usize, Point>>();
3831        cursor.seek(&DimensionPair {
3832            key: offset,
3833            value: None,
3834        });
3835        cursor.seek_to_start_of_current_excerpt();
3836        let excerpt = cursor.excerpt()?;
3837
3838        let excerpt_end = excerpt.range.context.end.to_offset(&excerpt.buffer);
3839        let current_position = self
3840            .anchor_before(offset)
3841            .text_anchor
3842            .to_offset(&excerpt.buffer);
3843        let excerpt_end = excerpt
3844            .buffer
3845            .anchor_before(excerpt_end.min(current_position));
3846
3847        if let Some(diff) = self.diffs.get(&excerpt.buffer_id) {
3848            for hunk in diff.hunks_intersecting_range_rev(
3849                excerpt.range.context.start..excerpt_end,
3850                &excerpt.buffer,
3851            ) {
3852                let hunk_end = hunk.buffer_range.end.to_offset(&excerpt.buffer);
3853                if hunk_end >= current_position {
3854                    continue;
3855                }
3856                let start =
3857                    Anchor::in_buffer(excerpt.id, excerpt.buffer_id, hunk.buffer_range.start)
3858                        .to_point(&self);
3859                return Some(MultiBufferRow(start.row));
3860            }
3861        }
3862
3863        loop {
3864            cursor.prev_excerpt();
3865            let excerpt = cursor.excerpt()?;
3866
3867            let Some(diff) = self.diffs.get(&excerpt.buffer_id) else {
3868                continue;
3869            };
3870            let mut hunks =
3871                diff.hunks_intersecting_range_rev(excerpt.range.context.clone(), &excerpt.buffer);
3872            let Some(hunk) = hunks.next() else {
3873                continue;
3874            };
3875            let start = Anchor::in_buffer(excerpt.id, excerpt.buffer_id, hunk.buffer_range.start)
3876                .to_point(&self);
3877            return Some(MultiBufferRow(start.row));
3878        }
3879    }
3880
3881    pub fn has_diff_hunks(&self) -> bool {
3882        self.diffs.values().any(|diff| !diff.is_empty())
3883    }
3884
3885    pub fn surrounding_word<T: ToOffset>(
3886        &self,
3887        start: T,
3888        for_completion: bool,
3889    ) -> (Range<usize>, Option<CharKind>) {
3890        let mut start = start.to_offset(self);
3891        let mut end = start;
3892        let mut next_chars = self.chars_at(start).peekable();
3893        let mut prev_chars = self.reversed_chars_at(start).peekable();
3894
3895        let classifier = self
3896            .char_classifier_at(start)
3897            .for_completion(for_completion);
3898
3899        let word_kind = cmp::max(
3900            prev_chars.peek().copied().map(|c| classifier.kind(c)),
3901            next_chars.peek().copied().map(|c| classifier.kind(c)),
3902        );
3903
3904        for ch in prev_chars {
3905            if Some(classifier.kind(ch)) == word_kind && ch != '\n' {
3906                start -= ch.len_utf8();
3907            } else {
3908                break;
3909            }
3910        }
3911
3912        for ch in next_chars {
3913            if Some(classifier.kind(ch)) == word_kind && ch != '\n' {
3914                end += ch.len_utf8();
3915            } else {
3916                break;
3917            }
3918        }
3919
3920        (start..end, word_kind)
3921    }
3922
3923    pub fn is_singleton(&self) -> bool {
3924        self.singleton
3925    }
3926
3927    pub fn as_singleton(&self) -> Option<(&ExcerptId, BufferId, &BufferSnapshot)> {
3928        if self.singleton {
3929            self.excerpts
3930                .iter()
3931                .next()
3932                .map(|e| (&e.id, e.buffer_id, &e.buffer))
3933        } else {
3934            None
3935        }
3936    }
3937
3938    pub fn len(&self) -> usize {
3939        self.diff_transforms.summary().output.len
3940    }
3941
3942    pub fn is_empty(&self) -> bool {
3943        self.excerpts.summary().text.len == 0
3944    }
3945
3946    pub fn widest_line_number(&self) -> u32 {
3947        self.excerpts.summary().widest_line_number + 1
3948    }
3949
3950    pub fn bytes_in_range<T: ToOffset>(&self, range: Range<T>) -> MultiBufferBytes {
3951        let range = range.start.to_offset(self)..range.end.to_offset(self);
3952        let mut excerpts = self.cursor::<usize>();
3953        excerpts.seek(&range.start);
3954
3955        let mut chunk;
3956        let mut has_trailing_newline;
3957        let excerpt_bytes;
3958        if let Some(region) = excerpts.region() {
3959            let mut bytes = region.buffer.bytes_in_range(
3960                region.buffer_range.start + range.start - region.range.start
3961                    ..(region.buffer_range.start + range.end - region.range.start)
3962                        .min(region.buffer_range.end),
3963            );
3964            chunk = bytes.next().unwrap_or(&[][..]);
3965            excerpt_bytes = Some(bytes);
3966            has_trailing_newline = region.has_trailing_newline && range.end >= region.range.end;
3967            if chunk.is_empty() && has_trailing_newline {
3968                chunk = b"\n";
3969                has_trailing_newline = false;
3970            }
3971        } else {
3972            chunk = &[][..];
3973            excerpt_bytes = None;
3974            has_trailing_newline = false;
3975        };
3976
3977        MultiBufferBytes {
3978            range,
3979            cursor: excerpts,
3980            excerpt_bytes,
3981            has_trailing_newline,
3982            chunk,
3983        }
3984    }
3985
3986    pub fn reversed_bytes_in_range<T: ToOffset>(
3987        &self,
3988        range: Range<T>,
3989    ) -> ReversedMultiBufferBytes {
3990        let range = range.start.to_offset(self)..range.end.to_offset(self);
3991        let mut chunks = self.reversed_chunks_in_range(range.clone());
3992        let chunk = chunks.next().map_or(&[][..], |c| c.as_bytes());
3993        ReversedMultiBufferBytes {
3994            range,
3995            chunks,
3996            chunk,
3997        }
3998    }
3999
4000    pub fn row_infos(&self, start_row: MultiBufferRow) -> MultiBufferRows {
4001        let mut cursor = self.cursor::<Point>();
4002        cursor.seek(&Point::new(start_row.0, 0));
4003        let mut result = MultiBufferRows {
4004            point: Point::new(0, 0),
4005            is_empty: self.excerpts.is_empty(),
4006            cursor,
4007        };
4008        result.seek(start_row);
4009        result
4010    }
4011
4012    pub fn chunks<T: ToOffset>(&self, range: Range<T>, language_aware: bool) -> MultiBufferChunks {
4013        let mut chunks = MultiBufferChunks {
4014            excerpt_offset_range: ExcerptOffset::new(0)..ExcerptOffset::new(0),
4015            range: 0..0,
4016            excerpts: self.excerpts.cursor(&()),
4017            diff_transforms: self.diff_transforms.cursor(&()),
4018            diffs: &self.diffs,
4019            diff_base_chunks: None,
4020            excerpt_chunks: None,
4021            buffer_chunk: None,
4022            language_aware,
4023        };
4024        let range = range.start.to_offset(self)..range.end.to_offset(self);
4025        chunks.seek(range);
4026        chunks
4027    }
4028
4029    pub fn clip_offset(&self, offset: usize, bias: Bias) -> usize {
4030        self.clip_dimension(offset, bias, text::BufferSnapshot::clip_offset)
4031    }
4032
4033    pub fn clip_point(&self, point: Point, bias: Bias) -> Point {
4034        self.clip_dimension(point, bias, text::BufferSnapshot::clip_point)
4035    }
4036
4037    pub fn clip_offset_utf16(&self, offset: OffsetUtf16, bias: Bias) -> OffsetUtf16 {
4038        self.clip_dimension(offset, bias, text::BufferSnapshot::clip_offset_utf16)
4039    }
4040
4041    pub fn clip_point_utf16(&self, point: Unclipped<PointUtf16>, bias: Bias) -> PointUtf16 {
4042        self.clip_dimension(point.0, bias, |buffer, point, bias| {
4043            buffer.clip_point_utf16(Unclipped(point), bias)
4044        })
4045    }
4046
4047    pub fn offset_to_point(&self, offset: usize) -> Point {
4048        self.convert_dimension(offset, text::BufferSnapshot::offset_to_point)
4049    }
4050
4051    pub fn offset_to_point_utf16(&self, offset: usize) -> PointUtf16 {
4052        self.convert_dimension(offset, text::BufferSnapshot::offset_to_point_utf16)
4053    }
4054
4055    pub fn point_to_point_utf16(&self, point: Point) -> PointUtf16 {
4056        self.convert_dimension(point, text::BufferSnapshot::point_to_point_utf16)
4057    }
4058
4059    pub fn point_to_offset(&self, point: Point) -> usize {
4060        self.convert_dimension(point, text::BufferSnapshot::point_to_offset)
4061    }
4062
4063    pub fn offset_utf16_to_offset(&self, offset: OffsetUtf16) -> usize {
4064        self.convert_dimension(offset, text::BufferSnapshot::offset_utf16_to_offset)
4065    }
4066
4067    pub fn offset_to_offset_utf16(&self, offset: usize) -> OffsetUtf16 {
4068        self.convert_dimension(offset, text::BufferSnapshot::offset_to_offset_utf16)
4069    }
4070
4071    pub fn point_utf16_to_offset(&self, point: PointUtf16) -> usize {
4072        self.convert_dimension(point, text::BufferSnapshot::point_utf16_to_offset)
4073    }
4074
4075    fn clip_dimension<D>(
4076        &self,
4077        position: D,
4078        bias: Bias,
4079        clip_buffer_position: fn(&text::BufferSnapshot, D, Bias) -> D,
4080    ) -> D
4081    where
4082        D: TextDimension + Ord + Sub<D, Output = D>,
4083    {
4084        let mut cursor = self.cursor();
4085        cursor.seek(&position);
4086        if let Some(region) = cursor.region() {
4087            if position >= region.range.end {
4088                return region.range.end;
4089            }
4090            let overshoot = position - region.range.start;
4091            let mut buffer_position = region.buffer_range.start;
4092            buffer_position.add_assign(&overshoot);
4093            let clipped_buffer_position =
4094                clip_buffer_position(&region.buffer, buffer_position, bias);
4095            let mut position = region.range.start;
4096            position.add_assign(&(clipped_buffer_position - region.buffer_range.start));
4097            position
4098        } else {
4099            D::from_text_summary(&self.text_summary())
4100        }
4101    }
4102
4103    fn convert_dimension<D1, D2>(
4104        &self,
4105        key: D1,
4106        convert_buffer_dimension: fn(&text::BufferSnapshot, D1) -> D2,
4107    ) -> D2
4108    where
4109        D1: TextDimension + Ord + Sub<D1, Output = D1>,
4110        D2: TextDimension + Ord + Sub<D2, Output = D2>,
4111    {
4112        let mut cursor = self.cursor::<DimensionPair<D1, D2>>();
4113        cursor.seek(&DimensionPair { key, value: None });
4114        if let Some(region) = cursor.region() {
4115            if key >= region.range.end.key {
4116                return region.range.end.value.unwrap();
4117            }
4118            let start_key = region.range.start.key;
4119            let start_value = region.range.start.value.unwrap();
4120            let buffer_start_key = region.buffer_range.start.key;
4121            let buffer_start_value = region.buffer_range.start.value.unwrap();
4122            let mut buffer_key = buffer_start_key;
4123            buffer_key.add_assign(&(key - start_key));
4124            let buffer_value = convert_buffer_dimension(&region.buffer, buffer_key);
4125            let mut result = start_value;
4126            result.add_assign(&(buffer_value - buffer_start_value));
4127            result
4128        } else {
4129            D2::from_text_summary(&self.text_summary())
4130        }
4131    }
4132
4133    pub fn point_to_buffer_offset<T: ToOffset>(
4134        &self,
4135        point: T,
4136    ) -> Option<(&BufferSnapshot, usize)> {
4137        let offset = point.to_offset(self);
4138        let mut cursor = self.cursor::<usize>();
4139        cursor.seek(&offset);
4140        let region = cursor.region()?;
4141        let overshoot = offset - region.range.start;
4142        let buffer_offset = region.buffer_range.start + overshoot;
4143        Some((region.buffer, buffer_offset))
4144    }
4145
4146    pub fn point_to_buffer_point(&self, point: Point) -> Option<(&BufferSnapshot, Point, bool)> {
4147        let mut cursor = self.cursor::<Point>();
4148        cursor.seek(&point);
4149        let region = cursor.region()?;
4150        let overshoot = point - region.range.start;
4151        let buffer_offset = region.buffer_range.start + overshoot;
4152        Some((region.buffer, buffer_offset, region.is_main_buffer))
4153    }
4154
4155    pub fn suggested_indents(
4156        &self,
4157        rows: impl IntoIterator<Item = u32>,
4158        cx: &App,
4159    ) -> BTreeMap<MultiBufferRow, IndentSize> {
4160        let mut result = BTreeMap::new();
4161
4162        let mut rows_for_excerpt = Vec::new();
4163        let mut cursor = self.cursor::<Point>();
4164        let mut rows = rows.into_iter().peekable();
4165        let mut prev_row = u32::MAX;
4166        let mut prev_language_indent_size = IndentSize::default();
4167
4168        while let Some(row) = rows.next() {
4169            cursor.seek(&Point::new(row, 0));
4170            let Some(region) = cursor.region() else {
4171                continue;
4172            };
4173
4174            // Retrieve the language and indent size once for each disjoint region being indented.
4175            let single_indent_size = if row.saturating_sub(1) == prev_row {
4176                prev_language_indent_size
4177            } else {
4178                region
4179                    .buffer
4180                    .language_indent_size_at(Point::new(row, 0), cx)
4181            };
4182            prev_language_indent_size = single_indent_size;
4183            prev_row = row;
4184
4185            let start_buffer_row = region.buffer_range.start.row;
4186            let start_multibuffer_row = region.range.start.row;
4187            let end_multibuffer_row = region.range.end.row;
4188
4189            rows_for_excerpt.push(row);
4190            while let Some(next_row) = rows.peek().copied() {
4191                if end_multibuffer_row > next_row {
4192                    rows_for_excerpt.push(next_row);
4193                    rows.next();
4194                } else {
4195                    break;
4196                }
4197            }
4198
4199            let buffer_rows = rows_for_excerpt
4200                .drain(..)
4201                .map(|row| start_buffer_row + row - start_multibuffer_row);
4202            let buffer_indents = region
4203                .buffer
4204                .suggested_indents(buffer_rows, single_indent_size);
4205            let multibuffer_indents = buffer_indents.into_iter().map(|(row, indent)| {
4206                (
4207                    MultiBufferRow(start_multibuffer_row + row - start_buffer_row),
4208                    indent,
4209                )
4210            });
4211            result.extend(multibuffer_indents);
4212        }
4213
4214        result
4215    }
4216
4217    pub fn indent_size_for_line(&self, row: MultiBufferRow) -> IndentSize {
4218        if let Some((buffer, range)) = self.buffer_line_for_row(row) {
4219            let mut size = buffer.indent_size_for_line(range.start.row);
4220            size.len = size
4221                .len
4222                .min(range.end.column)
4223                .saturating_sub(range.start.column);
4224            size
4225        } else {
4226            IndentSize::spaces(0)
4227        }
4228    }
4229
4230    pub fn line_indent_for_row(&self, row: MultiBufferRow) -> LineIndent {
4231        if let Some((buffer, range)) = self.buffer_line_for_row(row) {
4232            LineIndent::from_iter(buffer.text_for_range(range).flat_map(|s| s.chars()))
4233        } else {
4234            LineIndent::spaces(0)
4235        }
4236    }
4237
4238    pub fn indent_and_comment_for_line(&self, row: MultiBufferRow, cx: &App) -> String {
4239        let mut indent = self.indent_size_for_line(row).chars().collect::<String>();
4240
4241        if self.language_settings(cx).extend_comment_on_newline {
4242            if let Some(language_scope) = self.language_scope_at(Point::new(row.0, 0)) {
4243                let delimiters = language_scope.line_comment_prefixes();
4244                for delimiter in delimiters {
4245                    if *self
4246                        .chars_at(Point::new(row.0, indent.len() as u32))
4247                        .take(delimiter.chars().count())
4248                        .collect::<String>()
4249                        .as_str()
4250                        == **delimiter
4251                    {
4252                        indent.push_str(&delimiter);
4253                        break;
4254                    }
4255                }
4256            }
4257        }
4258
4259        indent
4260    }
4261
4262    pub fn is_line_whitespace_upto<T>(&self, position: T) -> bool
4263    where
4264        T: ToOffset,
4265    {
4266        for char in self.reversed_chars_at(position) {
4267            if !char.is_whitespace() {
4268                return false;
4269            }
4270            if char == '\n' {
4271                return true;
4272            }
4273        }
4274        return true;
4275    }
4276
4277    pub fn prev_non_blank_row(&self, mut row: MultiBufferRow) -> Option<MultiBufferRow> {
4278        while row.0 > 0 {
4279            row.0 -= 1;
4280            if !self.is_line_blank(row) {
4281                return Some(row);
4282            }
4283        }
4284        None
4285    }
4286
4287    pub fn line_len(&self, row: MultiBufferRow) -> u32 {
4288        if let Some((_, range)) = self.buffer_line_for_row(row) {
4289            range.end.column - range.start.column
4290        } else {
4291            0
4292        }
4293    }
4294
4295    pub fn buffer_line_for_row(
4296        &self,
4297        row: MultiBufferRow,
4298    ) -> Option<(&BufferSnapshot, Range<Point>)> {
4299        let mut cursor = self.cursor::<Point>();
4300        let point = Point::new(row.0, 0);
4301        cursor.seek(&point);
4302        let region = cursor.region()?;
4303        let overshoot = point.min(region.range.end) - region.range.start;
4304        let buffer_point = region.buffer_range.start + overshoot;
4305        if buffer_point.row > region.buffer_range.end.row {
4306            return None;
4307        }
4308        let line_start = Point::new(buffer_point.row, 0).max(region.buffer_range.start);
4309        let line_end = Point::new(buffer_point.row, region.buffer.line_len(buffer_point.row))
4310            .min(region.buffer_range.end);
4311        Some((region.buffer, line_start..line_end))
4312    }
4313
4314    pub fn max_point(&self) -> Point {
4315        self.text_summary().lines
4316    }
4317
4318    pub fn max_row(&self) -> MultiBufferRow {
4319        MultiBufferRow(self.text_summary().lines.row)
4320    }
4321
4322    pub fn text_summary(&self) -> TextSummary {
4323        self.diff_transforms.summary().output
4324    }
4325
4326    pub fn text_summary_for_range<D, O>(&self, range: Range<O>) -> D
4327    where
4328        D: TextDimension,
4329        O: ToOffset,
4330    {
4331        let range = range.start.to_offset(self)..range.end.to_offset(self);
4332        let mut cursor = self.diff_transforms.cursor::<(usize, ExcerptOffset)>(&());
4333        cursor.seek(&range.start, Bias::Right, &());
4334
4335        let Some(first_transform) = cursor.item() else {
4336            return D::from_text_summary(&TextSummary::default());
4337        };
4338
4339        let diff_transform_start = cursor.start().0;
4340        let diff_transform_end = cursor.end(&()).0;
4341        let diff_start = range.start;
4342        let start_overshoot = diff_start - diff_transform_start;
4343        let end_overshoot = std::cmp::min(range.end, diff_transform_end) - diff_transform_start;
4344
4345        let mut result = match first_transform {
4346            DiffTransform::BufferContent { .. } => {
4347                let excerpt_start = cursor.start().1 + ExcerptOffset::new(start_overshoot);
4348                let excerpt_end = cursor.start().1 + ExcerptOffset::new(end_overshoot);
4349                self.text_summary_for_excerpt_offset_range(excerpt_start..excerpt_end)
4350            }
4351            DiffTransform::DeletedHunk {
4352                buffer_id,
4353                base_text_byte_range,
4354                has_trailing_newline,
4355                ..
4356            } => {
4357                let buffer_start = base_text_byte_range.start + start_overshoot;
4358                let mut buffer_end = base_text_byte_range.start + end_overshoot;
4359                let Some(base_text) = self.diffs.get(buffer_id).map(|diff| diff.base_text()) else {
4360                    panic!("{:?} is in non-existent deleted hunk", range.start)
4361                };
4362
4363                let include_trailing_newline =
4364                    *has_trailing_newline && range.end >= diff_transform_end;
4365                if include_trailing_newline {
4366                    buffer_end -= 1;
4367                }
4368
4369                let mut summary =
4370                    base_text.text_summary_for_range::<D, _>(buffer_start..buffer_end);
4371
4372                if include_trailing_newline {
4373                    summary.add_assign(&D::from_text_summary(&TextSummary::newline()))
4374                }
4375
4376                summary
4377            }
4378        };
4379        if range.end < diff_transform_end {
4380            return result;
4381        }
4382
4383        cursor.next(&());
4384        result.add_assign(&D::from_text_summary(&cursor.summary(
4385            &range.end,
4386            Bias::Right,
4387            &(),
4388        )));
4389
4390        let Some(last_transform) = cursor.item() else {
4391            return result;
4392        };
4393
4394        let overshoot = range.end - cursor.start().0;
4395        let suffix = match last_transform {
4396            DiffTransform::BufferContent { .. } => {
4397                let end = cursor.start().1 + ExcerptOffset::new(overshoot);
4398                self.text_summary_for_excerpt_offset_range::<D>(cursor.start().1..end)
4399            }
4400            DiffTransform::DeletedHunk {
4401                base_text_byte_range,
4402                buffer_id,
4403                has_trailing_newline,
4404                ..
4405            } => {
4406                let buffer_end = base_text_byte_range.start + overshoot;
4407                let Some(base_text) = self.diffs.get(buffer_id).map(|diff| diff.base_text()) else {
4408                    panic!("{:?} is in non-existent deleted hunk", range.end)
4409                };
4410
4411                let mut suffix = base_text
4412                    .text_summary_for_range::<D, _>(base_text_byte_range.start..buffer_end);
4413                if *has_trailing_newline && buffer_end == base_text_byte_range.end + 1 {
4414                    suffix.add_assign(&D::from_text_summary(&TextSummary::newline()))
4415                }
4416                suffix
4417            }
4418        };
4419
4420        result.add_assign(&suffix);
4421        result
4422    }
4423
4424    fn text_summary_for_excerpt_offset_range<D>(&self, mut range: Range<ExcerptOffset>) -> D
4425    where
4426        D: TextDimension,
4427    {
4428        // let mut range = range.start..range.end;
4429        let mut summary = D::zero(&());
4430        let mut cursor = self.excerpts.cursor::<ExcerptOffset>(&());
4431        cursor.seek(&range.start, Bias::Right, &());
4432        if let Some(excerpt) = cursor.item() {
4433            let mut end_before_newline = cursor.end(&());
4434            if excerpt.has_trailing_newline {
4435                end_before_newline -= ExcerptOffset::new(1);
4436            }
4437
4438            let excerpt_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
4439            let start_in_excerpt = excerpt_start + (range.start - *cursor.start()).value;
4440            let end_in_excerpt =
4441                excerpt_start + (cmp::min(end_before_newline, range.end) - *cursor.start()).value;
4442            summary.add_assign(
4443                &excerpt
4444                    .buffer
4445                    .text_summary_for_range(start_in_excerpt..end_in_excerpt),
4446            );
4447
4448            if range.end > end_before_newline {
4449                summary.add_assign(&D::from_text_summary(&TextSummary::from("\n")));
4450            }
4451
4452            cursor.next(&());
4453        }
4454
4455        if range.end > *cursor.start() {
4456            summary.add_assign(
4457                &cursor
4458                    .summary::<_, ExcerptDimension<D>>(&range.end, Bias::Right, &())
4459                    .0,
4460            );
4461            if let Some(excerpt) = cursor.item() {
4462                range.end = cmp::max(*cursor.start(), range.end);
4463
4464                let excerpt_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
4465                let end_in_excerpt = excerpt_start + (range.end - *cursor.start()).value;
4466                summary.add_assign(
4467                    &excerpt
4468                        .buffer
4469                        .text_summary_for_range(excerpt_start..end_in_excerpt),
4470                );
4471            }
4472        }
4473
4474        summary
4475    }
4476
4477    pub fn summary_for_anchor<D>(&self, anchor: &Anchor) -> D
4478    where
4479        D: TextDimension + Ord + Sub<D, Output = D>,
4480    {
4481        self.summaries_for_anchors([anchor])[0]
4482    }
4483
4484    fn resolve_summary_for_anchor<D>(
4485        &self,
4486        anchor: &Anchor,
4487        excerpt_position: D,
4488        diff_transforms: &mut Cursor<DiffTransform, (ExcerptDimension<D>, OutputDimension<D>)>,
4489    ) -> D
4490    where
4491        D: TextDimension + Ord + Sub<D, Output = D>,
4492    {
4493        loop {
4494            let transform_end_position = diff_transforms.end(&()).0 .0;
4495            let at_transform_end =
4496                excerpt_position == transform_end_position && diff_transforms.item().is_some();
4497            if at_transform_end && anchor.text_anchor.bias == Bias::Right {
4498                diff_transforms.next(&());
4499                continue;
4500            }
4501
4502            let mut position = diff_transforms.start().1 .0;
4503            match diff_transforms.item() {
4504                Some(DiffTransform::DeletedHunk {
4505                    buffer_id,
4506                    base_text_byte_range,
4507                    ..
4508                }) => {
4509                    if let Some(diff_base_anchor) = &anchor.diff_base_anchor {
4510                        if let Some(base_text) =
4511                            self.diffs.get(buffer_id).map(|diff| diff.base_text())
4512                        {
4513                            if base_text.can_resolve(&diff_base_anchor) {
4514                                let base_text_offset = diff_base_anchor.to_offset(&base_text);
4515                                if base_text_offset >= base_text_byte_range.start
4516                                    && base_text_offset <= base_text_byte_range.end
4517                                {
4518                                    let position_in_hunk = base_text
4519                                        .text_summary_for_range::<D, _>(
4520                                            base_text_byte_range.start..base_text_offset,
4521                                        );
4522                                    position.add_assign(&position_in_hunk);
4523                                } else if at_transform_end {
4524                                    diff_transforms.next(&());
4525                                    continue;
4526                                }
4527                            }
4528                        }
4529                    }
4530                }
4531                _ => {
4532                    if at_transform_end && anchor.diff_base_anchor.is_some() {
4533                        diff_transforms.next(&());
4534                        continue;
4535                    }
4536                    let overshoot = excerpt_position - diff_transforms.start().0 .0;
4537                    position.add_assign(&overshoot);
4538                }
4539            }
4540
4541            return position;
4542        }
4543    }
4544
4545    fn excerpt_offset_for_anchor(&self, anchor: &Anchor) -> ExcerptOffset {
4546        let mut cursor = self
4547            .excerpts
4548            .cursor::<(Option<&Locator>, ExcerptOffset)>(&());
4549        let locator = self.excerpt_locator_for_id(anchor.excerpt_id);
4550
4551        cursor.seek(&Some(locator), Bias::Left, &());
4552        if cursor.item().is_none() {
4553            cursor.next(&());
4554        }
4555
4556        let mut position = cursor.start().1;
4557        if let Some(excerpt) = cursor.item() {
4558            if excerpt.id == anchor.excerpt_id {
4559                let excerpt_buffer_start = excerpt
4560                    .buffer
4561                    .offset_for_anchor(&excerpt.range.context.start);
4562                let excerpt_buffer_end =
4563                    excerpt.buffer.offset_for_anchor(&excerpt.range.context.end);
4564                let buffer_position = cmp::min(
4565                    excerpt_buffer_end,
4566                    excerpt.buffer.offset_for_anchor(&anchor.text_anchor),
4567                );
4568                if buffer_position > excerpt_buffer_start {
4569                    position.value += buffer_position - excerpt_buffer_start;
4570                }
4571            }
4572        }
4573        position
4574    }
4575
4576    pub fn summaries_for_anchors<'a, D, I>(&'a self, anchors: I) -> Vec<D>
4577    where
4578        D: TextDimension + Ord + Sub<D, Output = D>,
4579        I: 'a + IntoIterator<Item = &'a Anchor>,
4580    {
4581        let mut anchors = anchors.into_iter().peekable();
4582        let mut cursor = self.excerpts.cursor::<ExcerptSummary>(&());
4583        let mut diff_transforms_cursor = self
4584            .diff_transforms
4585            .cursor::<(ExcerptDimension<D>, OutputDimension<D>)>(&());
4586        diff_transforms_cursor.next(&());
4587
4588        let mut summaries = Vec::new();
4589        while let Some(anchor) = anchors.peek() {
4590            let excerpt_id = anchor.excerpt_id;
4591            let excerpt_anchors = iter::from_fn(|| {
4592                let anchor = anchors.peek()?;
4593                if anchor.excerpt_id == excerpt_id {
4594                    Some(anchors.next().unwrap())
4595                } else {
4596                    None
4597                }
4598            });
4599
4600            let locator = self.excerpt_locator_for_id(excerpt_id);
4601            cursor.seek_forward(locator, Bias::Left, &());
4602            if cursor.item().is_none() {
4603                cursor.next(&());
4604            }
4605
4606            let excerpt_start_position = D::from_text_summary(&cursor.start().text);
4607            if let Some(excerpt) = cursor.item() {
4608                if excerpt.id != excerpt_id {
4609                    let position = self.resolve_summary_for_anchor(
4610                        &Anchor::min(),
4611                        excerpt_start_position,
4612                        &mut diff_transforms_cursor,
4613                    );
4614                    summaries.extend(excerpt_anchors.map(|_| position));
4615                    continue;
4616                }
4617                let excerpt_buffer_start =
4618                    excerpt.range.context.start.summary::<D>(&excerpt.buffer);
4619                let excerpt_buffer_end = excerpt.range.context.end.summary::<D>(&excerpt.buffer);
4620                for (buffer_summary, anchor) in excerpt
4621                    .buffer
4622                    .summaries_for_anchors_with_payload::<D, _, _>(
4623                        excerpt_anchors.map(|a| (&a.text_anchor, a)),
4624                    )
4625                {
4626                    let summary = cmp::min(excerpt_buffer_end, buffer_summary);
4627                    let mut position = excerpt_start_position;
4628                    if summary > excerpt_buffer_start {
4629                        position.add_assign(&(summary - excerpt_buffer_start));
4630                    }
4631
4632                    if position > diff_transforms_cursor.start().0 .0 {
4633                        diff_transforms_cursor.seek_forward(
4634                            &ExcerptDimension(position),
4635                            Bias::Left,
4636                            &(),
4637                        );
4638                    }
4639
4640                    summaries.push(self.resolve_summary_for_anchor(
4641                        anchor,
4642                        position,
4643                        &mut diff_transforms_cursor,
4644                    ));
4645                }
4646            } else {
4647                diff_transforms_cursor.seek_forward(
4648                    &ExcerptDimension(excerpt_start_position),
4649                    Bias::Left,
4650                    &(),
4651                );
4652                let position = self.resolve_summary_for_anchor(
4653                    &Anchor::max(),
4654                    excerpt_start_position,
4655                    &mut diff_transforms_cursor,
4656                );
4657                summaries.extend(excerpt_anchors.map(|_| position));
4658            }
4659        }
4660
4661        summaries
4662    }
4663
4664    pub fn dimensions_from_points<'a, D>(
4665        &'a self,
4666        points: impl 'a + IntoIterator<Item = Point>,
4667    ) -> impl 'a + Iterator<Item = D>
4668    where
4669        D: TextDimension + Sub<D, Output = D>,
4670    {
4671        let mut cursor = self.cursor::<DimensionPair<Point, D>>();
4672        cursor.seek(&DimensionPair {
4673            key: Point::default(),
4674            value: None,
4675        });
4676        let mut points = points.into_iter();
4677        iter::from_fn(move || {
4678            let point = points.next()?;
4679
4680            cursor.seek_forward(&DimensionPair {
4681                key: point,
4682                value: None,
4683            });
4684
4685            if let Some(region) = cursor.region() {
4686                let overshoot = point - region.range.start.key;
4687                let buffer_point = region.buffer_range.start.key + overshoot;
4688                let mut position = region.range.start.value.unwrap();
4689                position.add_assign(
4690                    &region
4691                        .buffer
4692                        .text_summary_for_range(region.buffer_range.start.key..buffer_point),
4693                );
4694                return Some(position);
4695            } else {
4696                return Some(D::from_text_summary(&self.text_summary()));
4697            }
4698        })
4699    }
4700
4701    pub fn refresh_anchors<'a, I>(&'a self, anchors: I) -> Vec<(usize, Anchor, bool)>
4702    where
4703        I: 'a + IntoIterator<Item = &'a Anchor>,
4704    {
4705        let mut anchors = anchors.into_iter().enumerate().peekable();
4706        let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
4707        cursor.next(&());
4708
4709        let mut result = Vec::new();
4710
4711        while let Some((_, anchor)) = anchors.peek() {
4712            let old_excerpt_id = anchor.excerpt_id;
4713
4714            // Find the location where this anchor's excerpt should be.
4715            let old_locator = self.excerpt_locator_for_id(old_excerpt_id);
4716            cursor.seek_forward(&Some(old_locator), Bias::Left, &());
4717
4718            if cursor.item().is_none() {
4719                cursor.next(&());
4720            }
4721
4722            let next_excerpt = cursor.item();
4723            let prev_excerpt = cursor.prev_item();
4724
4725            // Process all of the anchors for this excerpt.
4726            while let Some((_, anchor)) = anchors.peek() {
4727                if anchor.excerpt_id != old_excerpt_id {
4728                    break;
4729                }
4730                let (anchor_ix, anchor) = anchors.next().unwrap();
4731                let mut anchor = *anchor;
4732
4733                // Leave min and max anchors unchanged if invalid or
4734                // if the old excerpt still exists at this location
4735                let mut kept_position = next_excerpt
4736                    .map_or(false, |e| e.id == old_excerpt_id && e.contains(&anchor))
4737                    || old_excerpt_id == ExcerptId::max()
4738                    || old_excerpt_id == ExcerptId::min();
4739
4740                // If the old excerpt no longer exists at this location, then attempt to
4741                // find an equivalent position for this anchor in an adjacent excerpt.
4742                if !kept_position {
4743                    for excerpt in [next_excerpt, prev_excerpt].iter().filter_map(|e| *e) {
4744                        if excerpt.contains(&anchor) {
4745                            anchor.excerpt_id = excerpt.id;
4746                            kept_position = true;
4747                            break;
4748                        }
4749                    }
4750                }
4751
4752                // If there's no adjacent excerpt that contains the anchor's position,
4753                // then report that the anchor has lost its position.
4754                if !kept_position {
4755                    anchor = if let Some(excerpt) = next_excerpt {
4756                        let mut text_anchor = excerpt
4757                            .range
4758                            .context
4759                            .start
4760                            .bias(anchor.text_anchor.bias, &excerpt.buffer);
4761                        if text_anchor
4762                            .cmp(&excerpt.range.context.end, &excerpt.buffer)
4763                            .is_gt()
4764                        {
4765                            text_anchor = excerpt.range.context.end;
4766                        }
4767                        Anchor {
4768                            buffer_id: Some(excerpt.buffer_id),
4769                            excerpt_id: excerpt.id,
4770                            text_anchor,
4771                            diff_base_anchor: None,
4772                        }
4773                    } else if let Some(excerpt) = prev_excerpt {
4774                        let mut text_anchor = excerpt
4775                            .range
4776                            .context
4777                            .end
4778                            .bias(anchor.text_anchor.bias, &excerpt.buffer);
4779                        if text_anchor
4780                            .cmp(&excerpt.range.context.start, &excerpt.buffer)
4781                            .is_lt()
4782                        {
4783                            text_anchor = excerpt.range.context.start;
4784                        }
4785                        Anchor {
4786                            buffer_id: Some(excerpt.buffer_id),
4787                            excerpt_id: excerpt.id,
4788                            text_anchor,
4789                            diff_base_anchor: None,
4790                        }
4791                    } else if anchor.text_anchor.bias == Bias::Left {
4792                        Anchor::min()
4793                    } else {
4794                        Anchor::max()
4795                    };
4796                }
4797
4798                result.push((anchor_ix, anchor, kept_position));
4799            }
4800        }
4801        result.sort_unstable_by(|a, b| a.1.cmp(&b.1, self));
4802        result
4803    }
4804
4805    pub fn anchor_before<T: ToOffset>(&self, position: T) -> Anchor {
4806        self.anchor_at(position, Bias::Left)
4807    }
4808
4809    pub fn anchor_after<T: ToOffset>(&self, position: T) -> Anchor {
4810        self.anchor_at(position, Bias::Right)
4811    }
4812
4813    pub fn anchor_at<T: ToOffset>(&self, position: T, mut bias: Bias) -> Anchor {
4814        let offset = position.to_offset(self);
4815
4816        // Find the given position in the diff transforms. Determine the corresponding
4817        // offset in the excerpts, and whether the position is within a deleted hunk.
4818        let mut diff_transforms = self.diff_transforms.cursor::<(usize, ExcerptOffset)>(&());
4819        diff_transforms.seek(&offset, Bias::Right, &());
4820
4821        if offset == diff_transforms.start().0 && bias == Bias::Left {
4822            if let Some(prev_item) = diff_transforms.prev_item() {
4823                match prev_item {
4824                    DiffTransform::DeletedHunk { .. } => {
4825                        diff_transforms.prev(&());
4826                    }
4827                    _ => {}
4828                }
4829            }
4830        }
4831        let offset_in_transform = offset - diff_transforms.start().0;
4832        let mut excerpt_offset = diff_transforms.start().1;
4833        let mut diff_base_anchor = None;
4834        if let Some(DiffTransform::DeletedHunk {
4835            buffer_id,
4836            base_text_byte_range,
4837            has_trailing_newline,
4838            ..
4839        }) = diff_transforms.item()
4840        {
4841            let diff = self.diffs.get(buffer_id).expect("missing diff");
4842            if offset_in_transform > base_text_byte_range.len() {
4843                debug_assert!(*has_trailing_newline);
4844                bias = Bias::Right;
4845            } else {
4846                diff_base_anchor = Some(
4847                    diff.base_text()
4848                        .anchor_at(base_text_byte_range.start + offset_in_transform, bias),
4849                );
4850                bias = Bias::Left;
4851            }
4852        } else {
4853            excerpt_offset += ExcerptOffset::new(offset_in_transform);
4854        };
4855
4856        if let Some((excerpt_id, buffer_id, buffer)) = self.as_singleton() {
4857            return Anchor {
4858                buffer_id: Some(buffer_id),
4859                excerpt_id: *excerpt_id,
4860                text_anchor: buffer.anchor_at(excerpt_offset.value, bias),
4861                diff_base_anchor,
4862            };
4863        }
4864
4865        let mut excerpts = self
4866            .excerpts
4867            .cursor::<(ExcerptOffset, Option<ExcerptId>)>(&());
4868        excerpts.seek(&excerpt_offset, Bias::Right, &());
4869        if excerpts.item().is_none() && excerpt_offset == excerpts.start().0 && bias == Bias::Left {
4870            excerpts.prev(&());
4871        }
4872        if let Some(excerpt) = excerpts.item() {
4873            let mut overshoot = excerpt_offset.saturating_sub(excerpts.start().0).value;
4874            if excerpt.has_trailing_newline && excerpt_offset == excerpts.end(&()).0 {
4875                overshoot -= 1;
4876                bias = Bias::Right;
4877            }
4878
4879            let buffer_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
4880            let text_anchor =
4881                excerpt.clip_anchor(excerpt.buffer.anchor_at(buffer_start + overshoot, bias));
4882            Anchor {
4883                buffer_id: Some(excerpt.buffer_id),
4884                excerpt_id: excerpt.id,
4885                text_anchor,
4886                diff_base_anchor,
4887            }
4888        } else if excerpt_offset.is_zero() && bias == Bias::Left {
4889            Anchor::min()
4890        } else {
4891            Anchor::max()
4892        }
4893    }
4894
4895    /// Returns an anchor for the given excerpt and text anchor,
4896    /// returns None if the excerpt_id is no longer valid.
4897    pub fn anchor_in_excerpt(
4898        &self,
4899        excerpt_id: ExcerptId,
4900        text_anchor: text::Anchor,
4901    ) -> Option<Anchor> {
4902        let locator = self.excerpt_locator_for_id(excerpt_id);
4903        let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
4904        cursor.seek(locator, Bias::Left, &());
4905        if let Some(excerpt) = cursor.item() {
4906            if excerpt.id == excerpt_id {
4907                let text_anchor = excerpt.clip_anchor(text_anchor);
4908                drop(cursor);
4909                return Some(Anchor {
4910                    buffer_id: Some(excerpt.buffer_id),
4911                    excerpt_id,
4912                    text_anchor,
4913                    diff_base_anchor: None,
4914                });
4915            }
4916        }
4917        None
4918    }
4919
4920    pub fn context_range_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<Range<text::Anchor>> {
4921        Some(self.excerpt(excerpt_id)?.range.context.clone())
4922    }
4923
4924    pub fn can_resolve(&self, anchor: &Anchor) -> bool {
4925        if anchor.excerpt_id == ExcerptId::min() || anchor.excerpt_id == ExcerptId::max() {
4926            true
4927        } else if let Some(excerpt) = self.excerpt(anchor.excerpt_id) {
4928            excerpt.buffer.can_resolve(&anchor.text_anchor)
4929        } else {
4930            false
4931        }
4932    }
4933
4934    pub fn excerpts(
4935        &self,
4936    ) -> impl Iterator<Item = (ExcerptId, &BufferSnapshot, ExcerptRange<text::Anchor>)> {
4937        self.excerpts
4938            .iter()
4939            .map(|excerpt| (excerpt.id, &excerpt.buffer, excerpt.range.clone()))
4940    }
4941
4942    fn cursor<D: TextDimension + Default>(&self) -> MultiBufferCursor<D> {
4943        let excerpts = self.excerpts.cursor(&());
4944        let diff_transforms = self.diff_transforms.cursor(&());
4945        MultiBufferCursor {
4946            excerpts,
4947            diff_transforms,
4948            diffs: &self.diffs,
4949            cached_region: None,
4950        }
4951    }
4952
4953    pub fn excerpt_before(&self, id: ExcerptId) -> Option<MultiBufferExcerpt<'_>> {
4954        let start_locator = self.excerpt_locator_for_id(id);
4955        let mut excerpts = self
4956            .excerpts
4957            .cursor::<(Option<&Locator>, ExcerptDimension<usize>)>(&());
4958        excerpts.seek(&Some(start_locator), Bias::Left, &());
4959        excerpts.prev(&());
4960
4961        let mut diff_transforms = self
4962            .diff_transforms
4963            .cursor::<(OutputDimension<usize>, ExcerptDimension<usize>)>(&());
4964        diff_transforms.seek(&excerpts.start().1, Bias::Left, &());
4965        if diff_transforms.end(&()).1 < excerpts.start().1 {
4966            diff_transforms.next(&());
4967        }
4968
4969        let excerpt = excerpts.item()?;
4970        Some(MultiBufferExcerpt {
4971            excerpt,
4972            offset: diff_transforms.start().0 .0,
4973            buffer_offset: excerpt.range.context.start.to_offset(&excerpt.buffer),
4974            excerpt_offset: excerpts.start().1.clone(),
4975            diff_transforms,
4976        })
4977    }
4978
4979    pub fn excerpt_boundaries_in_range<R, T>(
4980        &self,
4981        range: R,
4982    ) -> impl Iterator<Item = ExcerptBoundary> + '_
4983    where
4984        R: RangeBounds<T>,
4985        T: ToOffset,
4986    {
4987        let start_offset;
4988        let start = match range.start_bound() {
4989            Bound::Included(start) => {
4990                start_offset = start.to_offset(self);
4991                Bound::Included(start_offset)
4992            }
4993            Bound::Excluded(_) => {
4994                panic!("not supported")
4995            }
4996            Bound::Unbounded => {
4997                start_offset = 0;
4998                Bound::Unbounded
4999            }
5000        };
5001        let end = match range.end_bound() {
5002            Bound::Included(end) => Bound::Included(end.to_offset(self)),
5003            Bound::Excluded(end) => Bound::Excluded(end.to_offset(self)),
5004            Bound::Unbounded => Bound::Unbounded,
5005        };
5006        let bounds = (start, end);
5007
5008        let mut cursor = self.cursor::<DimensionPair<usize, Point>>();
5009        cursor.seek(&DimensionPair {
5010            key: start_offset,
5011            value: None,
5012        });
5013
5014        if cursor
5015            .region()
5016            .is_some_and(|region| bounds.contains(&region.range.start.key))
5017        {
5018            cursor.prev_excerpt();
5019        } else {
5020            cursor.seek_to_start_of_current_excerpt();
5021        }
5022        let mut prev_region = cursor.region();
5023
5024        cursor.next_excerpt();
5025
5026        let mut visited_end = false;
5027        iter::from_fn(move || loop {
5028            if self.singleton {
5029                return None;
5030            }
5031
5032            let next_region = cursor.region();
5033            cursor.next_excerpt();
5034
5035            let next_region_start = if let Some(region) = &next_region {
5036                if !bounds.contains(&region.range.start.key) {
5037                    prev_region = next_region;
5038                    continue;
5039                }
5040                region.range.start.value.unwrap()
5041            } else {
5042                if !bounds.contains(&self.len()) {
5043                    return None;
5044                }
5045                self.max_point()
5046            };
5047            let next_region_end = if let Some(region) = cursor.region() {
5048                region.range.start.value.unwrap()
5049            } else {
5050                self.max_point()
5051            };
5052
5053            let prev = prev_region.as_ref().map(|region| ExcerptInfo {
5054                id: region.excerpt.id,
5055                buffer: region.excerpt.buffer.clone(),
5056                buffer_id: region.excerpt.buffer_id,
5057                range: region.excerpt.range.clone(),
5058                end_row: MultiBufferRow(next_region_start.row),
5059            });
5060
5061            let next = next_region.as_ref().map(|region| ExcerptInfo {
5062                id: region.excerpt.id,
5063                buffer: region.excerpt.buffer.clone(),
5064                buffer_id: region.excerpt.buffer_id,
5065                range: region.excerpt.range.clone(),
5066                end_row: if region.excerpt.has_trailing_newline {
5067                    MultiBufferRow(next_region_end.row - 1)
5068                } else {
5069                    MultiBufferRow(next_region_end.row)
5070                },
5071            });
5072
5073            if next.is_none() {
5074                if visited_end {
5075                    return None;
5076                } else {
5077                    visited_end = true;
5078                }
5079            }
5080
5081            let row = MultiBufferRow(next_region_start.row);
5082
5083            prev_region = next_region;
5084
5085            return Some(ExcerptBoundary { row, prev, next });
5086        })
5087    }
5088
5089    pub fn edit_count(&self) -> usize {
5090        self.edit_count
5091    }
5092
5093    pub fn non_text_state_update_count(&self) -> usize {
5094        self.non_text_state_update_count
5095    }
5096
5097    /// Returns the smallest enclosing bracket ranges containing the given range or
5098    /// None if no brackets contain range or the range is not contained in a single
5099    /// excerpt
5100    ///
5101    /// Can optionally pass a range_filter to filter the ranges of brackets to consider
5102    pub fn innermost_enclosing_bracket_ranges<T: ToOffset>(
5103        &self,
5104        range: Range<T>,
5105        range_filter: Option<&dyn Fn(&BufferSnapshot, Range<usize>, Range<usize>) -> bool>,
5106    ) -> Option<(Range<usize>, Range<usize>)> {
5107        let range = range.start.to_offset(self)..range.end.to_offset(self);
5108        let mut excerpt = self.excerpt_containing(range.clone())?;
5109        let buffer = excerpt.buffer();
5110        let excerpt_buffer_range = excerpt.buffer_range();
5111
5112        // Filter to ranges contained in the excerpt
5113        let range_filter = |open: Range<usize>, close: Range<usize>| -> bool {
5114            excerpt_buffer_range.contains(&open.start)
5115                && excerpt_buffer_range.contains(&close.end)
5116                && range_filter.map_or(true, |filter| filter(buffer, open, close))
5117        };
5118
5119        let (open, close) = excerpt.buffer().innermost_enclosing_bracket_ranges(
5120            excerpt.map_range_to_buffer(range),
5121            Some(&range_filter),
5122        )?;
5123
5124        Some((
5125            excerpt.map_range_from_buffer(open),
5126            excerpt.map_range_from_buffer(close),
5127        ))
5128    }
5129
5130    /// Returns enclosing bracket ranges containing the given range or returns None if the range is
5131    /// not contained in a single excerpt
5132    pub fn enclosing_bracket_ranges<T: ToOffset>(
5133        &self,
5134        range: Range<T>,
5135    ) -> Option<impl Iterator<Item = (Range<usize>, Range<usize>)> + '_> {
5136        let range = range.start.to_offset(self)..range.end.to_offset(self);
5137        let mut excerpt = self.excerpt_containing(range.clone())?;
5138
5139        Some(
5140            excerpt
5141                .buffer()
5142                .enclosing_bracket_ranges(excerpt.map_range_to_buffer(range))
5143                .filter_map(move |pair| {
5144                    if excerpt.contains_buffer_range(pair.open_range.start..pair.close_range.end) {
5145                        Some((
5146                            excerpt.map_range_from_buffer(pair.open_range),
5147                            excerpt.map_range_from_buffer(pair.close_range),
5148                        ))
5149                    } else {
5150                        None
5151                    }
5152                }),
5153        )
5154    }
5155
5156    /// Returns enclosing bracket ranges containing the given range or returns None if the range is
5157    /// not contained in a single excerpt
5158    pub fn text_object_ranges<T: ToOffset>(
5159        &self,
5160        range: Range<T>,
5161        options: TreeSitterOptions,
5162    ) -> impl Iterator<Item = (Range<usize>, TextObject)> + '_ {
5163        let range = range.start.to_offset(self)..range.end.to_offset(self);
5164        self.excerpt_containing(range.clone())
5165            .map(|mut excerpt| {
5166                excerpt
5167                    .buffer()
5168                    .text_object_ranges(excerpt.map_range_to_buffer(range), options)
5169                    .filter_map(move |(range, text_object)| {
5170                        if excerpt.contains_buffer_range(range.clone()) {
5171                            Some((excerpt.map_range_from_buffer(range), text_object))
5172                        } else {
5173                            None
5174                        }
5175                    })
5176            })
5177            .into_iter()
5178            .flatten()
5179    }
5180
5181    /// Returns bracket range pairs overlapping the given `range` or returns None if the `range` is
5182    /// not contained in a single excerpt
5183    pub fn bracket_ranges<T: ToOffset>(
5184        &self,
5185        range: Range<T>,
5186    ) -> Option<impl Iterator<Item = (Range<usize>, Range<usize>)> + '_> {
5187        let range = range.start.to_offset(self)..range.end.to_offset(self);
5188        let mut excerpt = self.excerpt_containing(range.clone())?;
5189
5190        Some(
5191            excerpt
5192                .buffer()
5193                .bracket_ranges(excerpt.map_range_to_buffer(range))
5194                .filter_map(move |pair| {
5195                    let buffer_range = pair.open_range.start..pair.close_range.end;
5196                    if excerpt.contains_buffer_range(buffer_range) {
5197                        Some((
5198                            excerpt.map_range_from_buffer(pair.open_range),
5199                            excerpt.map_range_from_buffer(pair.close_range),
5200                        ))
5201                    } else {
5202                        None
5203                    }
5204                }),
5205        )
5206    }
5207
5208    pub fn redacted_ranges<'a, T: ToOffset>(
5209        &'a self,
5210        range: Range<T>,
5211        redaction_enabled: impl Fn(Option<&Arc<dyn File>>) -> bool + 'a,
5212    ) -> impl Iterator<Item = Range<usize>> + 'a {
5213        let range = range.start.to_offset(self)..range.end.to_offset(self);
5214        self.lift_buffer_metadata(range, move |buffer, range| {
5215            if redaction_enabled(buffer.file()) {
5216                Some(buffer.redacted_ranges(range).map(|range| (range, ())))
5217            } else {
5218                None
5219            }
5220        })
5221        .map(|(range, _, _)| range)
5222    }
5223
5224    pub fn runnable_ranges(
5225        &self,
5226        range: Range<Anchor>,
5227    ) -> impl Iterator<Item = language::RunnableRange> + '_ {
5228        let range = range.start.to_offset(self)..range.end.to_offset(self);
5229        self.lift_buffer_metadata(range, move |buffer, range| {
5230            Some(
5231                buffer
5232                    .runnable_ranges(range.clone())
5233                    .filter(move |runnable| {
5234                        runnable.run_range.start >= range.start
5235                            && runnable.run_range.end < range.end
5236                    })
5237                    .map(|runnable| (runnable.run_range.clone(), runnable)),
5238            )
5239        })
5240        .map(|(run_range, runnable, _)| language::RunnableRange {
5241            run_range,
5242            ..runnable
5243        })
5244    }
5245
5246    pub fn line_indents(
5247        &self,
5248        start_row: MultiBufferRow,
5249        buffer_filter: impl Fn(&BufferSnapshot) -> bool,
5250    ) -> impl Iterator<Item = (MultiBufferRow, LineIndent, &BufferSnapshot)> {
5251        let max_point = self.max_point();
5252        let mut cursor = self.cursor::<Point>();
5253        cursor.seek(&Point::new(start_row.0, 0));
5254        iter::from_fn(move || {
5255            let mut region = cursor.region()?;
5256            while !buffer_filter(&region.excerpt.buffer) {
5257                cursor.next();
5258                region = cursor.region()?;
5259            }
5260            let overshoot = start_row.0.saturating_sub(region.range.start.row);
5261            let buffer_start_row =
5262                (region.buffer_range.start.row + overshoot).min(region.buffer_range.end.row);
5263
5264            let buffer_end_row = if region.is_main_buffer
5265                && (region.has_trailing_newline || region.range.end == max_point)
5266            {
5267                region.buffer_range.end.row
5268            } else {
5269                region.buffer_range.end.row.saturating_sub(1)
5270            };
5271
5272            let line_indents = region
5273                .buffer
5274                .line_indents_in_row_range(buffer_start_row..buffer_end_row);
5275            cursor.next();
5276            return Some(line_indents.map(move |(buffer_row, indent)| {
5277                let row = region.range.start.row + (buffer_row - region.buffer_range.start.row);
5278                (MultiBufferRow(row), indent, &region.excerpt.buffer)
5279            }));
5280        })
5281        .flatten()
5282    }
5283
5284    pub fn reversed_line_indents(
5285        &self,
5286        end_row: MultiBufferRow,
5287        buffer_filter: impl Fn(&BufferSnapshot) -> bool,
5288    ) -> impl Iterator<Item = (MultiBufferRow, LineIndent, &BufferSnapshot)> {
5289        let max_point = self.max_point();
5290        let mut cursor = self.cursor::<Point>();
5291        cursor.seek(&Point::new(end_row.0, 0));
5292        iter::from_fn(move || {
5293            let mut region = cursor.region()?;
5294            while !buffer_filter(&region.excerpt.buffer) {
5295                cursor.prev();
5296                region = cursor.region()?;
5297            }
5298
5299            let buffer_start_row = region.buffer_range.start.row;
5300            let buffer_end_row = if region.is_main_buffer
5301                && (region.has_trailing_newline || region.range.end == max_point)
5302            {
5303                region.buffer_range.end.row + 1
5304            } else {
5305                region.buffer_range.end.row
5306            };
5307
5308            let overshoot = end_row.0 - region.range.start.row;
5309            let buffer_end_row =
5310                (region.buffer_range.start.row + overshoot + 1).min(buffer_end_row);
5311
5312            let line_indents = region
5313                .buffer
5314                .reversed_line_indents_in_row_range(buffer_start_row..buffer_end_row);
5315            cursor.prev();
5316            return Some(line_indents.map(move |(buffer_row, indent)| {
5317                let row = region.range.start.row + (buffer_row - region.buffer_range.start.row);
5318                (MultiBufferRow(row), indent, &region.excerpt.buffer)
5319            }));
5320        })
5321        .flatten()
5322    }
5323
5324    pub async fn enclosing_indent(
5325        &self,
5326        mut target_row: MultiBufferRow,
5327    ) -> Option<(Range<MultiBufferRow>, LineIndent)> {
5328        let max_row = MultiBufferRow(self.max_point().row);
5329        if target_row >= max_row {
5330            return None;
5331        }
5332
5333        let mut target_indent = self.line_indent_for_row(target_row);
5334
5335        // If the current row is at the start of an indented block, we want to return this
5336        // block as the enclosing indent.
5337        if !target_indent.is_line_empty() && target_row < max_row {
5338            let next_line_indent = self.line_indent_for_row(MultiBufferRow(target_row.0 + 1));
5339            if !next_line_indent.is_line_empty()
5340                && target_indent.raw_len() < next_line_indent.raw_len()
5341            {
5342                target_indent = next_line_indent;
5343                target_row.0 += 1;
5344            }
5345        }
5346
5347        const SEARCH_ROW_LIMIT: u32 = 25000;
5348        const SEARCH_WHITESPACE_ROW_LIMIT: u32 = 2500;
5349        const YIELD_INTERVAL: u32 = 100;
5350
5351        let mut accessed_row_counter = 0;
5352
5353        // If there is a blank line at the current row, search for the next non indented lines
5354        if target_indent.is_line_empty() {
5355            let start = MultiBufferRow(target_row.0.saturating_sub(SEARCH_WHITESPACE_ROW_LIMIT));
5356            let end =
5357                MultiBufferRow((max_row.0 + 1).min(target_row.0 + SEARCH_WHITESPACE_ROW_LIMIT));
5358
5359            let mut non_empty_line_above = None;
5360            for (row, indent, _) in self.reversed_line_indents(target_row, |_| true) {
5361                if row < start {
5362                    break;
5363                }
5364                accessed_row_counter += 1;
5365                if accessed_row_counter == YIELD_INTERVAL {
5366                    accessed_row_counter = 0;
5367                    yield_now().await;
5368                }
5369                if !indent.is_line_empty() {
5370                    non_empty_line_above = Some((row, indent));
5371                    break;
5372                }
5373            }
5374
5375            let mut non_empty_line_below = None;
5376            for (row, indent, _) in self.line_indents(target_row, |_| true) {
5377                if row > end {
5378                    break;
5379                }
5380                accessed_row_counter += 1;
5381                if accessed_row_counter == YIELD_INTERVAL {
5382                    accessed_row_counter = 0;
5383                    yield_now().await;
5384                }
5385                if !indent.is_line_empty() {
5386                    non_empty_line_below = Some((row, indent));
5387                    break;
5388                }
5389            }
5390
5391            let (row, indent) = match (non_empty_line_above, non_empty_line_below) {
5392                (Some((above_row, above_indent)), Some((below_row, below_indent))) => {
5393                    if above_indent.raw_len() >= below_indent.raw_len() {
5394                        (above_row, above_indent)
5395                    } else {
5396                        (below_row, below_indent)
5397                    }
5398                }
5399                (Some(above), None) => above,
5400                (None, Some(below)) => below,
5401                _ => return None,
5402            };
5403
5404            target_indent = indent;
5405            target_row = row;
5406        }
5407
5408        let start = MultiBufferRow(target_row.0.saturating_sub(SEARCH_ROW_LIMIT));
5409        let end = MultiBufferRow((max_row.0 + 1).min(target_row.0 + SEARCH_ROW_LIMIT));
5410
5411        let mut start_indent = None;
5412        for (row, indent, _) in self.reversed_line_indents(target_row, |_| true) {
5413            if row < start {
5414                break;
5415            }
5416            accessed_row_counter += 1;
5417            if accessed_row_counter == YIELD_INTERVAL {
5418                accessed_row_counter = 0;
5419                yield_now().await;
5420            }
5421            if !indent.is_line_empty() && indent.raw_len() < target_indent.raw_len() {
5422                start_indent = Some((row, indent));
5423                break;
5424            }
5425        }
5426        let (start_row, start_indent_size) = start_indent?;
5427
5428        let mut end_indent = (end, None);
5429        for (row, indent, _) in self.line_indents(target_row, |_| true) {
5430            if row > end {
5431                break;
5432            }
5433            accessed_row_counter += 1;
5434            if accessed_row_counter == YIELD_INTERVAL {
5435                accessed_row_counter = 0;
5436                yield_now().await;
5437            }
5438            if !indent.is_line_empty() && indent.raw_len() < target_indent.raw_len() {
5439                end_indent = (MultiBufferRow(row.0.saturating_sub(1)), Some(indent));
5440                break;
5441            }
5442        }
5443        let (end_row, end_indent_size) = end_indent;
5444
5445        let indent = if let Some(end_indent_size) = end_indent_size {
5446            if start_indent_size.raw_len() > end_indent_size.raw_len() {
5447                start_indent_size
5448            } else {
5449                end_indent_size
5450            }
5451        } else {
5452            start_indent_size
5453        };
5454
5455        Some((start_row..end_row, indent))
5456    }
5457
5458    pub fn indent_guides_in_range<T: ToPoint>(
5459        &self,
5460        range: Range<T>,
5461        ignore_disabled_for_language: bool,
5462        cx: &App,
5463    ) -> impl Iterator<Item = IndentGuide> {
5464        let range = range.start.to_point(self)..range.end.to_point(self);
5465        let start_row = MultiBufferRow(range.start.row);
5466        let end_row = MultiBufferRow(range.end.row);
5467
5468        let mut row_indents = self.line_indents(start_row, |buffer| {
5469            let settings =
5470                language_settings(buffer.language().map(|l| l.name()), buffer.file(), cx);
5471            settings.indent_guides.enabled || ignore_disabled_for_language
5472        });
5473
5474        let mut result = Vec::new();
5475        let mut indent_stack = SmallVec::<[IndentGuide; 8]>::new();
5476
5477        while let Some((first_row, mut line_indent, buffer)) = row_indents.next() {
5478            if first_row > end_row {
5479                break;
5480            }
5481            let current_depth = indent_stack.len() as u32;
5482
5483            let settings =
5484                language_settings(buffer.language().map(|l| l.name()), buffer.file(), cx);
5485            let tab_size = settings.tab_size.get() as u32;
5486
5487            // When encountering empty, continue until found useful line indent
5488            // then add to the indent stack with the depth found
5489            let mut found_indent = false;
5490            let mut last_row = first_row;
5491            if line_indent.is_line_empty() {
5492                while !found_indent {
5493                    let Some((target_row, new_line_indent, _)) = row_indents.next() else {
5494                        break;
5495                    };
5496                    const TRAILING_ROW_SEARCH_LIMIT: u32 = 25;
5497                    if target_row > MultiBufferRow(end_row.0 + TRAILING_ROW_SEARCH_LIMIT) {
5498                        break;
5499                    }
5500
5501                    if new_line_indent.is_line_empty() {
5502                        continue;
5503                    }
5504                    last_row = target_row.min(end_row);
5505                    line_indent = new_line_indent;
5506                    found_indent = true;
5507                    break;
5508                }
5509            } else {
5510                found_indent = true
5511            }
5512
5513            let depth = if found_indent {
5514                line_indent.len(tab_size) / tab_size
5515                    + ((line_indent.len(tab_size) % tab_size) > 0) as u32
5516            } else {
5517                current_depth
5518            };
5519
5520            match depth.cmp(&current_depth) {
5521                cmp::Ordering::Less => {
5522                    for _ in 0..(current_depth - depth) {
5523                        let mut indent = indent_stack.pop().unwrap();
5524                        if last_row != first_row {
5525                            // In this case, we landed on an empty row, had to seek forward,
5526                            // and discovered that the indent we where on is ending.
5527                            // This means that the last display row must
5528                            // be on line that ends this indent range, so we
5529                            // should display the range up to the first non-empty line
5530                            indent.end_row = MultiBufferRow(first_row.0.saturating_sub(1));
5531                        }
5532
5533                        result.push(indent)
5534                    }
5535                }
5536                cmp::Ordering::Greater => {
5537                    for next_depth in current_depth..depth {
5538                        indent_stack.push(IndentGuide {
5539                            buffer_id: buffer.remote_id(),
5540                            start_row: first_row,
5541                            end_row: last_row,
5542                            depth: next_depth,
5543                            tab_size,
5544                            settings: settings.indent_guides,
5545                        });
5546                    }
5547                }
5548                _ => {}
5549            }
5550
5551            for indent in indent_stack.iter_mut() {
5552                indent.end_row = last_row;
5553            }
5554        }
5555
5556        result.extend(indent_stack);
5557        result.into_iter()
5558    }
5559
5560    pub fn trailing_excerpt_update_count(&self) -> usize {
5561        self.trailing_excerpt_update_count
5562    }
5563
5564    pub fn file_at<T: ToOffset>(&self, point: T) -> Option<&Arc<dyn File>> {
5565        self.point_to_buffer_offset(point)
5566            .and_then(|(buffer, _)| buffer.file())
5567    }
5568
5569    pub fn language_at<T: ToOffset>(&self, point: T) -> Option<&Arc<Language>> {
5570        self.point_to_buffer_offset(point)
5571            .and_then(|(buffer, offset)| buffer.language_at(offset))
5572    }
5573
5574    fn language_settings<'a>(&'a self, cx: &'a App) -> Cow<'a, LanguageSettings> {
5575        self.excerpts
5576            .first()
5577            .map(|excerpt| &excerpt.buffer)
5578            .map(|buffer| {
5579                language_settings(
5580                    buffer.language().map(|language| language.name()),
5581                    buffer.file(),
5582                    cx,
5583                )
5584            })
5585            .unwrap_or_else(move || self.language_settings_at(0, cx))
5586    }
5587
5588    pub fn language_settings_at<'a, T: ToOffset>(
5589        &'a self,
5590        point: T,
5591        cx: &'a App,
5592    ) -> Cow<'a, LanguageSettings> {
5593        let mut language = None;
5594        let mut file = None;
5595        if let Some((buffer, offset)) = self.point_to_buffer_offset(point) {
5596            language = buffer.language_at(offset);
5597            file = buffer.file();
5598        }
5599        language_settings(language.map(|l| l.name()), file, cx)
5600    }
5601
5602    pub fn language_scope_at<T: ToOffset>(&self, point: T) -> Option<LanguageScope> {
5603        self.point_to_buffer_offset(point)
5604            .and_then(|(buffer, offset)| buffer.language_scope_at(offset))
5605    }
5606
5607    pub fn char_classifier_at<T: ToOffset>(&self, point: T) -> CharClassifier {
5608        self.point_to_buffer_offset(point)
5609            .map(|(buffer, offset)| buffer.char_classifier_at(offset))
5610            .unwrap_or_default()
5611    }
5612
5613    pub fn language_indent_size_at<T: ToOffset>(
5614        &self,
5615        position: T,
5616        cx: &App,
5617    ) -> Option<IndentSize> {
5618        let (buffer_snapshot, offset) = self.point_to_buffer_offset(position)?;
5619        Some(buffer_snapshot.language_indent_size_at(offset, cx))
5620    }
5621
5622    pub fn is_dirty(&self) -> bool {
5623        self.is_dirty
5624    }
5625
5626    pub fn has_deleted_file(&self) -> bool {
5627        self.has_deleted_file
5628    }
5629
5630    pub fn has_conflict(&self) -> bool {
5631        self.has_conflict
5632    }
5633
5634    pub fn has_diagnostics(&self) -> bool {
5635        self.excerpts
5636            .iter()
5637            .any(|excerpt| excerpt.buffer.has_diagnostics())
5638    }
5639
5640    pub fn diagnostic_group(
5641        &self,
5642        buffer_id: BufferId,
5643        group_id: usize,
5644    ) -> impl Iterator<Item = DiagnosticEntry<Point>> + '_ {
5645        self.lift_buffer_metadata(Point::zero()..self.max_point(), move |buffer, _| {
5646            if buffer.remote_id() != buffer_id {
5647                return None;
5648            };
5649            Some(
5650                buffer
5651                    .diagnostic_group(group_id)
5652                    .map(move |DiagnosticEntry { diagnostic, range }| (range, diagnostic)),
5653            )
5654        })
5655        .map(|(range, diagnostic, _)| DiagnosticEntry { diagnostic, range })
5656    }
5657
5658    pub fn diagnostics_in_range<'a, T>(
5659        &'a self,
5660        range: Range<T>,
5661    ) -> impl Iterator<Item = DiagnosticEntry<T>> + 'a
5662    where
5663        T: 'a
5664            + text::ToOffset
5665            + text::FromAnchor
5666            + TextDimension
5667            + Ord
5668            + Sub<T, Output = T>
5669            + fmt::Debug,
5670    {
5671        self.lift_buffer_metadata(range, move |buffer, buffer_range| {
5672            Some(
5673                buffer
5674                    .diagnostics_in_range(buffer_range.start..buffer_range.end, false)
5675                    .map(|entry| (entry.range, entry.diagnostic)),
5676            )
5677        })
5678        .map(|(range, diagnostic, _)| DiagnosticEntry { diagnostic, range })
5679    }
5680
5681    pub fn syntax_ancestor<T: ToOffset>(
5682        &self,
5683        range: Range<T>,
5684    ) -> Option<(tree_sitter::Node, MultiOrSingleBufferOffsetRange)> {
5685        let range = range.start.to_offset(self)..range.end.to_offset(self);
5686        let mut excerpt = self.excerpt_containing(range.clone())?;
5687        let node = excerpt
5688            .buffer()
5689            .syntax_ancestor(excerpt.map_range_to_buffer(range))?;
5690        let node_range = node.byte_range();
5691        let range = if excerpt.contains_buffer_range(node_range.clone()) {
5692            MultiOrSingleBufferOffsetRange::Multi(excerpt.map_range_from_buffer(node_range))
5693        } else {
5694            MultiOrSingleBufferOffsetRange::Single(node_range)
5695        };
5696        Some((node, range))
5697    }
5698
5699    pub fn outline(&self, theme: Option<&SyntaxTheme>) -> Option<Outline<Anchor>> {
5700        let (excerpt_id, _, buffer) = self.as_singleton()?;
5701        let outline = buffer.outline(theme)?;
5702        Some(Outline::new(
5703            outline
5704                .items
5705                .into_iter()
5706                .flat_map(|item| {
5707                    Some(OutlineItem {
5708                        depth: item.depth,
5709                        range: self.anchor_in_excerpt(*excerpt_id, item.range.start)?
5710                            ..self.anchor_in_excerpt(*excerpt_id, item.range.end)?,
5711                        text: item.text,
5712                        highlight_ranges: item.highlight_ranges,
5713                        name_ranges: item.name_ranges,
5714                        body_range: item.body_range.and_then(|body_range| {
5715                            Some(
5716                                self.anchor_in_excerpt(*excerpt_id, body_range.start)?
5717                                    ..self.anchor_in_excerpt(*excerpt_id, body_range.end)?,
5718                            )
5719                        }),
5720                        annotation_range: item.annotation_range.and_then(|annotation_range| {
5721                            Some(
5722                                self.anchor_in_excerpt(*excerpt_id, annotation_range.start)?
5723                                    ..self.anchor_in_excerpt(*excerpt_id, annotation_range.end)?,
5724                            )
5725                        }),
5726                    })
5727                })
5728                .collect(),
5729        ))
5730    }
5731
5732    pub fn symbols_containing<T: ToOffset>(
5733        &self,
5734        offset: T,
5735        theme: Option<&SyntaxTheme>,
5736    ) -> Option<(BufferId, Vec<OutlineItem<Anchor>>)> {
5737        let anchor = self.anchor_before(offset);
5738        let excerpt_id = anchor.excerpt_id;
5739        let excerpt = self.excerpt(excerpt_id)?;
5740        Some((
5741            excerpt.buffer_id,
5742            excerpt
5743                .buffer
5744                .symbols_containing(anchor.text_anchor, theme)
5745                .into_iter()
5746                .flatten()
5747                .flat_map(|item| {
5748                    Some(OutlineItem {
5749                        depth: item.depth,
5750                        range: self.anchor_in_excerpt(excerpt_id, item.range.start)?
5751                            ..self.anchor_in_excerpt(excerpt_id, item.range.end)?,
5752                        text: item.text,
5753                        highlight_ranges: item.highlight_ranges,
5754                        name_ranges: item.name_ranges,
5755                        body_range: item.body_range.and_then(|body_range| {
5756                            Some(
5757                                self.anchor_in_excerpt(excerpt_id, body_range.start)?
5758                                    ..self.anchor_in_excerpt(excerpt_id, body_range.end)?,
5759                            )
5760                        }),
5761                        annotation_range: item.annotation_range.and_then(|body_range| {
5762                            Some(
5763                                self.anchor_in_excerpt(excerpt_id, body_range.start)?
5764                                    ..self.anchor_in_excerpt(excerpt_id, body_range.end)?,
5765                            )
5766                        }),
5767                    })
5768                })
5769                .collect(),
5770        ))
5771    }
5772
5773    fn excerpt_locator_for_id(&self, id: ExcerptId) -> &Locator {
5774        if id == ExcerptId::min() {
5775            Locator::min_ref()
5776        } else if id == ExcerptId::max() {
5777            Locator::max_ref()
5778        } else {
5779            let mut cursor = self.excerpt_ids.cursor::<ExcerptId>(&());
5780            cursor.seek(&id, Bias::Left, &());
5781            if let Some(entry) = cursor.item() {
5782                if entry.id == id {
5783                    return &entry.locator;
5784                }
5785            }
5786            panic!("invalid excerpt id {:?}", id)
5787        }
5788    }
5789
5790    /// Returns the locators referenced by the given excerpt IDs, sorted by locator.
5791    fn excerpt_locators_for_ids(
5792        &self,
5793        ids: impl IntoIterator<Item = ExcerptId>,
5794    ) -> SmallVec<[Locator; 1]> {
5795        let mut sorted_ids = ids.into_iter().collect::<SmallVec<[_; 1]>>();
5796        sorted_ids.sort_unstable();
5797        let mut locators = SmallVec::new();
5798
5799        while sorted_ids.last() == Some(&ExcerptId::max()) {
5800            sorted_ids.pop();
5801            if let Some(mapping) = self.excerpt_ids.last() {
5802                locators.push(mapping.locator.clone());
5803            }
5804        }
5805
5806        let mut sorted_ids = sorted_ids.into_iter().dedup().peekable();
5807        if sorted_ids.peek() == Some(&ExcerptId::min()) {
5808            sorted_ids.next();
5809            if let Some(mapping) = self.excerpt_ids.first() {
5810                locators.push(mapping.locator.clone());
5811            }
5812        }
5813
5814        let mut cursor = self.excerpt_ids.cursor::<ExcerptId>(&());
5815        for id in sorted_ids {
5816            if cursor.seek_forward(&id, Bias::Left, &()) {
5817                locators.push(cursor.item().unwrap().locator.clone());
5818            } else {
5819                panic!("invalid excerpt id {:?}", id);
5820            }
5821        }
5822
5823        locators.sort_unstable();
5824        locators
5825    }
5826
5827    pub fn buffer_id_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<BufferId> {
5828        Some(self.excerpt(excerpt_id)?.buffer_id)
5829    }
5830
5831    pub fn buffer_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<&BufferSnapshot> {
5832        Some(&self.excerpt(excerpt_id)?.buffer)
5833    }
5834
5835    pub fn range_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<Range<Point>> {
5836        let mut cursor = self
5837            .excerpts
5838            .cursor::<(Option<&Locator>, ExcerptDimension<Point>)>(&());
5839        let locator = self.excerpt_locator_for_id(excerpt_id);
5840        if cursor.seek(&Some(locator), Bias::Left, &()) {
5841            let start = cursor.start().1.clone();
5842            let end = cursor.end(&()).1;
5843            let mut diff_transforms = self
5844                .diff_transforms
5845                .cursor::<(ExcerptDimension<Point>, OutputDimension<Point>)>(&());
5846            diff_transforms.seek(&start, Bias::Left, &());
5847            let overshoot = start.0 - diff_transforms.start().0 .0;
5848            let start = diff_transforms.start().1 .0 + overshoot;
5849            diff_transforms.seek(&end, Bias::Right, &());
5850            let overshoot = end.0 - diff_transforms.start().0 .0;
5851            let end = diff_transforms.start().1 .0 + overshoot;
5852            Some(start..end)
5853        } else {
5854            None
5855        }
5856    }
5857
5858    pub fn buffer_range_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<Range<text::Anchor>> {
5859        let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
5860        let locator = self.excerpt_locator_for_id(excerpt_id);
5861        if cursor.seek(&Some(locator), Bias::Left, &()) {
5862            if let Some(excerpt) = cursor.item() {
5863                return Some(excerpt.range.context.clone());
5864            }
5865        }
5866        None
5867    }
5868
5869    fn excerpt(&self, excerpt_id: ExcerptId) -> Option<&Excerpt> {
5870        let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
5871        let locator = self.excerpt_locator_for_id(excerpt_id);
5872        cursor.seek(&Some(locator), Bias::Left, &());
5873        if let Some(excerpt) = cursor.item() {
5874            if excerpt.id == excerpt_id {
5875                return Some(excerpt);
5876            }
5877        }
5878        None
5879    }
5880
5881    /// Returns the excerpt containing range and its offset start within the multibuffer or none if `range` spans multiple excerpts
5882    pub fn excerpt_containing<T: ToOffset>(&self, range: Range<T>) -> Option<MultiBufferExcerpt> {
5883        let range = range.start.to_offset(self)..range.end.to_offset(self);
5884        let mut cursor = self.cursor::<usize>();
5885        cursor.seek(&range.start);
5886
5887        let start_excerpt = cursor.excerpt()?;
5888        if range.end != range.start {
5889            cursor.seek_forward(&range.end);
5890            if cursor.excerpt()?.id != start_excerpt.id {
5891                return None;
5892            }
5893        }
5894
5895        cursor.seek_to_start_of_current_excerpt();
5896        let region = cursor.region()?;
5897        let offset = region.range.start;
5898        let buffer_offset = region.buffer_range.start;
5899        let excerpt_offset = cursor.excerpts.start().clone();
5900        Some(MultiBufferExcerpt {
5901            diff_transforms: cursor.diff_transforms,
5902            excerpt: start_excerpt,
5903            offset,
5904            buffer_offset,
5905            excerpt_offset,
5906        })
5907    }
5908
5909    pub fn selections_in_range<'a>(
5910        &'a self,
5911        range: &'a Range<Anchor>,
5912        include_local: bool,
5913    ) -> impl 'a + Iterator<Item = (ReplicaId, bool, CursorShape, Selection<Anchor>)> {
5914        let mut cursor = self.excerpts.cursor::<ExcerptSummary>(&());
5915        let start_locator = self.excerpt_locator_for_id(range.start.excerpt_id);
5916        let end_locator = self.excerpt_locator_for_id(range.end.excerpt_id);
5917        cursor.seek(start_locator, Bias::Left, &());
5918        cursor
5919            .take_while(move |excerpt| excerpt.locator <= *end_locator)
5920            .flat_map(move |excerpt| {
5921                let mut query_range = excerpt.range.context.start..excerpt.range.context.end;
5922                if excerpt.id == range.start.excerpt_id {
5923                    query_range.start = range.start.text_anchor;
5924                }
5925                if excerpt.id == range.end.excerpt_id {
5926                    query_range.end = range.end.text_anchor;
5927                }
5928
5929                excerpt
5930                    .buffer
5931                    .selections_in_range(query_range, include_local)
5932                    .flat_map(move |(replica_id, line_mode, cursor_shape, selections)| {
5933                        selections.map(move |selection| {
5934                            let mut start = Anchor {
5935                                buffer_id: Some(excerpt.buffer_id),
5936                                excerpt_id: excerpt.id,
5937                                text_anchor: selection.start,
5938                                diff_base_anchor: None,
5939                            };
5940                            let mut end = Anchor {
5941                                buffer_id: Some(excerpt.buffer_id),
5942                                excerpt_id: excerpt.id,
5943                                text_anchor: selection.end,
5944                                diff_base_anchor: None,
5945                            };
5946                            if range.start.cmp(&start, self).is_gt() {
5947                                start = range.start;
5948                            }
5949                            if range.end.cmp(&end, self).is_lt() {
5950                                end = range.end;
5951                            }
5952
5953                            (
5954                                replica_id,
5955                                line_mode,
5956                                cursor_shape,
5957                                Selection {
5958                                    id: selection.id,
5959                                    start,
5960                                    end,
5961                                    reversed: selection.reversed,
5962                                    goal: selection.goal,
5963                                },
5964                            )
5965                        })
5966                    })
5967            })
5968    }
5969
5970    pub fn show_headers(&self) -> bool {
5971        self.show_headers
5972    }
5973
5974    pub fn diff_for_buffer_id(&self, buffer_id: BufferId) -> Option<&BufferDiffSnapshot> {
5975        self.diffs.get(&buffer_id)
5976    }
5977}
5978
5979#[cfg(any(test, feature = "test-support"))]
5980impl MultiBufferSnapshot {
5981    pub fn random_byte_range(&self, start_offset: usize, rng: &mut impl rand::Rng) -> Range<usize> {
5982        let end = self.clip_offset(rng.gen_range(start_offset..=self.len()), Bias::Right);
5983        let start = self.clip_offset(rng.gen_range(start_offset..=end), Bias::Right);
5984        start..end
5985    }
5986
5987    #[cfg(any(test, feature = "test-support"))]
5988    fn check_invariants(&self) {
5989        let excerpts = self.excerpts.items(&());
5990        let excerpt_ids = self.excerpt_ids.items(&());
5991
5992        for (ix, excerpt) in excerpts.iter().enumerate() {
5993            if ix == 0 {
5994                if excerpt.locator <= Locator::min() {
5995                    panic!("invalid first excerpt locator {:?}", excerpt.locator);
5996                }
5997            } else if excerpt.locator <= excerpts[ix - 1].locator {
5998                panic!("excerpts are out-of-order: {:?}", excerpts);
5999            }
6000        }
6001
6002        for (ix, entry) in excerpt_ids.iter().enumerate() {
6003            if ix == 0 {
6004                if entry.id.cmp(&ExcerptId::min(), &self).is_le() {
6005                    panic!("invalid first excerpt id {:?}", entry.id);
6006                }
6007            } else if entry.id <= excerpt_ids[ix - 1].id {
6008                panic!("excerpt ids are out-of-order: {:?}", excerpt_ids);
6009            }
6010        }
6011
6012        if self.diff_transforms.summary().input != self.excerpts.summary().text {
6013            panic!(
6014                "incorrect input summary. expected {:?}, got {:?}. transforms: {:+?}",
6015                self.excerpts.summary().text.len,
6016                self.diff_transforms.summary().input,
6017                self.diff_transforms.items(&()),
6018            );
6019        }
6020
6021        let mut prev_transform: Option<&DiffTransform> = None;
6022        for item in self.diff_transforms.iter() {
6023            if let DiffTransform::BufferContent {
6024                summary,
6025                inserted_hunk_info,
6026            } = item
6027            {
6028                if let Some(DiffTransform::BufferContent {
6029                    inserted_hunk_info: prev_inserted_hunk_info,
6030                    ..
6031                }) = prev_transform
6032                {
6033                    if *inserted_hunk_info == *prev_inserted_hunk_info {
6034                        panic!(
6035                            "multiple adjacent buffer content transforms with is_inserted_hunk = {inserted_hunk_info:?}. transforms: {:+?}",
6036                            self.diff_transforms.items(&()));
6037                    }
6038                }
6039                if summary.len == 0 && !self.is_empty() {
6040                    panic!("empty buffer content transform");
6041                }
6042            }
6043            prev_transform = Some(item);
6044        }
6045    }
6046}
6047
6048impl<'a, D> MultiBufferCursor<'a, D>
6049where
6050    D: TextDimension + Ord + Sub<D, Output = D>,
6051{
6052    fn seek(&mut self, position: &D) {
6053        self.cached_region.take();
6054        self.diff_transforms
6055            .seek(&OutputDimension(*position), Bias::Right, &());
6056        if self.diff_transforms.item().is_none() && *position == self.diff_transforms.start().0 .0 {
6057            self.diff_transforms.prev(&());
6058        }
6059
6060        let mut excerpt_position = self.diff_transforms.start().1 .0;
6061        if let Some(DiffTransform::BufferContent { .. }) = self.diff_transforms.item() {
6062            let overshoot = *position - self.diff_transforms.start().0 .0;
6063            excerpt_position.add_assign(&overshoot);
6064        }
6065
6066        self.excerpts
6067            .seek(&ExcerptDimension(excerpt_position), Bias::Right, &());
6068        if self.excerpts.item().is_none() && excerpt_position == self.excerpts.start().0 {
6069            self.excerpts.prev(&());
6070        }
6071    }
6072
6073    fn seek_forward(&mut self, position: &D) {
6074        self.cached_region.take();
6075        self.diff_transforms
6076            .seek_forward(&OutputDimension(*position), Bias::Right, &());
6077        if self.diff_transforms.item().is_none() && *position == self.diff_transforms.start().0 .0 {
6078            self.diff_transforms.prev(&());
6079        }
6080
6081        let overshoot = *position - self.diff_transforms.start().0 .0;
6082        let mut excerpt_position = self.diff_transforms.start().1 .0;
6083        if let Some(DiffTransform::BufferContent { .. }) = self.diff_transforms.item() {
6084            excerpt_position.add_assign(&overshoot);
6085        }
6086
6087        self.excerpts
6088            .seek_forward(&ExcerptDimension(excerpt_position), Bias::Right, &());
6089        if self.excerpts.item().is_none() && excerpt_position == self.excerpts.start().0 {
6090            self.excerpts.prev(&());
6091        }
6092    }
6093
6094    fn next_excerpt(&mut self) {
6095        self.excerpts.next(&());
6096        self.seek_to_start_of_current_excerpt();
6097    }
6098
6099    fn prev_excerpt(&mut self) {
6100        self.excerpts.prev(&());
6101        self.seek_to_start_of_current_excerpt();
6102    }
6103
6104    fn seek_to_start_of_current_excerpt(&mut self) {
6105        self.cached_region.take();
6106        self.diff_transforms
6107            .seek(self.excerpts.start(), Bias::Left, &());
6108        if self.diff_transforms.end(&()).1 == *self.excerpts.start()
6109            && self.diff_transforms.start().1 < *self.excerpts.start()
6110            && self.diff_transforms.next_item().is_some()
6111        {
6112            self.diff_transforms.next(&());
6113        }
6114    }
6115
6116    fn next(&mut self) {
6117        self.cached_region.take();
6118        match self.diff_transforms.end(&()).1.cmp(&self.excerpts.end(&())) {
6119            cmp::Ordering::Less => self.diff_transforms.next(&()),
6120            cmp::Ordering::Greater => self.excerpts.next(&()),
6121            cmp::Ordering::Equal => {
6122                self.diff_transforms.next(&());
6123                if self.diff_transforms.end(&()).1 > self.excerpts.end(&())
6124                    || self.diff_transforms.item().is_none()
6125                {
6126                    self.excerpts.next(&());
6127                } else if let Some(DiffTransform::DeletedHunk { hunk_info, .. }) =
6128                    self.diff_transforms.item()
6129                {
6130                    if self
6131                        .excerpts
6132                        .item()
6133                        .map_or(false, |excerpt| excerpt.id != hunk_info.excerpt_id)
6134                    {
6135                        self.excerpts.next(&());
6136                    }
6137                }
6138            }
6139        }
6140    }
6141
6142    fn prev(&mut self) {
6143        self.cached_region.take();
6144        match self.diff_transforms.start().1.cmp(self.excerpts.start()) {
6145            cmp::Ordering::Less => self.excerpts.prev(&()),
6146            cmp::Ordering::Greater => self.diff_transforms.prev(&()),
6147            cmp::Ordering::Equal => {
6148                self.diff_transforms.prev(&());
6149                if self.diff_transforms.start().1 < *self.excerpts.start()
6150                    || self.diff_transforms.item().is_none()
6151                {
6152                    self.excerpts.prev(&());
6153                }
6154            }
6155        }
6156    }
6157
6158    fn region(&mut self) -> Option<MultiBufferRegion<'a, D>> {
6159        if self.cached_region.is_none() {
6160            self.cached_region = self.build_region();
6161        }
6162        self.cached_region.clone()
6163    }
6164
6165    fn is_at_end_of_excerpt(&mut self) -> bool {
6166        if self.diff_transforms.end(&()).1 < self.excerpts.end(&()) {
6167            return false;
6168        } else if self.diff_transforms.end(&()).1 > self.excerpts.end(&())
6169            || self.diff_transforms.item().is_none()
6170        {
6171            return true;
6172        }
6173
6174        let next_transform = self.diff_transforms.next_item();
6175        next_transform.map_or(true, |next_transform| match next_transform {
6176            DiffTransform::BufferContent { .. } => true,
6177            DiffTransform::DeletedHunk { hunk_info, .. } => self
6178                .excerpts
6179                .item()
6180                .map_or(false, |excerpt| excerpt.id != hunk_info.excerpt_id),
6181        })
6182    }
6183
6184    fn main_buffer_position(&self) -> Option<D> {
6185        let excerpt = self.excerpts.item()?;
6186        let buffer = &excerpt.buffer;
6187        let buffer_context_start = excerpt.range.context.start.summary::<D>(buffer);
6188        let mut buffer_start = buffer_context_start;
6189        let overshoot = self.diff_transforms.end(&()).1 .0 - self.excerpts.start().0;
6190        buffer_start.add_assign(&overshoot);
6191        Some(buffer_start)
6192    }
6193
6194    fn build_region(&self) -> Option<MultiBufferRegion<'a, D>> {
6195        let excerpt = self.excerpts.item()?;
6196        match self.diff_transforms.item()? {
6197            DiffTransform::DeletedHunk {
6198                buffer_id,
6199                base_text_byte_range,
6200                has_trailing_newline,
6201                hunk_info,
6202                ..
6203            } => {
6204                let diff = self.diffs.get(&buffer_id)?;
6205                let buffer = diff.base_text();
6206                let mut rope_cursor = buffer.as_rope().cursor(0);
6207                let buffer_start = rope_cursor.summary::<D>(base_text_byte_range.start);
6208                let buffer_range_len = rope_cursor.summary::<D>(base_text_byte_range.end);
6209                let mut buffer_end = buffer_start;
6210                buffer_end.add_assign(&buffer_range_len);
6211                let start = self.diff_transforms.start().0 .0;
6212                let end = self.diff_transforms.end(&()).0 .0;
6213                return Some(MultiBufferRegion {
6214                    buffer,
6215                    excerpt,
6216                    has_trailing_newline: *has_trailing_newline,
6217                    is_main_buffer: false,
6218                    diff_hunk_status: Some(DiffHunkStatus::deleted(
6219                        hunk_info.hunk_secondary_status,
6220                    )),
6221                    buffer_range: buffer_start..buffer_end,
6222                    range: start..end,
6223                });
6224            }
6225            DiffTransform::BufferContent {
6226                inserted_hunk_info, ..
6227            } => {
6228                let buffer = &excerpt.buffer;
6229                let buffer_context_start = excerpt.range.context.start.summary::<D>(buffer);
6230
6231                let mut start = self.diff_transforms.start().0 .0;
6232                let mut buffer_start = buffer_context_start;
6233                if self.diff_transforms.start().1 < *self.excerpts.start() {
6234                    let overshoot = self.excerpts.start().0 - self.diff_transforms.start().1 .0;
6235                    start.add_assign(&overshoot);
6236                } else {
6237                    let overshoot = self.diff_transforms.start().1 .0 - self.excerpts.start().0;
6238                    buffer_start.add_assign(&overshoot);
6239                }
6240
6241                let mut end;
6242                let mut buffer_end;
6243                let has_trailing_newline;
6244                if self.diff_transforms.end(&()).1 .0 < self.excerpts.end(&()).0 {
6245                    let overshoot = self.diff_transforms.end(&()).1 .0 - self.excerpts.start().0;
6246                    end = self.diff_transforms.end(&()).0 .0;
6247                    buffer_end = buffer_context_start;
6248                    buffer_end.add_assign(&overshoot);
6249                    has_trailing_newline = false;
6250                } else {
6251                    let overshoot = self.excerpts.end(&()).0 - self.diff_transforms.start().1 .0;
6252                    end = self.diff_transforms.start().0 .0;
6253                    end.add_assign(&overshoot);
6254                    buffer_end = excerpt.range.context.end.summary::<D>(buffer);
6255                    has_trailing_newline = excerpt.has_trailing_newline;
6256                };
6257
6258                Some(MultiBufferRegion {
6259                    buffer,
6260                    excerpt,
6261                    has_trailing_newline,
6262                    is_main_buffer: true,
6263                    diff_hunk_status: inserted_hunk_info
6264                        .map(|info| DiffHunkStatus::added(info.hunk_secondary_status)),
6265                    buffer_range: buffer_start..buffer_end,
6266                    range: start..end,
6267                })
6268            }
6269        }
6270    }
6271
6272    fn excerpt(&self) -> Option<&'a Excerpt> {
6273        self.excerpts.item()
6274    }
6275}
6276
6277impl History {
6278    fn start_transaction(&mut self, now: Instant) -> Option<TransactionId> {
6279        self.transaction_depth += 1;
6280        if self.transaction_depth == 1 {
6281            let id = self.next_transaction_id.tick();
6282            self.undo_stack.push(Transaction {
6283                id,
6284                buffer_transactions: Default::default(),
6285                first_edit_at: now,
6286                last_edit_at: now,
6287                suppress_grouping: false,
6288            });
6289            Some(id)
6290        } else {
6291            None
6292        }
6293    }
6294
6295    fn end_transaction(
6296        &mut self,
6297        now: Instant,
6298        buffer_transactions: HashMap<BufferId, TransactionId>,
6299    ) -> bool {
6300        assert_ne!(self.transaction_depth, 0);
6301        self.transaction_depth -= 1;
6302        if self.transaction_depth == 0 {
6303            if buffer_transactions.is_empty() {
6304                self.undo_stack.pop();
6305                false
6306            } else {
6307                self.redo_stack.clear();
6308                let transaction = self.undo_stack.last_mut().unwrap();
6309                transaction.last_edit_at = now;
6310                for (buffer_id, transaction_id) in buffer_transactions {
6311                    transaction
6312                        .buffer_transactions
6313                        .entry(buffer_id)
6314                        .or_insert(transaction_id);
6315                }
6316                true
6317            }
6318        } else {
6319            false
6320        }
6321    }
6322
6323    fn push_transaction<'a, T>(
6324        &mut self,
6325        buffer_transactions: T,
6326        now: Instant,
6327        cx: &Context<MultiBuffer>,
6328    ) where
6329        T: IntoIterator<Item = (&'a Entity<Buffer>, &'a language::Transaction)>,
6330    {
6331        assert_eq!(self.transaction_depth, 0);
6332        let transaction = Transaction {
6333            id: self.next_transaction_id.tick(),
6334            buffer_transactions: buffer_transactions
6335                .into_iter()
6336                .map(|(buffer, transaction)| (buffer.read(cx).remote_id(), transaction.id))
6337                .collect(),
6338            first_edit_at: now,
6339            last_edit_at: now,
6340            suppress_grouping: false,
6341        };
6342        if !transaction.buffer_transactions.is_empty() {
6343            self.undo_stack.push(transaction);
6344            self.redo_stack.clear();
6345        }
6346    }
6347
6348    fn finalize_last_transaction(&mut self) {
6349        if let Some(transaction) = self.undo_stack.last_mut() {
6350            transaction.suppress_grouping = true;
6351        }
6352    }
6353
6354    fn forget(&mut self, transaction_id: TransactionId) -> Option<Transaction> {
6355        if let Some(ix) = self
6356            .undo_stack
6357            .iter()
6358            .rposition(|transaction| transaction.id == transaction_id)
6359        {
6360            Some(self.undo_stack.remove(ix))
6361        } else if let Some(ix) = self
6362            .redo_stack
6363            .iter()
6364            .rposition(|transaction| transaction.id == transaction_id)
6365        {
6366            Some(self.redo_stack.remove(ix))
6367        } else {
6368            None
6369        }
6370    }
6371
6372    fn transaction(&self, transaction_id: TransactionId) -> Option<&Transaction> {
6373        self.undo_stack
6374            .iter()
6375            .find(|transaction| transaction.id == transaction_id)
6376            .or_else(|| {
6377                self.redo_stack
6378                    .iter()
6379                    .find(|transaction| transaction.id == transaction_id)
6380            })
6381    }
6382
6383    fn transaction_mut(&mut self, transaction_id: TransactionId) -> Option<&mut Transaction> {
6384        self.undo_stack
6385            .iter_mut()
6386            .find(|transaction| transaction.id == transaction_id)
6387            .or_else(|| {
6388                self.redo_stack
6389                    .iter_mut()
6390                    .find(|transaction| transaction.id == transaction_id)
6391            })
6392    }
6393
6394    fn pop_undo(&mut self) -> Option<&mut Transaction> {
6395        assert_eq!(self.transaction_depth, 0);
6396        if let Some(transaction) = self.undo_stack.pop() {
6397            self.redo_stack.push(transaction);
6398            self.redo_stack.last_mut()
6399        } else {
6400            None
6401        }
6402    }
6403
6404    fn pop_redo(&mut self) -> Option<&mut Transaction> {
6405        assert_eq!(self.transaction_depth, 0);
6406        if let Some(transaction) = self.redo_stack.pop() {
6407            self.undo_stack.push(transaction);
6408            self.undo_stack.last_mut()
6409        } else {
6410            None
6411        }
6412    }
6413
6414    fn remove_from_undo(&mut self, transaction_id: TransactionId) -> Option<&Transaction> {
6415        let ix = self
6416            .undo_stack
6417            .iter()
6418            .rposition(|transaction| transaction.id == transaction_id)?;
6419        let transaction = self.undo_stack.remove(ix);
6420        self.redo_stack.push(transaction);
6421        self.redo_stack.last()
6422    }
6423
6424    fn group(&mut self) -> Option<TransactionId> {
6425        let mut count = 0;
6426        let mut transactions = self.undo_stack.iter();
6427        if let Some(mut transaction) = transactions.next_back() {
6428            while let Some(prev_transaction) = transactions.next_back() {
6429                if !prev_transaction.suppress_grouping
6430                    && transaction.first_edit_at - prev_transaction.last_edit_at
6431                        <= self.group_interval
6432                {
6433                    transaction = prev_transaction;
6434                    count += 1;
6435                } else {
6436                    break;
6437                }
6438            }
6439        }
6440        self.group_trailing(count)
6441    }
6442
6443    fn group_until(&mut self, transaction_id: TransactionId) {
6444        let mut count = 0;
6445        for transaction in self.undo_stack.iter().rev() {
6446            if transaction.id == transaction_id {
6447                self.group_trailing(count);
6448                break;
6449            } else if transaction.suppress_grouping {
6450                break;
6451            } else {
6452                count += 1;
6453            }
6454        }
6455    }
6456
6457    fn group_trailing(&mut self, n: usize) -> Option<TransactionId> {
6458        let new_len = self.undo_stack.len() - n;
6459        let (transactions_to_keep, transactions_to_merge) = self.undo_stack.split_at_mut(new_len);
6460        if let Some(last_transaction) = transactions_to_keep.last_mut() {
6461            if let Some(transaction) = transactions_to_merge.last() {
6462                last_transaction.last_edit_at = transaction.last_edit_at;
6463            }
6464            for to_merge in transactions_to_merge {
6465                for (buffer_id, transaction_id) in &to_merge.buffer_transactions {
6466                    last_transaction
6467                        .buffer_transactions
6468                        .entry(*buffer_id)
6469                        .or_insert(*transaction_id);
6470                }
6471            }
6472        }
6473
6474        self.undo_stack.truncate(new_len);
6475        self.undo_stack.last().map(|t| t.id)
6476    }
6477}
6478
6479impl Excerpt {
6480    fn new(
6481        id: ExcerptId,
6482        locator: Locator,
6483        buffer_id: BufferId,
6484        buffer: BufferSnapshot,
6485        range: ExcerptRange<text::Anchor>,
6486        has_trailing_newline: bool,
6487    ) -> Self {
6488        Excerpt {
6489            id,
6490            locator,
6491            max_buffer_row: range.context.end.to_point(&buffer).row,
6492            text_summary: buffer
6493                .text_summary_for_range::<TextSummary, _>(range.context.to_offset(&buffer)),
6494            buffer_id,
6495            buffer,
6496            range,
6497            has_trailing_newline,
6498        }
6499    }
6500
6501    fn chunks_in_range(&self, range: Range<usize>, language_aware: bool) -> ExcerptChunks {
6502        let content_start = self.range.context.start.to_offset(&self.buffer);
6503        let chunks_start = content_start + range.start;
6504        let chunks_end = content_start + cmp::min(range.end, self.text_summary.len);
6505
6506        let footer_height = if self.has_trailing_newline
6507            && range.start <= self.text_summary.len
6508            && range.end > self.text_summary.len
6509        {
6510            1
6511        } else {
6512            0
6513        };
6514
6515        let content_chunks = self.buffer.chunks(chunks_start..chunks_end, language_aware);
6516
6517        ExcerptChunks {
6518            excerpt_id: self.id,
6519            content_chunks,
6520            footer_height,
6521        }
6522    }
6523
6524    fn seek_chunks(&self, excerpt_chunks: &mut ExcerptChunks, range: Range<usize>) {
6525        let content_start = self.range.context.start.to_offset(&self.buffer);
6526        let chunks_start = content_start + range.start;
6527        let chunks_end = content_start + cmp::min(range.end, self.text_summary.len);
6528        excerpt_chunks.content_chunks.seek(chunks_start..chunks_end);
6529        excerpt_chunks.footer_height = if self.has_trailing_newline
6530            && range.start <= self.text_summary.len
6531            && range.end > self.text_summary.len
6532        {
6533            1
6534        } else {
6535            0
6536        };
6537    }
6538
6539    fn clip_anchor(&self, text_anchor: text::Anchor) -> text::Anchor {
6540        if text_anchor
6541            .cmp(&self.range.context.start, &self.buffer)
6542            .is_lt()
6543        {
6544            self.range.context.start
6545        } else if text_anchor
6546            .cmp(&self.range.context.end, &self.buffer)
6547            .is_gt()
6548        {
6549            self.range.context.end
6550        } else {
6551            text_anchor
6552        }
6553    }
6554
6555    fn contains(&self, anchor: &Anchor) -> bool {
6556        Some(self.buffer_id) == anchor.buffer_id
6557            && self
6558                .range
6559                .context
6560                .start
6561                .cmp(&anchor.text_anchor, &self.buffer)
6562                .is_le()
6563            && self
6564                .range
6565                .context
6566                .end
6567                .cmp(&anchor.text_anchor, &self.buffer)
6568                .is_ge()
6569    }
6570
6571    /// The [`Excerpt`]'s start offset in its [`Buffer`]
6572    fn buffer_start_offset(&self) -> usize {
6573        self.range.context.start.to_offset(&self.buffer)
6574    }
6575
6576    /// The [`Excerpt`]'s end offset in its [`Buffer`]
6577    fn buffer_end_offset(&self) -> usize {
6578        self.buffer_start_offset() + self.text_summary.len
6579    }
6580}
6581
6582impl<'a> MultiBufferExcerpt<'a> {
6583    pub fn id(&self) -> ExcerptId {
6584        self.excerpt.id
6585    }
6586
6587    pub fn buffer_id(&self) -> BufferId {
6588        self.excerpt.buffer_id
6589    }
6590
6591    pub fn start_anchor(&self) -> Anchor {
6592        Anchor {
6593            buffer_id: Some(self.excerpt.buffer_id),
6594            excerpt_id: self.excerpt.id,
6595            text_anchor: self.excerpt.range.context.start,
6596            diff_base_anchor: None,
6597        }
6598    }
6599
6600    pub fn end_anchor(&self) -> Anchor {
6601        Anchor {
6602            buffer_id: Some(self.excerpt.buffer_id),
6603            excerpt_id: self.excerpt.id,
6604            text_anchor: self.excerpt.range.context.end,
6605            diff_base_anchor: None,
6606        }
6607    }
6608
6609    pub fn buffer(&self) -> &'a BufferSnapshot {
6610        &self.excerpt.buffer
6611    }
6612
6613    pub fn buffer_range(&self) -> Range<usize> {
6614        self.buffer_offset
6615            ..self
6616                .excerpt
6617                .range
6618                .context
6619                .end
6620                .to_offset(&self.excerpt.buffer.text)
6621    }
6622
6623    pub fn start_offset(&self) -> usize {
6624        self.offset
6625    }
6626
6627    /// Maps an offset within the [`MultiBuffer`] to an offset within the [`Buffer`]
6628    pub fn map_offset_to_buffer(&mut self, offset: usize) -> usize {
6629        self.map_range_to_buffer(offset..offset).start
6630    }
6631
6632    /// Maps a range within the [`MultiBuffer`] to a range within the [`Buffer`]
6633    pub fn map_range_to_buffer(&mut self, range: Range<usize>) -> Range<usize> {
6634        self.diff_transforms
6635            .seek(&OutputDimension(range.start), Bias::Right, &());
6636        let start = self.map_offset_to_buffer_internal(range.start);
6637        let end = if range.end > range.start {
6638            self.diff_transforms
6639                .seek_forward(&OutputDimension(range.end), Bias::Right, &());
6640            self.map_offset_to_buffer_internal(range.end)
6641        } else {
6642            start
6643        };
6644        start..end
6645    }
6646
6647    fn map_offset_to_buffer_internal(&self, offset: usize) -> usize {
6648        let mut excerpt_offset = self.diff_transforms.start().1.clone();
6649        if let Some(DiffTransform::BufferContent { .. }) = self.diff_transforms.item() {
6650            excerpt_offset.0 += offset - self.diff_transforms.start().0 .0;
6651        };
6652        let offset_in_excerpt = excerpt_offset.0.saturating_sub(self.excerpt_offset.0);
6653        self.buffer_offset + offset_in_excerpt
6654    }
6655
6656    /// Map an offset within the [`Buffer`] to an offset within the [`MultiBuffer`]
6657    pub fn map_offset_from_buffer(&mut self, buffer_offset: usize) -> usize {
6658        self.map_range_from_buffer(buffer_offset..buffer_offset)
6659            .start
6660    }
6661
6662    /// Map a range within the [`Buffer`] to a range within the [`MultiBuffer`]
6663    pub fn map_range_from_buffer(&mut self, buffer_range: Range<usize>) -> Range<usize> {
6664        if buffer_range.start < self.buffer_offset {
6665            log::warn!("Attempting to map a range from a buffer offset that starts before the current buffer offset");
6666            return buffer_range;
6667        }
6668        let overshoot = buffer_range.start - self.buffer_offset;
6669        let excerpt_offset = ExcerptDimension(self.excerpt_offset.0 + overshoot);
6670        self.diff_transforms.seek(&excerpt_offset, Bias::Right, &());
6671        if excerpt_offset.0 < self.diff_transforms.start().1 .0 {
6672            log::warn!("Attempting to map a range from a buffer offset that starts before the current buffer offset");
6673            return buffer_range;
6674        }
6675        let overshoot = excerpt_offset.0 - self.diff_transforms.start().1 .0;
6676        let start = self.diff_transforms.start().0 .0 + overshoot;
6677
6678        let end = if buffer_range.end > buffer_range.start {
6679            let overshoot = buffer_range.end - self.buffer_offset;
6680            let excerpt_offset = ExcerptDimension(self.excerpt_offset.0 + overshoot);
6681            self.diff_transforms
6682                .seek_forward(&excerpt_offset, Bias::Right, &());
6683            let overshoot = excerpt_offset.0 - self.diff_transforms.start().1 .0;
6684            self.diff_transforms.start().0 .0 + overshoot
6685        } else {
6686            start
6687        };
6688
6689        start..end
6690    }
6691
6692    /// Returns true if the entirety of the given range is in the buffer's excerpt
6693    pub fn contains_buffer_range(&self, range: Range<usize>) -> bool {
6694        range.start >= self.excerpt.buffer_start_offset()
6695            && range.end <= self.excerpt.buffer_end_offset()
6696    }
6697
6698    pub fn max_buffer_row(&self) -> u32 {
6699        self.excerpt.max_buffer_row
6700    }
6701}
6702
6703impl ExcerptId {
6704    pub fn min() -> Self {
6705        Self(0)
6706    }
6707
6708    pub fn max() -> Self {
6709        Self(usize::MAX)
6710    }
6711
6712    pub fn to_proto(&self) -> u64 {
6713        self.0 as _
6714    }
6715
6716    pub fn from_proto(proto: u64) -> Self {
6717        Self(proto as _)
6718    }
6719
6720    pub fn cmp(&self, other: &Self, snapshot: &MultiBufferSnapshot) -> cmp::Ordering {
6721        let a = snapshot.excerpt_locator_for_id(*self);
6722        let b = snapshot.excerpt_locator_for_id(*other);
6723        a.cmp(b).then_with(|| self.0.cmp(&other.0))
6724    }
6725}
6726
6727impl From<ExcerptId> for usize {
6728    fn from(val: ExcerptId) -> Self {
6729        val.0
6730    }
6731}
6732
6733impl fmt::Debug for Excerpt {
6734    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6735        f.debug_struct("Excerpt")
6736            .field("id", &self.id)
6737            .field("locator", &self.locator)
6738            .field("buffer_id", &self.buffer_id)
6739            .field("range", &self.range)
6740            .field("text_summary", &self.text_summary)
6741            .field("has_trailing_newline", &self.has_trailing_newline)
6742            .finish()
6743    }
6744}
6745
6746impl sum_tree::Item for Excerpt {
6747    type Summary = ExcerptSummary;
6748
6749    fn summary(&self, _cx: &()) -> Self::Summary {
6750        let mut text = self.text_summary;
6751        if self.has_trailing_newline {
6752            text += TextSummary::from("\n");
6753        }
6754        ExcerptSummary {
6755            excerpt_id: self.id,
6756            excerpt_locator: self.locator.clone(),
6757            widest_line_number: self.max_buffer_row,
6758            text,
6759        }
6760    }
6761}
6762
6763impl sum_tree::Item for ExcerptIdMapping {
6764    type Summary = ExcerptId;
6765
6766    fn summary(&self, _cx: &()) -> Self::Summary {
6767        self.id
6768    }
6769}
6770
6771impl sum_tree::KeyedItem for ExcerptIdMapping {
6772    type Key = ExcerptId;
6773
6774    fn key(&self) -> Self::Key {
6775        self.id
6776    }
6777}
6778
6779impl DiffTransform {
6780    fn hunk_info(&self) -> Option<DiffTransformHunkInfo> {
6781        match self {
6782            DiffTransform::DeletedHunk { hunk_info, .. } => Some(*hunk_info),
6783            DiffTransform::BufferContent {
6784                inserted_hunk_info, ..
6785            } => *inserted_hunk_info,
6786        }
6787    }
6788}
6789
6790impl sum_tree::Item for DiffTransform {
6791    type Summary = DiffTransformSummary;
6792
6793    fn summary(&self, _: &<Self::Summary as sum_tree::Summary>::Context) -> Self::Summary {
6794        match self {
6795            DiffTransform::BufferContent { summary, .. } => DiffTransformSummary {
6796                input: *summary,
6797                output: *summary,
6798            },
6799            DiffTransform::DeletedHunk { summary, .. } => DiffTransformSummary {
6800                input: TextSummary::default(),
6801                output: *summary,
6802            },
6803        }
6804    }
6805}
6806
6807impl DiffTransformSummary {
6808    fn excerpt_len(&self) -> ExcerptOffset {
6809        ExcerptOffset::new(self.input.len)
6810    }
6811}
6812
6813impl sum_tree::Summary for DiffTransformSummary {
6814    type Context = ();
6815
6816    fn zero(_: &Self::Context) -> Self {
6817        DiffTransformSummary {
6818            input: TextSummary::default(),
6819            output: TextSummary::default(),
6820        }
6821    }
6822
6823    fn add_summary(&mut self, summary: &Self, _: &Self::Context) {
6824        self.input += &summary.input;
6825        self.output += &summary.output;
6826    }
6827}
6828
6829impl sum_tree::Summary for ExcerptId {
6830    type Context = ();
6831
6832    fn zero(_cx: &()) -> Self {
6833        Default::default()
6834    }
6835
6836    fn add_summary(&mut self, other: &Self, _: &()) {
6837        *self = *other;
6838    }
6839}
6840
6841impl sum_tree::Summary for ExcerptSummary {
6842    type Context = ();
6843
6844    fn zero(_cx: &()) -> Self {
6845        Default::default()
6846    }
6847
6848    fn add_summary(&mut self, summary: &Self, _: &()) {
6849        debug_assert!(summary.excerpt_locator > self.excerpt_locator);
6850        self.excerpt_locator = summary.excerpt_locator.clone();
6851        self.text.add_summary(&summary.text, &());
6852        self.widest_line_number = cmp::max(self.widest_line_number, summary.widest_line_number);
6853    }
6854}
6855
6856impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for ExcerptOffset {
6857    fn zero(_cx: &()) -> Self {
6858        Default::default()
6859    }
6860
6861    fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
6862        self.value += summary.text.len;
6863    }
6864}
6865
6866impl sum_tree::SeekTarget<'_, ExcerptSummary, ExcerptSummary> for ExcerptOffset {
6867    fn cmp(&self, cursor_location: &ExcerptSummary, _: &()) -> cmp::Ordering {
6868        Ord::cmp(&self.value, &cursor_location.text.len)
6869    }
6870}
6871
6872impl<'a> sum_tree::SeekTarget<'a, ExcerptSummary, Option<&'a Locator>> for Locator {
6873    fn cmp(&self, cursor_location: &Option<&'a Locator>, _: &()) -> cmp::Ordering {
6874        Ord::cmp(&Some(self), cursor_location)
6875    }
6876}
6877
6878impl sum_tree::SeekTarget<'_, ExcerptSummary, ExcerptSummary> for Locator {
6879    fn cmp(&self, cursor_location: &ExcerptSummary, _: &()) -> cmp::Ordering {
6880        Ord::cmp(self, &cursor_location.excerpt_locator)
6881    }
6882}
6883
6884impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for ExcerptPoint {
6885    fn zero(_cx: &()) -> Self {
6886        Default::default()
6887    }
6888
6889    fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
6890        self.value += summary.text.lines;
6891    }
6892}
6893
6894impl<'a, D: TextDimension + Default> sum_tree::Dimension<'a, ExcerptSummary>
6895    for ExcerptDimension<D>
6896{
6897    fn zero(_: &()) -> Self {
6898        ExcerptDimension(D::default())
6899    }
6900
6901    fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
6902        self.0.add_assign(&D::from_text_summary(&summary.text))
6903    }
6904}
6905
6906impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for Option<&'a Locator> {
6907    fn zero(_cx: &()) -> Self {
6908        Default::default()
6909    }
6910
6911    fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
6912        *self = Some(&summary.excerpt_locator);
6913    }
6914}
6915
6916impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for Option<ExcerptId> {
6917    fn zero(_cx: &()) -> Self {
6918        Default::default()
6919    }
6920
6921    fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
6922        *self = Some(summary.excerpt_id);
6923    }
6924}
6925
6926#[derive(Clone, PartialOrd, Ord, Eq, PartialEq, Debug)]
6927struct ExcerptDimension<T>(T);
6928
6929#[derive(Clone, PartialOrd, Ord, Eq, PartialEq, Debug)]
6930struct OutputDimension<T>(T);
6931
6932impl<'a> sum_tree::Dimension<'a, DiffTransformSummary> for ExcerptOffset {
6933    fn zero(_: &()) -> Self {
6934        ExcerptOffset::new(0)
6935    }
6936
6937    fn add_summary(&mut self, summary: &'a DiffTransformSummary, _: &()) {
6938        self.value += summary.input.len;
6939    }
6940}
6941
6942impl<'a> sum_tree::Dimension<'a, DiffTransformSummary> for ExcerptPoint {
6943    fn zero(_: &()) -> Self {
6944        ExcerptPoint::new(0, 0)
6945    }
6946
6947    fn add_summary(&mut self, summary: &'a DiffTransformSummary, _: &()) {
6948        self.value += summary.input.lines;
6949    }
6950}
6951
6952impl<D: TextDimension + Ord> sum_tree::SeekTarget<'_, DiffTransformSummary, DiffTransformSummary>
6953    for ExcerptDimension<D>
6954{
6955    fn cmp(&self, cursor_location: &DiffTransformSummary, _: &()) -> cmp::Ordering {
6956        Ord::cmp(&self.0, &D::from_text_summary(&cursor_location.input))
6957    }
6958}
6959
6960impl<D: TextDimension + Ord>
6961    sum_tree::SeekTarget<'_, DiffTransformSummary, (OutputDimension<D>, ExcerptDimension<D>)>
6962    for ExcerptDimension<D>
6963{
6964    fn cmp(
6965        &self,
6966        cursor_location: &(OutputDimension<D>, ExcerptDimension<D>),
6967        _: &(),
6968    ) -> cmp::Ordering {
6969        Ord::cmp(&self.0, &cursor_location.1 .0)
6970    }
6971}
6972
6973impl<'a, D: TextDimension> sum_tree::Dimension<'a, DiffTransformSummary> for ExcerptDimension<D> {
6974    fn zero(_: &()) -> Self {
6975        ExcerptDimension(D::default())
6976    }
6977
6978    fn add_summary(&mut self, summary: &'a DiffTransformSummary, _: &()) {
6979        self.0.add_assign(&D::from_text_summary(&summary.input))
6980    }
6981}
6982
6983impl<'a, D: TextDimension> sum_tree::Dimension<'a, DiffTransformSummary> for OutputDimension<D> {
6984    fn zero(_: &()) -> Self {
6985        OutputDimension(D::default())
6986    }
6987
6988    fn add_summary(&mut self, summary: &'a DiffTransformSummary, _: &()) {
6989        self.0.add_assign(&D::from_text_summary(&summary.output))
6990    }
6991}
6992
6993impl<'a> sum_tree::Dimension<'a, DiffTransformSummary> for TextSummary {
6994    fn zero(_: &()) -> Self {
6995        TextSummary::default()
6996    }
6997
6998    fn add_summary(&mut self, summary: &'a DiffTransformSummary, _: &()) {
6999        *self += summary.output
7000    }
7001}
7002
7003impl<'a> sum_tree::Dimension<'a, DiffTransformSummary> for usize {
7004    fn zero(_: &()) -> Self {
7005        0
7006    }
7007
7008    fn add_summary(&mut self, summary: &'a DiffTransformSummary, _: &()) {
7009        *self += summary.output.len
7010    }
7011}
7012
7013impl<'a> sum_tree::Dimension<'a, DiffTransformSummary> for Point {
7014    fn zero(_: &()) -> Self {
7015        Point::new(0, 0)
7016    }
7017
7018    fn add_summary(&mut self, summary: &'a DiffTransformSummary, _: &()) {
7019        *self += summary.output.lines
7020    }
7021}
7022
7023impl MultiBufferRows<'_> {
7024    pub fn seek(&mut self, MultiBufferRow(row): MultiBufferRow) {
7025        self.point = Point::new(row, 0);
7026        self.cursor.seek(&self.point);
7027    }
7028}
7029
7030impl Iterator for MultiBufferRows<'_> {
7031    type Item = RowInfo;
7032
7033    fn next(&mut self) -> Option<Self::Item> {
7034        if self.is_empty && self.point.row == 0 {
7035            self.point += Point::new(1, 0);
7036            return Some(RowInfo {
7037                buffer_id: None,
7038                buffer_row: Some(0),
7039                multibuffer_row: Some(MultiBufferRow(0)),
7040                diff_status: None,
7041            });
7042        }
7043
7044        let mut region = self.cursor.region()?;
7045        while self.point >= region.range.end {
7046            self.cursor.next();
7047            if let Some(next_region) = self.cursor.region() {
7048                region = next_region;
7049            } else {
7050                if self.point == self.cursor.diff_transforms.end(&()).0 .0 {
7051                    let multibuffer_row = MultiBufferRow(self.point.row);
7052                    self.point += Point::new(1, 0);
7053                    let last_excerpt = self
7054                        .cursor
7055                        .excerpts
7056                        .item()
7057                        .or(self.cursor.excerpts.prev_item())?;
7058                    let last_row = last_excerpt
7059                        .range
7060                        .context
7061                        .end
7062                        .to_point(&last_excerpt.buffer)
7063                        .row;
7064                    return Some(RowInfo {
7065                        buffer_id: Some(last_excerpt.buffer_id),
7066                        buffer_row: Some(last_row),
7067                        multibuffer_row: Some(multibuffer_row),
7068                        diff_status: None,
7069                    });
7070                } else {
7071                    return None;
7072                }
7073            };
7074        }
7075
7076        let overshoot = self.point - region.range.start;
7077        let buffer_point = region.buffer_range.start + overshoot;
7078        let result = Some(RowInfo {
7079            buffer_id: Some(region.buffer.remote_id()),
7080            buffer_row: Some(buffer_point.row),
7081            multibuffer_row: Some(MultiBufferRow(self.point.row)),
7082            diff_status: region
7083                .diff_hunk_status
7084                .filter(|_| self.point < region.range.end),
7085        });
7086        self.point += Point::new(1, 0);
7087        result
7088    }
7089}
7090
7091impl<'a> MultiBufferChunks<'a> {
7092    pub fn offset(&self) -> usize {
7093        self.range.start
7094    }
7095
7096    pub fn seek(&mut self, range: Range<usize>) {
7097        self.diff_transforms.seek(&range.end, Bias::Right, &());
7098        let mut excerpt_end = self.diff_transforms.start().1;
7099        if let Some(DiffTransform::BufferContent { .. }) = self.diff_transforms.item() {
7100            let overshoot = range.end - self.diff_transforms.start().0;
7101            excerpt_end.value += overshoot;
7102        }
7103
7104        self.diff_transforms.seek(&range.start, Bias::Right, &());
7105        let mut excerpt_start = self.diff_transforms.start().1;
7106        if let Some(DiffTransform::BufferContent { .. }) = self.diff_transforms.item() {
7107            let overshoot = range.start - self.diff_transforms.start().0;
7108            excerpt_start.value += overshoot;
7109        }
7110
7111        self.seek_to_excerpt_offset_range(excerpt_start..excerpt_end);
7112        self.buffer_chunk.take();
7113        self.range = range;
7114    }
7115
7116    fn seek_to_excerpt_offset_range(&mut self, new_range: Range<ExcerptOffset>) {
7117        self.excerpt_offset_range = new_range.clone();
7118        self.excerpts.seek(&new_range.start, Bias::Right, &());
7119        if let Some(excerpt) = self.excerpts.item() {
7120            let excerpt_start = *self.excerpts.start();
7121            if let Some(excerpt_chunks) = self
7122                .excerpt_chunks
7123                .as_mut()
7124                .filter(|chunks| excerpt.id == chunks.excerpt_id)
7125            {
7126                excerpt.seek_chunks(
7127                    excerpt_chunks,
7128                    (self.excerpt_offset_range.start - excerpt_start).value
7129                        ..(self.excerpt_offset_range.end - excerpt_start).value,
7130                );
7131            } else {
7132                self.excerpt_chunks = Some(excerpt.chunks_in_range(
7133                    (self.excerpt_offset_range.start - excerpt_start).value
7134                        ..(self.excerpt_offset_range.end - excerpt_start).value,
7135                    self.language_aware,
7136                ));
7137            }
7138        } else {
7139            self.excerpt_chunks = None;
7140        }
7141    }
7142
7143    fn next_excerpt_chunk(&mut self) -> Option<Chunk<'a>> {
7144        loop {
7145            if self.excerpt_offset_range.is_empty() {
7146                return None;
7147            } else if let Some(chunk) = self.excerpt_chunks.as_mut()?.next() {
7148                self.excerpt_offset_range.start.value += chunk.text.len();
7149                return Some(chunk);
7150            } else {
7151                self.excerpts.next(&());
7152                let excerpt = self.excerpts.item()?;
7153                self.excerpt_chunks = Some(excerpt.chunks_in_range(
7154                    0..(self.excerpt_offset_range.end - *self.excerpts.start()).value,
7155                    self.language_aware,
7156                ));
7157            }
7158        }
7159    }
7160}
7161
7162impl<'a> Iterator for ReversedMultiBufferChunks<'a> {
7163    type Item = &'a str;
7164
7165    fn next(&mut self) -> Option<Self::Item> {
7166        let mut region = self.cursor.region()?;
7167        if self.offset == region.range.start {
7168            self.cursor.prev();
7169            region = self.cursor.region()?;
7170            let start_overshoot = self.start.saturating_sub(region.range.start);
7171            self.current_chunks = Some(region.buffer.reversed_chunks_in_range(
7172                region.buffer_range.start + start_overshoot..region.buffer_range.end,
7173            ));
7174        }
7175
7176        if self.offset == region.range.end && region.has_trailing_newline {
7177            self.offset -= 1;
7178            Some("\n")
7179        } else {
7180            let chunk = self.current_chunks.as_mut().unwrap().next()?;
7181            self.offset -= chunk.len();
7182            Some(chunk)
7183        }
7184    }
7185}
7186
7187impl<'a> Iterator for MultiBufferChunks<'a> {
7188    type Item = Chunk<'a>;
7189
7190    fn next(&mut self) -> Option<Chunk<'a>> {
7191        if self.range.start >= self.range.end {
7192            return None;
7193        }
7194        if self.range.start == self.diff_transforms.end(&()).0 {
7195            self.diff_transforms.next(&());
7196        }
7197
7198        let diff_transform_start = self.diff_transforms.start().0;
7199        let diff_transform_end = self.diff_transforms.end(&()).0;
7200        debug_assert!(self.range.start < diff_transform_end);
7201
7202        let diff_transform = self.diff_transforms.item()?;
7203        match diff_transform {
7204            DiffTransform::BufferContent { .. } => {
7205                let chunk = if let Some(chunk) = &mut self.buffer_chunk {
7206                    chunk
7207                } else {
7208                    let chunk = self.next_excerpt_chunk().unwrap();
7209                    self.buffer_chunk.insert(chunk)
7210                };
7211
7212                let chunk_end = self.range.start + chunk.text.len();
7213                let diff_transform_end = diff_transform_end.min(self.range.end);
7214
7215                if diff_transform_end < chunk_end {
7216                    let (before, after) =
7217                        chunk.text.split_at(diff_transform_end - self.range.start);
7218                    self.range.start = diff_transform_end;
7219                    chunk.text = after;
7220                    Some(Chunk {
7221                        text: before,
7222                        ..chunk.clone()
7223                    })
7224                } else {
7225                    self.range.start = chunk_end;
7226                    self.buffer_chunk.take()
7227                }
7228            }
7229            DiffTransform::DeletedHunk {
7230                buffer_id,
7231                base_text_byte_range,
7232                has_trailing_newline,
7233                ..
7234            } => {
7235                let base_text_start =
7236                    base_text_byte_range.start + self.range.start - diff_transform_start;
7237                let base_text_end =
7238                    base_text_byte_range.start + self.range.end - diff_transform_start;
7239                let base_text_end = base_text_end.min(base_text_byte_range.end);
7240
7241                let mut chunks = if let Some((_, mut chunks)) = self
7242                    .diff_base_chunks
7243                    .take()
7244                    .filter(|(id, _)| id == buffer_id)
7245                {
7246                    if chunks.range().start != base_text_start || chunks.range().end < base_text_end
7247                    {
7248                        chunks.seek(base_text_start..base_text_end);
7249                    }
7250                    chunks
7251                } else {
7252                    let base_buffer = &self.diffs.get(&buffer_id)?.base_text();
7253                    base_buffer.chunks(base_text_start..base_text_end, self.language_aware)
7254                };
7255
7256                let chunk = if let Some(chunk) = chunks.next() {
7257                    self.range.start += chunk.text.len();
7258                    self.diff_base_chunks = Some((*buffer_id, chunks));
7259                    chunk
7260                } else {
7261                    debug_assert!(has_trailing_newline);
7262                    self.range.start += "\n".len();
7263                    Chunk {
7264                        text: "\n",
7265                        ..Default::default()
7266                    }
7267                };
7268                Some(chunk)
7269            }
7270        }
7271    }
7272}
7273
7274impl MultiBufferBytes<'_> {
7275    fn consume(&mut self, len: usize) {
7276        self.range.start += len;
7277        self.chunk = &self.chunk[len..];
7278
7279        if !self.range.is_empty() && self.chunk.is_empty() {
7280            if let Some(chunk) = self.excerpt_bytes.as_mut().and_then(|bytes| bytes.next()) {
7281                self.chunk = chunk;
7282            } else if self.has_trailing_newline {
7283                self.has_trailing_newline = false;
7284                self.chunk = b"\n";
7285            } else {
7286                self.cursor.next();
7287                if let Some(region) = self.cursor.region() {
7288                    let mut excerpt_bytes = region.buffer.bytes_in_range(
7289                        region.buffer_range.start
7290                            ..(region.buffer_range.start + self.range.end - region.range.start)
7291                                .min(region.buffer_range.end),
7292                    );
7293                    self.chunk = excerpt_bytes.next().unwrap_or(&[]);
7294                    self.excerpt_bytes = Some(excerpt_bytes);
7295                    self.has_trailing_newline =
7296                        region.has_trailing_newline && self.range.end >= region.range.end;
7297                    if self.chunk.is_empty() && self.has_trailing_newline {
7298                        self.has_trailing_newline = false;
7299                        self.chunk = b"\n";
7300                    }
7301                }
7302            }
7303        }
7304    }
7305}
7306
7307impl<'a> Iterator for MultiBufferBytes<'a> {
7308    type Item = &'a [u8];
7309
7310    fn next(&mut self) -> Option<Self::Item> {
7311        let chunk = self.chunk;
7312        if chunk.is_empty() {
7313            None
7314        } else {
7315            self.consume(chunk.len());
7316            Some(chunk)
7317        }
7318    }
7319}
7320
7321impl io::Read for MultiBufferBytes<'_> {
7322    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
7323        let len = cmp::min(buf.len(), self.chunk.len());
7324        buf[..len].copy_from_slice(&self.chunk[..len]);
7325        if len > 0 {
7326            self.consume(len);
7327        }
7328        Ok(len)
7329    }
7330}
7331
7332impl io::Read for ReversedMultiBufferBytes<'_> {
7333    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
7334        let len = cmp::min(buf.len(), self.chunk.len());
7335        buf[..len].copy_from_slice(&self.chunk[..len]);
7336        buf[..len].reverse();
7337        if len > 0 {
7338            self.range.end -= len;
7339            self.chunk = &self.chunk[..self.chunk.len() - len];
7340            if !self.range.is_empty() && self.chunk.is_empty() {
7341                if let Some(chunk) = self.chunks.next() {
7342                    self.chunk = chunk.as_bytes();
7343                }
7344            }
7345        }
7346        Ok(len)
7347    }
7348}
7349
7350impl<'a> Iterator for ExcerptChunks<'a> {
7351    type Item = Chunk<'a>;
7352
7353    fn next(&mut self) -> Option<Self::Item> {
7354        if let Some(chunk) = self.content_chunks.next() {
7355            return Some(chunk);
7356        }
7357
7358        if self.footer_height > 0 {
7359            let text = unsafe { str::from_utf8_unchecked(&NEWLINES[..self.footer_height]) };
7360            self.footer_height = 0;
7361            return Some(Chunk {
7362                text,
7363                ..Default::default()
7364            });
7365        }
7366
7367        None
7368    }
7369}
7370
7371impl ToOffset for Point {
7372    fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
7373        snapshot.point_to_offset(*self)
7374    }
7375}
7376
7377impl ToOffset for usize {
7378    #[track_caller]
7379    fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
7380        assert!(*self <= snapshot.len(), "offset is out of range");
7381        *self
7382    }
7383}
7384
7385impl ToOffset for OffsetUtf16 {
7386    fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
7387        snapshot.offset_utf16_to_offset(*self)
7388    }
7389}
7390
7391impl ToOffset for PointUtf16 {
7392    fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
7393        snapshot.point_utf16_to_offset(*self)
7394    }
7395}
7396
7397impl ToOffsetUtf16 for OffsetUtf16 {
7398    fn to_offset_utf16(&self, _snapshot: &MultiBufferSnapshot) -> OffsetUtf16 {
7399        *self
7400    }
7401}
7402
7403impl ToOffsetUtf16 for usize {
7404    fn to_offset_utf16(&self, snapshot: &MultiBufferSnapshot) -> OffsetUtf16 {
7405        snapshot.offset_to_offset_utf16(*self)
7406    }
7407}
7408
7409impl ToPoint for usize {
7410    fn to_point<'a>(&self, snapshot: &MultiBufferSnapshot) -> Point {
7411        snapshot.offset_to_point(*self)
7412    }
7413}
7414
7415impl ToPoint for Point {
7416    fn to_point<'a>(&self, _: &MultiBufferSnapshot) -> Point {
7417        *self
7418    }
7419}
7420
7421impl ToPointUtf16 for usize {
7422    fn to_point_utf16<'a>(&self, snapshot: &MultiBufferSnapshot) -> PointUtf16 {
7423        snapshot.offset_to_point_utf16(*self)
7424    }
7425}
7426
7427impl ToPointUtf16 for Point {
7428    fn to_point_utf16<'a>(&self, snapshot: &MultiBufferSnapshot) -> PointUtf16 {
7429        snapshot.point_to_point_utf16(*self)
7430    }
7431}
7432
7433impl ToPointUtf16 for PointUtf16 {
7434    fn to_point_utf16<'a>(&self, _: &MultiBufferSnapshot) -> PointUtf16 {
7435        *self
7436    }
7437}
7438
7439impl From<ExcerptId> for EntityId {
7440    fn from(id: ExcerptId) -> Self {
7441        EntityId::from(id.0 as u64)
7442    }
7443}
7444
7445pub fn build_excerpt_ranges<T>(
7446    buffer: &BufferSnapshot,
7447    ranges: &[Range<T>],
7448    context_line_count: u32,
7449) -> (Vec<ExcerptRange<Point>>, Vec<usize>)
7450where
7451    T: text::ToPoint,
7452{
7453    let max_point = buffer.max_point();
7454    let mut range_counts = Vec::new();
7455    let mut excerpt_ranges = Vec::new();
7456    let mut range_iter = ranges
7457        .iter()
7458        .map(|range| range.start.to_point(buffer)..range.end.to_point(buffer))
7459        .peekable();
7460    while let Some(range) = range_iter.next() {
7461        let excerpt_start = Point::new(range.start.row.saturating_sub(context_line_count), 0);
7462        let row = (range.end.row + context_line_count).min(max_point.row);
7463        let mut excerpt_end = Point::new(row, buffer.line_len(row));
7464
7465        let mut ranges_in_excerpt = 1;
7466
7467        while let Some(next_range) = range_iter.peek() {
7468            if next_range.start.row <= excerpt_end.row + context_line_count {
7469                let row = (next_range.end.row + context_line_count).min(max_point.row);
7470                excerpt_end = Point::new(row, buffer.line_len(row));
7471
7472                ranges_in_excerpt += 1;
7473                range_iter.next();
7474            } else {
7475                break;
7476            }
7477        }
7478
7479        excerpt_ranges.push(ExcerptRange {
7480            context: excerpt_start..excerpt_end,
7481            primary: Some(range),
7482        });
7483        range_counts.push(ranges_in_excerpt);
7484    }
7485
7486    (excerpt_ranges, range_counts)
7487}