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