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