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