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