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>

Author: maxbrunsfeld

Cargo.lock

@@ -1006,9 +1006,12 @@ impl Context {
         cx: &mut ModelContext<Self>,
     ) {
         match event {
-            language::BufferEvent::Operation(operation) => cx.emit(ContextEvent::Operation(
-                ContextOperation::BufferOperation(operation.clone()),
-            )),
+            language::BufferEvent::Operation {
+                operation,
+                is_local: true,
+            } => cx.emit(ContextEvent::Operation(ContextOperation::BufferOperation(
+                operation.clone(),
+            ))),
             language::BufferEvent::Edited => {
                 self.count_remaining_tokens(cx);
                 self.reparse(cx);

crates/assistant/src/context.rs

@@ -175,7 +175,10 @@ impl ChannelBuffer {
         cx: &mut ModelContext<Self>,
     ) {
         match event {
-            language::BufferEvent::Operation(operation) => {
+            language::BufferEvent::Operation {
+                operation,
+                is_local: true,
+            } => {
                 if *ZED_ALWAYS_ACTIVE {
                     if let language::Operation::UpdateSelections { selections, .. } = operation {
                         if selections.is_empty() {

crates/channel/src/channel_buffer.rs

@@ -9,6 +9,8 @@ use std::{
 
 pub use system_clock::*;
 
+pub const LOCAL_BRANCH_REPLICA_ID: u16 = u16::MAX;
+
 /// A unique identifier for each distributed node.
 pub type ReplicaId = u16;
 
@@ -25,49 +27,62 @@ pub struct Lamport {
 
 /// A [vector clock](https://en.wikipedia.org/wiki/Vector_clock).
 #[derive(Clone, Default, Hash, Eq, PartialEq)]
-pub struct Global(SmallVec<[u32; 8]>);
+pub struct Global {
+    values: SmallVec<[u32; 8]>,
+    local_branch_value: u32,
+}
 
 impl Global {
     pub fn new() -> Self {
         Self::default()
     }
 
     pub fn get(&self, replica_id: ReplicaId) -> Seq {
-        self.0.get(replica_id as usize).copied().unwrap_or(0) as Seq
+        if replica_id == LOCAL_BRANCH_REPLICA_ID {
+            self.local_branch_value
+        } else {
+            self.values.get(replica_id as usize).copied().unwrap_or(0) as Seq
+        }
     }
 
     pub fn observe(&mut self, timestamp: Lamport) {
         if timestamp.value > 0 {
-            let new_len = timestamp.replica_id as usize + 1;
-            if new_len > self.0.len() {
-                self.0.resize(new_len, 0);
+            if timestamp.replica_id == LOCAL_BRANCH_REPLICA_ID {
+                self.local_branch_value = cmp::max(self.local_branch_value, timestamp.value);
+            } else {
+                let new_len = timestamp.replica_id as usize + 1;
+                if new_len > self.values.len() {
+                    self.values.resize(new_len, 0);
+                }
+
+                let entry = &mut self.values[timestamp.replica_id as usize];
+                *entry = cmp::max(*entry, timestamp.value);
             }
-
-            let entry = &mut self.0[timestamp.replica_id as usize];
-            *entry = cmp::max(*entry, timestamp.value);
         }
     }
 
     pub fn join(&mut self, other: &Self) {
-        if other.0.len() > self.0.len() {
-            self.0.resize(other.0.len(), 0);
+        if other.values.len() > self.values.len() {
+            self.values.resize(other.values.len(), 0);
         }
 
-        for (left, right) in self.0.iter_mut().zip(&other.0) {
+        for (left, right) in self.values.iter_mut().zip(&other.values) {
             *left = cmp::max(*left, *right);
         }
+
+        self.local_branch_value = cmp::max(self.local_branch_value, other.local_branch_value);
     }
 
     pub fn meet(&mut self, other: &Self) {
-        if other.0.len() > self.0.len() {
-            self.0.resize(other.0.len(), 0);
+        if other.values.len() > self.values.len() {
+            self.values.resize(other.values.len(), 0);
         }
 
         let mut new_len = 0;
         for (ix, (left, right)) in self
-            .0
+            .values
             .iter_mut()
-            .zip(other.0.iter().chain(iter::repeat(&0)))
+            .zip(other.values.iter().chain(iter::repeat(&0)))
             .enumerate()
         {
             if *left == 0 {
@@ -80,42 +95,53 @@ impl Global {
                 new_len = ix + 1;
             }
         }
-        self.0.resize(new_len, 0);
+        self.values.resize(new_len, 0);
+        self.local_branch_value = cmp::min(self.local_branch_value, other.local_branch_value);
     }
 
     pub fn observed(&self, timestamp: Lamport) -> bool {
         self.get(timestamp.replica_id) >= timestamp.value
     }
 
     pub fn observed_any(&self, other: &Self) -> bool {
-        self.0
+        self.values
             .iter()
-            .zip(other.0.iter())
+            .zip(other.values.iter())
             .any(|(left, right)| *right > 0 && left >= right)
+            || (other.local_branch_value > 0 && self.local_branch_value >= other.local_branch_value)
     }
 
     pub fn observed_all(&self, other: &Self) -> bool {
-        let mut rhs = other.0.iter();
-        self.0.iter().all(|left| match rhs.next() {
+        let mut rhs = other.values.iter();
+        self.values.iter().all(|left| match rhs.next() {
             Some(right) => left >= right,
             None => true,
         }) && rhs.next().is_none()
+            && self.local_branch_value >= other.local_branch_value
     }
 
     pub fn changed_since(&self, other: &Self) -> bool {
-        self.0.len() > other.0.len()
+        self.values.len() > other.values.len()
             || self
-                .0
+                .values
                 .iter()
-                .zip(other.0.iter())
+                .zip(other.values.iter())
                 .any(|(left, right)| left > right)
+            || self.local_branch_value > other.local_branch_value
     }
 
     pub fn iter(&self) -> impl Iterator<Item = Lamport> + '_ {
-        self.0.iter().enumerate().map(|(replica_id, seq)| Lamport {
-            replica_id: replica_id as ReplicaId,
-            value: *seq,
-        })
+        self.values
+            .iter()
+            .enumerate()
+            .map(|(replica_id, seq)| Lamport {
+                replica_id: replica_id as ReplicaId,
+                value: *seq,
+            })
+            .chain((self.local_branch_value > 0).then_some(Lamport {
+                replica_id: LOCAL_BRANCH_REPLICA_ID,
+                value: self.local_branch_value,
+            }))
     }
 }
 
@@ -192,6 +218,9 @@ impl fmt::Debug for Global {
             }
             write!(f, "{}: {}", timestamp.replica_id, timestamp.value)?;
         }
+        if self.local_branch_value > 0 {
+            write!(f, "<branch>: {}", self.local_branch_value)?;
+        }
         write!(f, "}}")
     }
 }

crates/clock/src/clock.rs

@@ -273,6 +273,7 @@ gpui::actions!(
         NextScreen,
         OpenExcerpts,
         OpenExcerptsSplit,
+        OpenProposedChangesEditor,
         OpenFile,
         OpenPermalinkToLine,
         OpenUrl,

crates/editor/src/actions.rs

@@ -35,6 +35,7 @@ mod lsp_ext;
 mod mouse_context_menu;
 pub mod movement;
 mod persistence;
+mod proposed_changes_editor;
 mod rust_analyzer_ext;
 pub mod scroll;
 mod selections_collection;
@@ -46,7 +47,7 @@ mod signature_help;
 #[cfg(any(test, feature = "test-support"))]
 pub mod test;
 
-use ::git::diff::{DiffHunk, DiffHunkStatus};
+use ::git::diff::DiffHunkStatus;
 use ::git::{parse_git_remote_url, BuildPermalinkParams, GitHostingProviderRegistry};
 pub(crate) use actions::*;
 use aho_corasick::AhoCorasick;
@@ -98,6 +99,7 @@ use language::{
 };
 use language::{point_to_lsp, BufferRow, CharClassifier, Runnable, RunnableRange};
 use linked_editing_ranges::refresh_linked_ranges;
+use proposed_changes_editor::{ProposedChangesBuffer, ProposedChangesEditor};
 use similar::{ChangeTag, TextDiff};
 use task::{ResolvedTask, TaskTemplate, TaskVariables};
 
@@ -113,7 +115,9 @@ pub use multi_buffer::{
     Anchor, AnchorRangeExt, ExcerptId, ExcerptRange, MultiBuffer, MultiBufferSnapshot, ToOffset,
     ToPoint,
 };
-use multi_buffer::{ExpandExcerptDirection, MultiBufferPoint, MultiBufferRow, ToOffsetUtf16};
+use multi_buffer::{
+    ExpandExcerptDirection, MultiBufferDiffHunk, MultiBufferPoint, MultiBufferRow, ToOffsetUtf16,
+};
 use ordered_float::OrderedFloat;
 use parking_lot::{Mutex, RwLock};
 use project::project_settings::{GitGutterSetting, ProjectSettings};
@@ -6152,7 +6156,7 @@ impl Editor {
     pub fn prepare_revert_change(
         revert_changes: &mut HashMap<BufferId, Vec<(Range<text::Anchor>, Rope)>>,
         multi_buffer: &Model<MultiBuffer>,
-        hunk: &DiffHunk<MultiBufferRow>,
+        hunk: &MultiBufferDiffHunk,
         cx: &AppContext,
     ) -> Option<()> {
         let buffer = multi_buffer.read(cx).buffer(hunk.buffer_id)?;
@@ -9338,7 +9342,7 @@ impl Editor {
         snapshot: &DisplaySnapshot,
         initial_point: Point,
         is_wrapped: bool,
-        hunks: impl Iterator<Item = DiffHunk<MultiBufferRow>>,
+        hunks: impl Iterator<Item = MultiBufferDiffHunk>,
         cx: &mut ViewContext<Editor>,
     ) -> bool {
         let display_point = initial_point.to_display_point(snapshot);
@@ -11885,6 +11889,52 @@ impl Editor {
         self.searchable
     }
 
+    fn open_proposed_changes_editor(
+        &mut self,
+        _: &OpenProposedChangesEditor,
+        cx: &mut ViewContext<Self>,
+    ) {
+        let Some(workspace) = self.workspace() else {
+            cx.propagate();
+            return;
+        };
+
+        let buffer = self.buffer.read(cx);
+        let mut new_selections_by_buffer = HashMap::default();
+        for selection in self.selections.all::<usize>(cx) {
+            for (buffer, mut range, _) in
+                buffer.range_to_buffer_ranges(selection.start..selection.end, cx)
+            {
+                if selection.reversed {
+                    mem::swap(&mut range.start, &mut range.end);
+                }
+                let mut range = range.to_point(buffer.read(cx));
+                range.start.column = 0;
+                range.end.column = buffer.read(cx).line_len(range.end.row);
+                new_selections_by_buffer
+                    .entry(buffer)
+                    .or_insert(Vec::new())
+                    .push(range)
+            }
+        }
+
+        let proposed_changes_buffers = new_selections_by_buffer
+            .into_iter()
+            .map(|(buffer, ranges)| ProposedChangesBuffer { buffer, ranges })
+            .collect::<Vec<_>>();
+        let proposed_changes_editor = cx.new_view(|cx| {
+            ProposedChangesEditor::new(proposed_changes_buffers, self.project.clone(), cx)
+        });
+
+        cx.window_context().defer(move |cx| {
+            workspace.update(cx, |workspace, cx| {
+                workspace.active_pane().update(cx, |pane, cx| {
+                    pane.add_item(Box::new(proposed_changes_editor), true, true, None, cx);
+                });
+            });
+        });
+    }
+
     fn open_excerpts_in_split(&mut self, _: &OpenExcerptsSplit, cx: &mut ViewContext<Self>) {
         self.open_excerpts_common(true, cx)
     }
@@ -12399,7 +12449,7 @@ impl Editor {
 fn hunks_for_selections(
     multi_buffer_snapshot: &MultiBufferSnapshot,
     selections: &[Selection<Anchor>],
-) -> Vec<DiffHunk<MultiBufferRow>> {
+) -> Vec<MultiBufferDiffHunk> {
     let buffer_rows_for_selections = selections.iter().map(|selection| {
         let head = selection.head();
         let tail = selection.tail();
@@ -12418,7 +12468,7 @@ fn hunks_for_selections(
 pub fn hunks_for_rows(
     rows: impl Iterator<Item = Range<MultiBufferRow>>,
     multi_buffer_snapshot: &MultiBufferSnapshot,
-) -> Vec<DiffHunk<MultiBufferRow>> {
+) -> Vec<MultiBufferDiffHunk> {
     let mut hunks = Vec::new();
     let mut processed_buffer_rows: HashMap<BufferId, HashSet<Range<text::Anchor>>> =
         HashMap::default();
@@ -12430,14 +12480,14 @@ pub fn hunks_for_rows(
             // when the caret is just above or just below the deleted hunk.
             let allow_adjacent = hunk_status(&hunk) == DiffHunkStatus::Removed;
             let related_to_selection = if allow_adjacent {
-                hunk.associated_range.overlaps(&query_rows)
-                    || hunk.associated_range.start == query_rows.end
-                    || hunk.associated_range.end == query_rows.start
+                hunk.row_range.overlaps(&query_rows)
+                    || hunk.row_range.start == query_rows.end
+                    || hunk.row_range.end == query_rows.start
             } else {
                 // `selected_multi_buffer_rows` are inclusive (e.g. [2..2] means 2nd row is selected)
-                // `hunk.associated_range` is exclusive (e.g. [2..3] means 2nd row is selected)
-                hunk.associated_range.overlaps(&selected_multi_buffer_rows)
-                    || selected_multi_buffer_rows.end == hunk.associated_range.start
+                // `hunk.row_range` is exclusive (e.g. [2..3] means 2nd row is selected)
+                hunk.row_range.overlaps(&selected_multi_buffer_rows)
+                    || selected_multi_buffer_rows.end == hunk.row_range.start
             };
             if related_to_selection {
                 if !processed_buffer_rows
@@ -13738,10 +13788,10 @@ impl RowRangeExt for Range<DisplayRow> {
     }
 }
 
-fn hunk_status(hunk: &DiffHunk<MultiBufferRow>) -> DiffHunkStatus {
+fn hunk_status(hunk: &MultiBufferDiffHunk) -> DiffHunkStatus {
     if hunk.diff_base_byte_range.is_empty() {
         DiffHunkStatus::Added
-    } else if hunk.associated_range.is_empty() {
+    } else if hunk.row_range.is_empty() {
         DiffHunkStatus::Removed
     } else {
         DiffHunkStatus::Modified

crates/editor/src/editor.rs

@@ -346,6 +346,7 @@ impl EditorElement {
         register_action(view, cx, Editor::toggle_code_actions);
         register_action(view, cx, Editor::open_excerpts);
         register_action(view, cx, Editor::open_excerpts_in_split);
+        register_action(view, cx, Editor::open_proposed_changes_editor);
         register_action(view, cx, Editor::toggle_soft_wrap);
         register_action(view, cx, Editor::toggle_tab_bar);
         register_action(view, cx, Editor::toggle_line_numbers);
@@ -3710,11 +3711,11 @@ impl EditorElement {
                                     )
                                     .map(|hunk| {
                                         let start_display_row =
-                                            MultiBufferPoint::new(hunk.associated_range.start.0, 0)
+                                            MultiBufferPoint::new(hunk.row_range.start.0, 0)
                                                 .to_display_point(&snapshot.display_snapshot)
                                                 .row();
                                         let mut end_display_row =
-                                            MultiBufferPoint::new(hunk.associated_range.end.0, 0)
+                                            MultiBufferPoint::new(hunk.row_range.end.0, 0)
                                                 .to_display_point(&snapshot.display_snapshot)
                                                 .row();
                                         if end_display_row != start_display_row {