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