Add the ability to propose changes to a set of buffers (#18170)

This PR introduces functionality for creating *branches* of buffers that
can be used to preview and edit change sets that haven't yet been
applied to the buffers themselves.

Release Notes:

- N/A

---------

Co-authored-by: Marshall Bowers <elliott.codes@gmail.com>
Co-authored-by: Marshall <marshall@zed.dev>

crates/git/src/diff.rs

@@ -1,7 +1,7 @@
 use rope::Rope;
 use std::{iter, ops::Range};
 use sum_tree::SumTree;
-use text::{Anchor, BufferId, BufferSnapshot, OffsetRangeExt, Point};
+use text::{Anchor, BufferSnapshot, OffsetRangeExt, Point};
 
 pub use git2 as libgit;
 use libgit::{DiffLineType as GitDiffLineType, DiffOptions as GitOptions, Patch as GitPatch};
@@ -13,29 +13,30 @@ pub enum DiffHunkStatus {
     Removed,
 }
 
-/// A diff hunk, representing a range of consequent lines in a singleton buffer, associated with a generic range.
+/// A diff hunk resolved to rows in the buffer.
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct DiffHunk<T> {
-    /// E.g. a range in multibuffer, that has an excerpt added, singleton buffer for which has this diff hunk.
-    /// Consider a singleton buffer with 10 lines, all of them are modified — so a corresponding diff hunk would have a range 0..10.
-    /// And a multibuffer with the excerpt of lines 2-6 from the singleton buffer.
-    /// If the multibuffer is searched for diff hunks, the associated range would be multibuffer rows, corresponding to rows 2..6 from the singleton buffer.
-    /// But the hunk range would be 0..10, same for any other excerpts from the same singleton buffer.
-    pub associated_range: Range<T>,
-    /// Singleton buffer ID this hunk belongs to.
-    pub buffer_id: BufferId,
-    /// A consequent range of lines in the singleton buffer, that were changed and produced this diff hunk.
+pub struct DiffHunk {
+    /// The buffer range, expressed in terms of rows.
+    pub row_range: Range<u32>,
+    /// The range in the buffer to which this hunk corresponds.
     pub buffer_range: Range<Anchor>,
-    /// Original singleton buffer text before the change, that was instead of the `buffer_range`.
+    /// The range in the buffer's diff base text to which this hunk corresponds.
     pub diff_base_byte_range: Range<usize>,
 }
 
-impl sum_tree::Item for DiffHunk<Anchor> {
+/// We store [`InternalDiffHunk`]s internally so we don't need to store the additional row range.
+#[derive(Debug, Clone)]
+struct InternalDiffHunk {
+    buffer_range: Range<Anchor>,
+    diff_base_byte_range: Range<usize>,
+}
+
+impl sum_tree::Item for InternalDiffHunk {
     type Summary = DiffHunkSummary;
 
     fn summary(&self) -> Self::Summary {
         DiffHunkSummary {
-            buffer_range: self.associated_range.clone(),
+            buffer_range: self.buffer_range.clone(),
         }
     }
 }
@@ -64,7 +65,7 @@ impl sum_tree::Summary for DiffHunkSummary {
 #[derive(Debug, Clone)]
 pub struct BufferDiff {
     last_buffer_version: Option<clock::Global>,
-    tree: SumTree<DiffHunk<Anchor>>,
+    tree: SumTree<InternalDiffHunk>,
 }
 
 impl BufferDiff {
@@ -79,11 +80,12 @@ impl BufferDiff {
         self.tree.is_empty()
     }
 
+    #[cfg(any(test, feature = "test-support"))]
     pub fn hunks_in_row_range<'a>(
         &'a self,
         range: Range<u32>,
         buffer: &'a BufferSnapshot,
-    ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
+    ) -> impl 'a + Iterator<Item = DiffHunk> {
         let start = buffer.anchor_before(Point::new(range.start, 0));
         let end = buffer.anchor_after(Point::new(range.end, 0));
 
@@ -94,7 +96,7 @@ impl BufferDiff {
         &'a self,
         range: Range<Anchor>,
         buffer: &'a BufferSnapshot,
-    ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
+    ) -> impl 'a + Iterator<Item = DiffHunk> {
         let mut cursor = self
             .tree
             .filter::<_, DiffHunkSummary>(buffer, move |summary| {
@@ -109,11 +111,8 @@ impl BufferDiff {
         })
         .flat_map(move |hunk| {
             [
-                (
-                    &hunk.associated_range.start,
-                    hunk.diff_base_byte_range.start,
-                ),
-                (&hunk.associated_range.end, hunk.diff_base_byte_range.end),
+                (&hunk.buffer_range.start, hunk.diff_base_byte_range.start),
+                (&hunk.buffer_range.end, hunk.diff_base_byte_range.end),
             ]
             .into_iter()
         });
@@ -129,10 +128,9 @@ impl BufferDiff {
             }
 
             Some(DiffHunk {
-                associated_range: start_point.row..end_point.row,
+                row_range: start_point.row..end_point.row,
                 diff_base_byte_range: start_base..end_base,
                 buffer_range: buffer.anchor_before(start_point)..buffer.anchor_after(end_point),
-                buffer_id: buffer.remote_id(),
             })
         })
     }
@@ -141,7 +139,7 @@ impl BufferDiff {
         &'a self,
         range: Range<Anchor>,
         buffer: &'a BufferSnapshot,
-    ) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
+    ) -> impl 'a + Iterator<Item = DiffHunk> {
         let mut cursor = self
             .tree
             .filter::<_, DiffHunkSummary>(buffer, move |summary| {
@@ -154,7 +152,7 @@ impl BufferDiff {
             cursor.prev(buffer);
 
             let hunk = cursor.item()?;
-            let range = hunk.associated_range.to_point(buffer);
+            let range = hunk.buffer_range.to_point(buffer);
             let end_row = if range.end.column > 0 {
                 range.end.row + 1
             } else {
@@ -162,10 +160,9 @@ impl BufferDiff {
             };
 
             Some(DiffHunk {
-                associated_range: range.start.row..end_row,
+                row_range: range.start.row..end_row,
                 diff_base_byte_range: hunk.diff_base_byte_range.clone(),
                 buffer_range: hunk.buffer_range.clone(),
-                buffer_id: hunk.buffer_id,
             })
         })
     }
@@ -196,7 +193,7 @@ impl BufferDiff {
     }
 
     #[cfg(test)]
-    fn hunks<'a>(&'a self, text: &'a BufferSnapshot) -> impl 'a + Iterator<Item = DiffHunk<u32>> {
+    fn hunks<'a>(&'a self, text: &'a BufferSnapshot) -> impl 'a + Iterator<Item = DiffHunk> {
         let start = text.anchor_before(Point::new(0, 0));
         let end = text.anchor_after(Point::new(u32::MAX, u32::MAX));
         self.hunks_intersecting_range(start..end, text)
@@ -229,7 +226,7 @@ impl BufferDiff {
         hunk_index: usize,
         buffer: &text::BufferSnapshot,
         buffer_row_divergence: &mut i64,
-    ) -> DiffHunk<Anchor> {
+    ) -> InternalDiffHunk {
         let line_item_count = patch.num_lines_in_hunk(hunk_index).unwrap();
         assert!(line_item_count > 0);
 
@@ -284,11 +281,9 @@ impl BufferDiff {
         let start = Point::new(buffer_row_range.start, 0);
         let end = Point::new(buffer_row_range.end, 0);
         let buffer_range = buffer.anchor_before(start)..buffer.anchor_before(end);
-        DiffHunk {
-            associated_range: buffer_range.clone(),
+        InternalDiffHunk {
             buffer_range,
             diff_base_byte_range,
-            buffer_id: buffer.remote_id(),
         }
     }
 }
@@ -302,17 +297,16 @@ pub fn assert_hunks<Iter>(
     diff_base: &str,
     expected_hunks: &[(Range<u32>, &str, &str)],
 ) where
-    Iter: Iterator<Item = DiffHunk<u32>>,
+    Iter: Iterator<Item = DiffHunk>,
 {
     let actual_hunks = diff_hunks
         .map(|hunk| {
             (
-                hunk.associated_range.clone(),
+                hunk.row_range.clone(),
                 &diff_base[hunk.diff_base_byte_range],
                 buffer
                     .text_for_range(
-                        Point::new(hunk.associated_range.start, 0)
-                            ..Point::new(hunk.associated_range.end, 0),
+                        Point::new(hunk.row_range.start, 0)..Point::new(hunk.row_range.end, 0),
                     )
                     .collect::<String>(),
             )