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