Add an apply button to hunks in proposed changes editor

crates/editor/src/actions.rs

@@ -193,6 +193,7 @@ gpui::actions!(
         AcceptPartialInlineCompletion,
         AddSelectionAbove,
         AddSelectionBelow,
+        ApplyDiffHunk,
         Backspace,
         Cancel,
         CancelLanguageServerWork,

crates/editor/src/editor.rs

@@ -6205,6 +6205,20 @@ impl Editor {
         }
     }
 
+    fn apply_selected_diff_hunks(&mut self, _: &ApplyDiffHunk, cx: &mut ViewContext<Self>) {
+        let snapshot = self.buffer.read(cx).snapshot(cx);
+        let hunks = hunks_for_selections(&snapshot, &self.selections.disjoint_anchors());
+        self.transact(cx, |editor, cx| {
+            for hunk in hunks {
+                if let Some(buffer) = editor.buffer.read(cx).buffer(hunk.buffer_id) {
+                    buffer.update(cx, |buffer, cx| {
+                        buffer.merge_into_base(Some(hunk.buffer_range.to_offset(buffer)), cx);
+                    });
+                }
+            }
+        });
+    }
+
     pub fn open_active_item_in_terminal(&mut self, _: &OpenInTerminal, cx: &mut ViewContext<Self>) {
         if let Some(working_directory) = self.active_excerpt(cx).and_then(|(_, buffer, _)| {
             let project_path = buffer.read(cx).project_path(cx)?;

crates/editor/src/element.rs

@@ -436,6 +436,7 @@ impl EditorElement {
         register_action(view, cx, Editor::accept_inline_completion);
         register_action(view, cx, Editor::revert_file);
         register_action(view, cx, Editor::revert_selected_hunks);
+        register_action(view, cx, Editor::apply_selected_diff_hunks);
         register_action(view, cx, Editor::open_active_item_in_terminal)
     }
 

crates/editor/src/proposed_changes_editor.rs

@@ -18,7 +18,7 @@ pub struct ProposedChangesEditor {
     editor: View<Editor>,
     _subscriptions: Vec<Subscription>,
     _recalculate_diffs_task: Task<Option<()>>,
-    recalculate_diffs_tx: mpsc::UnboundedSender<Model<Buffer>>,
+    recalculate_diffs_tx: mpsc::UnboundedSender<RecalculateDiff>,
 }
 
 pub struct ProposedChangesBuffer<T> {
@@ -30,6 +30,11 @@ pub struct ProposedChangesEditorToolbar {
     current_editor: Option<View<ProposedChangesEditor>>,
 }
 
+struct RecalculateDiff {
+    buffer: Model<Buffer>,
+    debounce: bool,
+}
+
 impl ProposedChangesEditor {
     pub fn new<T: ToOffset>(
         buffers: Vec<ProposedChangesBuffer<T>>,
@@ -63,16 +68,18 @@ impl ProposedChangesEditor {
             recalculate_diffs_tx,
             _recalculate_diffs_task: cx.spawn(|_, mut cx| async move {
                 let mut buffers_to_diff = HashSet::default();
-                while let Some(buffer) = recalculate_diffs_rx.next().await {
-                    buffers_to_diff.insert(buffer);
+                while let Some(mut recalculate_diff) = recalculate_diffs_rx.next().await {
+                    buffers_to_diff.insert(recalculate_diff.buffer);
 
-                    loop {
+                    while recalculate_diff.debounce {
                         cx.background_executor()
                             .timer(Duration::from_millis(250))
                             .await;
                         let mut had_further_changes = false;
-                        while let Ok(next_buffer) = recalculate_diffs_rx.try_next() {
-                            buffers_to_diff.insert(next_buffer?);
+                        while let Ok(next_recalculate_diff) = recalculate_diffs_rx.try_next() {
+                            let next_recalculate_diff = next_recalculate_diff?;
+                            recalculate_diff.debounce &= next_recalculate_diff.debounce;
+                            buffers_to_diff.insert(next_recalculate_diff.buffer);
                             had_further_changes = true;
                         }
                         if !had_further_changes {
@@ -99,19 +106,24 @@ impl ProposedChangesEditor {
         event: &BufferEvent,
         _cx: &mut ViewContext<Self>,
     ) {
-        if let BufferEvent::Edited = event {
-            self.recalculate_diffs_tx.unbounded_send(buffer).ok();
-        }
-    }
-
-    fn apply_all_changes(&self, cx: &mut ViewContext<Self>) {
-        let buffers = self.editor.read(cx).buffer.read(cx).all_buffers();
-        for branch_buffer in buffers {
-            if let Some(base_buffer) = branch_buffer.read(cx).diff_base_buffer() {
-                base_buffer.update(cx, |base_buffer, cx| {
-                    base_buffer.merge(&branch_buffer, None, cx)
-                });
+        match event {
+            BufferEvent::Operation { .. } => {
+                self.recalculate_diffs_tx
+                    .unbounded_send(RecalculateDiff {
+                        buffer,
+                        debounce: true,
+                    })
+                    .ok();
+            }
+            BufferEvent::DiffBaseChanged => {
+                self.recalculate_diffs_tx
+                    .unbounded_send(RecalculateDiff {
+                        buffer,
+                        debounce: false,
+                    })
+                    .ok();
             }
+            _ => (),
         }
     }
 }
@@ -188,7 +200,9 @@ impl Render for ProposedChangesEditorToolbar {
         Button::new("apply-changes", "Apply All").on_click(move |_, cx| {
             if let Some(editor) = &editor {
                 editor.update(cx, |editor, cx| {
-                    editor.apply_all_changes(cx);
+                    editor.editor.update(cx, |editor, cx| {
+                        editor.apply_all_changes(cx);
+                    })
                 });
             }
         })

crates/language/src/buffer.rs

@@ -62,7 +62,7 @@ pub use text::{
 use theme::SyntaxTheme;
 #[cfg(any(test, feature = "test-support"))]
 use util::RandomCharIter;
-use util::RangeExt;
+use util::{debug_panic, RangeExt};
 
 #[cfg(any(test, feature = "test-support"))]
 pub use {tree_sitter_rust, tree_sitter_typescript};
@@ -823,40 +823,41 @@ impl Buffer {
         })
     }
 
-    /// Applies all of the changes in `branch` buffer that intersect the given `range`
-    /// to this buffer.
-    pub fn merge(
-        &mut self,
-        branch: &Model<Self>,
-        range: Option<Range<Anchor>>,
-        cx: &mut ModelContext<Self>,
-    ) {
-        let edits = branch.read_with(cx, |branch, _| {
-            branch
-                .edits_since_in_range::<usize>(
-                    &self.version,
-                    range.unwrap_or(Anchor::MIN..Anchor::MAX),
-                )
-                .map(|edit| {
-                    (
-                        edit.old,
-                        branch.text_for_range(edit.new).collect::<String>(),
-                    )
+    /// Applies all of the changes in this buffer that intersect the given `range`
+    /// to its base buffer. This buffer must be a branch buffer to call this method.
+    pub fn merge_into_base(&mut self, range: Option<Range<usize>>, cx: &mut ModelContext<Self>) {
+        let Some(base_buffer) = self.diff_base_buffer() else {
+            debug_panic!("not a branch buffer");
+            return;
+        };
+
+        base_buffer.update(cx, |base_buffer, cx| {
+            let edits = self
+                .edits_since::<usize>(&base_buffer.version)
+                .filter_map(|edit| {
+                    if range
+                        .as_ref()
+                        .map_or(true, |range| range.overlaps(&edit.new))
+                    {
+                        Some((edit.old, self.text_for_range(edit.new).collect::<String>()))
+                    } else {
+                        None
+                    }
                 })
-                .collect::<Vec<_>>()
-        });
-        let operation = self.edit(edits, None, cx);
+                .collect::<Vec<_>>();
+
+            let operation = base_buffer.edit(edits, None, cx);
 
-        // Prevent this operation from being reapplied to the branch.
-        branch.update(cx, |branch, cx| {
+            // Prevent this operation from being reapplied to the branch.
             if let Some(BufferDiffBase::PastBufferVersion {
                 operations_to_ignore,
                 ..
-            }) = &mut branch.diff_base
+            }) = &mut self.diff_base
             {
                 operations_to_ignore.extend(operation);
             }
-            cx.emit(BufferEvent::Edited)
+
+            cx.emit(BufferEvent::DiffBaseChanged);
         });
     }
 

crates/language/src/buffer_tests.rs

@@ -2471,8 +2471,8 @@ fn test_branch_and_merge(cx: &mut TestAppContext) {
     });
 
     // Merging the branch applies all of its changes to the base.
-    base_buffer.update(cx, |base_buffer, cx| {
-        base_buffer.merge(&branch_buffer, None, cx);
+    branch_buffer.update(cx, |branch_buffer, cx| {
+        branch_buffer.merge_into_base(None, cx);
     });
 
     branch_buffer.update(cx, |branch_buffer, cx| {
@@ -2484,6 +2484,18 @@ fn test_branch_and_merge(cx: &mut TestAppContext) {
     });
 }
 
+#[gpui::test]
+fn test_merge_into_base(cx: &mut AppContext) {
+    init_settings(cx, |_| {});
+    let base = cx.new_model(|cx| Buffer::local("abcdefghijk", cx));
+    let branch = base.update(cx, |buffer, cx| buffer.branch(cx));
+    branch.update(cx, |branch, cx| {
+        branch.edit([(0..3, "ABC"), (7..9, "HI")], None, cx);
+        branch.merge_into_base(Some(5..8), cx);
+    });
+    assert_eq!(base.read(cx).text(), "abcdefgHIjk");
+}
+
 fn start_recalculating_diff(buffer: &Model<Buffer>, cx: &mut TestAppContext) {
     buffer
         .update(cx, |buffer, cx| buffer.recalculate_diff(cx).unwrap())