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