temp(repo): Correctly report merge conflicts while amending

Is this needed? Can we just use CherryPickFastError?

Author: claytonrcarter

git-branchless-lib/src/core/rewrite/execute.rs

@@ -435,8 +435,8 @@ mod in_memory {
     use crate::core::rewrite::move_branches;
     use crate::core::rewrite::plan::{OidOrLabel, RebaseCommand, RebasePlan};
     use crate::git::{
-        AmendFastOptions, CherryPickFastError, CherryPickFastOptions, GitRunInfo, MaybeZeroOid,
-        NonZeroOid, Repo,
+        AmendFastError, AmendFastOptions, CherryPickFastError, CherryPickFastOptions, GitRunInfo,
+        MaybeZeroOid, NonZeroOid, Repo,
     };
     use crate::util::EyreExitOr;
 
@@ -651,12 +651,23 @@ mod in_memory {
                                 Err(other) => eyre::bail!(other),
                             }
                         } else {
-                            repo.amend_fast(
+                            match repo.amend_fast(
                                 &rebased_commit.expect("rebased commit should not be None"),
                                 &AmendFastOptions::FromCommit {
                                     commit: commit_to_apply,
                                 },
-                            )?
+                            ) {
+                                Ok(amended_tree) => amended_tree,
+                                Err(AmendFastError::MergeConflict { conflicting_paths }) => {
+                                    return Ok(RebaseInMemoryResult::MergeFailed(
+                                        FailedMergeInfo::Conflict {
+                                            commit_oid: *commit_oid,
+                                            conflicting_paths,
+                                        },
+                                    ))
+                                }
+                                Err(other) => eyre::bail!(other),
+                            }
                         };
 
                         // FIXME should this be the description of this fixup commit or the original commit?

git-branchless-lib/src/git/mod.rs

@@ -22,7 +22,7 @@ pub use reference::{
     Branch, BranchType, CategorizedReferenceName, Reference, ReferenceName, ReferenceTarget,
 };
 pub use repo::{
-    message_prettify, AmendFastOptions, CherryPickFastError, CherryPickFastOptions,
+    message_prettify, AmendFastError, AmendFastOptions, CherryPickFastError, CherryPickFastOptions,
     Error as RepoError, GitVersion, PatchId, Repo, ResolvedReferenceInfo, Result as RepoResult,
     Time,
 };

git-branchless-lib/src/git/repo.rs

@@ -444,6 +444,37 @@ pub enum AmendFastOptions<'repo> {
     },
 }
 
+/// An error was raised when attempting the `Repo::amend_fast` operation.
+#[allow(missing_docs)]
+#[derive(Debug, Error)]
+pub enum AmendFastError {
+    /// A merge conflict occurred, so the amend could not continue.
+    #[error("merge conflict in {} paths", conflicting_paths.len())]
+    MergeConflict {
+        /// The paths that were in conflict.
+        conflicting_paths: HashSet<PathBuf>,
+    },
+
+    #[error("could not get paths touched by commit {commit}")]
+    GetPatch { commit: NonZeroOid },
+
+    #[error("could not get conflicts generated by cherry-pick of {commit} onto {onto}: {source}")]
+    GetConflicts {
+        source: git2::Error,
+        commit: NonZeroOid,
+        onto: NonZeroOid,
+    },
+
+    #[error(transparent)]
+    HydrateTree(tree::Error),
+
+    #[error(transparent)]
+    Repo(#[from] Error),
+
+    #[error(transparent)]
+    Git(git2::Error),
+}
+
 impl<'repo> AmendFastOptions<'repo> {
     /// Returns whether there are any paths to be amended.
     pub fn is_empty(&self) -> bool {
@@ -740,6 +771,18 @@ impl Repo {
     /// If the commit has more than one parent, returns `None`.
     #[instrument]
     pub fn get_patch_for_commit(&self, effects: &Effects, commit: &Commit) -> Result<Option<Diff>> {
+        self.get_patch_for_commit_inner(effects, commit, 3)
+    }
+
+    /// Get a patch for a commit with a specific amount of context.
+    ///
+    /// If the commit has more than one parent, returns `None`.
+    fn get_patch_for_commit_inner(
+        &self,
+        effects: &Effects,
+        commit: &Commit,
+        num_context_lines: usize,
+    ) -> Result<Option<Diff>> {
         let changed_paths = match self.get_paths_touched_by_commit(commit)? {
             None => return Ok(None),
             Some(changed_paths) => changed_paths,
@@ -760,7 +803,12 @@ impl Repo {
             None => None,
         };
         let current_tree = dehydrated_commit.get_tree()?;
-        let diff = self.get_diff_between_trees(effects, parent_tree.as_ref(), &current_tree, 3)?;
+        let diff = self.get_diff_between_trees(
+            effects,
+            parent_tree.as_ref(),
+            &current_tree,
+            num_context_lines,
+        )?;
         Ok(Some(diff))
     }
 
@@ -1425,10 +1473,14 @@ impl Repo {
     /// See `Repo::cherry_pick_fast` for motivation for performing the operation
     /// in-memory.
     #[instrument]
-    pub fn amend_fast(&self, parent_commit: &Commit, opts: &AmendFastOptions) -> Result<Tree> {
+    pub fn amend_fast(
+        &self,
+        parent_commit: &Commit,
+        opts: &AmendFastOptions,
+    ) -> std::result::Result<Tree, AmendFastError> {
         let parent_commit_pathbufs = self
             .get_paths_touched_by_commit(parent_commit)?
-            .ok_or_else(|| Error::GetPatch {
+            .ok_or_else(|| AmendFastError::GetPatch {
                 commit: parent_commit.get_oid(),
             })?
             .into_iter()