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