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