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 Some(existing_excerpt) = excerpts_cursor.item() else {
1723 break;
1724 };
1725 excerpts_cursor.seek_forward(&Some(locator), Bias::Left, &());
1726 let existing_end = existing_excerpt
1727 .range
1728 .context
1729 .end
1730 .to_point(&buffer_snapshot);
1731 if let Some((new_id, last)) = to_insert.last() {
1732 if existing_end <= last.context.end {
1733 self.snapshot
1734 .borrow_mut()
1735 .replaced_excerpts
1736 .insert(existing_id, *new_id);
1737 }
1738 }
1739 to_remove.push(existing_id);
1740 continue;
1741 }
1742 (Some(_), None) => {
1743 added_a_new_excerpt = true;
1744 to_insert.push((next_excerpt_id(), new_iter.next().unwrap()));
1745 continue;
1746 }
1747 };
1748 let locator = snapshot.excerpt_locator_for_id(*existing);
1749 excerpts_cursor.seek_forward(&Some(locator), Bias::Left, &());
1750 let Some(existing_excerpt) = excerpts_cursor.item() else {
1751 to_remove.push(existing_iter.next().unwrap());
1752 to_insert.push((next_excerpt_id(), new_iter.next().unwrap()));
1753 continue;
1754 };
1755 if existing_excerpt.buffer_id != buffer_snapshot.remote_id() {
1756 to_remove.push(existing_iter.next().unwrap());
1757 to_insert.push((next_excerpt_id(), new_iter.next().unwrap()));
1758 continue;
1759 }
1760
1761 let existing_start = existing_excerpt
1762 .range
1763 .context
1764 .start
1765 .to_point(&buffer_snapshot);
1766 let existing_end = existing_excerpt
1767 .range
1768 .context
1769 .end
1770 .to_point(&buffer_snapshot);
1771
1772 if existing_end < new.context.start {
1773 let existing_id = existing_iter.next().unwrap();
1774 if let Some((new_id, last)) = to_insert.last() {
1775 if existing_end <= last.context.end {
1776 self.snapshot
1777 .borrow_mut()
1778 .replaced_excerpts
1779 .insert(existing_id, *new_id);
1780 }
1781 }
1782 to_remove.push(existing_id);
1783 continue;
1784 } else if existing_start > new.context.end {
1785 to_insert.push((next_excerpt_id(), new_iter.next().unwrap()));
1786 continue;
1787 }
1788
1789 if existing_start == new.context.start && existing_end == new.context.end {
1790 excerpt_ids.extend(to_insert.iter().map(|(id, _)| id));
1791 self.insert_excerpts_with_ids_after(
1792 insert_after,
1793 buffer.clone(),
1794 mem::take(&mut to_insert),
1795 cx,
1796 );
1797 insert_after = existing_iter.next().unwrap();
1798 excerpt_ids.push(insert_after);
1799 new_iter.next();
1800 } else {
1801 let existing_id = existing_iter.next().unwrap();
1802 let new_id = next_excerpt_id();
1803 self.snapshot
1804 .borrow_mut()
1805 .replaced_excerpts
1806 .insert(existing_id, new_id);
1807 to_remove.push(existing_id);
1808 let mut range = new_iter.next().unwrap();
1809 range.context.start = range.context.start.min(existing_start);
1810 range.context.end = range.context.end.max(existing_end);
1811 to_insert.push((new_id, range));
1812 }
1813 }
1814
1815 excerpt_ids.extend(to_insert.iter().map(|(id, _)| id));
1816 self.insert_excerpts_with_ids_after(insert_after, buffer, to_insert, cx);
1817 self.remove_excerpts(to_remove, cx);
1818 if excerpt_ids.is_empty() {
1819 self.excerpts_by_path.remove(&path);
1820 } else {
1821 for excerpt_id in &excerpt_ids {
1822 self.paths_by_excerpt.insert(*excerpt_id, path.clone());
1823 }
1824 self.excerpts_by_path.insert(path, excerpt_ids.clone());
1825 }
1826
1827 (excerpt_ids, added_a_new_excerpt)
1828 }
1829
1830 pub fn paths(&self) -> impl Iterator<Item = PathKey> + '_ {
1831 self.excerpts_by_path.keys().cloned()
1832 }
1833
1834 pub fn remove_excerpts_for_path(&mut self, path: PathKey, cx: &mut Context<Self>) {
1835 if let Some(to_remove) = self.excerpts_by_path.remove(&path) {
1836 self.remove_excerpts(to_remove, cx)
1837 }
1838 }
1839
1840 pub fn insert_excerpts_after<O>(
1841 &mut self,
1842 prev_excerpt_id: ExcerptId,
1843 buffer: Entity<Buffer>,
1844 ranges: impl IntoIterator<Item = ExcerptRange<O>>,
1845 cx: &mut Context<Self>,
1846 ) -> Vec<ExcerptId>
1847 where
1848 O: text::ToOffset,
1849 {
1850 let mut ids = Vec::new();
1851 let mut next_excerpt_id =
1852 if let Some(last_entry) = self.snapshot.borrow().excerpt_ids.last() {
1853 last_entry.id.0 + 1
1854 } else {
1855 1
1856 };
1857 self.insert_excerpts_with_ids_after(
1858 prev_excerpt_id,
1859 buffer,
1860 ranges.into_iter().map(|range| {
1861 let id = ExcerptId(post_inc(&mut next_excerpt_id));
1862 ids.push(id);
1863 (id, range)
1864 }),
1865 cx,
1866 );
1867 ids
1868 }
1869
1870 pub fn insert_excerpts_with_ids_after<O>(
1871 &mut self,
1872 prev_excerpt_id: ExcerptId,
1873 buffer: Entity<Buffer>,
1874 ranges: impl IntoIterator<Item = (ExcerptId, ExcerptRange<O>)>,
1875 cx: &mut Context<Self>,
1876 ) where
1877 O: text::ToOffset,
1878 {
1879 assert_eq!(self.history.transaction_depth, 0);
1880 let mut ranges = ranges.into_iter().peekable();
1881 if ranges.peek().is_none() {
1882 return Default::default();
1883 }
1884
1885 self.sync(cx);
1886
1887 let buffer_snapshot = buffer.read(cx).snapshot();
1888 let buffer_id = buffer_snapshot.remote_id();
1889
1890 let mut buffers = self.buffers.borrow_mut();
1891 let buffer_state = buffers.entry(buffer_id).or_insert_with(|| {
1892 self.buffer_changed_since_sync.replace(true);
1893 buffer.update(cx, |buffer, _| {
1894 buffer.record_changes(Rc::downgrade(&self.buffer_changed_since_sync));
1895 });
1896 BufferState {
1897 last_version: buffer_snapshot.version().clone(),
1898 last_non_text_state_update_count: buffer_snapshot.non_text_state_update_count(),
1899 excerpts: Default::default(),
1900 _subscriptions: [
1901 cx.observe(&buffer, |_, _, cx| cx.notify()),
1902 cx.subscribe(&buffer, Self::on_buffer_event),
1903 ],
1904 buffer: buffer.clone(),
1905 }
1906 });
1907
1908 let mut snapshot = self.snapshot.borrow_mut();
1909
1910 let mut prev_locator = snapshot.excerpt_locator_for_id(prev_excerpt_id).clone();
1911 let mut new_excerpt_ids = mem::take(&mut snapshot.excerpt_ids);
1912 let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>(&());
1913 let mut new_excerpts = cursor.slice(&prev_locator, Bias::Right, &());
1914 prev_locator = cursor.start().unwrap_or(Locator::min_ref()).clone();
1915
1916 let edit_start = ExcerptOffset::new(new_excerpts.summary().text.len);
1917 new_excerpts.update_last(
1918 |excerpt| {
1919 excerpt.has_trailing_newline = true;
1920 },
1921 &(),
1922 );
1923
1924 let next_locator = if let Some(excerpt) = cursor.item() {
1925 excerpt.locator.clone()
1926 } else {
1927 Locator::max()
1928 };
1929
1930 let mut excerpts = Vec::new();
1931 while let Some((id, range)) = ranges.next() {
1932 let locator = Locator::between(&prev_locator, &next_locator);
1933 if let Err(ix) = buffer_state.excerpts.binary_search(&locator) {
1934 buffer_state.excerpts.insert(ix, locator.clone());
1935 }
1936 let range = ExcerptRange {
1937 context: buffer_snapshot.anchor_before(&range.context.start)
1938 ..buffer_snapshot.anchor_after(&range.context.end),
1939 primary: buffer_snapshot.anchor_before(&range.primary.start)
1940 ..buffer_snapshot.anchor_after(&range.primary.end),
1941 };
1942 excerpts.push((id, range.clone()));
1943 let excerpt = Excerpt::new(
1944 id,
1945 locator.clone(),
1946 buffer_id,
1947 buffer_snapshot.clone(),
1948 range,
1949 ranges.peek().is_some() || cursor.item().is_some(),
1950 );
1951 new_excerpts.push(excerpt, &());
1952 prev_locator = locator.clone();
1953
1954 if let Some(last_mapping_entry) = new_excerpt_ids.last() {
1955 assert!(id > last_mapping_entry.id, "excerpt ids must be increasing");
1956 }
1957 new_excerpt_ids.push(ExcerptIdMapping { id, locator }, &());
1958 }
1959
1960 let edit_end = ExcerptOffset::new(new_excerpts.summary().text.len);
1961
1962 let suffix = cursor.suffix(&());
1963 let changed_trailing_excerpt = suffix.is_empty();
1964 new_excerpts.append(suffix, &());
1965 drop(cursor);
1966 snapshot.excerpts = new_excerpts;
1967 snapshot.excerpt_ids = new_excerpt_ids;
1968 if changed_trailing_excerpt {
1969 snapshot.trailing_excerpt_update_count += 1;
1970 }
1971
1972 self.sync_diff_transforms(
1973 &mut snapshot,
1974 vec![Edit {
1975 old: edit_start..edit_start,
1976 new: edit_start..edit_end,
1977 }],
1978 DiffChangeKind::BufferEdited,
1979 );
1980 cx.emit(Event::Edited {
1981 singleton_buffer_edited: false,
1982 edited_buffer: None,
1983 });
1984 cx.emit(Event::ExcerptsAdded {
1985 buffer,
1986 predecessor: prev_excerpt_id,
1987 excerpts,
1988 });
1989 cx.notify();
1990 }
1991
1992 pub fn clear(&mut self, cx: &mut Context<Self>) {
1993 self.sync(cx);
1994 let ids = self.excerpt_ids();
1995 self.buffers.borrow_mut().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
2005 self.sync_diff_transforms(
2006 &mut snapshot,
2007 vec![Edit {
2008 old: start..prev_len,
2009 new: start..start,
2010 }],
2011 DiffChangeKind::BufferEdited,
2012 );
2013 cx.emit(Event::Edited {
2014 singleton_buffer_edited: false,
2015 edited_buffer: None,
2016 });
2017 cx.emit(Event::ExcerptsRemoved { ids });
2018 cx.notify();
2019 }
2020
2021 pub fn excerpts_for_buffer(
2022 &self,
2023 buffer_id: BufferId,
2024 cx: &App,
2025 ) -> Vec<(ExcerptId, ExcerptRange<text::Anchor>)> {
2026 let mut excerpts = Vec::new();
2027 let snapshot = self.read(cx);
2028 let buffers = self.buffers.borrow();
2029 let mut cursor = snapshot.excerpts.cursor::<Option<&Locator>>(&());
2030 for locator in buffers
2031 .get(&buffer_id)
2032 .map(|state| &state.excerpts)
2033 .into_iter()
2034 .flatten()
2035 {
2036 cursor.seek_forward(&Some(locator), Bias::Left, &());
2037 if let Some(excerpt) = cursor.item() {
2038 if excerpt.locator == *locator {
2039 excerpts.push((excerpt.id, excerpt.range.clone()));
2040 }
2041 }
2042 }
2043
2044 excerpts
2045 }
2046
2047 pub fn excerpt_ranges_for_buffer(&self, buffer_id: BufferId, cx: &App) -> Vec<Range<Point>> {
2048 let snapshot = self.read(cx);
2049 let buffers = self.buffers.borrow();
2050 let mut excerpts = snapshot
2051 .excerpts
2052 .cursor::<(Option<&Locator>, ExcerptDimension<Point>)>(&());
2053 let mut diff_transforms = snapshot
2054 .diff_transforms
2055 .cursor::<(ExcerptDimension<Point>, OutputDimension<Point>)>(&());
2056 diff_transforms.next(&());
2057 let locators = buffers
2058 .get(&buffer_id)
2059 .into_iter()
2060 .flat_map(|state| &state.excerpts);
2061 let mut result = Vec::new();
2062 for locator in locators {
2063 excerpts.seek_forward(&Some(locator), Bias::Left, &());
2064 if let Some(excerpt) = excerpts.item() {
2065 if excerpt.locator == *locator {
2066 let excerpt_start = excerpts.start().1.clone();
2067 let excerpt_end =
2068 ExcerptDimension(excerpt_start.0 + excerpt.text_summary.lines);
2069
2070 diff_transforms.seek_forward(&excerpt_start, Bias::Left, &());
2071 let overshoot = excerpt_start.0 - diff_transforms.start().0.0;
2072 let start = diff_transforms.start().1.0 + overshoot;
2073
2074 diff_transforms.seek_forward(&excerpt_end, Bias::Right, &());
2075 let overshoot = excerpt_end.0 - diff_transforms.start().0.0;
2076 let end = diff_transforms.start().1.0 + overshoot;
2077
2078 result.push(start..end)
2079 }
2080 }
2081 }
2082 result
2083 }
2084
2085 pub fn excerpt_buffer_ids(&self) -> Vec<BufferId> {
2086 self.snapshot
2087 .borrow()
2088 .excerpts
2089 .iter()
2090 .map(|entry| entry.buffer_id)
2091 .collect()
2092 }
2093
2094 pub fn excerpt_ids(&self) -> Vec<ExcerptId> {
2095 self.snapshot
2096 .borrow()
2097 .excerpts
2098 .iter()
2099 .map(|entry| entry.id)
2100 .collect()
2101 }
2102
2103 pub fn excerpt_containing(
2104 &self,
2105 position: impl ToOffset,
2106 cx: &App,
2107 ) -> Option<(ExcerptId, Entity<Buffer>, Range<text::Anchor>)> {
2108 let snapshot = self.read(cx);
2109 let offset = position.to_offset(&snapshot);
2110
2111 let mut cursor = snapshot.cursor::<usize>();
2112 cursor.seek(&offset);
2113 cursor
2114 .excerpt()
2115 .or_else(|| snapshot.excerpts.last())
2116 .map(|excerpt| {
2117 (
2118 excerpt.id,
2119 self.buffers
2120 .borrow()
2121 .get(&excerpt.buffer_id)
2122 .unwrap()
2123 .buffer
2124 .clone(),
2125 excerpt.range.context.clone(),
2126 )
2127 })
2128 }
2129
2130 // If point is at the end of the buffer, the last excerpt is returned
2131 pub fn point_to_buffer_offset<T: ToOffset>(
2132 &self,
2133 point: T,
2134 cx: &App,
2135 ) -> Option<(Entity<Buffer>, usize)> {
2136 let snapshot = self.read(cx);
2137 let (buffer, offset) = snapshot.point_to_buffer_offset(point)?;
2138 Some((
2139 self.buffers
2140 .borrow()
2141 .get(&buffer.remote_id())?
2142 .buffer
2143 .clone(),
2144 offset,
2145 ))
2146 }
2147
2148 // If point is at the end of the buffer, the last excerpt is returned
2149 pub fn point_to_buffer_point<T: ToPoint>(
2150 &self,
2151 point: T,
2152 cx: &App,
2153 ) -> Option<(Entity<Buffer>, Point, ExcerptId)> {
2154 let snapshot = self.read(cx);
2155 let (buffer, point, is_main_buffer) =
2156 snapshot.point_to_buffer_point(point.to_point(&snapshot))?;
2157 Some((
2158 self.buffers
2159 .borrow()
2160 .get(&buffer.remote_id())?
2161 .buffer
2162 .clone(),
2163 point,
2164 is_main_buffer,
2165 ))
2166 }
2167
2168 pub fn buffer_point_to_anchor(
2169 &self,
2170 buffer: &Entity<Buffer>,
2171 point: Point,
2172 cx: &App,
2173 ) -> Option<Anchor> {
2174 let mut found = None;
2175 let snapshot = buffer.read(cx).snapshot();
2176 for (excerpt_id, range) in self.excerpts_for_buffer(snapshot.remote_id(), cx) {
2177 let start = range.context.start.to_point(&snapshot);
2178 let end = range.context.end.to_point(&snapshot);
2179 if start <= point && point < end {
2180 found = Some((snapshot.clip_point(point, Bias::Left), excerpt_id));
2181 break;
2182 }
2183 if point < start {
2184 found = Some((start, excerpt_id));
2185 }
2186 if point > end {
2187 found = Some((end, excerpt_id));
2188 }
2189 }
2190
2191 found.map(|(point, excerpt_id)| {
2192 let text_anchor = snapshot.anchor_after(point);
2193 Anchor::in_buffer(excerpt_id, snapshot.remote_id(), text_anchor)
2194 })
2195 }
2196
2197 pub fn remove_excerpts(
2198 &mut self,
2199 excerpt_ids: impl IntoIterator<Item = ExcerptId>,
2200 cx: &mut Context<Self>,
2201 ) {
2202 self.sync(cx);
2203 let ids = excerpt_ids.into_iter().collect::<Vec<_>>();
2204 if ids.is_empty() {
2205 return;
2206 }
2207
2208 let mut buffers = self.buffers.borrow_mut();
2209 let mut snapshot = self.snapshot.borrow_mut();
2210 let mut new_excerpts = SumTree::default();
2211 let mut cursor = snapshot
2212 .excerpts
2213 .cursor::<(Option<&Locator>, ExcerptOffset)>(&());
2214 let mut edits = Vec::new();
2215 let mut excerpt_ids = ids.iter().copied().peekable();
2216 let mut removed_buffer_ids = Vec::new();
2217
2218 while let Some(excerpt_id) = excerpt_ids.next() {
2219 self.paths_by_excerpt.remove(&excerpt_id);
2220 // Seek to the next excerpt to remove, preserving any preceding excerpts.
2221 let locator = snapshot.excerpt_locator_for_id(excerpt_id);
2222 new_excerpts.append(cursor.slice(&Some(locator), Bias::Left, &()), &());
2223
2224 if let Some(mut excerpt) = cursor.item() {
2225 if excerpt.id != excerpt_id {
2226 continue;
2227 }
2228 let mut old_start = cursor.start().1;
2229
2230 // Skip over the removed excerpt.
2231 'remove_excerpts: loop {
2232 if let Some(buffer_state) = buffers.get_mut(&excerpt.buffer_id) {
2233 buffer_state.excerpts.retain(|l| l != &excerpt.locator);
2234 if buffer_state.excerpts.is_empty() {
2235 log::debug!(
2236 "removing buffer and diff for buffer {}",
2237 excerpt.buffer_id
2238 );
2239 buffers.remove(&excerpt.buffer_id);
2240 removed_buffer_ids.push(excerpt.buffer_id);
2241 }
2242 }
2243 cursor.next(&());
2244
2245 // Skip over any subsequent excerpts that are also removed.
2246 if let Some(&next_excerpt_id) = excerpt_ids.peek() {
2247 let next_locator = snapshot.excerpt_locator_for_id(next_excerpt_id);
2248 if let Some(next_excerpt) = cursor.item() {
2249 if next_excerpt.locator == *next_locator {
2250 excerpt_ids.next();
2251 excerpt = next_excerpt;
2252 continue 'remove_excerpts;
2253 }
2254 }
2255 }
2256
2257 break;
2258 }
2259
2260 // When removing the last excerpt, remove the trailing newline from
2261 // the previous excerpt.
2262 if cursor.item().is_none() && old_start.value > 0 {
2263 old_start.value -= 1;
2264 new_excerpts.update_last(|e| e.has_trailing_newline = false, &());
2265 }
2266
2267 // Push an edit for the removal of this run of excerpts.
2268 let old_end = cursor.start().1;
2269 let new_start = ExcerptOffset::new(new_excerpts.summary().text.len);
2270 edits.push(Edit {
2271 old: old_start..old_end,
2272 new: new_start..new_start,
2273 });
2274 }
2275 }
2276 let suffix = cursor.suffix(&());
2277 let changed_trailing_excerpt = suffix.is_empty();
2278 new_excerpts.append(suffix, &());
2279 drop(cursor);
2280 snapshot.excerpts = new_excerpts;
2281 for buffer_id in removed_buffer_ids {
2282 self.diffs.remove(&buffer_id);
2283 snapshot.diffs.remove(&buffer_id);
2284 }
2285
2286 if changed_trailing_excerpt {
2287 snapshot.trailing_excerpt_update_count += 1;
2288 }
2289
2290 self.sync_diff_transforms(&mut snapshot, edits, DiffChangeKind::BufferEdited);
2291 self.buffer_changed_since_sync.replace(true);
2292 cx.emit(Event::Edited {
2293 singleton_buffer_edited: false,
2294 edited_buffer: None,
2295 });
2296 cx.emit(Event::ExcerptsRemoved { ids });
2297 cx.notify();
2298 }
2299
2300 pub fn wait_for_anchors<'a, Anchors: 'a + Iterator<Item = Anchor>>(
2301 &self,
2302 anchors: Anchors,
2303 cx: &mut Context<Self>,
2304 ) -> impl 'static + Future<Output = Result<()>> + use<Anchors> {
2305 let borrow = self.buffers.borrow();
2306 let mut error = None;
2307 let mut futures = Vec::new();
2308 for anchor in anchors {
2309 if let Some(buffer_id) = anchor.buffer_id {
2310 if let Some(buffer) = borrow.get(&buffer_id) {
2311 buffer.buffer.update(cx, |buffer, _| {
2312 futures.push(buffer.wait_for_anchors([anchor.text_anchor]))
2313 });
2314 } else {
2315 error = Some(anyhow!(
2316 "buffer {buffer_id} is not part of this multi-buffer"
2317 ));
2318 break;
2319 }
2320 }
2321 }
2322 async move {
2323 if let Some(error) = error {
2324 Err(error)?;
2325 }
2326 for future in futures {
2327 future.await?;
2328 }
2329 Ok(())
2330 }
2331 }
2332
2333 pub fn text_anchor_for_position<T: ToOffset>(
2334 &self,
2335 position: T,
2336 cx: &App,
2337 ) -> Option<(Entity<Buffer>, language::Anchor)> {
2338 let snapshot = self.read(cx);
2339 let anchor = snapshot.anchor_before(position);
2340 let buffer = self
2341 .buffers
2342 .borrow()
2343 .get(&anchor.buffer_id?)?
2344 .buffer
2345 .clone();
2346 Some((buffer, anchor.text_anchor))
2347 }
2348
2349 fn on_buffer_event(
2350 &mut self,
2351 buffer: Entity<Buffer>,
2352 event: &language::BufferEvent,
2353 cx: &mut Context<Self>,
2354 ) {
2355 cx.emit(match event {
2356 language::BufferEvent::Edited => Event::Edited {
2357 singleton_buffer_edited: true,
2358 edited_buffer: Some(buffer.clone()),
2359 },
2360 language::BufferEvent::DirtyChanged => Event::DirtyChanged,
2361 language::BufferEvent::Saved => Event::Saved,
2362 language::BufferEvent::FileHandleChanged => Event::FileHandleChanged,
2363 language::BufferEvent::Reloaded => Event::Reloaded,
2364 language::BufferEvent::ReloadNeeded => Event::ReloadNeeded,
2365 language::BufferEvent::LanguageChanged => {
2366 Event::LanguageChanged(buffer.read(cx).remote_id())
2367 }
2368 language::BufferEvent::Reparsed => Event::Reparsed(buffer.read(cx).remote_id()),
2369 language::BufferEvent::DiagnosticsUpdated => Event::DiagnosticsUpdated,
2370 language::BufferEvent::Closed => Event::Closed,
2371 language::BufferEvent::Discarded => Event::Discarded,
2372 language::BufferEvent::CapabilityChanged => {
2373 self.capability = buffer.read(cx).capability();
2374 Event::CapabilityChanged
2375 }
2376 language::BufferEvent::Operation { .. } => return,
2377 });
2378 }
2379
2380 fn buffer_diff_language_changed(&mut self, diff: Entity<BufferDiff>, cx: &mut Context<Self>) {
2381 self.sync(cx);
2382 let mut snapshot = self.snapshot.borrow_mut();
2383 let diff = diff.read(cx);
2384 let buffer_id = diff.buffer_id;
2385 let diff = diff.snapshot(cx);
2386 snapshot.diffs.insert(buffer_id, diff);
2387 }
2388
2389 fn buffer_diff_changed(
2390 &mut self,
2391 diff: Entity<BufferDiff>,
2392 range: Range<text::Anchor>,
2393 cx: &mut Context<Self>,
2394 ) {
2395 self.sync(cx);
2396 self.buffer_changed_since_sync.replace(true);
2397
2398 let diff = diff.read(cx);
2399 let buffer_id = diff.buffer_id;
2400 let buffers = self.buffers.borrow();
2401 let Some(buffer_state) = buffers.get(&buffer_id) else {
2402 return;
2403 };
2404
2405 let buffer = buffer_state.buffer.read(cx);
2406 let diff_change_range = range.to_offset(buffer);
2407
2408 let new_diff = diff.snapshot(cx);
2409 let mut snapshot = self.snapshot.borrow_mut();
2410 let base_text_changed = snapshot
2411 .diffs
2412 .get(&buffer_id)
2413 .map_or(true, |old_diff| !new_diff.base_texts_eq(old_diff));
2414
2415 snapshot.diffs.insert(buffer_id, new_diff);
2416
2417 let mut excerpt_edits = Vec::new();
2418 for locator in &buffer_state.excerpts {
2419 let mut cursor = snapshot
2420 .excerpts
2421 .cursor::<(Option<&Locator>, ExcerptOffset)>(&());
2422 cursor.seek_forward(&Some(locator), Bias::Left, &());
2423 if let Some(excerpt) = cursor.item() {
2424 if excerpt.locator == *locator {
2425 let excerpt_buffer_range = excerpt.range.context.to_offset(&excerpt.buffer);
2426 if diff_change_range.end < excerpt_buffer_range.start
2427 || diff_change_range.start > excerpt_buffer_range.end
2428 {
2429 continue;
2430 }
2431 let excerpt_start = cursor.start().1;
2432 let excerpt_len = ExcerptOffset::new(excerpt.text_summary.len);
2433 let diff_change_start_in_excerpt = ExcerptOffset::new(
2434 diff_change_range
2435 .start
2436 .saturating_sub(excerpt_buffer_range.start),
2437 );
2438 let diff_change_end_in_excerpt = ExcerptOffset::new(
2439 diff_change_range
2440 .end
2441 .saturating_sub(excerpt_buffer_range.start),
2442 );
2443 let edit_start = excerpt_start + diff_change_start_in_excerpt.min(excerpt_len);
2444 let edit_end = excerpt_start + diff_change_end_in_excerpt.min(excerpt_len);
2445 excerpt_edits.push(Edit {
2446 old: edit_start..edit_end,
2447 new: edit_start..edit_end,
2448 });
2449 }
2450 }
2451 }
2452
2453 self.sync_diff_transforms(
2454 &mut snapshot,
2455 excerpt_edits,
2456 DiffChangeKind::DiffUpdated {
2457 base_changed: base_text_changed,
2458 },
2459 );
2460 cx.emit(Event::Edited {
2461 singleton_buffer_edited: false,
2462 edited_buffer: None,
2463 });
2464 }
2465
2466 pub fn all_buffers(&self) -> HashSet<Entity<Buffer>> {
2467 self.buffers
2468 .borrow()
2469 .values()
2470 .map(|state| state.buffer.clone())
2471 .collect()
2472 }
2473
2474 pub fn buffer(&self, buffer_id: BufferId) -> Option<Entity<Buffer>> {
2475 self.buffers
2476 .borrow()
2477 .get(&buffer_id)
2478 .map(|state| state.buffer.clone())
2479 }
2480
2481 pub fn language_at<T: ToOffset>(&self, point: T, cx: &App) -> Option<Arc<Language>> {
2482 self.point_to_buffer_offset(point, cx)
2483 .and_then(|(buffer, offset)| buffer.read(cx).language_at(offset))
2484 }
2485
2486 pub fn language_settings<'a>(&'a self, cx: &'a App) -> Cow<'a, LanguageSettings> {
2487 let buffer_id = self
2488 .snapshot
2489 .borrow()
2490 .excerpts
2491 .first()
2492 .map(|excerpt| excerpt.buffer.remote_id());
2493 buffer_id
2494 .and_then(|buffer_id| self.buffer(buffer_id))
2495 .map(|buffer| {
2496 let buffer = buffer.read(cx);
2497 language_settings(buffer.language().map(|l| l.name()), buffer.file(), cx)
2498 })
2499 .unwrap_or_else(move || self.language_settings_at(0, cx))
2500 }
2501
2502 pub fn language_settings_at<'a, T: ToOffset>(
2503 &'a self,
2504 point: T,
2505 cx: &'a App,
2506 ) -> Cow<'a, LanguageSettings> {
2507 let mut language = None;
2508 let mut file = None;
2509 if let Some((buffer, offset)) = self.point_to_buffer_offset(point, cx) {
2510 let buffer = buffer.read(cx);
2511 language = buffer.language_at(offset);
2512 file = buffer.file();
2513 }
2514 language_settings(language.map(|l| l.name()), file, cx)
2515 }
2516
2517 pub fn for_each_buffer(&self, mut f: impl FnMut(&Entity<Buffer>)) {
2518 self.buffers
2519 .borrow()
2520 .values()
2521 .for_each(|state| f(&state.buffer))
2522 }
2523
2524 pub fn title<'a>(&'a self, cx: &'a App) -> Cow<'a, str> {
2525 if let Some(title) = self.title.as_ref() {
2526 return title.into();
2527 }
2528
2529 if let Some(buffer) = self.as_singleton() {
2530 if let Some(file) = buffer.read(cx).file() {
2531 return file.file_name(cx).to_string_lossy();
2532 }
2533 }
2534
2535 "untitled".into()
2536 }
2537
2538 pub fn set_title(&mut self, title: String, cx: &mut Context<Self>) {
2539 self.title = Some(title);
2540 cx.notify();
2541 }
2542
2543 /// Preserve preview tabs containing this multibuffer until additional edits occur.
2544 pub fn refresh_preview(&self, cx: &mut Context<Self>) {
2545 for buffer_state in self.buffers.borrow().values() {
2546 buffer_state
2547 .buffer
2548 .update(cx, |buffer, _cx| buffer.refresh_preview());
2549 }
2550 }
2551
2552 /// Whether we should preserve the preview status of a tab containing this multi-buffer.
2553 pub fn preserve_preview(&self, cx: &App) -> bool {
2554 self.buffers
2555 .borrow()
2556 .values()
2557 .all(|state| state.buffer.read(cx).preserve_preview())
2558 }
2559
2560 #[cfg(any(test, feature = "test-support"))]
2561 pub fn is_parsing(&self, cx: &App) -> bool {
2562 self.as_singleton().unwrap().read(cx).is_parsing()
2563 }
2564
2565 pub fn add_diff(&mut self, diff: Entity<BufferDiff>, cx: &mut Context<Self>) {
2566 let buffer_id = diff.read(cx).buffer_id;
2567 self.buffer_diff_changed(diff.clone(), text::Anchor::MIN..text::Anchor::MAX, cx);
2568 self.diffs.insert(buffer_id, DiffState::new(diff, cx));
2569 }
2570
2571 pub fn diff_for(&self, buffer_id: BufferId) -> Option<Entity<BufferDiff>> {
2572 self.diffs.get(&buffer_id).map(|state| state.diff.clone())
2573 }
2574
2575 pub fn expand_diff_hunks(&mut self, ranges: Vec<Range<Anchor>>, cx: &mut Context<Self>) {
2576 self.expand_or_collapse_diff_hunks(ranges, true, cx);
2577 }
2578
2579 pub fn collapse_diff_hunks(&mut self, ranges: Vec<Range<Anchor>>, cx: &mut Context<Self>) {
2580 self.expand_or_collapse_diff_hunks(ranges, false, cx);
2581 }
2582
2583 pub fn set_all_diff_hunks_expanded(&mut self, cx: &mut Context<Self>) {
2584 self.snapshot.borrow_mut().all_diff_hunks_expanded = true;
2585 self.expand_or_collapse_diff_hunks(vec![Anchor::min()..Anchor::max()], true, cx);
2586 }
2587
2588 pub fn all_diff_hunks_expanded(&self) -> bool {
2589 self.snapshot.borrow().all_diff_hunks_expanded
2590 }
2591
2592 pub fn has_multiple_hunks(&self, cx: &App) -> bool {
2593 self.read(cx)
2594 .diff_hunks_in_range(Anchor::min()..Anchor::max())
2595 .nth(1)
2596 .is_some()
2597 }
2598
2599 pub fn single_hunk_is_expanded(&self, range: Range<Anchor>, cx: &App) -> bool {
2600 let snapshot = self.read(cx);
2601 let mut cursor = snapshot.diff_transforms.cursor::<usize>(&());
2602 let offset_range = range.to_offset(&snapshot);
2603 cursor.seek(&offset_range.start, Bias::Left, &());
2604 while let Some(item) = cursor.item() {
2605 if *cursor.start() >= offset_range.end && *cursor.start() > offset_range.start {
2606 break;
2607 }
2608 if item.hunk_info().is_some() {
2609 return true;
2610 }
2611 cursor.next(&());
2612 }
2613 false
2614 }
2615
2616 pub fn has_expanded_diff_hunks_in_ranges(&self, ranges: &[Range<Anchor>], cx: &App) -> bool {
2617 let snapshot = self.read(cx);
2618 let mut cursor = snapshot.diff_transforms.cursor::<usize>(&());
2619 for range in ranges {
2620 let range = range.to_point(&snapshot);
2621 let start = snapshot.point_to_offset(Point::new(range.start.row, 0));
2622 let end = snapshot.point_to_offset(Point::new(range.end.row + 1, 0));
2623 let start = start.saturating_sub(1);
2624 let end = snapshot.len().min(end + 1);
2625 cursor.seek(&start, Bias::Right, &());
2626 while let Some(item) = cursor.item() {
2627 if *cursor.start() >= end {
2628 break;
2629 }
2630 if item.hunk_info().is_some() {
2631 return true;
2632 }
2633 cursor.next(&());
2634 }
2635 }
2636 false
2637 }
2638
2639 pub fn expand_or_collapse_diff_hunks_inner(
2640 &mut self,
2641 ranges: impl IntoIterator<Item = (Range<Point>, ExcerptId)>,
2642 expand: bool,
2643 cx: &mut Context<Self>,
2644 ) {
2645 if self.snapshot.borrow().all_diff_hunks_expanded && !expand {
2646 return;
2647 }
2648 self.sync(cx);
2649 let mut snapshot = self.snapshot.borrow_mut();
2650 let mut excerpt_edits = Vec::new();
2651 for (range, end_excerpt_id) in ranges {
2652 for diff_hunk in snapshot.diff_hunks_in_range(range) {
2653 if diff_hunk.excerpt_id.cmp(&end_excerpt_id, &snapshot).is_gt() {
2654 continue;
2655 }
2656 let start = Anchor::in_buffer(
2657 diff_hunk.excerpt_id,
2658 diff_hunk.buffer_id,
2659 diff_hunk.buffer_range.start,
2660 );
2661 let end = Anchor::in_buffer(
2662 diff_hunk.excerpt_id,
2663 diff_hunk.buffer_id,
2664 diff_hunk.buffer_range.end,
2665 );
2666 let start = snapshot.excerpt_offset_for_anchor(&start);
2667 let end = snapshot.excerpt_offset_for_anchor(&end);
2668 excerpt_edits.push(text::Edit {
2669 old: start..end,
2670 new: start..end,
2671 });
2672 }
2673 }
2674
2675 self.sync_diff_transforms(
2676 &mut snapshot,
2677 excerpt_edits,
2678 DiffChangeKind::ExpandOrCollapseHunks { expand },
2679 );
2680 cx.emit(Event::DiffHunksToggled);
2681 cx.emit(Event::Edited {
2682 singleton_buffer_edited: false,
2683 edited_buffer: None,
2684 });
2685 }
2686
2687 pub fn expand_or_collapse_diff_hunks(
2688 &mut self,
2689 ranges: Vec<Range<Anchor>>,
2690 expand: bool,
2691 cx: &mut Context<Self>,
2692 ) {
2693 let snapshot = self.snapshot.borrow().clone();
2694 let ranges = ranges.iter().map(move |range| {
2695 let end_excerpt_id = range.end.excerpt_id;
2696 let range = range.to_point(&snapshot);
2697 let mut peek_end = range.end;
2698 if range.end.row < snapshot.max_row().0 {
2699 peek_end = Point::new(range.end.row + 1, 0);
2700 };
2701 (range.start..peek_end, end_excerpt_id)
2702 });
2703 self.expand_or_collapse_diff_hunks_inner(ranges, expand, cx);
2704 }
2705
2706 pub fn resize_excerpt(
2707 &mut self,
2708 id: ExcerptId,
2709 range: Range<text::Anchor>,
2710 cx: &mut Context<Self>,
2711 ) {
2712 self.sync(cx);
2713
2714 let mut snapshot = self.snapshot.borrow_mut();
2715 let locator = snapshot.excerpt_locator_for_id(id);
2716 let mut new_excerpts = SumTree::default();
2717 let mut cursor = snapshot
2718 .excerpts
2719 .cursor::<(Option<&Locator>, ExcerptOffset)>(&());
2720 let mut edits = Vec::<Edit<ExcerptOffset>>::new();
2721
2722 let prefix = cursor.slice(&Some(locator), Bias::Left, &());
2723 new_excerpts.append(prefix, &());
2724
2725 let mut excerpt = cursor.item().unwrap().clone();
2726 let old_text_len = ExcerptOffset::new(excerpt.text_summary.len);
2727
2728 excerpt.range.context.start = range.start;
2729 excerpt.range.context.end = range.end;
2730 excerpt.max_buffer_row = range.end.to_point(&excerpt.buffer).row;
2731
2732 excerpt.text_summary = excerpt
2733 .buffer
2734 .text_summary_for_range(excerpt.range.context.clone());
2735
2736 let new_start_offset = ExcerptOffset::new(new_excerpts.summary().text.len);
2737 let old_start_offset = cursor.start().1;
2738 let new_text_len = ExcerptOffset::new(excerpt.text_summary.len);
2739 let edit = Edit {
2740 old: old_start_offset..old_start_offset + old_text_len,
2741 new: new_start_offset..new_start_offset + new_text_len,
2742 };
2743
2744 if let Some(last_edit) = edits.last_mut() {
2745 if last_edit.old.end == edit.old.start {
2746 last_edit.old.end = edit.old.end;
2747 last_edit.new.end = edit.new.end;
2748 } else {
2749 edits.push(edit);
2750 }
2751 } else {
2752 edits.push(edit);
2753 }
2754
2755 new_excerpts.push(excerpt, &());
2756
2757 cursor.next(&());
2758
2759 new_excerpts.append(cursor.suffix(&()), &());
2760
2761 drop(cursor);
2762 snapshot.excerpts = new_excerpts;
2763
2764 self.sync_diff_transforms(&mut snapshot, edits, DiffChangeKind::BufferEdited);
2765 cx.emit(Event::Edited {
2766 singleton_buffer_edited: false,
2767 edited_buffer: None,
2768 });
2769 cx.emit(Event::ExcerptsExpanded { ids: vec![id] });
2770 cx.notify();
2771 }
2772
2773 pub fn expand_excerpts(
2774 &mut self,
2775 ids: impl IntoIterator<Item = ExcerptId>,
2776 line_count: u32,
2777 direction: ExpandExcerptDirection,
2778 cx: &mut Context<Self>,
2779 ) {
2780 if line_count == 0 {
2781 return;
2782 }
2783 self.sync(cx);
2784 if !self.excerpts_by_path.is_empty() {
2785 self.expand_excerpts_with_paths(ids, line_count, direction, cx);
2786 return;
2787 }
2788 let mut snapshot = self.snapshot.borrow_mut();
2789
2790 let ids = ids.into_iter().collect::<Vec<_>>();
2791 let locators = snapshot.excerpt_locators_for_ids(ids.iter().copied());
2792 let mut new_excerpts = SumTree::default();
2793 let mut cursor = snapshot
2794 .excerpts
2795 .cursor::<(Option<&Locator>, ExcerptOffset)>(&());
2796 let mut edits = Vec::<Edit<ExcerptOffset>>::new();
2797
2798 for locator in &locators {
2799 let prefix = cursor.slice(&Some(locator), Bias::Left, &());
2800 new_excerpts.append(prefix, &());
2801
2802 let mut excerpt = cursor.item().unwrap().clone();
2803 let old_text_len = ExcerptOffset::new(excerpt.text_summary.len);
2804
2805 let up_line_count = if direction.should_expand_up() {
2806 line_count
2807 } else {
2808 0
2809 };
2810
2811 let start_row = excerpt
2812 .range
2813 .context
2814 .start
2815 .to_point(&excerpt.buffer)
2816 .row
2817 .saturating_sub(up_line_count);
2818 let start_point = Point::new(start_row, 0);
2819 excerpt.range.context.start = excerpt.buffer.anchor_before(start_point);
2820
2821 let down_line_count = if direction.should_expand_down() {
2822 line_count
2823 } else {
2824 0
2825 };
2826
2827 let mut end_point = excerpt.buffer.clip_point(
2828 excerpt.range.context.end.to_point(&excerpt.buffer)
2829 + Point::new(down_line_count, 0),
2830 Bias::Left,
2831 );
2832 end_point.column = excerpt.buffer.line_len(end_point.row);
2833 excerpt.range.context.end = excerpt.buffer.anchor_after(end_point);
2834 excerpt.max_buffer_row = end_point.row;
2835
2836 excerpt.text_summary = excerpt
2837 .buffer
2838 .text_summary_for_range(excerpt.range.context.clone());
2839
2840 let new_start_offset = ExcerptOffset::new(new_excerpts.summary().text.len);
2841 let old_start_offset = cursor.start().1;
2842 let new_text_len = ExcerptOffset::new(excerpt.text_summary.len);
2843 let edit = Edit {
2844 old: old_start_offset..old_start_offset + old_text_len,
2845 new: new_start_offset..new_start_offset + new_text_len,
2846 };
2847
2848 if let Some(last_edit) = edits.last_mut() {
2849 if last_edit.old.end == edit.old.start {
2850 last_edit.old.end = edit.old.end;
2851 last_edit.new.end = edit.new.end;
2852 } else {
2853 edits.push(edit);
2854 }
2855 } else {
2856 edits.push(edit);
2857 }
2858
2859 new_excerpts.push(excerpt, &());
2860
2861 cursor.next(&());
2862 }
2863
2864 new_excerpts.append(cursor.suffix(&()), &());
2865
2866 drop(cursor);
2867 snapshot.excerpts = new_excerpts;
2868
2869 self.sync_diff_transforms(&mut snapshot, edits, DiffChangeKind::BufferEdited);
2870 cx.emit(Event::Edited {
2871 singleton_buffer_edited: false,
2872 edited_buffer: None,
2873 });
2874 cx.emit(Event::ExcerptsExpanded { ids });
2875 cx.notify();
2876 }
2877
2878 fn sync(&self, cx: &App) {
2879 let changed = self.buffer_changed_since_sync.replace(false);
2880 if !changed {
2881 return;
2882 }
2883
2884 let mut snapshot = self.snapshot.borrow_mut();
2885 let mut excerpts_to_edit = Vec::new();
2886 let mut non_text_state_updated = false;
2887 let mut is_dirty = false;
2888 let mut has_deleted_file = false;
2889 let mut has_conflict = false;
2890 let mut edited = false;
2891 let mut buffers = self.buffers.borrow_mut();
2892 for buffer_state in buffers.values_mut() {
2893 let buffer = buffer_state.buffer.read(cx);
2894 let version = buffer.version();
2895 let non_text_state_update_count = buffer.non_text_state_update_count();
2896
2897 let buffer_edited = version.changed_since(&buffer_state.last_version);
2898 let buffer_non_text_state_updated =
2899 non_text_state_update_count > buffer_state.last_non_text_state_update_count;
2900 if buffer_edited || buffer_non_text_state_updated {
2901 buffer_state.last_version = version;
2902 buffer_state.last_non_text_state_update_count = non_text_state_update_count;
2903 excerpts_to_edit.extend(
2904 buffer_state
2905 .excerpts
2906 .iter()
2907 .map(|locator| (locator, buffer_state.buffer.clone(), buffer_edited)),
2908 );
2909 }
2910
2911 edited |= buffer_edited;
2912 non_text_state_updated |= buffer_non_text_state_updated;
2913 is_dirty |= buffer.is_dirty();
2914 has_deleted_file |= buffer
2915 .file()
2916 .map_or(false, |file| file.disk_state() == DiskState::Deleted);
2917 has_conflict |= buffer.has_conflict();
2918 }
2919 if edited {
2920 snapshot.edit_count += 1;
2921 }
2922 if non_text_state_updated {
2923 snapshot.non_text_state_update_count += 1;
2924 }
2925 snapshot.is_dirty = is_dirty;
2926 snapshot.has_deleted_file = has_deleted_file;
2927 snapshot.has_conflict = has_conflict;
2928
2929 for (id, diff) in self.diffs.iter() {
2930 if snapshot.diffs.get(&id).is_none() {
2931 snapshot.diffs.insert(*id, diff.diff.read(cx).snapshot(cx));
2932 }
2933 }
2934
2935 excerpts_to_edit.sort_unstable_by_key(|(locator, _, _)| *locator);
2936
2937 let mut edits = Vec::new();
2938 let mut new_excerpts = SumTree::default();
2939 let mut cursor = snapshot
2940 .excerpts
2941 .cursor::<(Option<&Locator>, ExcerptOffset)>(&());
2942
2943 for (locator, buffer, buffer_edited) in excerpts_to_edit {
2944 new_excerpts.append(cursor.slice(&Some(locator), Bias::Left, &()), &());
2945 let old_excerpt = cursor.item().unwrap();
2946 let buffer = buffer.read(cx);
2947 let buffer_id = buffer.remote_id();
2948
2949 let mut new_excerpt;
2950 if buffer_edited {
2951 edits.extend(
2952 buffer
2953 .edits_since_in_range::<usize>(
2954 old_excerpt.buffer.version(),
2955 old_excerpt.range.context.clone(),
2956 )
2957 .map(|edit| {
2958 let excerpt_old_start = cursor.start().1;
2959 let excerpt_new_start =
2960 ExcerptOffset::new(new_excerpts.summary().text.len);
2961 let old_start = excerpt_old_start + ExcerptOffset::new(edit.old.start);
2962 let old_end = excerpt_old_start + ExcerptOffset::new(edit.old.end);
2963 let new_start = excerpt_new_start + ExcerptOffset::new(edit.new.start);
2964 let new_end = excerpt_new_start + ExcerptOffset::new(edit.new.end);
2965 Edit {
2966 old: old_start..old_end,
2967 new: new_start..new_end,
2968 }
2969 }),
2970 );
2971
2972 new_excerpt = Excerpt::new(
2973 old_excerpt.id,
2974 locator.clone(),
2975 buffer_id,
2976 buffer.snapshot(),
2977 old_excerpt.range.clone(),
2978 old_excerpt.has_trailing_newline,
2979 );
2980 } else {
2981 new_excerpt = old_excerpt.clone();
2982 new_excerpt.buffer = buffer.snapshot();
2983 }
2984
2985 new_excerpts.push(new_excerpt, &());
2986 cursor.next(&());
2987 }
2988 new_excerpts.append(cursor.suffix(&()), &());
2989
2990 drop(cursor);
2991 snapshot.excerpts = new_excerpts;
2992
2993 self.sync_diff_transforms(&mut snapshot, edits, DiffChangeKind::BufferEdited);
2994 }
2995
2996 fn sync_diff_transforms(
2997 &self,
2998 snapshot: &mut MultiBufferSnapshot,
2999 excerpt_edits: Vec<text::Edit<ExcerptOffset>>,
3000 change_kind: DiffChangeKind,
3001 ) {
3002 if excerpt_edits.is_empty() {
3003 return;
3004 }
3005
3006 let mut excerpts = snapshot.excerpts.cursor::<ExcerptOffset>(&());
3007 let mut old_diff_transforms = snapshot
3008 .diff_transforms
3009 .cursor::<(ExcerptOffset, usize)>(&());
3010 let mut new_diff_transforms = SumTree::default();
3011 let mut old_expanded_hunks = HashSet::default();
3012 let mut output_edits = Vec::new();
3013 let mut output_delta = 0_isize;
3014 let mut at_transform_boundary = true;
3015 let mut end_of_current_insert = None;
3016
3017 let mut excerpt_edits = excerpt_edits.into_iter().peekable();
3018 while let Some(edit) = excerpt_edits.next() {
3019 excerpts.seek_forward(&edit.new.start, Bias::Right, &());
3020 if excerpts.item().is_none() && *excerpts.start() == edit.new.start {
3021 excerpts.prev(&());
3022 }
3023
3024 // Keep any transforms that are before the edit.
3025 if at_transform_boundary {
3026 at_transform_boundary = false;
3027 let transforms_before_edit =
3028 old_diff_transforms.slice(&edit.old.start, Bias::Left, &());
3029 self.append_diff_transforms(&mut new_diff_transforms, transforms_before_edit);
3030 if let Some(transform) = old_diff_transforms.item() {
3031 if old_diff_transforms.end(&()).0 == edit.old.start
3032 && old_diff_transforms.start().0 < edit.old.start
3033 {
3034 self.push_diff_transform(&mut new_diff_transforms, transform.clone());
3035 old_diff_transforms.next(&());
3036 }
3037 }
3038 }
3039
3040 // Compute the start of the edit in output coordinates.
3041 let edit_start_overshoot = (edit.old.start - old_diff_transforms.start().0).value;
3042 let edit_old_start = old_diff_transforms.start().1 + edit_start_overshoot;
3043 let edit_new_start = (edit_old_start as isize + output_delta) as usize;
3044
3045 let changed_diff_hunks = self.recompute_diff_transforms_for_edit(
3046 &edit,
3047 &mut excerpts,
3048 &mut old_diff_transforms,
3049 &mut new_diff_transforms,
3050 &mut end_of_current_insert,
3051 &mut old_expanded_hunks,
3052 &snapshot,
3053 change_kind,
3054 );
3055
3056 // Compute the end of the edit in output coordinates.
3057 let edit_old_end_overshoot = edit.old.end - old_diff_transforms.start().0;
3058 let edit_new_end_overshoot = edit.new.end - new_diff_transforms.summary().excerpt_len();
3059 let edit_old_end = old_diff_transforms.start().1 + edit_old_end_overshoot.value;
3060 let edit_new_end =
3061 new_diff_transforms.summary().output.len + edit_new_end_overshoot.value;
3062 let output_edit = Edit {
3063 old: edit_old_start..edit_old_end,
3064 new: edit_new_start..edit_new_end,
3065 };
3066
3067 output_delta += (output_edit.new.end - output_edit.new.start) as isize;
3068 output_delta -= (output_edit.old.end - output_edit.old.start) as isize;
3069 if changed_diff_hunks || matches!(change_kind, DiffChangeKind::BufferEdited) {
3070 output_edits.push(output_edit);
3071 }
3072
3073 // If this is the last edit that intersects the current diff transform,
3074 // then recreate the content up to the end of this transform, to prepare
3075 // for reusing additional slices of the old transforms.
3076 if excerpt_edits.peek().map_or(true, |next_edit| {
3077 next_edit.old.start >= old_diff_transforms.end(&()).0
3078 }) {
3079 let keep_next_old_transform = (old_diff_transforms.start().0 >= edit.old.end)
3080 && match old_diff_transforms.item() {
3081 Some(DiffTransform::BufferContent {
3082 inserted_hunk_info: Some(hunk),
3083 ..
3084 }) => excerpts.item().is_some_and(|excerpt| {
3085 hunk.hunk_start_anchor.is_valid(&excerpt.buffer)
3086 }),
3087 _ => true,
3088 };
3089
3090 let mut excerpt_offset = edit.new.end;
3091 if !keep_next_old_transform {
3092 excerpt_offset += old_diff_transforms.end(&()).0 - edit.old.end;
3093 old_diff_transforms.next(&());
3094 }
3095
3096 old_expanded_hunks.clear();
3097 self.push_buffer_content_transform(
3098 &snapshot,
3099 &mut new_diff_transforms,
3100 excerpt_offset,
3101 end_of_current_insert,
3102 );
3103 at_transform_boundary = true;
3104 }
3105 }
3106
3107 // Keep any transforms that are after the last edit.
3108 self.append_diff_transforms(&mut new_diff_transforms, old_diff_transforms.suffix(&()));
3109
3110 // Ensure there's always at least one buffer content transform.
3111 if new_diff_transforms.is_empty() {
3112 new_diff_transforms.push(
3113 DiffTransform::BufferContent {
3114 summary: Default::default(),
3115 inserted_hunk_info: None,
3116 },
3117 &(),
3118 );
3119 }
3120
3121 self.subscriptions.publish(output_edits);
3122 drop(old_diff_transforms);
3123 drop(excerpts);
3124 snapshot.diff_transforms = new_diff_transforms;
3125 snapshot.edit_count += 1;
3126
3127 #[cfg(any(test, feature = "test-support"))]
3128 snapshot.check_invariants();
3129 }
3130
3131 fn recompute_diff_transforms_for_edit(
3132 &self,
3133 edit: &Edit<TypedOffset<Excerpt>>,
3134 excerpts: &mut Cursor<Excerpt, TypedOffset<Excerpt>>,
3135 old_diff_transforms: &mut Cursor<DiffTransform, (TypedOffset<Excerpt>, usize)>,
3136 new_diff_transforms: &mut SumTree<DiffTransform>,
3137 end_of_current_insert: &mut Option<(TypedOffset<Excerpt>, DiffTransformHunkInfo)>,
3138 old_expanded_hunks: &mut HashSet<DiffTransformHunkInfo>,
3139 snapshot: &MultiBufferSnapshot,
3140 change_kind: DiffChangeKind,
3141 ) -> bool {
3142 log::trace!(
3143 "recomputing diff transform for edit {:?} => {:?}",
3144 edit.old.start.value..edit.old.end.value,
3145 edit.new.start.value..edit.new.end.value
3146 );
3147
3148 // Record which hunks were previously expanded.
3149 while let Some(item) = old_diff_transforms.item() {
3150 if let Some(hunk_info) = item.hunk_info() {
3151 log::trace!(
3152 "previously expanded hunk at {}",
3153 old_diff_transforms.start().0
3154 );
3155 old_expanded_hunks.insert(hunk_info);
3156 }
3157 if old_diff_transforms.end(&()).0 > edit.old.end {
3158 break;
3159 }
3160 old_diff_transforms.next(&());
3161 }
3162
3163 // Avoid querying diff hunks if there's no possibility of hunks being expanded.
3164 let all_diff_hunks_expanded = snapshot.all_diff_hunks_expanded;
3165 if old_expanded_hunks.is_empty()
3166 && change_kind == DiffChangeKind::BufferEdited
3167 && !all_diff_hunks_expanded
3168 {
3169 return false;
3170 }
3171
3172 // Visit each excerpt that intersects the edit.
3173 let mut did_expand_hunks = false;
3174 while let Some(excerpt) = excerpts.item() {
3175 // Recompute the expanded hunks in the portion of the excerpt that
3176 // intersects the edit.
3177 if let Some(diff) = snapshot.diffs.get(&excerpt.buffer_id) {
3178 let buffer = &excerpt.buffer;
3179 let excerpt_start = *excerpts.start();
3180 let excerpt_end = excerpt_start + ExcerptOffset::new(excerpt.text_summary.len);
3181 let excerpt_buffer_start = excerpt.range.context.start.to_offset(buffer);
3182 let excerpt_buffer_end = excerpt_buffer_start + excerpt.text_summary.len;
3183 let edit_buffer_start =
3184 excerpt_buffer_start + edit.new.start.value.saturating_sub(excerpt_start.value);
3185 let edit_buffer_end =
3186 excerpt_buffer_start + edit.new.end.value.saturating_sub(excerpt_start.value);
3187 let edit_buffer_end = edit_buffer_end.min(excerpt_buffer_end);
3188 let edit_anchor_range =
3189 buffer.anchor_before(edit_buffer_start)..buffer.anchor_after(edit_buffer_end);
3190
3191 for hunk in diff.hunks_intersecting_range(edit_anchor_range, buffer) {
3192 if hunk.is_created_file() && !all_diff_hunks_expanded {
3193 continue;
3194 }
3195
3196 let hunk_buffer_range = hunk.buffer_range.to_offset(buffer);
3197 if hunk_buffer_range.start < excerpt_buffer_start {
3198 log::trace!("skipping hunk that starts before excerpt");
3199 continue;
3200 }
3201
3202 let hunk_info = DiffTransformHunkInfo {
3203 excerpt_id: excerpt.id,
3204 hunk_start_anchor: hunk.buffer_range.start,
3205 hunk_secondary_status: hunk.secondary_status,
3206 };
3207
3208 let hunk_excerpt_start = excerpt_start
3209 + ExcerptOffset::new(
3210 hunk_buffer_range.start.saturating_sub(excerpt_buffer_start),
3211 );
3212 let hunk_excerpt_end = excerpt_end.min(
3213 excerpt_start
3214 + ExcerptOffset::new(hunk_buffer_range.end - excerpt_buffer_start),
3215 );
3216
3217 self.push_buffer_content_transform(
3218 snapshot,
3219 new_diff_transforms,
3220 hunk_excerpt_start,
3221 *end_of_current_insert,
3222 );
3223
3224 // For every existing hunk, determine if it was previously expanded
3225 // and if it should currently be expanded.
3226 let was_previously_expanded = old_expanded_hunks.contains(&hunk_info);
3227 let should_expand_hunk = match &change_kind {
3228 DiffChangeKind::DiffUpdated { base_changed: true } => {
3229 was_previously_expanded || all_diff_hunks_expanded
3230 }
3231 DiffChangeKind::ExpandOrCollapseHunks { expand } => {
3232 let intersects = hunk_buffer_range.is_empty()
3233 || hunk_buffer_range.end > edit_buffer_start;
3234 if *expand {
3235 intersects || was_previously_expanded || all_diff_hunks_expanded
3236 } else {
3237 !intersects && (was_previously_expanded || all_diff_hunks_expanded)
3238 }
3239 }
3240 _ => was_previously_expanded || all_diff_hunks_expanded,
3241 };
3242
3243 if should_expand_hunk {
3244 did_expand_hunks = true;
3245 log::trace!(
3246 "expanding hunk {:?}, excerpt:{:?}",
3247 hunk_excerpt_start.value..hunk_excerpt_end.value,
3248 excerpt.id
3249 );
3250
3251 if !hunk.diff_base_byte_range.is_empty()
3252 && hunk_buffer_range.start >= edit_buffer_start
3253 && hunk_buffer_range.start <= excerpt_buffer_end
3254 {
3255 let base_text = diff.base_text();
3256 let mut text_cursor =
3257 base_text.as_rope().cursor(hunk.diff_base_byte_range.start);
3258 let mut base_text_summary =
3259 text_cursor.summary::<TextSummary>(hunk.diff_base_byte_range.end);
3260
3261 let mut has_trailing_newline = false;
3262 if base_text_summary.last_line_chars > 0 {
3263 base_text_summary += TextSummary::newline();
3264 has_trailing_newline = true;
3265 }
3266
3267 new_diff_transforms.push(
3268 DiffTransform::DeletedHunk {
3269 base_text_byte_range: hunk.diff_base_byte_range.clone(),
3270 summary: base_text_summary,
3271 buffer_id: excerpt.buffer_id,
3272 hunk_info,
3273 has_trailing_newline,
3274 },
3275 &(),
3276 );
3277 }
3278
3279 if !hunk_buffer_range.is_empty() {
3280 *end_of_current_insert =
3281 Some((hunk_excerpt_end.min(excerpt_end), hunk_info));
3282 }
3283 }
3284 }
3285 }
3286
3287 if excerpts.end(&()) <= edit.new.end {
3288 excerpts.next(&());
3289 } else {
3290 break;
3291 }
3292 }
3293
3294 did_expand_hunks || !old_expanded_hunks.is_empty()
3295 }
3296
3297 fn append_diff_transforms(
3298 &self,
3299 new_transforms: &mut SumTree<DiffTransform>,
3300 subtree: SumTree<DiffTransform>,
3301 ) {
3302 if let Some(DiffTransform::BufferContent {
3303 inserted_hunk_info,
3304 summary,
3305 }) = subtree.first()
3306 {
3307 if self.extend_last_buffer_content_transform(
3308 new_transforms,
3309 *inserted_hunk_info,
3310 *summary,
3311 ) {
3312 let mut cursor = subtree.cursor::<()>(&());
3313 cursor.next(&());
3314 cursor.next(&());
3315 new_transforms.append(cursor.suffix(&()), &());
3316 return;
3317 }
3318 }
3319 new_transforms.append(subtree, &());
3320 }
3321
3322 fn push_diff_transform(
3323 &self,
3324 new_transforms: &mut SumTree<DiffTransform>,
3325 transform: DiffTransform,
3326 ) {
3327 if let DiffTransform::BufferContent {
3328 inserted_hunk_info: inserted_hunk_anchor,
3329 summary,
3330 } = transform
3331 {
3332 if self.extend_last_buffer_content_transform(
3333 new_transforms,
3334 inserted_hunk_anchor,
3335 summary,
3336 ) {
3337 return;
3338 }
3339 }
3340 new_transforms.push(transform, &());
3341 }
3342
3343 fn push_buffer_content_transform(
3344 &self,
3345 old_snapshot: &MultiBufferSnapshot,
3346 new_transforms: &mut SumTree<DiffTransform>,
3347 end_offset: ExcerptOffset,
3348 current_inserted_hunk: Option<(ExcerptOffset, DiffTransformHunkInfo)>,
3349 ) {
3350 let inserted_region = current_inserted_hunk.map(|(insertion_end_offset, hunk_info)| {
3351 (end_offset.min(insertion_end_offset), Some(hunk_info))
3352 });
3353 let unchanged_region = [(end_offset, None)];
3354
3355 for (end_offset, inserted_hunk_info) in inserted_region.into_iter().chain(unchanged_region)
3356 {
3357 let start_offset = new_transforms.summary().excerpt_len();
3358 if end_offset <= start_offset {
3359 continue;
3360 }
3361 let summary_to_add = old_snapshot
3362 .text_summary_for_excerpt_offset_range::<TextSummary>(start_offset..end_offset);
3363
3364 if !self.extend_last_buffer_content_transform(
3365 new_transforms,
3366 inserted_hunk_info,
3367 summary_to_add,
3368 ) {
3369 new_transforms.push(
3370 DiffTransform::BufferContent {
3371 summary: summary_to_add,
3372 inserted_hunk_info,
3373 },
3374 &(),
3375 )
3376 }
3377 }
3378 }
3379
3380 fn extend_last_buffer_content_transform(
3381 &self,
3382 new_transforms: &mut SumTree<DiffTransform>,
3383 new_inserted_hunk_info: Option<DiffTransformHunkInfo>,
3384 summary_to_add: TextSummary,
3385 ) -> bool {
3386 let mut did_extend = false;
3387 new_transforms.update_last(
3388 |last_transform| {
3389 if let DiffTransform::BufferContent {
3390 summary,
3391 inserted_hunk_info: inserted_hunk_anchor,
3392 } = last_transform
3393 {
3394 if *inserted_hunk_anchor == new_inserted_hunk_info {
3395 *summary += summary_to_add;
3396 did_extend = true;
3397 }
3398 }
3399 },
3400 &(),
3401 );
3402 did_extend
3403 }
3404}
3405
3406fn build_excerpt_ranges(
3407 ranges: impl IntoIterator<Item = Range<Point>>,
3408 context_line_count: u32,
3409 buffer_snapshot: &BufferSnapshot,
3410) -> Vec<ExcerptRange<Point>> {
3411 ranges
3412 .into_iter()
3413 .map(|range| {
3414 let start_row = range.start.row.saturating_sub(context_line_count);
3415 let start = Point::new(start_row, 0);
3416 let end_row = (range.end.row + context_line_count).min(buffer_snapshot.max_point().row);
3417 let end = Point::new(end_row, buffer_snapshot.line_len(end_row));
3418 ExcerptRange {
3419 context: start..end,
3420 primary: range,
3421 }
3422 })
3423 .collect()
3424}
3425
3426#[cfg(any(test, feature = "test-support"))]
3427impl MultiBuffer {
3428 pub fn build_simple(text: &str, cx: &mut gpui::App) -> Entity<Self> {
3429 let buffer = cx.new(|cx| Buffer::local(text, cx));
3430 cx.new(|cx| Self::singleton(buffer, cx))
3431 }
3432
3433 pub fn build_multi<const COUNT: usize>(
3434 excerpts: [(&str, Vec<Range<Point>>); COUNT],
3435 cx: &mut gpui::App,
3436 ) -> Entity<Self> {
3437 let multi = cx.new(|_| Self::new(Capability::ReadWrite));
3438 for (text, ranges) in excerpts {
3439 let buffer = cx.new(|cx| Buffer::local(text, cx));
3440 let excerpt_ranges = ranges
3441 .into_iter()
3442 .map(|range| ExcerptRange::new(range.clone()));
3443 multi.update(cx, |multi, cx| {
3444 multi.push_excerpts(buffer, excerpt_ranges, cx)
3445 });
3446 }
3447
3448 multi
3449 }
3450
3451 pub fn build_from_buffer(buffer: Entity<Buffer>, cx: &mut gpui::App) -> Entity<Self> {
3452 cx.new(|cx| Self::singleton(buffer, cx))
3453 }
3454
3455 pub fn build_random(rng: &mut impl rand::Rng, cx: &mut gpui::App) -> Entity<Self> {
3456 cx.new(|cx| {
3457 let mut multibuffer = MultiBuffer::new(Capability::ReadWrite);
3458 let mutation_count = rng.gen_range(1..=5);
3459 multibuffer.randomly_edit_excerpts(rng, mutation_count, cx);
3460 multibuffer
3461 })
3462 }
3463
3464 pub fn randomly_edit(
3465 &mut self,
3466 rng: &mut impl rand::Rng,
3467 edit_count: usize,
3468 cx: &mut Context<Self>,
3469 ) {
3470 use util::RandomCharIter;
3471
3472 let snapshot = self.read(cx);
3473 let mut edits: Vec<(Range<usize>, Arc<str>)> = Vec::new();
3474 let mut last_end = None;
3475 for _ in 0..edit_count {
3476 if last_end.map_or(false, |last_end| last_end >= snapshot.len()) {
3477 break;
3478 }
3479
3480 let new_start = last_end.map_or(0, |last_end| last_end + 1);
3481 let end = snapshot.clip_offset(rng.gen_range(new_start..=snapshot.len()), Bias::Right);
3482 let start = snapshot.clip_offset(rng.gen_range(new_start..=end), Bias::Right);
3483 last_end = Some(end);
3484
3485 let mut range = start..end;
3486 if rng.gen_bool(0.2) {
3487 mem::swap(&mut range.start, &mut range.end);
3488 }
3489
3490 let new_text_len = rng.gen_range(0..10);
3491 let new_text: String = RandomCharIter::new(&mut *rng).take(new_text_len).collect();
3492
3493 edits.push((range, new_text.into()));
3494 }
3495 log::info!("mutating multi-buffer with {:?}", edits);
3496 drop(snapshot);
3497
3498 self.edit(edits, None, cx);
3499 }
3500
3501 pub fn randomly_edit_excerpts(
3502 &mut self,
3503 rng: &mut impl rand::Rng,
3504 mutation_count: usize,
3505 cx: &mut Context<Self>,
3506 ) {
3507 use rand::prelude::*;
3508 use std::env;
3509 use util::RandomCharIter;
3510
3511 let max_excerpts = env::var("MAX_EXCERPTS")
3512 .map(|i| i.parse().expect("invalid `MAX_EXCERPTS` variable"))
3513 .unwrap_or(5);
3514
3515 let mut buffers = Vec::new();
3516 for _ in 0..mutation_count {
3517 if rng.gen_bool(0.05) {
3518 log::info!("Clearing multi-buffer");
3519 self.clear(cx);
3520 continue;
3521 } else if rng.gen_bool(0.1) && !self.excerpt_ids().is_empty() {
3522 let ids = self.excerpt_ids();
3523 let mut excerpts = HashSet::default();
3524 for _ in 0..rng.gen_range(0..ids.len()) {
3525 excerpts.extend(ids.choose(rng).copied());
3526 }
3527
3528 let line_count = rng.gen_range(0..5);
3529
3530 log::info!("Expanding excerpts {excerpts:?} by {line_count} lines");
3531
3532 self.expand_excerpts(
3533 excerpts.iter().cloned(),
3534 line_count,
3535 ExpandExcerptDirection::UpAndDown,
3536 cx,
3537 );
3538 continue;
3539 }
3540
3541 let excerpt_ids = self.excerpt_ids();
3542 if excerpt_ids.is_empty() || (rng.r#gen() && excerpt_ids.len() < max_excerpts) {
3543 let buffer_handle = if rng.r#gen() || self.buffers.borrow().is_empty() {
3544 let text = RandomCharIter::new(&mut *rng).take(10).collect::<String>();
3545 buffers.push(cx.new(|cx| Buffer::local(text, cx)));
3546 let buffer = buffers.last().unwrap().read(cx);
3547 log::info!(
3548 "Creating new buffer {} with text: {:?}",
3549 buffer.remote_id(),
3550 buffer.text()
3551 );
3552 buffers.last().unwrap().clone()
3553 } else {
3554 self.buffers
3555 .borrow()
3556 .values()
3557 .choose(rng)
3558 .unwrap()
3559 .buffer
3560 .clone()
3561 };
3562
3563 let buffer = buffer_handle.read(cx);
3564 let buffer_text = buffer.text();
3565 let ranges = (0..rng.gen_range(0..5))
3566 .map(|_| {
3567 let end_ix =
3568 buffer.clip_offset(rng.gen_range(0..=buffer.len()), Bias::Right);
3569 let start_ix = buffer.clip_offset(rng.gen_range(0..=end_ix), Bias::Left);
3570 ExcerptRange::new(start_ix..end_ix)
3571 })
3572 .collect::<Vec<_>>();
3573 log::info!(
3574 "Inserting excerpts from buffer {} and ranges {:?}: {:?}",
3575 buffer_handle.read(cx).remote_id(),
3576 ranges.iter().map(|r| &r.context).collect::<Vec<_>>(),
3577 ranges
3578 .iter()
3579 .map(|r| &buffer_text[r.context.clone()])
3580 .collect::<Vec<_>>()
3581 );
3582
3583 let excerpt_id = self.push_excerpts(buffer_handle.clone(), ranges, cx);
3584 log::info!("Inserted with ids: {:?}", excerpt_id);
3585 } else {
3586 let remove_count = rng.gen_range(1..=excerpt_ids.len());
3587 let mut excerpts_to_remove = excerpt_ids
3588 .choose_multiple(rng, remove_count)
3589 .cloned()
3590 .collect::<Vec<_>>();
3591 let snapshot = self.snapshot.borrow();
3592 excerpts_to_remove.sort_unstable_by(|a, b| a.cmp(b, &snapshot));
3593 drop(snapshot);
3594 log::info!("Removing excerpts {:?}", excerpts_to_remove);
3595 self.remove_excerpts(excerpts_to_remove, cx);
3596 }
3597 }
3598 }
3599
3600 pub fn randomly_mutate(
3601 &mut self,
3602 rng: &mut impl rand::Rng,
3603 mutation_count: usize,
3604 cx: &mut Context<Self>,
3605 ) {
3606 use rand::prelude::*;
3607
3608 if rng.gen_bool(0.7) || self.singleton {
3609 let buffer = self
3610 .buffers
3611 .borrow()
3612 .values()
3613 .choose(rng)
3614 .map(|state| state.buffer.clone());
3615
3616 if let Some(buffer) = buffer {
3617 buffer.update(cx, |buffer, cx| {
3618 if rng.r#gen() {
3619 buffer.randomly_edit(rng, mutation_count, cx);
3620 } else {
3621 buffer.randomly_undo_redo(rng, cx);
3622 }
3623 });
3624 } else {
3625 self.randomly_edit(rng, mutation_count, cx);
3626 }
3627 } else {
3628 self.randomly_edit_excerpts(rng, mutation_count, cx);
3629 }
3630
3631 self.check_invariants(cx);
3632 }
3633
3634 fn check_invariants(&self, cx: &App) {
3635 self.read(cx).check_invariants();
3636 }
3637}
3638
3639impl EventEmitter<Event> for MultiBuffer {}
3640
3641impl MultiBufferSnapshot {
3642 pub fn text(&self) -> String {
3643 self.chunks(0..self.len(), false)
3644 .map(|chunk| chunk.text)
3645 .collect()
3646 }
3647
3648 pub fn reversed_chars_at<T: ToOffset>(&self, position: T) -> impl Iterator<Item = char> + '_ {
3649 self.reversed_chunks_in_range(0..position.to_offset(self))
3650 .flat_map(|c| c.chars().rev())
3651 }
3652
3653 fn reversed_chunks_in_range(&self, range: Range<usize>) -> ReversedMultiBufferChunks {
3654 let mut cursor = self.cursor::<usize>();
3655 cursor.seek(&range.end);
3656 let current_chunks = cursor.region().as_ref().map(|region| {
3657 let start_overshoot = range.start.saturating_sub(region.range.start);
3658 let end_overshoot = range.end - region.range.start;
3659 let end = (region.buffer_range.start + end_overshoot).min(region.buffer_range.end);
3660 let start = region.buffer_range.start + start_overshoot;
3661 region.buffer.reversed_chunks_in_range(start..end)
3662 });
3663 ReversedMultiBufferChunks {
3664 cursor,
3665 current_chunks,
3666 start: range.start,
3667 offset: range.end,
3668 }
3669 }
3670
3671 pub fn chars_at<T: ToOffset>(&self, position: T) -> impl Iterator<Item = char> + '_ {
3672 let offset = position.to_offset(self);
3673 self.text_for_range(offset..self.len())
3674 .flat_map(|chunk| chunk.chars())
3675 }
3676
3677 pub fn text_for_range<T: ToOffset>(&self, range: Range<T>) -> impl Iterator<Item = &str> + '_ {
3678 self.chunks(range, false).map(|chunk| chunk.text)
3679 }
3680
3681 pub fn is_line_blank(&self, row: MultiBufferRow) -> bool {
3682 self.text_for_range(Point::new(row.0, 0)..Point::new(row.0, self.line_len(row)))
3683 .all(|chunk| chunk.matches(|c: char| !c.is_whitespace()).next().is_none())
3684 }
3685
3686 pub fn contains_str_at<T>(&self, position: T, needle: &str) -> bool
3687 where
3688 T: ToOffset,
3689 {
3690 let position = position.to_offset(self);
3691 position == self.clip_offset(position, Bias::Left)
3692 && self
3693 .bytes_in_range(position..self.len())
3694 .flatten()
3695 .copied()
3696 .take(needle.len())
3697 .eq(needle.bytes())
3698 }
3699
3700 pub fn diff_hunks(&self) -> impl Iterator<Item = MultiBufferDiffHunk> + '_ {
3701 self.diff_hunks_in_range(Anchor::min()..Anchor::max())
3702 }
3703
3704 pub fn diff_hunks_in_range<T: ToPoint>(
3705 &self,
3706 range: Range<T>,
3707 ) -> impl Iterator<Item = MultiBufferDiffHunk> + '_ {
3708 let query_range = range.start.to_point(self)..range.end.to_point(self);
3709 self.lift_buffer_metadata(query_range.clone(), move |buffer, buffer_range| {
3710 let diff = self.diffs.get(&buffer.remote_id())?;
3711 let buffer_start = buffer.anchor_before(buffer_range.start);
3712 let buffer_end = buffer.anchor_after(buffer_range.end);
3713 Some(
3714 diff.hunks_intersecting_range(buffer_start..buffer_end, buffer)
3715 .filter_map(|hunk| {
3716 if hunk.is_created_file() && !self.all_diff_hunks_expanded {
3717 return None;
3718 }
3719 Some((hunk.range.clone(), hunk))
3720 }),
3721 )
3722 })
3723 .filter_map(move |(range, hunk, excerpt)| {
3724 if range.start != range.end && range.end == query_range.start && !hunk.range.is_empty()
3725 {
3726 return None;
3727 }
3728 let end_row = if range.end.column == 0 {
3729 range.end.row
3730 } else {
3731 range.end.row + 1
3732 };
3733 Some(MultiBufferDiffHunk {
3734 row_range: MultiBufferRow(range.start.row)..MultiBufferRow(end_row),
3735 buffer_id: excerpt.buffer_id,
3736 excerpt_id: excerpt.id,
3737 buffer_range: hunk.buffer_range.clone(),
3738 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
3739 secondary_status: hunk.secondary_status,
3740 })
3741 })
3742 }
3743
3744 pub fn excerpt_ids_for_range<T: ToOffset>(
3745 &self,
3746 range: Range<T>,
3747 ) -> impl Iterator<Item = ExcerptId> + '_ {
3748 let range = range.start.to_offset(self)..range.end.to_offset(self);
3749 let mut cursor = self.cursor::<usize>();
3750 cursor.seek(&range.start);
3751 std::iter::from_fn(move || {
3752 let region = cursor.region()?;
3753 if region.range.start >= range.end {
3754 return None;
3755 }
3756 cursor.next_excerpt();
3757 Some(region.excerpt.id)
3758 })
3759 }
3760
3761 pub fn buffer_ids_for_range<T: ToOffset>(
3762 &self,
3763 range: Range<T>,
3764 ) -> impl Iterator<Item = BufferId> + '_ {
3765 let range = range.start.to_offset(self)..range.end.to_offset(self);
3766 let mut cursor = self.cursor::<usize>();
3767 cursor.seek(&range.start);
3768 std::iter::from_fn(move || {
3769 let region = cursor.region()?;
3770 if region.range.start > range.end
3771 || region.range.start == range.end && region.range.start > range.start
3772 {
3773 return None;
3774 }
3775 cursor.next_excerpt();
3776 Some(region.excerpt.buffer_id)
3777 })
3778 }
3779
3780 pub fn ranges_to_buffer_ranges<T: ToOffset>(
3781 &self,
3782 ranges: impl Iterator<Item = Range<T>>,
3783 ) -> impl Iterator<Item = (&BufferSnapshot, Range<usize>, ExcerptId)> {
3784 ranges.flat_map(|range| self.range_to_buffer_ranges(range).into_iter())
3785 }
3786
3787 pub fn range_to_buffer_ranges<T: ToOffset>(
3788 &self,
3789 range: Range<T>,
3790 ) -> Vec<(&BufferSnapshot, Range<usize>, ExcerptId)> {
3791 let start = range.start.to_offset(&self);
3792 let end = range.end.to_offset(&self);
3793
3794 let mut cursor = self.cursor::<usize>();
3795 cursor.seek(&start);
3796
3797 let mut result: Vec<(&BufferSnapshot, Range<usize>, ExcerptId)> = Vec::new();
3798 while let Some(region) = cursor.region() {
3799 if region.range.start > end {
3800 break;
3801 }
3802 if region.is_main_buffer {
3803 let start_overshoot = start.saturating_sub(region.range.start);
3804 let end_overshoot = end.saturating_sub(region.range.start);
3805 let start = region
3806 .buffer_range
3807 .end
3808 .min(region.buffer_range.start + start_overshoot);
3809 let end = region
3810 .buffer_range
3811 .end
3812 .min(region.buffer_range.start + end_overshoot);
3813 if let Some(prev) = result.last_mut().filter(|(_, prev_range, excerpt_id)| {
3814 *excerpt_id == region.excerpt.id && prev_range.end == start
3815 }) {
3816 prev.1.end = end;
3817 } else {
3818 result.push((region.buffer, start..end, region.excerpt.id));
3819 }
3820 }
3821 cursor.next();
3822 }
3823 result
3824 }
3825
3826 pub fn range_to_buffer_ranges_with_deleted_hunks<T: ToOffset>(
3827 &self,
3828 range: Range<T>,
3829 ) -> impl Iterator<Item = (&BufferSnapshot, Range<usize>, ExcerptId, Option<Anchor>)> + '_ {
3830 let start = range.start.to_offset(&self);
3831 let end = range.end.to_offset(&self);
3832
3833 let mut cursor = self.cursor::<usize>();
3834 cursor.seek(&start);
3835
3836 std::iter::from_fn(move || {
3837 let region = cursor.region()?;
3838 if region.range.start > end {
3839 return None;
3840 }
3841 let start_overshoot = start.saturating_sub(region.range.start);
3842 let end_overshoot = end.saturating_sub(region.range.start);
3843 let start = region
3844 .buffer_range
3845 .end
3846 .min(region.buffer_range.start + start_overshoot);
3847 let end = region
3848 .buffer_range
3849 .end
3850 .min(region.buffer_range.start + end_overshoot);
3851
3852 let region_excerpt_id = region.excerpt.id;
3853 let deleted_hunk_anchor = if region.is_main_buffer {
3854 None
3855 } else {
3856 Some(self.anchor_before(region.range.start))
3857 };
3858 let result = (
3859 region.buffer,
3860 start..end,
3861 region_excerpt_id,
3862 deleted_hunk_anchor,
3863 );
3864 cursor.next();
3865 Some(result)
3866 })
3867 }
3868
3869 /// Retrieves buffer metadata for the given range, and converts it into multi-buffer
3870 /// coordinates.
3871 ///
3872 /// The given callback will be called for every excerpt intersecting the given range. It will
3873 /// be passed the excerpt's buffer and the buffer range that the input range intersects.
3874 /// The callback should return an iterator of metadata items from that buffer, each paired
3875 /// with a buffer range.
3876 ///
3877 /// The returned iterator yields each of these metadata items, paired with its range in
3878 /// multi-buffer coordinates.
3879 fn lift_buffer_metadata<'a, D, M, I>(
3880 &'a self,
3881 query_range: Range<D>,
3882 get_buffer_metadata: impl 'a + Fn(&'a BufferSnapshot, Range<D>) -> Option<I>,
3883 ) -> impl Iterator<Item = (Range<D>, M, &'a Excerpt)> + 'a
3884 where
3885 I: Iterator<Item = (Range<D>, M)> + 'a,
3886 D: TextDimension + Ord + Sub<D, Output = D>,
3887 {
3888 let max_position = D::from_text_summary(&self.text_summary());
3889 let mut current_excerpt_metadata: Option<(ExcerptId, I)> = None;
3890 let mut cursor = self.cursor::<D>();
3891
3892 // Find the excerpt and buffer offset where the given range ends.
3893 cursor.seek(&query_range.end);
3894 let mut range_end = None;
3895 while let Some(region) = cursor.region() {
3896 if region.is_main_buffer {
3897 let mut buffer_end = region.buffer_range.start;
3898 let overshoot = if query_range.end > region.range.start {
3899 query_range.end - region.range.start
3900 } else {
3901 D::default()
3902 };
3903 buffer_end.add_assign(&overshoot);
3904 range_end = Some((region.excerpt.id, buffer_end));
3905 break;
3906 }
3907 cursor.next();
3908 }
3909
3910 cursor.seek(&query_range.start);
3911
3912 if let Some(region) = cursor.region().filter(|region| !region.is_main_buffer) {
3913 if region.range.start > D::zero(&()) {
3914 cursor.prev()
3915 }
3916 }
3917
3918 iter::from_fn(move || {
3919 loop {
3920 let excerpt = cursor.excerpt()?;
3921
3922 // If we have already retrieved metadata for this excerpt, continue to use it.
3923 let metadata_iter = if let Some((_, metadata)) = current_excerpt_metadata
3924 .as_mut()
3925 .filter(|(excerpt_id, _)| *excerpt_id == excerpt.id)
3926 {
3927 Some(metadata)
3928 }
3929 // Otherwise, compute the intersection of the input range with the excerpt's range,
3930 // and retrieve the metadata for the resulting range.
3931 else {
3932 let region = cursor.region()?;
3933 let mut buffer_start;
3934 if region.is_main_buffer {
3935 buffer_start = region.buffer_range.start;
3936 if query_range.start > region.range.start {
3937 let overshoot = query_range.start - region.range.start;
3938 buffer_start.add_assign(&overshoot);
3939 }
3940 buffer_start = buffer_start.min(region.buffer_range.end);
3941 } else {
3942 buffer_start = cursor.main_buffer_position()?;
3943 };
3944 let mut buffer_end = excerpt.range.context.end.summary::<D>(&excerpt.buffer);
3945 if let Some((end_excerpt_id, end_buffer_offset)) = range_end {
3946 if excerpt.id == end_excerpt_id {
3947 buffer_end = buffer_end.min(end_buffer_offset);
3948 }
3949 }
3950
3951 if let Some(iterator) =
3952 get_buffer_metadata(&excerpt.buffer, buffer_start..buffer_end)
3953 {
3954 Some(&mut current_excerpt_metadata.insert((excerpt.id, iterator)).1)
3955 } else {
3956 None
3957 }
3958 };
3959
3960 // Visit each metadata item.
3961 if let Some((metadata_buffer_range, metadata)) =
3962 metadata_iter.and_then(Iterator::next)
3963 {
3964 // Find the multibuffer regions that contain the start and end of
3965 // the metadata item's range.
3966 if metadata_buffer_range.start > D::default() {
3967 while let Some(region) = cursor.region() {
3968 if region.is_main_buffer
3969 && (region.buffer_range.end >= metadata_buffer_range.start
3970 || cursor.is_at_end_of_excerpt())
3971 {
3972 break;
3973 }
3974 cursor.next();
3975 }
3976 }
3977 let start_region = cursor.region()?;
3978 while let Some(region) = cursor.region() {
3979 if region.is_main_buffer
3980 && (region.buffer_range.end > metadata_buffer_range.end
3981 || cursor.is_at_end_of_excerpt())
3982 {
3983 break;
3984 }
3985 cursor.next();
3986 }
3987 let end_region = cursor.region();
3988
3989 // Convert the metadata item's range into multibuffer coordinates.
3990 let mut start_position = start_region.range.start;
3991 let region_buffer_start = start_region.buffer_range.start;
3992 if start_region.is_main_buffer
3993 && metadata_buffer_range.start > region_buffer_start
3994 {
3995 start_position
3996 .add_assign(&(metadata_buffer_range.start - region_buffer_start));
3997 start_position = start_position.min(start_region.range.end);
3998 }
3999
4000 let mut end_position = max_position;
4001 if let Some(end_region) = &end_region {
4002 end_position = end_region.range.start;
4003 debug_assert!(end_region.is_main_buffer);
4004 let region_buffer_start = end_region.buffer_range.start;
4005 if metadata_buffer_range.end > region_buffer_start {
4006 end_position
4007 .add_assign(&(metadata_buffer_range.end - region_buffer_start));
4008 }
4009 end_position = end_position.min(end_region.range.end);
4010 }
4011
4012 if start_position <= query_range.end && end_position >= query_range.start {
4013 return Some((start_position..end_position, metadata, excerpt));
4014 }
4015 }
4016 // When there are no more metadata items for this excerpt, move to the next excerpt.
4017 else {
4018 current_excerpt_metadata.take();
4019 if let Some((end_excerpt_id, _)) = range_end {
4020 if excerpt.id == end_excerpt_id {
4021 return None;
4022 }
4023 }
4024 cursor.next_excerpt();
4025 }
4026 }
4027 })
4028 }
4029
4030 pub fn diff_hunk_before<T: ToOffset>(&self, position: T) -> Option<MultiBufferRow> {
4031 let offset = position.to_offset(self);
4032
4033 let mut cursor = self.cursor::<DimensionPair<usize, Point>>();
4034 cursor.seek(&DimensionPair {
4035 key: offset,
4036 value: None,
4037 });
4038 cursor.seek_to_start_of_current_excerpt();
4039 let excerpt = cursor.excerpt()?;
4040
4041 let excerpt_end = excerpt.range.context.end.to_offset(&excerpt.buffer);
4042 let current_position = self
4043 .anchor_before(offset)
4044 .text_anchor
4045 .to_offset(&excerpt.buffer);
4046 let excerpt_end = excerpt
4047 .buffer
4048 .anchor_before(excerpt_end.min(current_position));
4049
4050 if let Some(diff) = self.diffs.get(&excerpt.buffer_id) {
4051 for hunk in diff.hunks_intersecting_range_rev(
4052 excerpt.range.context.start..excerpt_end,
4053 &excerpt.buffer,
4054 ) {
4055 let hunk_end = hunk.buffer_range.end.to_offset(&excerpt.buffer);
4056 if hunk_end >= current_position {
4057 continue;
4058 }
4059 let start =
4060 Anchor::in_buffer(excerpt.id, excerpt.buffer_id, hunk.buffer_range.start)
4061 .to_point(&self);
4062 return Some(MultiBufferRow(start.row));
4063 }
4064 }
4065
4066 loop {
4067 cursor.prev_excerpt();
4068 let excerpt = cursor.excerpt()?;
4069
4070 let Some(diff) = self.diffs.get(&excerpt.buffer_id) else {
4071 continue;
4072 };
4073 let mut hunks =
4074 diff.hunks_intersecting_range_rev(excerpt.range.context.clone(), &excerpt.buffer);
4075 let Some(hunk) = hunks.next() else {
4076 continue;
4077 };
4078 let start = Anchor::in_buffer(excerpt.id, excerpt.buffer_id, hunk.buffer_range.start)
4079 .to_point(&self);
4080 return Some(MultiBufferRow(start.row));
4081 }
4082 }
4083
4084 pub fn has_diff_hunks(&self) -> bool {
4085 self.diffs.values().any(|diff| !diff.is_empty())
4086 }
4087
4088 pub fn surrounding_word<T: ToOffset>(
4089 &self,
4090 start: T,
4091 for_completion: bool,
4092 ) -> (Range<usize>, Option<CharKind>) {
4093 let mut start = start.to_offset(self);
4094 let mut end = start;
4095 let mut next_chars = self.chars_at(start).peekable();
4096 let mut prev_chars = self.reversed_chars_at(start).peekable();
4097
4098 let classifier = self
4099 .char_classifier_at(start)
4100 .for_completion(for_completion);
4101
4102 let word_kind = cmp::max(
4103 prev_chars.peek().copied().map(|c| classifier.kind(c)),
4104 next_chars.peek().copied().map(|c| classifier.kind(c)),
4105 );
4106
4107 for ch in prev_chars {
4108 if Some(classifier.kind(ch)) == word_kind && ch != '\n' {
4109 start -= ch.len_utf8();
4110 } else {
4111 break;
4112 }
4113 }
4114
4115 for ch in next_chars {
4116 if Some(classifier.kind(ch)) == word_kind && ch != '\n' {
4117 end += ch.len_utf8();
4118 } else {
4119 break;
4120 }
4121 }
4122
4123 (start..end, word_kind)
4124 }
4125
4126 pub fn is_singleton(&self) -> bool {
4127 self.singleton
4128 }
4129
4130 pub fn as_singleton(&self) -> Option<(&ExcerptId, BufferId, &BufferSnapshot)> {
4131 if self.singleton {
4132 self.excerpts
4133 .iter()
4134 .next()
4135 .map(|e| (&e.id, e.buffer_id, &e.buffer))
4136 } else {
4137 None
4138 }
4139 }
4140
4141 pub fn len(&self) -> usize {
4142 self.diff_transforms.summary().output.len
4143 }
4144
4145 pub fn is_empty(&self) -> bool {
4146 self.excerpts.summary().text.len == 0
4147 }
4148
4149 pub fn widest_line_number(&self) -> u32 {
4150 // widest_line_number is 0-based, so 1 is added to get the displayed line number.
4151 self.excerpts.summary().widest_line_number + 1
4152 }
4153
4154 pub fn bytes_in_range<T: ToOffset>(&self, range: Range<T>) -> MultiBufferBytes {
4155 let range = range.start.to_offset(self)..range.end.to_offset(self);
4156 let mut excerpts = self.cursor::<usize>();
4157 excerpts.seek(&range.start);
4158
4159 let mut chunk;
4160 let mut has_trailing_newline;
4161 let excerpt_bytes;
4162 if let Some(region) = excerpts.region() {
4163 let mut bytes = region.buffer.bytes_in_range(
4164 region.buffer_range.start + range.start - region.range.start
4165 ..(region.buffer_range.start + range.end - region.range.start)
4166 .min(region.buffer_range.end),
4167 );
4168 chunk = bytes.next().unwrap_or(&[][..]);
4169 excerpt_bytes = Some(bytes);
4170 has_trailing_newline = region.has_trailing_newline && range.end >= region.range.end;
4171 if chunk.is_empty() && has_trailing_newline {
4172 chunk = b"\n";
4173 has_trailing_newline = false;
4174 }
4175 } else {
4176 chunk = &[][..];
4177 excerpt_bytes = None;
4178 has_trailing_newline = false;
4179 };
4180
4181 MultiBufferBytes {
4182 range,
4183 cursor: excerpts,
4184 excerpt_bytes,
4185 has_trailing_newline,
4186 chunk,
4187 }
4188 }
4189
4190 pub fn reversed_bytes_in_range<T: ToOffset>(
4191 &self,
4192 range: Range<T>,
4193 ) -> ReversedMultiBufferBytes {
4194 let range = range.start.to_offset(self)..range.end.to_offset(self);
4195 let mut chunks = self.reversed_chunks_in_range(range.clone());
4196 let chunk = chunks.next().map_or(&[][..], |c| c.as_bytes());
4197 ReversedMultiBufferBytes {
4198 range,
4199 chunks,
4200 chunk,
4201 }
4202 }
4203
4204 pub fn row_infos(&self, start_row: MultiBufferRow) -> MultiBufferRows {
4205 let mut cursor = self.cursor::<Point>();
4206 cursor.seek(&Point::new(start_row.0, 0));
4207 let mut result = MultiBufferRows {
4208 point: Point::new(0, 0),
4209 is_empty: self.excerpts.is_empty(),
4210 is_singleton: self.is_singleton(),
4211 cursor,
4212 };
4213 result.seek(start_row);
4214 result
4215 }
4216
4217 pub fn chunks<T: ToOffset>(&self, range: Range<T>, language_aware: bool) -> MultiBufferChunks {
4218 let mut chunks = MultiBufferChunks {
4219 excerpt_offset_range: ExcerptOffset::new(0)..ExcerptOffset::new(0),
4220 range: 0..0,
4221 excerpts: self.excerpts.cursor(&()),
4222 diff_transforms: self.diff_transforms.cursor(&()),
4223 diffs: &self.diffs,
4224 diff_base_chunks: None,
4225 excerpt_chunks: None,
4226 buffer_chunk: None,
4227 language_aware,
4228 };
4229 let range = range.start.to_offset(self)..range.end.to_offset(self);
4230 chunks.seek(range);
4231 chunks
4232 }
4233
4234 pub fn clip_offset(&self, offset: usize, bias: Bias) -> usize {
4235 self.clip_dimension(offset, bias, text::BufferSnapshot::clip_offset)
4236 }
4237
4238 pub fn clip_point(&self, point: Point, bias: Bias) -> Point {
4239 self.clip_dimension(point, bias, text::BufferSnapshot::clip_point)
4240 }
4241
4242 pub fn clip_offset_utf16(&self, offset: OffsetUtf16, bias: Bias) -> OffsetUtf16 {
4243 self.clip_dimension(offset, bias, text::BufferSnapshot::clip_offset_utf16)
4244 }
4245
4246 pub fn clip_point_utf16(&self, point: Unclipped<PointUtf16>, bias: Bias) -> PointUtf16 {
4247 self.clip_dimension(point.0, bias, |buffer, point, bias| {
4248 buffer.clip_point_utf16(Unclipped(point), bias)
4249 })
4250 }
4251
4252 pub fn offset_to_point(&self, offset: usize) -> Point {
4253 self.convert_dimension(offset, text::BufferSnapshot::offset_to_point)
4254 }
4255
4256 pub fn offset_to_point_utf16(&self, offset: usize) -> PointUtf16 {
4257 self.convert_dimension(offset, text::BufferSnapshot::offset_to_point_utf16)
4258 }
4259
4260 pub fn point_to_point_utf16(&self, point: Point) -> PointUtf16 {
4261 self.convert_dimension(point, text::BufferSnapshot::point_to_point_utf16)
4262 }
4263
4264 pub fn point_to_offset(&self, point: Point) -> usize {
4265 self.convert_dimension(point, text::BufferSnapshot::point_to_offset)
4266 }
4267
4268 pub fn offset_utf16_to_offset(&self, offset: OffsetUtf16) -> usize {
4269 self.convert_dimension(offset, text::BufferSnapshot::offset_utf16_to_offset)
4270 }
4271
4272 pub fn offset_to_offset_utf16(&self, offset: usize) -> OffsetUtf16 {
4273 self.convert_dimension(offset, text::BufferSnapshot::offset_to_offset_utf16)
4274 }
4275
4276 pub fn point_utf16_to_offset(&self, point: PointUtf16) -> usize {
4277 self.convert_dimension(point, text::BufferSnapshot::point_utf16_to_offset)
4278 }
4279
4280 fn clip_dimension<D>(
4281 &self,
4282 position: D,
4283 bias: Bias,
4284 clip_buffer_position: fn(&text::BufferSnapshot, D, Bias) -> D,
4285 ) -> D
4286 where
4287 D: TextDimension + Ord + Sub<D, Output = D>,
4288 {
4289 let mut cursor = self.cursor();
4290 cursor.seek(&position);
4291 if let Some(region) = cursor.region() {
4292 if position >= region.range.end {
4293 return region.range.end;
4294 }
4295 let overshoot = position - region.range.start;
4296 let mut buffer_position = region.buffer_range.start;
4297 buffer_position.add_assign(&overshoot);
4298 let clipped_buffer_position =
4299 clip_buffer_position(®ion.buffer, buffer_position, bias);
4300 let mut position = region.range.start;
4301 position.add_assign(&(clipped_buffer_position - region.buffer_range.start));
4302 position
4303 } else {
4304 D::from_text_summary(&self.text_summary())
4305 }
4306 }
4307
4308 fn convert_dimension<D1, D2>(
4309 &self,
4310 key: D1,
4311 convert_buffer_dimension: fn(&text::BufferSnapshot, D1) -> D2,
4312 ) -> D2
4313 where
4314 D1: TextDimension + Ord + Sub<D1, Output = D1>,
4315 D2: TextDimension + Ord + Sub<D2, Output = D2>,
4316 {
4317 let mut cursor = self.cursor::<DimensionPair<D1, D2>>();
4318 cursor.seek(&DimensionPair { key, value: None });
4319 if let Some(region) = cursor.region() {
4320 if key >= region.range.end.key {
4321 return region.range.end.value.unwrap();
4322 }
4323 let start_key = region.range.start.key;
4324 let start_value = region.range.start.value.unwrap();
4325 let buffer_start_key = region.buffer_range.start.key;
4326 let buffer_start_value = region.buffer_range.start.value.unwrap();
4327 let mut buffer_key = buffer_start_key;
4328 buffer_key.add_assign(&(key - start_key));
4329 let buffer_value = convert_buffer_dimension(®ion.buffer, buffer_key);
4330 let mut result = start_value;
4331 result.add_assign(&(buffer_value - buffer_start_value));
4332 result
4333 } else {
4334 D2::from_text_summary(&self.text_summary())
4335 }
4336 }
4337
4338 pub fn point_to_buffer_offset<T: ToOffset>(
4339 &self,
4340 point: T,
4341 ) -> Option<(&BufferSnapshot, usize)> {
4342 let offset = point.to_offset(self);
4343 let mut cursor = self.cursor::<usize>();
4344 cursor.seek(&offset);
4345 let region = cursor.region()?;
4346 let overshoot = offset - region.range.start;
4347 let buffer_offset = region.buffer_range.start + overshoot;
4348 if buffer_offset == region.buffer.len() + 1
4349 && region.has_trailing_newline
4350 && !region.is_main_buffer
4351 {
4352 return Some((&cursor.excerpt()?.buffer, cursor.main_buffer_position()?));
4353 } else if buffer_offset > region.buffer.len() {
4354 return None;
4355 }
4356 Some((region.buffer, buffer_offset))
4357 }
4358
4359 pub fn point_to_buffer_point(
4360 &self,
4361 point: Point,
4362 ) -> Option<(&BufferSnapshot, Point, ExcerptId)> {
4363 let mut cursor = self.cursor::<Point>();
4364 cursor.seek(&point);
4365 let region = cursor.region()?;
4366 let overshoot = point - region.range.start;
4367 let buffer_point = region.buffer_range.start + overshoot;
4368 let excerpt = cursor.excerpt()?;
4369 if buffer_point == region.buffer.max_point() + Point::new(1, 0)
4370 && region.has_trailing_newline
4371 && !region.is_main_buffer
4372 {
4373 return Some((&excerpt.buffer, cursor.main_buffer_position()?, excerpt.id));
4374 } else if buffer_point > region.buffer.max_point() {
4375 return None;
4376 }
4377 Some((region.buffer, buffer_point, excerpt.id))
4378 }
4379
4380 pub fn suggested_indents(
4381 &self,
4382 rows: impl IntoIterator<Item = u32>,
4383 cx: &App,
4384 ) -> BTreeMap<MultiBufferRow, IndentSize> {
4385 let mut result = BTreeMap::new();
4386
4387 let mut rows_for_excerpt = Vec::new();
4388 let mut cursor = self.cursor::<Point>();
4389 let mut rows = rows.into_iter().peekable();
4390 let mut prev_row = u32::MAX;
4391 let mut prev_language_indent_size = IndentSize::default();
4392
4393 while let Some(row) = rows.next() {
4394 cursor.seek(&Point::new(row, 0));
4395 let Some(region) = cursor.region() else {
4396 continue;
4397 };
4398
4399 // Retrieve the language and indent size once for each disjoint region being indented.
4400 let single_indent_size = if row.saturating_sub(1) == prev_row {
4401 prev_language_indent_size
4402 } else {
4403 region
4404 .buffer
4405 .language_indent_size_at(Point::new(row, 0), cx)
4406 };
4407 prev_language_indent_size = single_indent_size;
4408 prev_row = row;
4409
4410 let start_buffer_row = region.buffer_range.start.row;
4411 let start_multibuffer_row = region.range.start.row;
4412 let end_multibuffer_row = region.range.end.row;
4413
4414 rows_for_excerpt.push(row);
4415 while let Some(next_row) = rows.peek().copied() {
4416 if end_multibuffer_row > next_row {
4417 rows_for_excerpt.push(next_row);
4418 rows.next();
4419 } else {
4420 break;
4421 }
4422 }
4423
4424 let buffer_rows = rows_for_excerpt
4425 .drain(..)
4426 .map(|row| start_buffer_row + row - start_multibuffer_row);
4427 let buffer_indents = region
4428 .buffer
4429 .suggested_indents(buffer_rows, single_indent_size);
4430 let multibuffer_indents = buffer_indents.into_iter().map(|(row, indent)| {
4431 (
4432 MultiBufferRow(start_multibuffer_row + row - start_buffer_row),
4433 indent,
4434 )
4435 });
4436 result.extend(multibuffer_indents);
4437 }
4438
4439 result
4440 }
4441
4442 pub fn indent_size_for_line(&self, row: MultiBufferRow) -> IndentSize {
4443 if let Some((buffer, range)) = self.buffer_line_for_row(row) {
4444 let mut size = buffer.indent_size_for_line(range.start.row);
4445 size.len = size
4446 .len
4447 .min(range.end.column)
4448 .saturating_sub(range.start.column);
4449 size
4450 } else {
4451 IndentSize::spaces(0)
4452 }
4453 }
4454
4455 pub fn line_indent_for_row(&self, row: MultiBufferRow) -> LineIndent {
4456 if let Some((buffer, range)) = self.buffer_line_for_row(row) {
4457 LineIndent::from_iter(buffer.text_for_range(range).flat_map(|s| s.chars()))
4458 } else {
4459 LineIndent::spaces(0)
4460 }
4461 }
4462
4463 pub fn indent_and_comment_for_line(&self, row: MultiBufferRow, cx: &App) -> String {
4464 let mut indent = self.indent_size_for_line(row).chars().collect::<String>();
4465
4466 if self.language_settings(cx).extend_comment_on_newline {
4467 if let Some(language_scope) = self.language_scope_at(Point::new(row.0, 0)) {
4468 let delimiters = language_scope.line_comment_prefixes();
4469 for delimiter in delimiters {
4470 if *self
4471 .chars_at(Point::new(row.0, indent.len() as u32))
4472 .take(delimiter.chars().count())
4473 .collect::<String>()
4474 .as_str()
4475 == **delimiter
4476 {
4477 indent.push_str(&delimiter);
4478 break;
4479 }
4480 }
4481 }
4482 }
4483
4484 indent
4485 }
4486
4487 pub fn is_line_whitespace_upto<T>(&self, position: T) -> bool
4488 where
4489 T: ToOffset,
4490 {
4491 for char in self.reversed_chars_at(position) {
4492 if !char.is_whitespace() {
4493 return false;
4494 }
4495 if char == '\n' {
4496 return true;
4497 }
4498 }
4499 return true;
4500 }
4501
4502 pub fn prev_non_blank_row(&self, mut row: MultiBufferRow) -> Option<MultiBufferRow> {
4503 while row.0 > 0 {
4504 row.0 -= 1;
4505 if !self.is_line_blank(row) {
4506 return Some(row);
4507 }
4508 }
4509 None
4510 }
4511
4512 pub fn line_len(&self, row: MultiBufferRow) -> u32 {
4513 if let Some((_, range)) = self.buffer_line_for_row(row) {
4514 range.end.column - range.start.column
4515 } else {
4516 0
4517 }
4518 }
4519
4520 pub fn buffer_line_for_row(
4521 &self,
4522 row: MultiBufferRow,
4523 ) -> Option<(&BufferSnapshot, Range<Point>)> {
4524 let mut cursor = self.cursor::<Point>();
4525 let point = Point::new(row.0, 0);
4526 cursor.seek(&point);
4527 let region = cursor.region()?;
4528 let overshoot = point.min(region.range.end) - region.range.start;
4529 let buffer_point = region.buffer_range.start + overshoot;
4530 if buffer_point.row > region.buffer_range.end.row {
4531 return None;
4532 }
4533 let line_start = Point::new(buffer_point.row, 0).max(region.buffer_range.start);
4534 let line_end = Point::new(buffer_point.row, region.buffer.line_len(buffer_point.row))
4535 .min(region.buffer_range.end);
4536 Some((region.buffer, line_start..line_end))
4537 }
4538
4539 pub fn max_point(&self) -> Point {
4540 self.text_summary().lines
4541 }
4542
4543 pub fn max_row(&self) -> MultiBufferRow {
4544 MultiBufferRow(self.text_summary().lines.row)
4545 }
4546
4547 pub fn text_summary(&self) -> TextSummary {
4548 self.diff_transforms.summary().output
4549 }
4550
4551 pub fn text_summary_for_range<D, O>(&self, range: Range<O>) -> D
4552 where
4553 D: TextDimension,
4554 O: ToOffset,
4555 {
4556 let range = range.start.to_offset(self)..range.end.to_offset(self);
4557 let mut cursor = self.diff_transforms.cursor::<(usize, ExcerptOffset)>(&());
4558 cursor.seek(&range.start, Bias::Right, &());
4559
4560 let Some(first_transform) = cursor.item() else {
4561 return D::from_text_summary(&TextSummary::default());
4562 };
4563
4564 let diff_transform_start = cursor.start().0;
4565 let diff_transform_end = cursor.end(&()).0;
4566 let diff_start = range.start;
4567 let start_overshoot = diff_start - diff_transform_start;
4568 let end_overshoot = std::cmp::min(range.end, diff_transform_end) - diff_transform_start;
4569
4570 let mut result = match first_transform {
4571 DiffTransform::BufferContent { .. } => {
4572 let excerpt_start = cursor.start().1 + ExcerptOffset::new(start_overshoot);
4573 let excerpt_end = cursor.start().1 + ExcerptOffset::new(end_overshoot);
4574 self.text_summary_for_excerpt_offset_range(excerpt_start..excerpt_end)
4575 }
4576 DiffTransform::DeletedHunk {
4577 buffer_id,
4578 base_text_byte_range,
4579 has_trailing_newline,
4580 ..
4581 } => {
4582 let buffer_start = base_text_byte_range.start + start_overshoot;
4583 let mut buffer_end = base_text_byte_range.start + end_overshoot;
4584 let Some(base_text) = self.diffs.get(buffer_id).map(|diff| diff.base_text()) else {
4585 panic!("{:?} is in non-existent deleted hunk", range.start)
4586 };
4587
4588 let include_trailing_newline =
4589 *has_trailing_newline && range.end >= diff_transform_end;
4590 if include_trailing_newline {
4591 buffer_end -= 1;
4592 }
4593
4594 let mut summary =
4595 base_text.text_summary_for_range::<D, _>(buffer_start..buffer_end);
4596
4597 if include_trailing_newline {
4598 summary.add_assign(&D::from_text_summary(&TextSummary::newline()))
4599 }
4600
4601 summary
4602 }
4603 };
4604 if range.end < diff_transform_end {
4605 return result;
4606 }
4607
4608 cursor.next(&());
4609 result.add_assign(&D::from_text_summary(&cursor.summary(
4610 &range.end,
4611 Bias::Right,
4612 &(),
4613 )));
4614
4615 let Some(last_transform) = cursor.item() else {
4616 return result;
4617 };
4618
4619 let overshoot = range.end - cursor.start().0;
4620 let suffix = match last_transform {
4621 DiffTransform::BufferContent { .. } => {
4622 let end = cursor.start().1 + ExcerptOffset::new(overshoot);
4623 self.text_summary_for_excerpt_offset_range::<D>(cursor.start().1..end)
4624 }
4625 DiffTransform::DeletedHunk {
4626 base_text_byte_range,
4627 buffer_id,
4628 has_trailing_newline,
4629 ..
4630 } => {
4631 let buffer_end = base_text_byte_range.start + overshoot;
4632 let Some(base_text) = self.diffs.get(buffer_id).map(|diff| diff.base_text()) else {
4633 panic!("{:?} is in non-existent deleted hunk", range.end)
4634 };
4635
4636 let mut suffix = base_text
4637 .text_summary_for_range::<D, _>(base_text_byte_range.start..buffer_end);
4638 if *has_trailing_newline && buffer_end == base_text_byte_range.end + 1 {
4639 suffix.add_assign(&D::from_text_summary(&TextSummary::newline()))
4640 }
4641 suffix
4642 }
4643 };
4644
4645 result.add_assign(&suffix);
4646 result
4647 }
4648
4649 fn text_summary_for_excerpt_offset_range<D>(&self, mut range: Range<ExcerptOffset>) -> D
4650 where
4651 D: TextDimension,
4652 {
4653 // let mut range = range.start..range.end;
4654 let mut summary = D::zero(&());
4655 let mut cursor = self.excerpts.cursor::<ExcerptOffset>(&());
4656 cursor.seek(&range.start, Bias::Right, &());
4657 if let Some(excerpt) = cursor.item() {
4658 let mut end_before_newline = cursor.end(&());
4659 if excerpt.has_trailing_newline {
4660 end_before_newline -= ExcerptOffset::new(1);
4661 }
4662
4663 let excerpt_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
4664 let start_in_excerpt = excerpt_start + (range.start - *cursor.start()).value;
4665 let end_in_excerpt =
4666 excerpt_start + (cmp::min(end_before_newline, range.end) - *cursor.start()).value;
4667 summary.add_assign(
4668 &excerpt
4669 .buffer
4670 .text_summary_for_range(start_in_excerpt..end_in_excerpt),
4671 );
4672
4673 if range.end > end_before_newline {
4674 summary.add_assign(&D::from_text_summary(&TextSummary::from("\n")));
4675 }
4676
4677 cursor.next(&());
4678 }
4679
4680 if range.end > *cursor.start() {
4681 summary.add_assign(
4682 &cursor
4683 .summary::<_, ExcerptDimension<D>>(&range.end, Bias::Right, &())
4684 .0,
4685 );
4686 if let Some(excerpt) = cursor.item() {
4687 range.end = cmp::max(*cursor.start(), range.end);
4688
4689 let excerpt_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
4690 let end_in_excerpt = excerpt_start + (range.end - *cursor.start()).value;
4691 summary.add_assign(
4692 &excerpt
4693 .buffer
4694 .text_summary_for_range(excerpt_start..end_in_excerpt),
4695 );
4696 }
4697 }
4698
4699 summary
4700 }
4701
4702 pub fn summary_for_anchor<D>(&self, anchor: &Anchor) -> D
4703 where
4704 D: TextDimension + Ord + Sub<D, Output = D>,
4705 {
4706 self.summaries_for_anchors([anchor])[0]
4707 }
4708
4709 fn resolve_summary_for_anchor<D>(
4710 &self,
4711 anchor: &Anchor,
4712 excerpt_position: D,
4713 diff_transforms: &mut Cursor<DiffTransform, (ExcerptDimension<D>, OutputDimension<D>)>,
4714 ) -> D
4715 where
4716 D: TextDimension + Ord + Sub<D, Output = D>,
4717 {
4718 loop {
4719 let transform_end_position = diff_transforms.end(&()).0.0;
4720 let at_transform_end =
4721 excerpt_position == transform_end_position && diff_transforms.item().is_some();
4722 if at_transform_end && anchor.text_anchor.bias == Bias::Right {
4723 diff_transforms.next(&());
4724 continue;
4725 }
4726
4727 let mut position = diff_transforms.start().1.0;
4728 match diff_transforms.item() {
4729 Some(DiffTransform::DeletedHunk {
4730 buffer_id,
4731 base_text_byte_range,
4732 ..
4733 }) => {
4734 if let Some(diff_base_anchor) = &anchor.diff_base_anchor {
4735 if let Some(base_text) =
4736 self.diffs.get(buffer_id).map(|diff| diff.base_text())
4737 {
4738 if base_text.can_resolve(&diff_base_anchor) {
4739 let base_text_offset = diff_base_anchor.to_offset(&base_text);
4740 if base_text_offset >= base_text_byte_range.start
4741 && base_text_offset <= base_text_byte_range.end
4742 {
4743 let position_in_hunk = base_text
4744 .text_summary_for_range::<D, _>(
4745 base_text_byte_range.start..base_text_offset,
4746 );
4747 position.add_assign(&position_in_hunk);
4748 } else if at_transform_end {
4749 diff_transforms.next(&());
4750 continue;
4751 }
4752 }
4753 }
4754 }
4755 }
4756 _ => {
4757 if at_transform_end && anchor.diff_base_anchor.is_some() {
4758 diff_transforms.next(&());
4759 continue;
4760 }
4761 let overshoot = excerpt_position - diff_transforms.start().0.0;
4762 position.add_assign(&overshoot);
4763 }
4764 }
4765
4766 return position;
4767 }
4768 }
4769
4770 fn excerpt_offset_for_anchor(&self, anchor: &Anchor) -> ExcerptOffset {
4771 let mut cursor = self
4772 .excerpts
4773 .cursor::<(Option<&Locator>, ExcerptOffset)>(&());
4774 let locator = self.excerpt_locator_for_id(anchor.excerpt_id);
4775
4776 cursor.seek(&Some(locator), Bias::Left, &());
4777 if cursor.item().is_none() {
4778 cursor.next(&());
4779 }
4780
4781 let mut position = cursor.start().1;
4782 if let Some(excerpt) = cursor.item() {
4783 if excerpt.id == anchor.excerpt_id {
4784 let excerpt_buffer_start = excerpt
4785 .buffer
4786 .offset_for_anchor(&excerpt.range.context.start);
4787 let excerpt_buffer_end =
4788 excerpt.buffer.offset_for_anchor(&excerpt.range.context.end);
4789 let buffer_position = cmp::min(
4790 excerpt_buffer_end,
4791 excerpt.buffer.offset_for_anchor(&anchor.text_anchor),
4792 );
4793 if buffer_position > excerpt_buffer_start {
4794 position.value += buffer_position - excerpt_buffer_start;
4795 }
4796 }
4797 }
4798 position
4799 }
4800
4801 pub fn latest_excerpt_id(&self, mut excerpt_id: ExcerptId) -> ExcerptId {
4802 while let Some(replacement) = self.replaced_excerpts.get(&excerpt_id) {
4803 excerpt_id = *replacement;
4804 }
4805 return excerpt_id;
4806 }
4807
4808 pub fn summaries_for_anchors<'a, D, I>(&'a self, anchors: I) -> Vec<D>
4809 where
4810 D: TextDimension + Ord + Sub<D, Output = D>,
4811 I: 'a + IntoIterator<Item = &'a Anchor>,
4812 {
4813 let mut anchors = anchors.into_iter().peekable();
4814 let mut cursor = self.excerpts.cursor::<ExcerptSummary>(&());
4815 let mut diff_transforms_cursor = self
4816 .diff_transforms
4817 .cursor::<(ExcerptDimension<D>, OutputDimension<D>)>(&());
4818 diff_transforms_cursor.next(&());
4819
4820 let mut summaries = Vec::new();
4821 while let Some(anchor) = anchors.peek() {
4822 let excerpt_id = self.latest_excerpt_id(anchor.excerpt_id);
4823 let excerpt_anchors = iter::from_fn(|| {
4824 let anchor = anchors.peek()?;
4825 if self.latest_excerpt_id(anchor.excerpt_id) == excerpt_id {
4826 Some(anchors.next().unwrap())
4827 } else {
4828 None
4829 }
4830 });
4831
4832 let locator = self.excerpt_locator_for_id(excerpt_id);
4833 cursor.seek_forward(locator, Bias::Left, &());
4834 if cursor.item().is_none() {
4835 cursor.next(&());
4836 }
4837
4838 let excerpt_start_position = D::from_text_summary(&cursor.start().text);
4839 if let Some(excerpt) = cursor.item() {
4840 if excerpt.id != excerpt_id {
4841 let position = self.resolve_summary_for_anchor(
4842 &Anchor::min(),
4843 excerpt_start_position,
4844 &mut diff_transforms_cursor,
4845 );
4846 summaries.extend(excerpt_anchors.map(|_| position));
4847 continue;
4848 }
4849 let excerpt_buffer_start =
4850 excerpt.range.context.start.summary::<D>(&excerpt.buffer);
4851 let excerpt_buffer_end = excerpt.range.context.end.summary::<D>(&excerpt.buffer);
4852 for (buffer_summary, anchor) in excerpt
4853 .buffer
4854 .summaries_for_anchors_with_payload::<D, _, _>(
4855 excerpt_anchors.map(|a| (&a.text_anchor, a)),
4856 )
4857 {
4858 let summary = cmp::min(excerpt_buffer_end, buffer_summary);
4859 let mut position = excerpt_start_position;
4860 if summary > excerpt_buffer_start {
4861 position.add_assign(&(summary - excerpt_buffer_start));
4862 }
4863
4864 if position > diff_transforms_cursor.start().0.0 {
4865 diff_transforms_cursor.seek_forward(
4866 &ExcerptDimension(position),
4867 Bias::Left,
4868 &(),
4869 );
4870 }
4871
4872 summaries.push(self.resolve_summary_for_anchor(
4873 anchor,
4874 position,
4875 &mut diff_transforms_cursor,
4876 ));
4877 }
4878 } else {
4879 diff_transforms_cursor.seek_forward(
4880 &ExcerptDimension(excerpt_start_position),
4881 Bias::Left,
4882 &(),
4883 );
4884 let position = self.resolve_summary_for_anchor(
4885 &Anchor::max(),
4886 excerpt_start_position,
4887 &mut diff_transforms_cursor,
4888 );
4889 summaries.extend(excerpt_anchors.map(|_| position));
4890 }
4891 }
4892
4893 summaries
4894 }
4895
4896 pub fn dimensions_from_points<'a, D>(
4897 &'a self,
4898 points: impl 'a + IntoIterator<Item = Point>,
4899 ) -> impl 'a + Iterator<Item = D>
4900 where
4901 D: TextDimension + Sub<D, Output = D>,
4902 {
4903 let mut cursor = self.cursor::<DimensionPair<Point, D>>();
4904 cursor.seek(&DimensionPair {
4905 key: Point::default(),
4906 value: None,
4907 });
4908 let mut points = points.into_iter();
4909 iter::from_fn(move || {
4910 let point = points.next()?;
4911
4912 cursor.seek_forward(&DimensionPair {
4913 key: point,
4914 value: None,
4915 });
4916
4917 if let Some(region) = cursor.region() {
4918 let overshoot = point - region.range.start.key;
4919 let buffer_point = region.buffer_range.start.key + overshoot;
4920 let mut position = region.range.start.value.unwrap();
4921 position.add_assign(
4922 ®ion
4923 .buffer
4924 .text_summary_for_range(region.buffer_range.start.key..buffer_point),
4925 );
4926 if point == region.range.end.key && region.has_trailing_newline {
4927 position.add_assign(&D::from_text_summary(&TextSummary::newline()));
4928 }
4929 return Some(position);
4930 } else {
4931 return Some(D::from_text_summary(&self.text_summary()));
4932 }
4933 })
4934 }
4935
4936 pub fn refresh_anchors<'a, I>(&'a self, anchors: I) -> Vec<(usize, Anchor, bool)>
4937 where
4938 I: 'a + IntoIterator<Item = &'a Anchor>,
4939 {
4940 let mut anchors = anchors.into_iter().enumerate().peekable();
4941 let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
4942 cursor.next(&());
4943
4944 let mut result = Vec::new();
4945
4946 while let Some((_, anchor)) = anchors.peek() {
4947 let old_excerpt_id = anchor.excerpt_id;
4948
4949 // Find the location where this anchor's excerpt should be.
4950 let old_locator = self.excerpt_locator_for_id(old_excerpt_id);
4951 cursor.seek_forward(&Some(old_locator), Bias::Left, &());
4952
4953 if cursor.item().is_none() {
4954 cursor.next(&());
4955 }
4956
4957 let next_excerpt = cursor.item();
4958 let prev_excerpt = cursor.prev_item();
4959
4960 // Process all of the anchors for this excerpt.
4961 while let Some((_, anchor)) = anchors.peek() {
4962 if anchor.excerpt_id != old_excerpt_id {
4963 break;
4964 }
4965 let (anchor_ix, anchor) = anchors.next().unwrap();
4966 let mut anchor = *anchor;
4967
4968 // Leave min and max anchors unchanged if invalid or
4969 // if the old excerpt still exists at this location
4970 let mut kept_position = next_excerpt
4971 .map_or(false, |e| e.id == old_excerpt_id && e.contains(&anchor))
4972 || old_excerpt_id == ExcerptId::max()
4973 || old_excerpt_id == ExcerptId::min();
4974
4975 // If the old excerpt no longer exists at this location, then attempt to
4976 // find an equivalent position for this anchor in an adjacent excerpt.
4977 if !kept_position {
4978 for excerpt in [next_excerpt, prev_excerpt].iter().filter_map(|e| *e) {
4979 if excerpt.contains(&anchor) {
4980 anchor.excerpt_id = excerpt.id;
4981 kept_position = true;
4982 break;
4983 }
4984 }
4985 }
4986
4987 // If there's no adjacent excerpt that contains the anchor's position,
4988 // then report that the anchor has lost its position.
4989 if !kept_position {
4990 anchor = if let Some(excerpt) = next_excerpt {
4991 let mut text_anchor = excerpt
4992 .range
4993 .context
4994 .start
4995 .bias(anchor.text_anchor.bias, &excerpt.buffer);
4996 if text_anchor
4997 .cmp(&excerpt.range.context.end, &excerpt.buffer)
4998 .is_gt()
4999 {
5000 text_anchor = excerpt.range.context.end;
5001 }
5002 Anchor {
5003 buffer_id: Some(excerpt.buffer_id),
5004 excerpt_id: excerpt.id,
5005 text_anchor,
5006 diff_base_anchor: None,
5007 }
5008 } else if let Some(excerpt) = prev_excerpt {
5009 let mut text_anchor = excerpt
5010 .range
5011 .context
5012 .end
5013 .bias(anchor.text_anchor.bias, &excerpt.buffer);
5014 if text_anchor
5015 .cmp(&excerpt.range.context.start, &excerpt.buffer)
5016 .is_lt()
5017 {
5018 text_anchor = excerpt.range.context.start;
5019 }
5020 Anchor {
5021 buffer_id: Some(excerpt.buffer_id),
5022 excerpt_id: excerpt.id,
5023 text_anchor,
5024 diff_base_anchor: None,
5025 }
5026 } else if anchor.text_anchor.bias == Bias::Left {
5027 Anchor::min()
5028 } else {
5029 Anchor::max()
5030 };
5031 }
5032
5033 result.push((anchor_ix, anchor, kept_position));
5034 }
5035 }
5036 result.sort_unstable_by(|a, b| a.1.cmp(&b.1, self));
5037 result
5038 }
5039
5040 pub fn anchor_before<T: ToOffset>(&self, position: T) -> Anchor {
5041 self.anchor_at(position, Bias::Left)
5042 }
5043
5044 pub fn anchor_after<T: ToOffset>(&self, position: T) -> Anchor {
5045 self.anchor_at(position, Bias::Right)
5046 }
5047
5048 pub fn anchor_at<T: ToOffset>(&self, position: T, mut bias: Bias) -> Anchor {
5049 let offset = position.to_offset(self);
5050
5051 // Find the given position in the diff transforms. Determine the corresponding
5052 // offset in the excerpts, and whether the position is within a deleted hunk.
5053 let mut diff_transforms = self.diff_transforms.cursor::<(usize, ExcerptOffset)>(&());
5054 diff_transforms.seek(&offset, Bias::Right, &());
5055
5056 if offset == diff_transforms.start().0 && bias == Bias::Left {
5057 if let Some(prev_item) = diff_transforms.prev_item() {
5058 match prev_item {
5059 DiffTransform::DeletedHunk { .. } => {
5060 diff_transforms.prev(&());
5061 }
5062 _ => {}
5063 }
5064 }
5065 }
5066 let offset_in_transform = offset - diff_transforms.start().0;
5067 let mut excerpt_offset = diff_transforms.start().1;
5068 let mut diff_base_anchor = None;
5069 if let Some(DiffTransform::DeletedHunk {
5070 buffer_id,
5071 base_text_byte_range,
5072 has_trailing_newline,
5073 ..
5074 }) = diff_transforms.item()
5075 {
5076 let diff = self.diffs.get(buffer_id).expect("missing diff");
5077 if offset_in_transform > base_text_byte_range.len() {
5078 debug_assert!(*has_trailing_newline);
5079 bias = Bias::Right;
5080 } else {
5081 diff_base_anchor = Some(
5082 diff.base_text()
5083 .anchor_at(base_text_byte_range.start + offset_in_transform, bias),
5084 );
5085 bias = Bias::Left;
5086 }
5087 } else {
5088 excerpt_offset += ExcerptOffset::new(offset_in_transform);
5089 };
5090
5091 if let Some((excerpt_id, buffer_id, buffer)) = self.as_singleton() {
5092 return Anchor {
5093 buffer_id: Some(buffer_id),
5094 excerpt_id: *excerpt_id,
5095 text_anchor: buffer.anchor_at(excerpt_offset.value, bias),
5096 diff_base_anchor,
5097 };
5098 }
5099
5100 let mut excerpts = self
5101 .excerpts
5102 .cursor::<(ExcerptOffset, Option<ExcerptId>)>(&());
5103 excerpts.seek(&excerpt_offset, Bias::Right, &());
5104 if excerpts.item().is_none() && excerpt_offset == excerpts.start().0 && bias == Bias::Left {
5105 excerpts.prev(&());
5106 }
5107 if let Some(excerpt) = excerpts.item() {
5108 let mut overshoot = excerpt_offset.saturating_sub(excerpts.start().0).value;
5109 if excerpt.has_trailing_newline && excerpt_offset == excerpts.end(&()).0 {
5110 overshoot -= 1;
5111 bias = Bias::Right;
5112 }
5113
5114 let buffer_start = excerpt.range.context.start.to_offset(&excerpt.buffer);
5115 let text_anchor =
5116 excerpt.clip_anchor(excerpt.buffer.anchor_at(buffer_start + overshoot, bias));
5117 Anchor {
5118 buffer_id: Some(excerpt.buffer_id),
5119 excerpt_id: excerpt.id,
5120 text_anchor,
5121 diff_base_anchor,
5122 }
5123 } else if excerpt_offset.is_zero() && bias == Bias::Left {
5124 Anchor::min()
5125 } else {
5126 Anchor::max()
5127 }
5128 }
5129
5130 /// Returns an anchor for the given excerpt and text anchor,
5131 /// returns None if the excerpt_id is no longer valid.
5132 pub fn anchor_in_excerpt(
5133 &self,
5134 excerpt_id: ExcerptId,
5135 text_anchor: text::Anchor,
5136 ) -> Option<Anchor> {
5137 let locator = self.excerpt_locator_for_id(excerpt_id);
5138 let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
5139 cursor.seek(locator, Bias::Left, &());
5140 if let Some(excerpt) = cursor.item() {
5141 if excerpt.id == excerpt_id {
5142 let text_anchor = excerpt.clip_anchor(text_anchor);
5143 drop(cursor);
5144 return Some(Anchor {
5145 buffer_id: Some(excerpt.buffer_id),
5146 excerpt_id,
5147 text_anchor,
5148 diff_base_anchor: None,
5149 });
5150 }
5151 }
5152 None
5153 }
5154
5155 pub fn context_range_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<Range<text::Anchor>> {
5156 Some(self.excerpt(excerpt_id)?.range.context.clone())
5157 }
5158
5159 pub fn can_resolve(&self, anchor: &Anchor) -> bool {
5160 if anchor.excerpt_id == ExcerptId::min() || anchor.excerpt_id == ExcerptId::max() {
5161 true
5162 } else if let Some(excerpt) = self.excerpt(anchor.excerpt_id) {
5163 excerpt.buffer.can_resolve(&anchor.text_anchor)
5164 } else {
5165 false
5166 }
5167 }
5168
5169 pub fn excerpts(
5170 &self,
5171 ) -> impl Iterator<Item = (ExcerptId, &BufferSnapshot, ExcerptRange<text::Anchor>)> {
5172 self.excerpts
5173 .iter()
5174 .map(|excerpt| (excerpt.id, &excerpt.buffer, excerpt.range.clone()))
5175 }
5176
5177 fn cursor<D: TextDimension + Default>(&self) -> MultiBufferCursor<D> {
5178 let excerpts = self.excerpts.cursor(&());
5179 let diff_transforms = self.diff_transforms.cursor(&());
5180 MultiBufferCursor {
5181 excerpts,
5182 diff_transforms,
5183 diffs: &self.diffs,
5184 cached_region: None,
5185 }
5186 }
5187
5188 pub fn excerpt_before(&self, id: ExcerptId) -> Option<MultiBufferExcerpt<'_>> {
5189 let start_locator = self.excerpt_locator_for_id(id);
5190 let mut excerpts = self
5191 .excerpts
5192 .cursor::<(Option<&Locator>, ExcerptDimension<usize>)>(&());
5193 excerpts.seek(&Some(start_locator), Bias::Left, &());
5194 excerpts.prev(&());
5195
5196 let mut diff_transforms = self
5197 .diff_transforms
5198 .cursor::<(OutputDimension<usize>, ExcerptDimension<usize>)>(&());
5199 diff_transforms.seek(&excerpts.start().1, Bias::Left, &());
5200 if diff_transforms.end(&()).1 < excerpts.start().1 {
5201 diff_transforms.next(&());
5202 }
5203
5204 let excerpt = excerpts.item()?;
5205 Some(MultiBufferExcerpt {
5206 excerpt,
5207 offset: diff_transforms.start().0.0,
5208 buffer_offset: excerpt.range.context.start.to_offset(&excerpt.buffer),
5209 excerpt_offset: excerpts.start().1.clone(),
5210 diff_transforms,
5211 })
5212 }
5213
5214 pub fn excerpt_boundaries_in_range<R, T>(
5215 &self,
5216 range: R,
5217 ) -> impl Iterator<Item = ExcerptBoundary> + '_
5218 where
5219 R: RangeBounds<T>,
5220 T: ToOffset,
5221 {
5222 let start_offset;
5223 let start = match range.start_bound() {
5224 Bound::Included(start) => {
5225 start_offset = start.to_offset(self);
5226 Bound::Included(start_offset)
5227 }
5228 Bound::Excluded(_) => {
5229 panic!("not supported")
5230 }
5231 Bound::Unbounded => {
5232 start_offset = 0;
5233 Bound::Unbounded
5234 }
5235 };
5236 let end = match range.end_bound() {
5237 Bound::Included(end) => Bound::Included(end.to_offset(self)),
5238 Bound::Excluded(end) => Bound::Excluded(end.to_offset(self)),
5239 Bound::Unbounded => Bound::Unbounded,
5240 };
5241 let bounds = (start, end);
5242
5243 let mut cursor = self.cursor::<DimensionPair<usize, Point>>();
5244 cursor.seek(&DimensionPair {
5245 key: start_offset,
5246 value: None,
5247 });
5248
5249 if cursor
5250 .region()
5251 .is_some_and(|region| bounds.contains(®ion.range.start.key))
5252 {
5253 cursor.prev_excerpt();
5254 } else {
5255 cursor.seek_to_start_of_current_excerpt();
5256 }
5257 let mut prev_region = cursor.region();
5258
5259 cursor.next_excerpt();
5260
5261 iter::from_fn(move || {
5262 loop {
5263 if self.singleton {
5264 return None;
5265 }
5266
5267 let next_region = cursor.region()?;
5268 cursor.next_excerpt();
5269 if !bounds.contains(&next_region.range.start.key) {
5270 prev_region = Some(next_region);
5271 continue;
5272 }
5273
5274 let next_region_start = next_region.range.start.value.unwrap();
5275 let next_region_end = if let Some(region) = cursor.region() {
5276 region.range.start.value.unwrap()
5277 } else {
5278 self.max_point()
5279 };
5280
5281 let prev = prev_region.as_ref().map(|region| ExcerptInfo {
5282 id: region.excerpt.id,
5283 buffer: region.excerpt.buffer.clone(),
5284 buffer_id: region.excerpt.buffer_id,
5285 range: region.excerpt.range.clone(),
5286 end_row: MultiBufferRow(next_region_start.row),
5287 });
5288
5289 let next = ExcerptInfo {
5290 id: next_region.excerpt.id,
5291 buffer: next_region.excerpt.buffer.clone(),
5292 buffer_id: next_region.excerpt.buffer_id,
5293 range: next_region.excerpt.range.clone(),
5294 end_row: if next_region.excerpt.has_trailing_newline {
5295 MultiBufferRow(next_region_end.row - 1)
5296 } else {
5297 MultiBufferRow(next_region_end.row)
5298 },
5299 };
5300
5301 let row = MultiBufferRow(next_region_start.row);
5302
5303 prev_region = Some(next_region);
5304
5305 return Some(ExcerptBoundary { row, prev, next });
5306 }
5307 })
5308 }
5309
5310 pub fn edit_count(&self) -> usize {
5311 self.edit_count
5312 }
5313
5314 pub fn non_text_state_update_count(&self) -> usize {
5315 self.non_text_state_update_count
5316 }
5317
5318 /// Returns the smallest enclosing bracket ranges containing the given range or
5319 /// None if no brackets contain range or the range is not contained in a single
5320 /// excerpt
5321 ///
5322 /// Can optionally pass a range_filter to filter the ranges of brackets to consider
5323 pub fn innermost_enclosing_bracket_ranges<T: ToOffset>(
5324 &self,
5325 range: Range<T>,
5326 range_filter: Option<&dyn Fn(&BufferSnapshot, Range<usize>, Range<usize>) -> bool>,
5327 ) -> Option<(Range<usize>, Range<usize>)> {
5328 let range = range.start.to_offset(self)..range.end.to_offset(self);
5329 let mut excerpt = self.excerpt_containing(range.clone())?;
5330 let buffer = excerpt.buffer();
5331 let excerpt_buffer_range = excerpt.buffer_range();
5332
5333 // Filter to ranges contained in the excerpt
5334 let range_filter = |open: Range<usize>, close: Range<usize>| -> bool {
5335 excerpt_buffer_range.contains(&open.start)
5336 && excerpt_buffer_range.contains(&close.end)
5337 && range_filter.map_or(true, |filter| filter(buffer, open, close))
5338 };
5339
5340 let (open, close) = excerpt.buffer().innermost_enclosing_bracket_ranges(
5341 excerpt.map_range_to_buffer(range),
5342 Some(&range_filter),
5343 )?;
5344
5345 Some((
5346 excerpt.map_range_from_buffer(open),
5347 excerpt.map_range_from_buffer(close),
5348 ))
5349 }
5350
5351 /// Returns enclosing bracket ranges containing the given range or returns None if the range is
5352 /// not contained in a single excerpt
5353 pub fn enclosing_bracket_ranges<T: ToOffset>(
5354 &self,
5355 range: Range<T>,
5356 ) -> Option<impl Iterator<Item = (Range<usize>, Range<usize>)> + '_> {
5357 let range = range.start.to_offset(self)..range.end.to_offset(self);
5358 let mut excerpt = self.excerpt_containing(range.clone())?;
5359
5360 Some(
5361 excerpt
5362 .buffer()
5363 .enclosing_bracket_ranges(excerpt.map_range_to_buffer(range))
5364 .filter_map(move |pair| {
5365 if excerpt.contains_buffer_range(pair.open_range.start..pair.close_range.end) {
5366 Some((
5367 excerpt.map_range_from_buffer(pair.open_range),
5368 excerpt.map_range_from_buffer(pair.close_range),
5369 ))
5370 } else {
5371 None
5372 }
5373 }),
5374 )
5375 }
5376
5377 /// Returns enclosing bracket ranges containing the given range or returns None if the range is
5378 /// not contained in a single excerpt
5379 pub fn text_object_ranges<T: ToOffset>(
5380 &self,
5381 range: Range<T>,
5382 options: TreeSitterOptions,
5383 ) -> impl Iterator<Item = (Range<usize>, TextObject)> + '_ {
5384 let range = range.start.to_offset(self)..range.end.to_offset(self);
5385 self.excerpt_containing(range.clone())
5386 .map(|mut excerpt| {
5387 excerpt
5388 .buffer()
5389 .text_object_ranges(excerpt.map_range_to_buffer(range), options)
5390 .filter_map(move |(range, text_object)| {
5391 if excerpt.contains_buffer_range(range.clone()) {
5392 Some((excerpt.map_range_from_buffer(range), text_object))
5393 } else {
5394 None
5395 }
5396 })
5397 })
5398 .into_iter()
5399 .flatten()
5400 }
5401
5402 /// Returns bracket range pairs overlapping the given `range` or returns None if the `range` is
5403 /// not contained in a single excerpt
5404 pub fn bracket_ranges<T: ToOffset>(
5405 &self,
5406 range: Range<T>,
5407 ) -> Option<impl Iterator<Item = (Range<usize>, Range<usize>)> + '_> {
5408 let range = range.start.to_offset(self)..range.end.to_offset(self);
5409 let mut excerpt = self.excerpt_containing(range.clone())?;
5410
5411 Some(
5412 excerpt
5413 .buffer()
5414 .bracket_ranges(excerpt.map_range_to_buffer(range))
5415 .filter_map(move |pair| {
5416 let buffer_range = pair.open_range.start..pair.close_range.end;
5417 if excerpt.contains_buffer_range(buffer_range) {
5418 Some((
5419 excerpt.map_range_from_buffer(pair.open_range),
5420 excerpt.map_range_from_buffer(pair.close_range),
5421 ))
5422 } else {
5423 None
5424 }
5425 }),
5426 )
5427 }
5428
5429 pub fn redacted_ranges<'a, T: ToOffset>(
5430 &'a self,
5431 range: Range<T>,
5432 redaction_enabled: impl Fn(Option<&Arc<dyn File>>) -> bool + 'a,
5433 ) -> impl Iterator<Item = Range<usize>> + 'a {
5434 let range = range.start.to_offset(self)..range.end.to_offset(self);
5435 self.lift_buffer_metadata(range, move |buffer, range| {
5436 if redaction_enabled(buffer.file()) {
5437 Some(buffer.redacted_ranges(range).map(|range| (range, ())))
5438 } else {
5439 None
5440 }
5441 })
5442 .map(|(range, _, _)| range)
5443 }
5444
5445 pub fn runnable_ranges(
5446 &self,
5447 range: Range<Anchor>,
5448 ) -> impl Iterator<Item = language::RunnableRange> + '_ {
5449 let range = range.start.to_offset(self)..range.end.to_offset(self);
5450 self.lift_buffer_metadata(range, move |buffer, range| {
5451 Some(
5452 buffer
5453 .runnable_ranges(range.clone())
5454 .filter(move |runnable| {
5455 runnable.run_range.start >= range.start
5456 && runnable.run_range.end < range.end
5457 })
5458 .map(|runnable| (runnable.run_range.clone(), runnable)),
5459 )
5460 })
5461 .map(|(run_range, runnable, _)| language::RunnableRange {
5462 run_range,
5463 ..runnable
5464 })
5465 }
5466
5467 pub fn line_indents(
5468 &self,
5469 start_row: MultiBufferRow,
5470 buffer_filter: impl Fn(&BufferSnapshot) -> bool,
5471 ) -> impl Iterator<Item = (MultiBufferRow, LineIndent, &BufferSnapshot)> {
5472 let max_point = self.max_point();
5473 let mut cursor = self.cursor::<Point>();
5474 cursor.seek(&Point::new(start_row.0, 0));
5475 iter::from_fn(move || {
5476 let mut region = cursor.region()?;
5477 while !buffer_filter(®ion.excerpt.buffer) {
5478 cursor.next();
5479 region = cursor.region()?;
5480 }
5481 let overshoot = start_row.0.saturating_sub(region.range.start.row);
5482 let buffer_start_row =
5483 (region.buffer_range.start.row + overshoot).min(region.buffer_range.end.row);
5484
5485 let buffer_end_row = if region.is_main_buffer
5486 && (region.has_trailing_newline || region.range.end == max_point)
5487 {
5488 region.buffer_range.end.row
5489 } else {
5490 region.buffer_range.end.row.saturating_sub(1)
5491 };
5492
5493 let line_indents = region
5494 .buffer
5495 .line_indents_in_row_range(buffer_start_row..buffer_end_row);
5496 cursor.next();
5497 return Some(line_indents.map(move |(buffer_row, indent)| {
5498 let row = region.range.start.row + (buffer_row - region.buffer_range.start.row);
5499 (MultiBufferRow(row), indent, ®ion.excerpt.buffer)
5500 }));
5501 })
5502 .flatten()
5503 }
5504
5505 pub fn reversed_line_indents(
5506 &self,
5507 end_row: MultiBufferRow,
5508 buffer_filter: impl Fn(&BufferSnapshot) -> bool,
5509 ) -> impl Iterator<Item = (MultiBufferRow, LineIndent, &BufferSnapshot)> {
5510 let max_point = self.max_point();
5511 let mut cursor = self.cursor::<Point>();
5512 cursor.seek(&Point::new(end_row.0, 0));
5513 iter::from_fn(move || {
5514 let mut region = cursor.region()?;
5515 while !buffer_filter(®ion.excerpt.buffer) {
5516 cursor.prev();
5517 region = cursor.region()?;
5518 }
5519
5520 let buffer_start_row = region.buffer_range.start.row;
5521 let buffer_end_row = if region.is_main_buffer
5522 && (region.has_trailing_newline || region.range.end == max_point)
5523 {
5524 region.buffer_range.end.row + 1
5525 } else {
5526 region.buffer_range.end.row
5527 };
5528
5529 let overshoot = end_row.0 - region.range.start.row;
5530 let buffer_end_row =
5531 (region.buffer_range.start.row + overshoot + 1).min(buffer_end_row);
5532
5533 let line_indents = region
5534 .buffer
5535 .reversed_line_indents_in_row_range(buffer_start_row..buffer_end_row);
5536 cursor.prev();
5537 return Some(line_indents.map(move |(buffer_row, indent)| {
5538 let row = region.range.start.row + (buffer_row - region.buffer_range.start.row);
5539 (MultiBufferRow(row), indent, ®ion.excerpt.buffer)
5540 }));
5541 })
5542 .flatten()
5543 }
5544
5545 pub async fn enclosing_indent(
5546 &self,
5547 mut target_row: MultiBufferRow,
5548 ) -> Option<(Range<MultiBufferRow>, LineIndent)> {
5549 let max_row = MultiBufferRow(self.max_point().row);
5550 if target_row >= max_row {
5551 return None;
5552 }
5553
5554 let mut target_indent = self.line_indent_for_row(target_row);
5555
5556 // If the current row is at the start of an indented block, we want to return this
5557 // block as the enclosing indent.
5558 if !target_indent.is_line_empty() && target_row < max_row {
5559 let next_line_indent = self.line_indent_for_row(MultiBufferRow(target_row.0 + 1));
5560 if !next_line_indent.is_line_empty()
5561 && target_indent.raw_len() < next_line_indent.raw_len()
5562 {
5563 target_indent = next_line_indent;
5564 target_row.0 += 1;
5565 }
5566 }
5567
5568 const SEARCH_ROW_LIMIT: u32 = 25000;
5569 const SEARCH_WHITESPACE_ROW_LIMIT: u32 = 2500;
5570 const YIELD_INTERVAL: u32 = 100;
5571
5572 let mut accessed_row_counter = 0;
5573
5574 // If there is a blank line at the current row, search for the next non indented lines
5575 if target_indent.is_line_empty() {
5576 let start = MultiBufferRow(target_row.0.saturating_sub(SEARCH_WHITESPACE_ROW_LIMIT));
5577 let end =
5578 MultiBufferRow((max_row.0 + 1).min(target_row.0 + SEARCH_WHITESPACE_ROW_LIMIT));
5579
5580 let mut non_empty_line_above = None;
5581 for (row, indent, _) in self.reversed_line_indents(target_row, |_| true) {
5582 if row < start {
5583 break;
5584 }
5585 accessed_row_counter += 1;
5586 if accessed_row_counter == YIELD_INTERVAL {
5587 accessed_row_counter = 0;
5588 yield_now().await;
5589 }
5590 if !indent.is_line_empty() {
5591 non_empty_line_above = Some((row, indent));
5592 break;
5593 }
5594 }
5595
5596 let mut non_empty_line_below = None;
5597 for (row, indent, _) in self.line_indents(target_row, |_| true) {
5598 if row > end {
5599 break;
5600 }
5601 accessed_row_counter += 1;
5602 if accessed_row_counter == YIELD_INTERVAL {
5603 accessed_row_counter = 0;
5604 yield_now().await;
5605 }
5606 if !indent.is_line_empty() {
5607 non_empty_line_below = Some((row, indent));
5608 break;
5609 }
5610 }
5611
5612 let (row, indent) = match (non_empty_line_above, non_empty_line_below) {
5613 (Some((above_row, above_indent)), Some((below_row, below_indent))) => {
5614 if above_indent.raw_len() >= below_indent.raw_len() {
5615 (above_row, above_indent)
5616 } else {
5617 (below_row, below_indent)
5618 }
5619 }
5620 (Some(above), None) => above,
5621 (None, Some(below)) => below,
5622 _ => return None,
5623 };
5624
5625 target_indent = indent;
5626 target_row = row;
5627 }
5628
5629 let start = MultiBufferRow(target_row.0.saturating_sub(SEARCH_ROW_LIMIT));
5630 let end = MultiBufferRow((max_row.0 + 1).min(target_row.0 + SEARCH_ROW_LIMIT));
5631
5632 let mut start_indent = None;
5633 for (row, indent, _) in self.reversed_line_indents(target_row, |_| true) {
5634 if row < start {
5635 break;
5636 }
5637 accessed_row_counter += 1;
5638 if accessed_row_counter == YIELD_INTERVAL {
5639 accessed_row_counter = 0;
5640 yield_now().await;
5641 }
5642 if !indent.is_line_empty() && indent.raw_len() < target_indent.raw_len() {
5643 start_indent = Some((row, indent));
5644 break;
5645 }
5646 }
5647 let (start_row, start_indent_size) = start_indent?;
5648
5649 let mut end_indent = (end, None);
5650 for (row, indent, _) in self.line_indents(target_row, |_| true) {
5651 if row > end {
5652 break;
5653 }
5654 accessed_row_counter += 1;
5655 if accessed_row_counter == YIELD_INTERVAL {
5656 accessed_row_counter = 0;
5657 yield_now().await;
5658 }
5659 if !indent.is_line_empty() && indent.raw_len() < target_indent.raw_len() {
5660 end_indent = (MultiBufferRow(row.0.saturating_sub(1)), Some(indent));
5661 break;
5662 }
5663 }
5664 let (end_row, end_indent_size) = end_indent;
5665
5666 let indent = if let Some(end_indent_size) = end_indent_size {
5667 if start_indent_size.raw_len() > end_indent_size.raw_len() {
5668 start_indent_size
5669 } else {
5670 end_indent_size
5671 }
5672 } else {
5673 start_indent_size
5674 };
5675
5676 Some((start_row..end_row, indent))
5677 }
5678
5679 pub fn indent_guides_in_range<T: ToPoint>(
5680 &self,
5681 range: Range<T>,
5682 ignore_disabled_for_language: bool,
5683 cx: &App,
5684 ) -> impl Iterator<Item = IndentGuide> {
5685 let range = range.start.to_point(self)..range.end.to_point(self);
5686 let start_row = MultiBufferRow(range.start.row);
5687 let end_row = MultiBufferRow(range.end.row);
5688
5689 let mut row_indents = self.line_indents(start_row, |buffer| {
5690 let settings =
5691 language_settings(buffer.language().map(|l| l.name()), buffer.file(), cx);
5692 settings.indent_guides.enabled || ignore_disabled_for_language
5693 });
5694
5695 let mut result = Vec::new();
5696 let mut indent_stack = SmallVec::<[IndentGuide; 8]>::new();
5697
5698 while let Some((first_row, mut line_indent, buffer)) = row_indents.next() {
5699 if first_row > end_row {
5700 break;
5701 }
5702 let current_depth = indent_stack.len() as u32;
5703
5704 let settings =
5705 language_settings(buffer.language().map(|l| l.name()), buffer.file(), cx);
5706 let tab_size = settings.tab_size.get() as u32;
5707
5708 // When encountering empty, continue until found useful line indent
5709 // then add to the indent stack with the depth found
5710 let mut found_indent = false;
5711 let mut last_row = first_row;
5712 if line_indent.is_line_empty() {
5713 while !found_indent {
5714 let Some((target_row, new_line_indent, _)) = row_indents.next() else {
5715 break;
5716 };
5717 const TRAILING_ROW_SEARCH_LIMIT: u32 = 25;
5718 if target_row > MultiBufferRow(end_row.0 + TRAILING_ROW_SEARCH_LIMIT) {
5719 break;
5720 }
5721
5722 if new_line_indent.is_line_empty() {
5723 continue;
5724 }
5725 last_row = target_row.min(end_row);
5726 line_indent = new_line_indent;
5727 found_indent = true;
5728 break;
5729 }
5730 } else {
5731 found_indent = true
5732 }
5733
5734 let depth = if found_indent {
5735 line_indent.len(tab_size) / tab_size
5736 + ((line_indent.len(tab_size) % tab_size) > 0) as u32
5737 } else {
5738 current_depth
5739 };
5740
5741 match depth.cmp(¤t_depth) {
5742 cmp::Ordering::Less => {
5743 for _ in 0..(current_depth - depth) {
5744 let mut indent = indent_stack.pop().unwrap();
5745 if last_row != first_row {
5746 // In this case, we landed on an empty row, had to seek forward,
5747 // and discovered that the indent we where on is ending.
5748 // This means that the last display row must
5749 // be on line that ends this indent range, so we
5750 // should display the range up to the first non-empty line
5751 indent.end_row = MultiBufferRow(first_row.0.saturating_sub(1));
5752 }
5753
5754 result.push(indent)
5755 }
5756 }
5757 cmp::Ordering::Greater => {
5758 for next_depth in current_depth..depth {
5759 indent_stack.push(IndentGuide {
5760 buffer_id: buffer.remote_id(),
5761 start_row: first_row,
5762 end_row: last_row,
5763 depth: next_depth,
5764 tab_size,
5765 settings: settings.indent_guides,
5766 });
5767 }
5768 }
5769 _ => {}
5770 }
5771
5772 for indent in indent_stack.iter_mut() {
5773 indent.end_row = last_row;
5774 }
5775 }
5776
5777 result.extend(indent_stack);
5778 result.into_iter()
5779 }
5780
5781 pub fn trailing_excerpt_update_count(&self) -> usize {
5782 self.trailing_excerpt_update_count
5783 }
5784
5785 pub fn file_at<T: ToOffset>(&self, point: T) -> Option<&Arc<dyn File>> {
5786 self.point_to_buffer_offset(point)
5787 .and_then(|(buffer, _)| buffer.file())
5788 }
5789
5790 pub fn language_at<T: ToOffset>(&self, point: T) -> Option<&Arc<Language>> {
5791 self.point_to_buffer_offset(point)
5792 .and_then(|(buffer, offset)| buffer.language_at(offset))
5793 }
5794
5795 fn language_settings<'a>(&'a self, cx: &'a App) -> Cow<'a, LanguageSettings> {
5796 self.excerpts
5797 .first()
5798 .map(|excerpt| &excerpt.buffer)
5799 .map(|buffer| {
5800 language_settings(
5801 buffer.language().map(|language| language.name()),
5802 buffer.file(),
5803 cx,
5804 )
5805 })
5806 .unwrap_or_else(move || self.language_settings_at(0, cx))
5807 }
5808
5809 pub fn language_settings_at<'a, T: ToOffset>(
5810 &'a self,
5811 point: T,
5812 cx: &'a App,
5813 ) -> Cow<'a, LanguageSettings> {
5814 let mut language = None;
5815 let mut file = None;
5816 if let Some((buffer, offset)) = self.point_to_buffer_offset(point) {
5817 language = buffer.language_at(offset);
5818 file = buffer.file();
5819 }
5820 language_settings(language.map(|l| l.name()), file, cx)
5821 }
5822
5823 pub fn language_scope_at<T: ToOffset>(&self, point: T) -> Option<LanguageScope> {
5824 self.point_to_buffer_offset(point)
5825 .and_then(|(buffer, offset)| buffer.language_scope_at(offset))
5826 }
5827
5828 pub fn char_classifier_at<T: ToOffset>(&self, point: T) -> CharClassifier {
5829 self.point_to_buffer_offset(point)
5830 .map(|(buffer, offset)| buffer.char_classifier_at(offset))
5831 .unwrap_or_default()
5832 }
5833
5834 pub fn language_indent_size_at<T: ToOffset>(
5835 &self,
5836 position: T,
5837 cx: &App,
5838 ) -> Option<IndentSize> {
5839 let (buffer_snapshot, offset) = self.point_to_buffer_offset(position)?;
5840 Some(buffer_snapshot.language_indent_size_at(offset, cx))
5841 }
5842
5843 pub fn is_dirty(&self) -> bool {
5844 self.is_dirty
5845 }
5846
5847 pub fn has_deleted_file(&self) -> bool {
5848 self.has_deleted_file
5849 }
5850
5851 pub fn has_conflict(&self) -> bool {
5852 self.has_conflict
5853 }
5854
5855 pub fn has_diagnostics(&self) -> bool {
5856 self.excerpts
5857 .iter()
5858 .any(|excerpt| excerpt.buffer.has_diagnostics())
5859 }
5860
5861 pub fn diagnostic_group(
5862 &self,
5863 buffer_id: BufferId,
5864 group_id: usize,
5865 ) -> impl Iterator<Item = DiagnosticEntry<Point>> + '_ {
5866 self.lift_buffer_metadata(Point::zero()..self.max_point(), move |buffer, _| {
5867 if buffer.remote_id() != buffer_id {
5868 return None;
5869 };
5870 Some(
5871 buffer
5872 .diagnostic_group(group_id)
5873 .map(move |DiagnosticEntry { diagnostic, range }| (range, diagnostic)),
5874 )
5875 })
5876 .map(|(range, diagnostic, _)| DiagnosticEntry { diagnostic, range })
5877 }
5878
5879 pub fn diagnostics_in_range<'a, T>(
5880 &'a self,
5881 range: Range<T>,
5882 ) -> impl Iterator<Item = DiagnosticEntry<T>> + 'a
5883 where
5884 T: 'a
5885 + text::ToOffset
5886 + text::FromAnchor
5887 + TextDimension
5888 + Ord
5889 + Sub<T, Output = T>
5890 + fmt::Debug,
5891 {
5892 self.lift_buffer_metadata(range, move |buffer, buffer_range| {
5893 Some(
5894 buffer
5895 .diagnostics_in_range(buffer_range.start..buffer_range.end, false)
5896 .map(|entry| (entry.range, entry.diagnostic)),
5897 )
5898 })
5899 .map(|(range, diagnostic, _)| DiagnosticEntry { diagnostic, range })
5900 }
5901
5902 pub fn syntax_ancestor<T: ToOffset>(
5903 &self,
5904 range: Range<T>,
5905 ) -> Option<(tree_sitter::Node, MultiOrSingleBufferOffsetRange)> {
5906 let range = range.start.to_offset(self)..range.end.to_offset(self);
5907 let mut excerpt = self.excerpt_containing(range.clone())?;
5908 let node = excerpt
5909 .buffer()
5910 .syntax_ancestor(excerpt.map_range_to_buffer(range))?;
5911 let node_range = node.byte_range();
5912 let range = if excerpt.contains_buffer_range(node_range.clone()) {
5913 MultiOrSingleBufferOffsetRange::Multi(excerpt.map_range_from_buffer(node_range))
5914 } else {
5915 MultiOrSingleBufferOffsetRange::Single(node_range)
5916 };
5917 Some((node, range))
5918 }
5919
5920 pub fn outline(&self, theme: Option<&SyntaxTheme>) -> Option<Outline<Anchor>> {
5921 let (excerpt_id, _, buffer) = self.as_singleton()?;
5922 let outline = buffer.outline(theme)?;
5923 Some(Outline::new(
5924 outline
5925 .items
5926 .into_iter()
5927 .flat_map(|item| {
5928 Some(OutlineItem {
5929 depth: item.depth,
5930 range: self.anchor_in_excerpt(*excerpt_id, item.range.start)?
5931 ..self.anchor_in_excerpt(*excerpt_id, item.range.end)?,
5932 text: item.text,
5933 highlight_ranges: item.highlight_ranges,
5934 name_ranges: item.name_ranges,
5935 body_range: item.body_range.and_then(|body_range| {
5936 Some(
5937 self.anchor_in_excerpt(*excerpt_id, body_range.start)?
5938 ..self.anchor_in_excerpt(*excerpt_id, body_range.end)?,
5939 )
5940 }),
5941 annotation_range: item.annotation_range.and_then(|annotation_range| {
5942 Some(
5943 self.anchor_in_excerpt(*excerpt_id, annotation_range.start)?
5944 ..self.anchor_in_excerpt(*excerpt_id, annotation_range.end)?,
5945 )
5946 }),
5947 })
5948 })
5949 .collect(),
5950 ))
5951 }
5952
5953 pub fn symbols_containing<T: ToOffset>(
5954 &self,
5955 offset: T,
5956 theme: Option<&SyntaxTheme>,
5957 ) -> Option<(BufferId, Vec<OutlineItem<Anchor>>)> {
5958 let anchor = self.anchor_before(offset);
5959 let excerpt_id = anchor.excerpt_id;
5960 let excerpt = self.excerpt(excerpt_id)?;
5961 Some((
5962 excerpt.buffer_id,
5963 excerpt
5964 .buffer
5965 .symbols_containing(anchor.text_anchor, theme)
5966 .into_iter()
5967 .flatten()
5968 .flat_map(|item| {
5969 Some(OutlineItem {
5970 depth: item.depth,
5971 range: self.anchor_in_excerpt(excerpt_id, item.range.start)?
5972 ..self.anchor_in_excerpt(excerpt_id, item.range.end)?,
5973 text: item.text,
5974 highlight_ranges: item.highlight_ranges,
5975 name_ranges: item.name_ranges,
5976 body_range: item.body_range.and_then(|body_range| {
5977 Some(
5978 self.anchor_in_excerpt(excerpt_id, body_range.start)?
5979 ..self.anchor_in_excerpt(excerpt_id, body_range.end)?,
5980 )
5981 }),
5982 annotation_range: item.annotation_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 })
5989 })
5990 .collect(),
5991 ))
5992 }
5993
5994 fn excerpt_locator_for_id(&self, id: ExcerptId) -> &Locator {
5995 if id == ExcerptId::min() {
5996 Locator::min_ref()
5997 } else if id == ExcerptId::max() {
5998 Locator::max_ref()
5999 } else {
6000 let mut cursor = self.excerpt_ids.cursor::<ExcerptId>(&());
6001 cursor.seek(&id, Bias::Left, &());
6002 if let Some(entry) = cursor.item() {
6003 if entry.id == id {
6004 return &entry.locator;
6005 }
6006 }
6007 panic!("invalid excerpt id {:?}", id)
6008 }
6009 }
6010
6011 /// Returns the locators referenced by the given excerpt IDs, sorted by locator.
6012 fn excerpt_locators_for_ids(
6013 &self,
6014 ids: impl IntoIterator<Item = ExcerptId>,
6015 ) -> SmallVec<[Locator; 1]> {
6016 let mut sorted_ids = ids.into_iter().collect::<SmallVec<[_; 1]>>();
6017 sorted_ids.sort_unstable();
6018 let mut locators = SmallVec::new();
6019
6020 while sorted_ids.last() == Some(&ExcerptId::max()) {
6021 sorted_ids.pop();
6022 if let Some(mapping) = self.excerpt_ids.last() {
6023 locators.push(mapping.locator.clone());
6024 }
6025 }
6026
6027 let mut sorted_ids = sorted_ids.into_iter().dedup().peekable();
6028 if sorted_ids.peek() == Some(&ExcerptId::min()) {
6029 sorted_ids.next();
6030 if let Some(mapping) = self.excerpt_ids.first() {
6031 locators.push(mapping.locator.clone());
6032 }
6033 }
6034
6035 let mut cursor = self.excerpt_ids.cursor::<ExcerptId>(&());
6036 for id in sorted_ids {
6037 if cursor.seek_forward(&id, Bias::Left, &()) {
6038 locators.push(cursor.item().unwrap().locator.clone());
6039 } else {
6040 panic!("invalid excerpt id {:?}", id);
6041 }
6042 }
6043
6044 locators.sort_unstable();
6045 locators
6046 }
6047
6048 pub fn buffer_id_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<BufferId> {
6049 Some(self.excerpt(excerpt_id)?.buffer_id)
6050 }
6051
6052 pub fn buffer_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<&BufferSnapshot> {
6053 Some(&self.excerpt(excerpt_id)?.buffer)
6054 }
6055
6056 pub fn range_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<Range<Point>> {
6057 let mut cursor = self
6058 .excerpts
6059 .cursor::<(Option<&Locator>, ExcerptDimension<Point>)>(&());
6060 let locator = self.excerpt_locator_for_id(excerpt_id);
6061 if cursor.seek(&Some(locator), Bias::Left, &()) {
6062 let start = cursor.start().1.clone();
6063 let end = cursor.end(&()).1;
6064 let mut diff_transforms = self
6065 .diff_transforms
6066 .cursor::<(ExcerptDimension<Point>, OutputDimension<Point>)>(&());
6067 diff_transforms.seek(&start, Bias::Left, &());
6068 let overshoot = start.0 - diff_transforms.start().0.0;
6069 let start = diff_transforms.start().1.0 + overshoot;
6070 diff_transforms.seek(&end, Bias::Right, &());
6071 let overshoot = end.0 - diff_transforms.start().0.0;
6072 let end = diff_transforms.start().1.0 + overshoot;
6073 Some(start..end)
6074 } else {
6075 None
6076 }
6077 }
6078
6079 pub fn buffer_range_for_excerpt(&self, excerpt_id: ExcerptId) -> Option<Range<text::Anchor>> {
6080 let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
6081 let locator = self.excerpt_locator_for_id(excerpt_id);
6082 if cursor.seek(&Some(locator), Bias::Left, &()) {
6083 if let Some(excerpt) = cursor.item() {
6084 return Some(excerpt.range.context.clone());
6085 }
6086 }
6087 None
6088 }
6089
6090 fn excerpt(&self, excerpt_id: ExcerptId) -> Option<&Excerpt> {
6091 let mut cursor = self.excerpts.cursor::<Option<&Locator>>(&());
6092 let locator = self.excerpt_locator_for_id(excerpt_id);
6093 cursor.seek(&Some(locator), Bias::Left, &());
6094 if let Some(excerpt) = cursor.item() {
6095 if excerpt.id == excerpt_id {
6096 return Some(excerpt);
6097 }
6098 }
6099 None
6100 }
6101
6102 /// Returns the excerpt containing range and its offset start within the multibuffer or none if `range` spans multiple excerpts
6103 pub fn excerpt_containing<T: ToOffset>(&self, range: Range<T>) -> Option<MultiBufferExcerpt> {
6104 let range = range.start.to_offset(self)..range.end.to_offset(self);
6105 let mut cursor = self.cursor::<usize>();
6106 cursor.seek(&range.start);
6107
6108 let start_excerpt = cursor.excerpt()?;
6109 if range.end != range.start {
6110 cursor.seek_forward(&range.end);
6111 if cursor.excerpt()?.id != start_excerpt.id {
6112 return None;
6113 }
6114 }
6115
6116 cursor.seek_to_start_of_current_excerpt();
6117 let region = cursor.region()?;
6118 let offset = region.range.start;
6119 let buffer_offset = region.buffer_range.start;
6120 let excerpt_offset = cursor.excerpts.start().clone();
6121 Some(MultiBufferExcerpt {
6122 diff_transforms: cursor.diff_transforms,
6123 excerpt: start_excerpt,
6124 offset,
6125 buffer_offset,
6126 excerpt_offset,
6127 })
6128 }
6129
6130 pub fn selections_in_range<'a>(
6131 &'a self,
6132 range: &'a Range<Anchor>,
6133 include_local: bool,
6134 ) -> impl 'a + Iterator<Item = (ReplicaId, bool, CursorShape, Selection<Anchor>)> {
6135 let mut cursor = self.excerpts.cursor::<ExcerptSummary>(&());
6136 let start_locator = self.excerpt_locator_for_id(range.start.excerpt_id);
6137 let end_locator = self.excerpt_locator_for_id(range.end.excerpt_id);
6138 cursor.seek(start_locator, Bias::Left, &());
6139 cursor
6140 .take_while(move |excerpt| excerpt.locator <= *end_locator)
6141 .flat_map(move |excerpt| {
6142 let mut query_range = excerpt.range.context.start..excerpt.range.context.end;
6143 if excerpt.id == range.start.excerpt_id {
6144 query_range.start = range.start.text_anchor;
6145 }
6146 if excerpt.id == range.end.excerpt_id {
6147 query_range.end = range.end.text_anchor;
6148 }
6149
6150 excerpt
6151 .buffer
6152 .selections_in_range(query_range, include_local)
6153 .flat_map(move |(replica_id, line_mode, cursor_shape, selections)| {
6154 selections.map(move |selection| {
6155 let mut start = Anchor {
6156 buffer_id: Some(excerpt.buffer_id),
6157 excerpt_id: excerpt.id,
6158 text_anchor: selection.start,
6159 diff_base_anchor: None,
6160 };
6161 let mut end = Anchor {
6162 buffer_id: Some(excerpt.buffer_id),
6163 excerpt_id: excerpt.id,
6164 text_anchor: selection.end,
6165 diff_base_anchor: None,
6166 };
6167 if range.start.cmp(&start, self).is_gt() {
6168 start = range.start;
6169 }
6170 if range.end.cmp(&end, self).is_lt() {
6171 end = range.end;
6172 }
6173
6174 (
6175 replica_id,
6176 line_mode,
6177 cursor_shape,
6178 Selection {
6179 id: selection.id,
6180 start,
6181 end,
6182 reversed: selection.reversed,
6183 goal: selection.goal,
6184 },
6185 )
6186 })
6187 })
6188 })
6189 }
6190
6191 pub fn show_headers(&self) -> bool {
6192 self.show_headers
6193 }
6194
6195 pub fn diff_for_buffer_id(&self, buffer_id: BufferId) -> Option<&BufferDiffSnapshot> {
6196 self.diffs.get(&buffer_id)
6197 }
6198}
6199
6200#[cfg(any(test, feature = "test-support"))]
6201impl MultiBufferSnapshot {
6202 pub fn random_byte_range(&self, start_offset: usize, rng: &mut impl rand::Rng) -> Range<usize> {
6203 let end = self.clip_offset(rng.gen_range(start_offset..=self.len()), Bias::Right);
6204 let start = self.clip_offset(rng.gen_range(start_offset..=end), Bias::Right);
6205 start..end
6206 }
6207
6208 #[cfg(any(test, feature = "test-support"))]
6209 fn check_invariants(&self) {
6210 let excerpts = self.excerpts.items(&());
6211 let excerpt_ids = self.excerpt_ids.items(&());
6212
6213 for (ix, excerpt) in excerpts.iter().enumerate() {
6214 if ix == 0 {
6215 if excerpt.locator <= Locator::min() {
6216 panic!("invalid first excerpt locator {:?}", excerpt.locator);
6217 }
6218 } else if excerpt.locator <= excerpts[ix - 1].locator {
6219 panic!("excerpts are out-of-order: {:?}", excerpts);
6220 }
6221 }
6222
6223 for (ix, entry) in excerpt_ids.iter().enumerate() {
6224 if ix == 0 {
6225 if entry.id.cmp(&ExcerptId::min(), &self).is_le() {
6226 panic!("invalid first excerpt id {:?}", entry.id);
6227 }
6228 } else if entry.id <= excerpt_ids[ix - 1].id {
6229 panic!("excerpt ids are out-of-order: {:?}", excerpt_ids);
6230 }
6231 }
6232
6233 if self.diff_transforms.summary().input != self.excerpts.summary().text {
6234 panic!(
6235 "incorrect input summary. expected {:?}, got {:?}. transforms: {:+?}",
6236 self.excerpts.summary().text.len,
6237 self.diff_transforms.summary().input,
6238 self.diff_transforms.items(&()),
6239 );
6240 }
6241
6242 let mut prev_transform: Option<&DiffTransform> = None;
6243 for item in self.diff_transforms.iter() {
6244 if let DiffTransform::BufferContent {
6245 summary,
6246 inserted_hunk_info,
6247 } = item
6248 {
6249 if let Some(DiffTransform::BufferContent {
6250 inserted_hunk_info: prev_inserted_hunk_info,
6251 ..
6252 }) = prev_transform
6253 {
6254 if *inserted_hunk_info == *prev_inserted_hunk_info {
6255 panic!(
6256 "multiple adjacent buffer content transforms with is_inserted_hunk = {inserted_hunk_info:?}. transforms: {:+?}",
6257 self.diff_transforms.items(&())
6258 );
6259 }
6260 }
6261 if summary.len == 0 && !self.is_empty() {
6262 panic!("empty buffer content transform");
6263 }
6264 }
6265 prev_transform = Some(item);
6266 }
6267 }
6268}
6269
6270impl<'a, D> MultiBufferCursor<'a, D>
6271where
6272 D: TextDimension + Ord + Sub<D, Output = D>,
6273{
6274 fn seek(&mut self, position: &D) {
6275 self.cached_region.take();
6276 self.diff_transforms
6277 .seek(&OutputDimension(*position), Bias::Right, &());
6278 if self.diff_transforms.item().is_none() && *position == self.diff_transforms.start().0.0 {
6279 self.diff_transforms.prev(&());
6280 }
6281
6282 let mut excerpt_position = self.diff_transforms.start().1.0;
6283 if let Some(DiffTransform::BufferContent { .. }) = self.diff_transforms.item() {
6284 let overshoot = *position - self.diff_transforms.start().0.0;
6285 excerpt_position.add_assign(&overshoot);
6286 }
6287
6288 self.excerpts
6289 .seek(&ExcerptDimension(excerpt_position), Bias::Right, &());
6290 if self.excerpts.item().is_none() && excerpt_position == self.excerpts.start().0 {
6291 self.excerpts.prev(&());
6292 }
6293 }
6294
6295 fn seek_forward(&mut self, position: &D) {
6296 self.cached_region.take();
6297 self.diff_transforms
6298 .seek_forward(&OutputDimension(*position), Bias::Right, &());
6299 if self.diff_transforms.item().is_none() && *position == self.diff_transforms.start().0.0 {
6300 self.diff_transforms.prev(&());
6301 }
6302
6303 let overshoot = *position - self.diff_transforms.start().0.0;
6304 let mut excerpt_position = self.diff_transforms.start().1.0;
6305 if let Some(DiffTransform::BufferContent { .. }) = self.diff_transforms.item() {
6306 excerpt_position.add_assign(&overshoot);
6307 }
6308
6309 self.excerpts
6310 .seek_forward(&ExcerptDimension(excerpt_position), Bias::Right, &());
6311 if self.excerpts.item().is_none() && excerpt_position == self.excerpts.start().0 {
6312 self.excerpts.prev(&());
6313 }
6314 }
6315
6316 fn next_excerpt(&mut self) {
6317 self.excerpts.next(&());
6318 self.seek_to_start_of_current_excerpt();
6319 }
6320
6321 fn prev_excerpt(&mut self) {
6322 self.excerpts.prev(&());
6323 self.seek_to_start_of_current_excerpt();
6324 }
6325
6326 fn seek_to_start_of_current_excerpt(&mut self) {
6327 self.cached_region.take();
6328 self.diff_transforms
6329 .seek(self.excerpts.start(), Bias::Left, &());
6330 if self.diff_transforms.end(&()).1 == *self.excerpts.start()
6331 && self.diff_transforms.start().1 < *self.excerpts.start()
6332 && self.diff_transforms.next_item().is_some()
6333 {
6334 self.diff_transforms.next(&());
6335 }
6336 }
6337
6338 fn next(&mut self) {
6339 self.cached_region.take();
6340 match self.diff_transforms.end(&()).1.cmp(&self.excerpts.end(&())) {
6341 cmp::Ordering::Less => self.diff_transforms.next(&()),
6342 cmp::Ordering::Greater => self.excerpts.next(&()),
6343 cmp::Ordering::Equal => {
6344 self.diff_transforms.next(&());
6345 if self.diff_transforms.end(&()).1 > self.excerpts.end(&())
6346 || self.diff_transforms.item().is_none()
6347 {
6348 self.excerpts.next(&());
6349 } else if let Some(DiffTransform::DeletedHunk { hunk_info, .. }) =
6350 self.diff_transforms.item()
6351 {
6352 if self
6353 .excerpts
6354 .item()
6355 .map_or(false, |excerpt| excerpt.id != hunk_info.excerpt_id)
6356 {
6357 self.excerpts.next(&());
6358 }
6359 }
6360 }
6361 }
6362 }
6363
6364 fn prev(&mut self) {
6365 self.cached_region.take();
6366 match self.diff_transforms.start().1.cmp(self.excerpts.start()) {
6367 cmp::Ordering::Less => self.excerpts.prev(&()),
6368 cmp::Ordering::Greater => self.diff_transforms.prev(&()),
6369 cmp::Ordering::Equal => {
6370 self.diff_transforms.prev(&());
6371 if self.diff_transforms.start().1 < *self.excerpts.start()
6372 || self.diff_transforms.item().is_none()
6373 {
6374 self.excerpts.prev(&());
6375 }
6376 }
6377 }
6378 }
6379
6380 fn region(&mut self) -> Option<MultiBufferRegion<'a, D>> {
6381 if self.cached_region.is_none() {
6382 self.cached_region = self.build_region();
6383 }
6384 self.cached_region.clone()
6385 }
6386
6387 fn is_at_start_of_excerpt(&mut self) -> bool {
6388 if self.diff_transforms.start().1 > *self.excerpts.start() {
6389 return false;
6390 } else if self.diff_transforms.start().1 < *self.excerpts.start() {
6391 return true;
6392 }
6393
6394 self.diff_transforms.prev(&());
6395 let prev_transform = self.diff_transforms.item();
6396 self.diff_transforms.next(&());
6397
6398 prev_transform.map_or(true, |next_transform| {
6399 matches!(next_transform, DiffTransform::BufferContent { .. })
6400 })
6401 }
6402
6403 fn is_at_end_of_excerpt(&mut self) -> bool {
6404 if self.diff_transforms.end(&()).1 < self.excerpts.end(&()) {
6405 return false;
6406 } else if self.diff_transforms.end(&()).1 > self.excerpts.end(&())
6407 || self.diff_transforms.item().is_none()
6408 {
6409 return true;
6410 }
6411
6412 let next_transform = self.diff_transforms.next_item();
6413 next_transform.map_or(true, |next_transform| match next_transform {
6414 DiffTransform::BufferContent { .. } => true,
6415 DiffTransform::DeletedHunk { hunk_info, .. } => self
6416 .excerpts
6417 .item()
6418 .map_or(false, |excerpt| excerpt.id != hunk_info.excerpt_id),
6419 })
6420 }
6421
6422 fn main_buffer_position(&self) -> Option<D> {
6423 let excerpt = self.excerpts.item()?;
6424 let buffer = &excerpt.buffer;
6425 let buffer_context_start = excerpt.range.context.start.summary::<D>(buffer);
6426 let mut buffer_start = buffer_context_start;
6427 let overshoot = self.diff_transforms.end(&()).1.0 - self.excerpts.start().0;
6428 buffer_start.add_assign(&overshoot);
6429 Some(buffer_start)
6430 }
6431
6432 fn build_region(&self) -> Option<MultiBufferRegion<'a, D>> {
6433 let excerpt = self.excerpts.item()?;
6434 match self.diff_transforms.item()? {
6435 DiffTransform::DeletedHunk {
6436 buffer_id,
6437 base_text_byte_range,
6438 has_trailing_newline,
6439 hunk_info,
6440 ..
6441 } => {
6442 let diff = self.diffs.get(&buffer_id)?;
6443 let buffer = diff.base_text();
6444 let mut rope_cursor = buffer.as_rope().cursor(0);
6445 let buffer_start = rope_cursor.summary::<D>(base_text_byte_range.start);
6446 let buffer_range_len = rope_cursor.summary::<D>(base_text_byte_range.end);
6447 let mut buffer_end = buffer_start;
6448 buffer_end.add_assign(&buffer_range_len);
6449 let start = self.diff_transforms.start().0.0;
6450 let end = self.diff_transforms.end(&()).0.0;
6451 return Some(MultiBufferRegion {
6452 buffer,
6453 excerpt,
6454 has_trailing_newline: *has_trailing_newline,
6455 is_main_buffer: false,
6456 diff_hunk_status: Some(DiffHunkStatus::deleted(
6457 hunk_info.hunk_secondary_status,
6458 )),
6459 buffer_range: buffer_start..buffer_end,
6460 range: start..end,
6461 });
6462 }
6463 DiffTransform::BufferContent {
6464 inserted_hunk_info, ..
6465 } => {
6466 let buffer = &excerpt.buffer;
6467 let buffer_context_start = excerpt.range.context.start.summary::<D>(buffer);
6468
6469 let mut start = self.diff_transforms.start().0.0;
6470 let mut buffer_start = buffer_context_start;
6471 if self.diff_transforms.start().1 < *self.excerpts.start() {
6472 let overshoot = self.excerpts.start().0 - self.diff_transforms.start().1.0;
6473 start.add_assign(&overshoot);
6474 } else {
6475 let overshoot = self.diff_transforms.start().1.0 - self.excerpts.start().0;
6476 buffer_start.add_assign(&overshoot);
6477 }
6478
6479 let mut end;
6480 let mut buffer_end;
6481 let has_trailing_newline;
6482 if self.diff_transforms.end(&()).1.0 < self.excerpts.end(&()).0 {
6483 let overshoot = self.diff_transforms.end(&()).1.0 - self.excerpts.start().0;
6484 end = self.diff_transforms.end(&()).0.0;
6485 buffer_end = buffer_context_start;
6486 buffer_end.add_assign(&overshoot);
6487 has_trailing_newline = false;
6488 } else {
6489 let overshoot = self.excerpts.end(&()).0 - self.diff_transforms.start().1.0;
6490 end = self.diff_transforms.start().0.0;
6491 end.add_assign(&overshoot);
6492 buffer_end = excerpt.range.context.end.summary::<D>(buffer);
6493 has_trailing_newline = excerpt.has_trailing_newline;
6494 };
6495
6496 Some(MultiBufferRegion {
6497 buffer,
6498 excerpt,
6499 has_trailing_newline,
6500 is_main_buffer: true,
6501 diff_hunk_status: inserted_hunk_info
6502 .map(|info| DiffHunkStatus::added(info.hunk_secondary_status)),
6503 buffer_range: buffer_start..buffer_end,
6504 range: start..end,
6505 })
6506 }
6507 }
6508 }
6509
6510 fn excerpt(&self) -> Option<&'a Excerpt> {
6511 self.excerpts.item()
6512 }
6513}
6514
6515impl History {
6516 fn start_transaction(&mut self, now: Instant) -> Option<TransactionId> {
6517 self.transaction_depth += 1;
6518 if self.transaction_depth == 1 {
6519 let id = self.next_transaction_id.tick();
6520 self.undo_stack.push(Transaction {
6521 id,
6522 buffer_transactions: Default::default(),
6523 first_edit_at: now,
6524 last_edit_at: now,
6525 suppress_grouping: false,
6526 });
6527 Some(id)
6528 } else {
6529 None
6530 }
6531 }
6532
6533 fn end_transaction(
6534 &mut self,
6535 now: Instant,
6536 buffer_transactions: HashMap<BufferId, TransactionId>,
6537 ) -> bool {
6538 assert_ne!(self.transaction_depth, 0);
6539 self.transaction_depth -= 1;
6540 if self.transaction_depth == 0 {
6541 if buffer_transactions.is_empty() {
6542 self.undo_stack.pop();
6543 false
6544 } else {
6545 self.redo_stack.clear();
6546 let transaction = self.undo_stack.last_mut().unwrap();
6547 transaction.last_edit_at = now;
6548 for (buffer_id, transaction_id) in buffer_transactions {
6549 transaction
6550 .buffer_transactions
6551 .entry(buffer_id)
6552 .or_insert(transaction_id);
6553 }
6554 true
6555 }
6556 } else {
6557 false
6558 }
6559 }
6560
6561 fn push_transaction<'a, T>(
6562 &mut self,
6563 buffer_transactions: T,
6564 now: Instant,
6565 cx: &Context<MultiBuffer>,
6566 ) where
6567 T: IntoIterator<Item = (&'a Entity<Buffer>, &'a language::Transaction)>,
6568 {
6569 assert_eq!(self.transaction_depth, 0);
6570 let transaction = Transaction {
6571 id: self.next_transaction_id.tick(),
6572 buffer_transactions: buffer_transactions
6573 .into_iter()
6574 .map(|(buffer, transaction)| (buffer.read(cx).remote_id(), transaction.id))
6575 .collect(),
6576 first_edit_at: now,
6577 last_edit_at: now,
6578 suppress_grouping: false,
6579 };
6580 if !transaction.buffer_transactions.is_empty() {
6581 self.undo_stack.push(transaction);
6582 self.redo_stack.clear();
6583 }
6584 }
6585
6586 fn finalize_last_transaction(&mut self) {
6587 if let Some(transaction) = self.undo_stack.last_mut() {
6588 transaction.suppress_grouping = true;
6589 }
6590 }
6591
6592 fn forget(&mut self, transaction_id: TransactionId) -> Option<Transaction> {
6593 if let Some(ix) = self
6594 .undo_stack
6595 .iter()
6596 .rposition(|transaction| transaction.id == transaction_id)
6597 {
6598 Some(self.undo_stack.remove(ix))
6599 } else if let Some(ix) = self
6600 .redo_stack
6601 .iter()
6602 .rposition(|transaction| transaction.id == transaction_id)
6603 {
6604 Some(self.redo_stack.remove(ix))
6605 } else {
6606 None
6607 }
6608 }
6609
6610 fn transaction(&self, transaction_id: TransactionId) -> Option<&Transaction> {
6611 self.undo_stack
6612 .iter()
6613 .find(|transaction| transaction.id == transaction_id)
6614 .or_else(|| {
6615 self.redo_stack
6616 .iter()
6617 .find(|transaction| transaction.id == transaction_id)
6618 })
6619 }
6620
6621 fn transaction_mut(&mut self, transaction_id: TransactionId) -> Option<&mut Transaction> {
6622 self.undo_stack
6623 .iter_mut()
6624 .find(|transaction| transaction.id == transaction_id)
6625 .or_else(|| {
6626 self.redo_stack
6627 .iter_mut()
6628 .find(|transaction| transaction.id == transaction_id)
6629 })
6630 }
6631
6632 fn pop_undo(&mut self) -> Option<&mut Transaction> {
6633 assert_eq!(self.transaction_depth, 0);
6634 if let Some(transaction) = self.undo_stack.pop() {
6635 self.redo_stack.push(transaction);
6636 self.redo_stack.last_mut()
6637 } else {
6638 None
6639 }
6640 }
6641
6642 fn pop_redo(&mut self) -> Option<&mut Transaction> {
6643 assert_eq!(self.transaction_depth, 0);
6644 if let Some(transaction) = self.redo_stack.pop() {
6645 self.undo_stack.push(transaction);
6646 self.undo_stack.last_mut()
6647 } else {
6648 None
6649 }
6650 }
6651
6652 fn remove_from_undo(&mut self, transaction_id: TransactionId) -> Option<&Transaction> {
6653 let ix = self
6654 .undo_stack
6655 .iter()
6656 .rposition(|transaction| transaction.id == transaction_id)?;
6657 let transaction = self.undo_stack.remove(ix);
6658 self.redo_stack.push(transaction);
6659 self.redo_stack.last()
6660 }
6661
6662 fn group(&mut self) -> Option<TransactionId> {
6663 let mut count = 0;
6664 let mut transactions = self.undo_stack.iter();
6665 if let Some(mut transaction) = transactions.next_back() {
6666 while let Some(prev_transaction) = transactions.next_back() {
6667 if !prev_transaction.suppress_grouping
6668 && transaction.first_edit_at - prev_transaction.last_edit_at
6669 <= self.group_interval
6670 {
6671 transaction = prev_transaction;
6672 count += 1;
6673 } else {
6674 break;
6675 }
6676 }
6677 }
6678 self.group_trailing(count)
6679 }
6680
6681 fn group_until(&mut self, transaction_id: TransactionId) {
6682 let mut count = 0;
6683 for transaction in self.undo_stack.iter().rev() {
6684 if transaction.id == transaction_id {
6685 self.group_trailing(count);
6686 break;
6687 } else if transaction.suppress_grouping {
6688 break;
6689 } else {
6690 count += 1;
6691 }
6692 }
6693 }
6694
6695 fn group_trailing(&mut self, n: usize) -> Option<TransactionId> {
6696 let new_len = self.undo_stack.len() - n;
6697 let (transactions_to_keep, transactions_to_merge) = self.undo_stack.split_at_mut(new_len);
6698 if let Some(last_transaction) = transactions_to_keep.last_mut() {
6699 if let Some(transaction) = transactions_to_merge.last() {
6700 last_transaction.last_edit_at = transaction.last_edit_at;
6701 }
6702 for to_merge in transactions_to_merge {
6703 for (buffer_id, transaction_id) in &to_merge.buffer_transactions {
6704 last_transaction
6705 .buffer_transactions
6706 .entry(*buffer_id)
6707 .or_insert(*transaction_id);
6708 }
6709 }
6710 }
6711
6712 self.undo_stack.truncate(new_len);
6713 self.undo_stack.last().map(|t| t.id)
6714 }
6715}
6716
6717impl Excerpt {
6718 fn new(
6719 id: ExcerptId,
6720 locator: Locator,
6721 buffer_id: BufferId,
6722 buffer: BufferSnapshot,
6723 range: ExcerptRange<text::Anchor>,
6724 has_trailing_newline: bool,
6725 ) -> Self {
6726 Excerpt {
6727 id,
6728 locator,
6729 max_buffer_row: range.context.end.to_point(&buffer).row,
6730 text_summary: buffer
6731 .text_summary_for_range::<TextSummary, _>(range.context.to_offset(&buffer)),
6732 buffer_id,
6733 buffer,
6734 range,
6735 has_trailing_newline,
6736 }
6737 }
6738
6739 fn chunks_in_range(&self, range: Range<usize>, language_aware: bool) -> ExcerptChunks {
6740 let content_start = self.range.context.start.to_offset(&self.buffer);
6741 let chunks_start = content_start + range.start;
6742 let chunks_end = content_start + cmp::min(range.end, self.text_summary.len);
6743
6744 let footer_height = if self.has_trailing_newline
6745 && range.start <= self.text_summary.len
6746 && range.end > self.text_summary.len
6747 {
6748 1
6749 } else {
6750 0
6751 };
6752
6753 let content_chunks = self.buffer.chunks(chunks_start..chunks_end, language_aware);
6754
6755 ExcerptChunks {
6756 excerpt_id: self.id,
6757 content_chunks,
6758 footer_height,
6759 }
6760 }
6761
6762 fn seek_chunks(&self, excerpt_chunks: &mut ExcerptChunks, range: Range<usize>) {
6763 let content_start = self.range.context.start.to_offset(&self.buffer);
6764 let chunks_start = content_start + range.start;
6765 let chunks_end = content_start + cmp::min(range.end, self.text_summary.len);
6766 excerpt_chunks.content_chunks.seek(chunks_start..chunks_end);
6767 excerpt_chunks.footer_height = if self.has_trailing_newline
6768 && range.start <= self.text_summary.len
6769 && range.end > self.text_summary.len
6770 {
6771 1
6772 } else {
6773 0
6774 };
6775 }
6776
6777 fn clip_anchor(&self, text_anchor: text::Anchor) -> text::Anchor {
6778 if text_anchor
6779 .cmp(&self.range.context.start, &self.buffer)
6780 .is_lt()
6781 {
6782 self.range.context.start
6783 } else if text_anchor
6784 .cmp(&self.range.context.end, &self.buffer)
6785 .is_gt()
6786 {
6787 self.range.context.end
6788 } else {
6789 text_anchor
6790 }
6791 }
6792
6793 fn contains(&self, anchor: &Anchor) -> bool {
6794 Some(self.buffer_id) == anchor.buffer_id
6795 && self
6796 .range
6797 .context
6798 .start
6799 .cmp(&anchor.text_anchor, &self.buffer)
6800 .is_le()
6801 && self
6802 .range
6803 .context
6804 .end
6805 .cmp(&anchor.text_anchor, &self.buffer)
6806 .is_ge()
6807 }
6808
6809 /// The [`Excerpt`]'s start offset in its [`Buffer`]
6810 fn buffer_start_offset(&self) -> usize {
6811 self.range.context.start.to_offset(&self.buffer)
6812 }
6813
6814 /// The [`Excerpt`]'s end offset in its [`Buffer`]
6815 fn buffer_end_offset(&self) -> usize {
6816 self.buffer_start_offset() + self.text_summary.len
6817 }
6818}
6819
6820impl<'a> MultiBufferExcerpt<'a> {
6821 pub fn id(&self) -> ExcerptId {
6822 self.excerpt.id
6823 }
6824
6825 pub fn buffer_id(&self) -> BufferId {
6826 self.excerpt.buffer_id
6827 }
6828
6829 pub fn start_anchor(&self) -> Anchor {
6830 Anchor {
6831 buffer_id: Some(self.excerpt.buffer_id),
6832 excerpt_id: self.excerpt.id,
6833 text_anchor: self.excerpt.range.context.start,
6834 diff_base_anchor: None,
6835 }
6836 }
6837
6838 pub fn end_anchor(&self) -> Anchor {
6839 Anchor {
6840 buffer_id: Some(self.excerpt.buffer_id),
6841 excerpt_id: self.excerpt.id,
6842 text_anchor: self.excerpt.range.context.end,
6843 diff_base_anchor: None,
6844 }
6845 }
6846
6847 pub fn buffer(&self) -> &'a BufferSnapshot {
6848 &self.excerpt.buffer
6849 }
6850
6851 pub fn buffer_range(&self) -> Range<usize> {
6852 self.buffer_offset
6853 ..self
6854 .excerpt
6855 .range
6856 .context
6857 .end
6858 .to_offset(&self.excerpt.buffer.text)
6859 }
6860
6861 pub fn start_offset(&self) -> usize {
6862 self.offset
6863 }
6864
6865 /// Maps an offset within the [`MultiBuffer`] to an offset within the [`Buffer`]
6866 pub fn map_offset_to_buffer(&mut self, offset: usize) -> usize {
6867 self.map_range_to_buffer(offset..offset).start
6868 }
6869
6870 /// Maps a range within the [`MultiBuffer`] to a range within the [`Buffer`]
6871 pub fn map_range_to_buffer(&mut self, range: Range<usize>) -> Range<usize> {
6872 self.diff_transforms
6873 .seek(&OutputDimension(range.start), Bias::Right, &());
6874 let start = self.map_offset_to_buffer_internal(range.start);
6875 let end = if range.end > range.start {
6876 self.diff_transforms
6877 .seek_forward(&OutputDimension(range.end), Bias::Right, &());
6878 self.map_offset_to_buffer_internal(range.end)
6879 } else {
6880 start
6881 };
6882 start..end
6883 }
6884
6885 fn map_offset_to_buffer_internal(&self, offset: usize) -> usize {
6886 let mut excerpt_offset = self.diff_transforms.start().1.clone();
6887 if let Some(DiffTransform::BufferContent { .. }) = self.diff_transforms.item() {
6888 excerpt_offset.0 += offset - self.diff_transforms.start().0.0;
6889 };
6890 let offset_in_excerpt = excerpt_offset.0.saturating_sub(self.excerpt_offset.0);
6891 self.buffer_offset + offset_in_excerpt
6892 }
6893
6894 /// Map an offset within the [`Buffer`] to an offset within the [`MultiBuffer`]
6895 pub fn map_offset_from_buffer(&mut self, buffer_offset: usize) -> usize {
6896 self.map_range_from_buffer(buffer_offset..buffer_offset)
6897 .start
6898 }
6899
6900 /// Map a range within the [`Buffer`] to a range within the [`MultiBuffer`]
6901 pub fn map_range_from_buffer(&mut self, buffer_range: Range<usize>) -> Range<usize> {
6902 if buffer_range.start < self.buffer_offset {
6903 log::warn!(
6904 "Attempting to map a range from a buffer offset that starts before the current buffer offset"
6905 );
6906 return buffer_range;
6907 }
6908 let overshoot = buffer_range.start - self.buffer_offset;
6909 let excerpt_offset = ExcerptDimension(self.excerpt_offset.0 + overshoot);
6910 self.diff_transforms.seek(&excerpt_offset, Bias::Right, &());
6911 if excerpt_offset.0 < self.diff_transforms.start().1.0 {
6912 log::warn!(
6913 "Attempting to map a range from a buffer offset that starts before the current buffer offset"
6914 );
6915 return buffer_range;
6916 }
6917 let overshoot = excerpt_offset.0 - self.diff_transforms.start().1.0;
6918 let start = self.diff_transforms.start().0.0 + overshoot;
6919
6920 let end = if buffer_range.end > buffer_range.start {
6921 let overshoot = buffer_range.end - self.buffer_offset;
6922 let excerpt_offset = ExcerptDimension(self.excerpt_offset.0 + overshoot);
6923 self.diff_transforms
6924 .seek_forward(&excerpt_offset, Bias::Right, &());
6925 let overshoot = excerpt_offset.0 - self.diff_transforms.start().1.0;
6926 self.diff_transforms.start().0.0 + overshoot
6927 } else {
6928 start
6929 };
6930
6931 start..end
6932 }
6933
6934 /// Returns true if the entirety of the given range is in the buffer's excerpt
6935 pub fn contains_buffer_range(&self, range: Range<usize>) -> bool {
6936 range.start >= self.excerpt.buffer_start_offset()
6937 && range.end <= self.excerpt.buffer_end_offset()
6938 }
6939
6940 pub fn max_buffer_row(&self) -> u32 {
6941 self.excerpt.max_buffer_row
6942 }
6943}
6944
6945impl ExcerptId {
6946 pub fn min() -> Self {
6947 Self(0)
6948 }
6949
6950 pub fn max() -> Self {
6951 Self(usize::MAX)
6952 }
6953
6954 pub fn to_proto(&self) -> u64 {
6955 self.0 as _
6956 }
6957
6958 pub fn from_proto(proto: u64) -> Self {
6959 Self(proto as _)
6960 }
6961
6962 pub fn cmp(&self, other: &Self, snapshot: &MultiBufferSnapshot) -> cmp::Ordering {
6963 let a = snapshot.excerpt_locator_for_id(*self);
6964 let b = snapshot.excerpt_locator_for_id(*other);
6965 a.cmp(b).then_with(|| self.0.cmp(&other.0))
6966 }
6967}
6968
6969impl From<ExcerptId> for usize {
6970 fn from(val: ExcerptId) -> Self {
6971 val.0
6972 }
6973}
6974
6975impl fmt::Debug for Excerpt {
6976 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
6977 f.debug_struct("Excerpt")
6978 .field("id", &self.id)
6979 .field("locator", &self.locator)
6980 .field("buffer_id", &self.buffer_id)
6981 .field("range", &self.range)
6982 .field("text_summary", &self.text_summary)
6983 .field("has_trailing_newline", &self.has_trailing_newline)
6984 .finish()
6985 }
6986}
6987
6988impl sum_tree::Item for Excerpt {
6989 type Summary = ExcerptSummary;
6990
6991 fn summary(&self, _cx: &()) -> Self::Summary {
6992 let mut text = self.text_summary;
6993 if self.has_trailing_newline {
6994 text += TextSummary::from("\n");
6995 }
6996 ExcerptSummary {
6997 excerpt_id: self.id,
6998 excerpt_locator: self.locator.clone(),
6999 widest_line_number: self.max_buffer_row,
7000 text,
7001 }
7002 }
7003}
7004
7005impl sum_tree::Item for ExcerptIdMapping {
7006 type Summary = ExcerptId;
7007
7008 fn summary(&self, _cx: &()) -> Self::Summary {
7009 self.id
7010 }
7011}
7012
7013impl sum_tree::KeyedItem for ExcerptIdMapping {
7014 type Key = ExcerptId;
7015
7016 fn key(&self) -> Self::Key {
7017 self.id
7018 }
7019}
7020
7021impl DiffTransform {
7022 fn hunk_info(&self) -> Option<DiffTransformHunkInfo> {
7023 match self {
7024 DiffTransform::DeletedHunk { hunk_info, .. } => Some(*hunk_info),
7025 DiffTransform::BufferContent {
7026 inserted_hunk_info, ..
7027 } => *inserted_hunk_info,
7028 }
7029 }
7030}
7031
7032impl sum_tree::Item for DiffTransform {
7033 type Summary = DiffTransformSummary;
7034
7035 fn summary(&self, _: &<Self::Summary as sum_tree::Summary>::Context) -> Self::Summary {
7036 match self {
7037 DiffTransform::BufferContent { summary, .. } => DiffTransformSummary {
7038 input: *summary,
7039 output: *summary,
7040 },
7041 DiffTransform::DeletedHunk { summary, .. } => DiffTransformSummary {
7042 input: TextSummary::default(),
7043 output: *summary,
7044 },
7045 }
7046 }
7047}
7048
7049impl DiffTransformSummary {
7050 fn excerpt_len(&self) -> ExcerptOffset {
7051 ExcerptOffset::new(self.input.len)
7052 }
7053}
7054
7055impl sum_tree::Summary for DiffTransformSummary {
7056 type Context = ();
7057
7058 fn zero(_: &Self::Context) -> Self {
7059 DiffTransformSummary {
7060 input: TextSummary::default(),
7061 output: TextSummary::default(),
7062 }
7063 }
7064
7065 fn add_summary(&mut self, summary: &Self, _: &Self::Context) {
7066 self.input += &summary.input;
7067 self.output += &summary.output;
7068 }
7069}
7070
7071impl sum_tree::Summary for ExcerptId {
7072 type Context = ();
7073
7074 fn zero(_cx: &()) -> Self {
7075 Default::default()
7076 }
7077
7078 fn add_summary(&mut self, other: &Self, _: &()) {
7079 *self = *other;
7080 }
7081}
7082
7083impl sum_tree::Summary for ExcerptSummary {
7084 type Context = ();
7085
7086 fn zero(_cx: &()) -> Self {
7087 Default::default()
7088 }
7089
7090 fn add_summary(&mut self, summary: &Self, _: &()) {
7091 debug_assert!(summary.excerpt_locator > self.excerpt_locator);
7092 self.excerpt_locator = summary.excerpt_locator.clone();
7093 self.text.add_summary(&summary.text, &());
7094 self.widest_line_number = cmp::max(self.widest_line_number, summary.widest_line_number);
7095 }
7096}
7097
7098impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for ExcerptOffset {
7099 fn zero(_cx: &()) -> Self {
7100 Default::default()
7101 }
7102
7103 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
7104 self.value += summary.text.len;
7105 }
7106}
7107
7108impl sum_tree::SeekTarget<'_, ExcerptSummary, ExcerptSummary> for ExcerptOffset {
7109 fn cmp(&self, cursor_location: &ExcerptSummary, _: &()) -> cmp::Ordering {
7110 Ord::cmp(&self.value, &cursor_location.text.len)
7111 }
7112}
7113
7114impl<'a> sum_tree::SeekTarget<'a, ExcerptSummary, Option<&'a Locator>> for Locator {
7115 fn cmp(&self, cursor_location: &Option<&'a Locator>, _: &()) -> cmp::Ordering {
7116 Ord::cmp(&Some(self), cursor_location)
7117 }
7118}
7119
7120impl sum_tree::SeekTarget<'_, ExcerptSummary, ExcerptSummary> for Locator {
7121 fn cmp(&self, cursor_location: &ExcerptSummary, _: &()) -> cmp::Ordering {
7122 Ord::cmp(self, &cursor_location.excerpt_locator)
7123 }
7124}
7125
7126impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for ExcerptPoint {
7127 fn zero(_cx: &()) -> Self {
7128 Default::default()
7129 }
7130
7131 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
7132 self.value += summary.text.lines;
7133 }
7134}
7135
7136impl<'a, D: TextDimension + Default> sum_tree::Dimension<'a, ExcerptSummary>
7137 for ExcerptDimension<D>
7138{
7139 fn zero(_: &()) -> Self {
7140 ExcerptDimension(D::default())
7141 }
7142
7143 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
7144 self.0.add_assign(&D::from_text_summary(&summary.text))
7145 }
7146}
7147
7148impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for Option<&'a Locator> {
7149 fn zero(_cx: &()) -> Self {
7150 Default::default()
7151 }
7152
7153 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
7154 *self = Some(&summary.excerpt_locator);
7155 }
7156}
7157
7158impl<'a> sum_tree::Dimension<'a, ExcerptSummary> for Option<ExcerptId> {
7159 fn zero(_cx: &()) -> Self {
7160 Default::default()
7161 }
7162
7163 fn add_summary(&mut self, summary: &'a ExcerptSummary, _: &()) {
7164 *self = Some(summary.excerpt_id);
7165 }
7166}
7167
7168#[derive(Clone, PartialOrd, Ord, Eq, PartialEq, Debug)]
7169struct ExcerptDimension<T>(T);
7170
7171#[derive(Clone, PartialOrd, Ord, Eq, PartialEq, Debug)]
7172struct OutputDimension<T>(T);
7173
7174impl<'a> sum_tree::Dimension<'a, DiffTransformSummary> for ExcerptOffset {
7175 fn zero(_: &()) -> Self {
7176 ExcerptOffset::new(0)
7177 }
7178
7179 fn add_summary(&mut self, summary: &'a DiffTransformSummary, _: &()) {
7180 self.value += summary.input.len;
7181 }
7182}
7183
7184impl<'a> sum_tree::Dimension<'a, DiffTransformSummary> for ExcerptPoint {
7185 fn zero(_: &()) -> Self {
7186 ExcerptPoint::new(0, 0)
7187 }
7188
7189 fn add_summary(&mut self, summary: &'a DiffTransformSummary, _: &()) {
7190 self.value += summary.input.lines;
7191 }
7192}
7193
7194impl<D: TextDimension + Ord> sum_tree::SeekTarget<'_, DiffTransformSummary, DiffTransformSummary>
7195 for ExcerptDimension<D>
7196{
7197 fn cmp(&self, cursor_location: &DiffTransformSummary, _: &()) -> cmp::Ordering {
7198 Ord::cmp(&self.0, &D::from_text_summary(&cursor_location.input))
7199 }
7200}
7201
7202impl<D: TextDimension + Ord>
7203 sum_tree::SeekTarget<'_, DiffTransformSummary, (OutputDimension<D>, ExcerptDimension<D>)>
7204 for ExcerptDimension<D>
7205{
7206 fn cmp(
7207 &self,
7208 cursor_location: &(OutputDimension<D>, ExcerptDimension<D>),
7209 _: &(),
7210 ) -> cmp::Ordering {
7211 Ord::cmp(&self.0, &cursor_location.1.0)
7212 }
7213}
7214
7215impl<'a, D: TextDimension> sum_tree::Dimension<'a, DiffTransformSummary> for ExcerptDimension<D> {
7216 fn zero(_: &()) -> Self {
7217 ExcerptDimension(D::default())
7218 }
7219
7220 fn add_summary(&mut self, summary: &'a DiffTransformSummary, _: &()) {
7221 self.0.add_assign(&D::from_text_summary(&summary.input))
7222 }
7223}
7224
7225impl<'a, D: TextDimension> sum_tree::Dimension<'a, DiffTransformSummary> for OutputDimension<D> {
7226 fn zero(_: &()) -> Self {
7227 OutputDimension(D::default())
7228 }
7229
7230 fn add_summary(&mut self, summary: &'a DiffTransformSummary, _: &()) {
7231 self.0.add_assign(&D::from_text_summary(&summary.output))
7232 }
7233}
7234
7235impl<'a> sum_tree::Dimension<'a, DiffTransformSummary> for TextSummary {
7236 fn zero(_: &()) -> Self {
7237 TextSummary::default()
7238 }
7239
7240 fn add_summary(&mut self, summary: &'a DiffTransformSummary, _: &()) {
7241 *self += summary.output
7242 }
7243}
7244
7245impl<'a> sum_tree::Dimension<'a, DiffTransformSummary> for usize {
7246 fn zero(_: &()) -> Self {
7247 0
7248 }
7249
7250 fn add_summary(&mut self, summary: &'a DiffTransformSummary, _: &()) {
7251 *self += summary.output.len
7252 }
7253}
7254
7255impl<'a> sum_tree::Dimension<'a, DiffTransformSummary> for Point {
7256 fn zero(_: &()) -> Self {
7257 Point::new(0, 0)
7258 }
7259
7260 fn add_summary(&mut self, summary: &'a DiffTransformSummary, _: &()) {
7261 *self += summary.output.lines
7262 }
7263}
7264
7265impl MultiBufferRows<'_> {
7266 pub fn seek(&mut self, MultiBufferRow(row): MultiBufferRow) {
7267 self.point = Point::new(row, 0);
7268 self.cursor.seek(&self.point);
7269 }
7270}
7271
7272impl Iterator for MultiBufferRows<'_> {
7273 type Item = RowInfo;
7274
7275 fn next(&mut self) -> Option<Self::Item> {
7276 if self.is_empty && self.point.row == 0 {
7277 self.point += Point::new(1, 0);
7278 return Some(RowInfo {
7279 buffer_id: None,
7280 buffer_row: Some(0),
7281 multibuffer_row: Some(MultiBufferRow(0)),
7282 diff_status: None,
7283 expand_info: None,
7284 });
7285 }
7286
7287 let mut region = self.cursor.region()?;
7288 while self.point >= region.range.end {
7289 self.cursor.next();
7290 if let Some(next_region) = self.cursor.region() {
7291 region = next_region;
7292 } else {
7293 if self.point == self.cursor.diff_transforms.end(&()).0.0 {
7294 let multibuffer_row = MultiBufferRow(self.point.row);
7295 let last_excerpt = self
7296 .cursor
7297 .excerpts
7298 .item()
7299 .or(self.cursor.excerpts.prev_item())?;
7300 let last_row = last_excerpt
7301 .range
7302 .context
7303 .end
7304 .to_point(&last_excerpt.buffer)
7305 .row;
7306
7307 let first_row = last_excerpt
7308 .range
7309 .context
7310 .start
7311 .to_point(&last_excerpt.buffer)
7312 .row;
7313
7314 let expand_info = if self.is_singleton {
7315 None
7316 } else {
7317 let needs_expand_up = first_row == last_row
7318 && last_row > 0
7319 && !region.diff_hunk_status.is_some_and(|d| d.is_deleted());
7320 let needs_expand_down = last_row < last_excerpt.buffer.max_point().row;
7321
7322 if needs_expand_up && needs_expand_down {
7323 Some(ExpandExcerptDirection::UpAndDown)
7324 } else if needs_expand_up {
7325 Some(ExpandExcerptDirection::Up)
7326 } else if needs_expand_down {
7327 Some(ExpandExcerptDirection::Down)
7328 } else {
7329 None
7330 }
7331 .map(|direction| ExpandInfo {
7332 direction,
7333 excerpt_id: last_excerpt.id,
7334 })
7335 };
7336 self.point += Point::new(1, 0);
7337 return Some(RowInfo {
7338 buffer_id: Some(last_excerpt.buffer_id),
7339 buffer_row: Some(last_row),
7340 multibuffer_row: Some(multibuffer_row),
7341 diff_status: None,
7342 expand_info,
7343 });
7344 } else {
7345 return None;
7346 }
7347 };
7348 }
7349
7350 let overshoot = self.point - region.range.start;
7351 let buffer_point = region.buffer_range.start + overshoot;
7352 let expand_info = if self.is_singleton {
7353 None
7354 } else {
7355 let needs_expand_up = self.point.row == region.range.start.row
7356 && self.cursor.is_at_start_of_excerpt()
7357 && buffer_point.row > 0;
7358 let needs_expand_down = (region.excerpt.has_trailing_newline
7359 && self.point.row + 1 == region.range.end.row
7360 || !region.excerpt.has_trailing_newline && self.point.row == region.range.end.row)
7361 && self.cursor.is_at_end_of_excerpt()
7362 && buffer_point.row < region.buffer.max_point().row;
7363
7364 if needs_expand_up && needs_expand_down {
7365 Some(ExpandExcerptDirection::UpAndDown)
7366 } else if needs_expand_up {
7367 Some(ExpandExcerptDirection::Up)
7368 } else if needs_expand_down {
7369 Some(ExpandExcerptDirection::Down)
7370 } else {
7371 None
7372 }
7373 .map(|direction| ExpandInfo {
7374 direction,
7375 excerpt_id: region.excerpt.id,
7376 })
7377 };
7378
7379 let result = Some(RowInfo {
7380 buffer_id: Some(region.buffer.remote_id()),
7381 buffer_row: Some(buffer_point.row),
7382 multibuffer_row: Some(MultiBufferRow(self.point.row)),
7383 diff_status: region
7384 .diff_hunk_status
7385 .filter(|_| self.point < region.range.end),
7386 expand_info,
7387 });
7388 self.point += Point::new(1, 0);
7389 result
7390 }
7391}
7392
7393impl<'a> MultiBufferChunks<'a> {
7394 pub fn offset(&self) -> usize {
7395 self.range.start
7396 }
7397
7398 pub fn seek(&mut self, range: Range<usize>) {
7399 self.diff_transforms.seek(&range.end, Bias::Right, &());
7400 let mut excerpt_end = self.diff_transforms.start().1;
7401 if let Some(DiffTransform::BufferContent { .. }) = self.diff_transforms.item() {
7402 let overshoot = range.end - self.diff_transforms.start().0;
7403 excerpt_end.value += overshoot;
7404 }
7405
7406 self.diff_transforms.seek(&range.start, Bias::Right, &());
7407 let mut excerpt_start = self.diff_transforms.start().1;
7408 if let Some(DiffTransform::BufferContent { .. }) = self.diff_transforms.item() {
7409 let overshoot = range.start - self.diff_transforms.start().0;
7410 excerpt_start.value += overshoot;
7411 }
7412
7413 self.seek_to_excerpt_offset_range(excerpt_start..excerpt_end);
7414 self.buffer_chunk.take();
7415 self.range = range;
7416 }
7417
7418 fn seek_to_excerpt_offset_range(&mut self, new_range: Range<ExcerptOffset>) {
7419 self.excerpt_offset_range = new_range.clone();
7420 self.excerpts.seek(&new_range.start, Bias::Right, &());
7421 if let Some(excerpt) = self.excerpts.item() {
7422 let excerpt_start = *self.excerpts.start();
7423 if let Some(excerpt_chunks) = self
7424 .excerpt_chunks
7425 .as_mut()
7426 .filter(|chunks| excerpt.id == chunks.excerpt_id)
7427 {
7428 excerpt.seek_chunks(
7429 excerpt_chunks,
7430 (self.excerpt_offset_range.start - excerpt_start).value
7431 ..(self.excerpt_offset_range.end - excerpt_start).value,
7432 );
7433 } else {
7434 self.excerpt_chunks = Some(excerpt.chunks_in_range(
7435 (self.excerpt_offset_range.start - excerpt_start).value
7436 ..(self.excerpt_offset_range.end - excerpt_start).value,
7437 self.language_aware,
7438 ));
7439 }
7440 } else {
7441 self.excerpt_chunks = None;
7442 }
7443 }
7444
7445 fn next_excerpt_chunk(&mut self) -> Option<Chunk<'a>> {
7446 loop {
7447 if self.excerpt_offset_range.is_empty() {
7448 return None;
7449 } else if let Some(chunk) = self.excerpt_chunks.as_mut()?.next() {
7450 self.excerpt_offset_range.start.value += chunk.text.len();
7451 return Some(chunk);
7452 } else {
7453 self.excerpts.next(&());
7454 let excerpt = self.excerpts.item()?;
7455 self.excerpt_chunks = Some(excerpt.chunks_in_range(
7456 0..(self.excerpt_offset_range.end - *self.excerpts.start()).value,
7457 self.language_aware,
7458 ));
7459 }
7460 }
7461 }
7462}
7463
7464impl<'a> Iterator for ReversedMultiBufferChunks<'a> {
7465 type Item = &'a str;
7466
7467 fn next(&mut self) -> Option<Self::Item> {
7468 let mut region = self.cursor.region()?;
7469 if self.offset == region.range.start {
7470 self.cursor.prev();
7471 region = self.cursor.region()?;
7472 let start_overshoot = self.start.saturating_sub(region.range.start);
7473 self.current_chunks = Some(region.buffer.reversed_chunks_in_range(
7474 region.buffer_range.start + start_overshoot..region.buffer_range.end,
7475 ));
7476 }
7477
7478 if self.offset == region.range.end && region.has_trailing_newline {
7479 self.offset -= 1;
7480 Some("\n")
7481 } else {
7482 let chunk = self.current_chunks.as_mut().unwrap().next()?;
7483 self.offset -= chunk.len();
7484 Some(chunk)
7485 }
7486 }
7487}
7488
7489impl<'a> Iterator for MultiBufferChunks<'a> {
7490 type Item = Chunk<'a>;
7491
7492 fn next(&mut self) -> Option<Chunk<'a>> {
7493 if self.range.start >= self.range.end {
7494 return None;
7495 }
7496 if self.range.start == self.diff_transforms.end(&()).0 {
7497 self.diff_transforms.next(&());
7498 }
7499
7500 let diff_transform_start = self.diff_transforms.start().0;
7501 let diff_transform_end = self.diff_transforms.end(&()).0;
7502 debug_assert!(self.range.start < diff_transform_end);
7503
7504 let diff_transform = self.diff_transforms.item()?;
7505 match diff_transform {
7506 DiffTransform::BufferContent { .. } => {
7507 let chunk = if let Some(chunk) = &mut self.buffer_chunk {
7508 chunk
7509 } else {
7510 let chunk = self.next_excerpt_chunk().unwrap();
7511 self.buffer_chunk.insert(chunk)
7512 };
7513
7514 let chunk_end = self.range.start + chunk.text.len();
7515 let diff_transform_end = diff_transform_end.min(self.range.end);
7516
7517 if diff_transform_end < chunk_end {
7518 let (before, after) =
7519 chunk.text.split_at(diff_transform_end - self.range.start);
7520 self.range.start = diff_transform_end;
7521 chunk.text = after;
7522 Some(Chunk {
7523 text: before,
7524 ..chunk.clone()
7525 })
7526 } else {
7527 self.range.start = chunk_end;
7528 self.buffer_chunk.take()
7529 }
7530 }
7531 DiffTransform::DeletedHunk {
7532 buffer_id,
7533 base_text_byte_range,
7534 has_trailing_newline,
7535 ..
7536 } => {
7537 let base_text_start =
7538 base_text_byte_range.start + self.range.start - diff_transform_start;
7539 let base_text_end =
7540 base_text_byte_range.start + self.range.end - diff_transform_start;
7541 let base_text_end = base_text_end.min(base_text_byte_range.end);
7542
7543 let mut chunks = if let Some((_, mut chunks)) = self
7544 .diff_base_chunks
7545 .take()
7546 .filter(|(id, _)| id == buffer_id)
7547 {
7548 if chunks.range().start != base_text_start || chunks.range().end < base_text_end
7549 {
7550 chunks.seek(base_text_start..base_text_end);
7551 }
7552 chunks
7553 } else {
7554 let base_buffer = &self.diffs.get(&buffer_id)?.base_text();
7555 base_buffer.chunks(base_text_start..base_text_end, self.language_aware)
7556 };
7557
7558 let chunk = if let Some(chunk) = chunks.next() {
7559 self.range.start += chunk.text.len();
7560 self.diff_base_chunks = Some((*buffer_id, chunks));
7561 chunk
7562 } else {
7563 debug_assert!(has_trailing_newline);
7564 self.range.start += "\n".len();
7565 Chunk {
7566 text: "\n",
7567 ..Default::default()
7568 }
7569 };
7570 Some(chunk)
7571 }
7572 }
7573 }
7574}
7575
7576impl MultiBufferBytes<'_> {
7577 fn consume(&mut self, len: usize) {
7578 self.range.start += len;
7579 self.chunk = &self.chunk[len..];
7580
7581 if !self.range.is_empty() && self.chunk.is_empty() {
7582 if let Some(chunk) = self.excerpt_bytes.as_mut().and_then(|bytes| bytes.next()) {
7583 self.chunk = chunk;
7584 } else if self.has_trailing_newline {
7585 self.has_trailing_newline = false;
7586 self.chunk = b"\n";
7587 } else {
7588 self.cursor.next();
7589 if let Some(region) = self.cursor.region() {
7590 let mut excerpt_bytes = region.buffer.bytes_in_range(
7591 region.buffer_range.start
7592 ..(region.buffer_range.start + self.range.end - region.range.start)
7593 .min(region.buffer_range.end),
7594 );
7595 self.chunk = excerpt_bytes.next().unwrap_or(&[]);
7596 self.excerpt_bytes = Some(excerpt_bytes);
7597 self.has_trailing_newline =
7598 region.has_trailing_newline && self.range.end >= region.range.end;
7599 if self.chunk.is_empty() && self.has_trailing_newline {
7600 self.has_trailing_newline = false;
7601 self.chunk = b"\n";
7602 }
7603 }
7604 }
7605 }
7606 }
7607}
7608
7609impl<'a> Iterator for MultiBufferBytes<'a> {
7610 type Item = &'a [u8];
7611
7612 fn next(&mut self) -> Option<Self::Item> {
7613 let chunk = self.chunk;
7614 if chunk.is_empty() {
7615 None
7616 } else {
7617 self.consume(chunk.len());
7618 Some(chunk)
7619 }
7620 }
7621}
7622
7623impl io::Read for MultiBufferBytes<'_> {
7624 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
7625 let len = cmp::min(buf.len(), self.chunk.len());
7626 buf[..len].copy_from_slice(&self.chunk[..len]);
7627 if len > 0 {
7628 self.consume(len);
7629 }
7630 Ok(len)
7631 }
7632}
7633
7634impl io::Read for ReversedMultiBufferBytes<'_> {
7635 fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
7636 let len = cmp::min(buf.len(), self.chunk.len());
7637 buf[..len].copy_from_slice(&self.chunk[..len]);
7638 buf[..len].reverse();
7639 if len > 0 {
7640 self.range.end -= len;
7641 self.chunk = &self.chunk[..self.chunk.len() - len];
7642 if !self.range.is_empty() && self.chunk.is_empty() {
7643 if let Some(chunk) = self.chunks.next() {
7644 self.chunk = chunk.as_bytes();
7645 }
7646 }
7647 }
7648 Ok(len)
7649 }
7650}
7651
7652impl<'a> Iterator for ExcerptChunks<'a> {
7653 type Item = Chunk<'a>;
7654
7655 fn next(&mut self) -> Option<Self::Item> {
7656 if let Some(chunk) = self.content_chunks.next() {
7657 return Some(chunk);
7658 }
7659
7660 if self.footer_height > 0 {
7661 let text = unsafe { str::from_utf8_unchecked(&NEWLINES[..self.footer_height]) };
7662 self.footer_height = 0;
7663 return Some(Chunk {
7664 text,
7665 ..Default::default()
7666 });
7667 }
7668
7669 None
7670 }
7671}
7672
7673impl ToOffset for Point {
7674 fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
7675 snapshot.point_to_offset(*self)
7676 }
7677}
7678
7679impl ToOffset for usize {
7680 #[track_caller]
7681 fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
7682 assert!(*self <= snapshot.len(), "offset is out of range");
7683 *self
7684 }
7685}
7686
7687impl ToOffset for OffsetUtf16 {
7688 fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
7689 snapshot.offset_utf16_to_offset(*self)
7690 }
7691}
7692
7693impl ToOffset for PointUtf16 {
7694 fn to_offset<'a>(&self, snapshot: &MultiBufferSnapshot) -> usize {
7695 snapshot.point_utf16_to_offset(*self)
7696 }
7697}
7698
7699impl ToOffsetUtf16 for OffsetUtf16 {
7700 fn to_offset_utf16(&self, _snapshot: &MultiBufferSnapshot) -> OffsetUtf16 {
7701 *self
7702 }
7703}
7704
7705impl ToOffsetUtf16 for usize {
7706 fn to_offset_utf16(&self, snapshot: &MultiBufferSnapshot) -> OffsetUtf16 {
7707 snapshot.offset_to_offset_utf16(*self)
7708 }
7709}
7710
7711impl ToPoint for usize {
7712 fn to_point<'a>(&self, snapshot: &MultiBufferSnapshot) -> Point {
7713 snapshot.offset_to_point(*self)
7714 }
7715}
7716
7717impl ToPoint for Point {
7718 fn to_point<'a>(&self, _: &MultiBufferSnapshot) -> Point {
7719 *self
7720 }
7721}
7722
7723impl ToPointUtf16 for usize {
7724 fn to_point_utf16<'a>(&self, snapshot: &MultiBufferSnapshot) -> PointUtf16 {
7725 snapshot.offset_to_point_utf16(*self)
7726 }
7727}
7728
7729impl ToPointUtf16 for Point {
7730 fn to_point_utf16<'a>(&self, snapshot: &MultiBufferSnapshot) -> PointUtf16 {
7731 snapshot.point_to_point_utf16(*self)
7732 }
7733}
7734
7735impl ToPointUtf16 for PointUtf16 {
7736 fn to_point_utf16<'a>(&self, _: &MultiBufferSnapshot) -> PointUtf16 {
7737 *self
7738 }
7739}
7740
7741impl From<ExcerptId> for EntityId {
7742 fn from(id: ExcerptId) -> Self {
7743 EntityId::from(id.0 as u64)
7744 }
7745}