Don't throw on merge conflict

Instead of throwing an exception, return the merge error in the normal
way, as this early failure was requested by the user and thus not an
exceptional circunstance.

Author: carlosmn

LibGit2Sharp.Tests/MergeFixture.cs

@@ -301,13 +301,14 @@ public void CanFailOnFirstMergeConflict()
             string path = SandboxMergeTestRepo();
             using (var repo = new Repository(path))
             {
-                var master = repo.Lookup<Commit>("master");
-                var branch = repo.Lookup<Commit>("conflicts");
+                var mergeResult = repo.Merge("conflicts", Constants.Signature, new MergeOptions() { FailOnConflict = true, });
+                Assert.Equal(MergeStatus.Conflicts, mergeResult.Status);
 
-                Assert.Throws<ConflictInMergeException>(() =>
-                {
-                    repo.Merge("conflicts", Constants.Signature, new MergeOptions() { FailOnConflict = true, });
-                });
+                var master = repo.Branches["master"];
+                var branch = repo.Branches["conflicts"];
+                var mergeTreeResult = repo.ObjectDatabase.MergeCommits(master.Tip, branch.Tip, new MergeTreeOptions() { FailOnConflict = true });
+                Assert.Equal(MergeTreeStatus.Conflicts, mergeTreeResult.Status);
+                Assert.Empty(mergeTreeResult.Conflicts);
             }
 
         }

LibGit2Sharp/ConflictInMergeException.cs

@@ -125,7 +125,6 @@ private static readonly Dictionary<GitErrorCode, Func<string, GitErrorCode, GitE
                     { GitErrorCode.UnmergedEntries, (m, r, c) => new UnmergedIndexEntriesException(m, r, c) },
                     { GitErrorCode.NonFastForward, (m, r, c) => new NonFastForwardException(m, r, c) },
                     { GitErrorCode.Conflict, (m, r, c) => new CheckoutConflictException(m, r, c) },
-                    { GitErrorCode.MergeConflict, (m ,r, c) => new ConflictInMergeException(m, r, c) },
                     { GitErrorCode.LockedFile, (m, r, c) => new LockedFileException(m, r, c) },
                     { GitErrorCode.NotFound, (m, r, c) => new NotFoundException(m, r, c) },
                     { GitErrorCode.Peel, (m, r, c) => new PeelException(m, r, c)  },

LibGit2Sharp/Core/Ensure.cs

@@ -1101,11 +1101,19 @@ public static void git_index_clear(Index index)
 
         #region git_merge_
 
-        public static IndexSafeHandle git_merge_commits(RepositorySafeHandle repo, GitObjectSafeHandle ourCommit, GitObjectSafeHandle theirCommit, GitMergeOpts opts)
+        public static IndexSafeHandle git_merge_commits(RepositorySafeHandle repo, GitObjectSafeHandle ourCommit, GitObjectSafeHandle theirCommit, GitMergeOpts opts, out bool earlyStop)
         {
             IndexSafeHandle index;
             int res = NativeMethods.git_merge_commits(out index, repo, ourCommit, theirCommit, ref opts);
-            Ensure.ZeroResult(res);
+            if (res == (int)GitErrorCode.MergeConflict)
+            {
+                earlyStop = true;
+            }
+            else
+            {
+                earlyStop = false;
+                Ensure.ZeroResult(res);
+            }
 
             return index;
         }
@@ -1189,7 +1197,7 @@ public static ObjectId git_annotated_commit_id(GitAnnotatedCommitHandle mergeHea
             return NativeMethods.git_annotated_commit_id(mergeHead).MarshalAsObjectId();
         }
 
-        public static void git_merge(RepositorySafeHandle repo, GitAnnotatedCommitHandle[] heads, GitMergeOpts mergeOptions, GitCheckoutOpts checkoutOptions)
+        public static void git_merge(RepositorySafeHandle repo, GitAnnotatedCommitHandle[] heads, GitMergeOpts mergeOptions, GitCheckoutOpts checkoutOptions, out bool earlyStop)
         {
             IntPtr[] their_heads = heads.Select(head => head.DangerousGetHandle()).ToArray();
 
@@ -1199,7 +1207,15 @@ public static void git_merge(RepositorySafeHandle repo, GitAnnotatedCommitHandle
                                               ref mergeOptions,
                                               ref checkoutOptions);
 
-            Ensure.ZeroResult(res);
+            if (res == (int)GitErrorCode.MergeConflict)
+            {
+                earlyStop = true;
+            }
+            else
+            {
+                earlyStop = false;
+                Ensure.ZeroResult(res);
+            }
         }
 
         public static void git_merge_analysis(

LibGit2Sharp/Core/Proxy.cs

@@ -69,7 +69,6 @@
     <Compile Include="CommitOptions.cs" />
     <Compile Include="CommitSortStrategies.cs" />
     <Compile Include="CompareOptions.cs" />
-    <Compile Include="ConflictInMergeException.cs" />
     <Compile Include="Core\FileHistory.cs" />
     <Compile Include="Core\GitFetchOptions.cs" />
     <Compile Include="Core\GitPushUpdate.cs" />

LibGit2Sharp/LibGit2Sharp.csproj

@@ -23,9 +23,8 @@ protected MergeOptionsBase()
         public bool FindRenames { get; set; }
 
         /// <summary>
-        /// If set, do not create conflict entries but fail the operation. No
-        /// merged index will be created and a <see cref="LibGit2Sharp.ConflictInMergeException"/>
-        /// exception will be thrown.
+        /// If set, do not create or return conflict entries, but stop and return
+        /// an error result after finding the first conflict.
         /// </summary>
         public bool FailOnConflict { get; set; }
 

LibGit2Sharp/MergeOptionsBase.cs

@@ -603,22 +603,41 @@ public virtual MergeTreeResult MergeCommits(Commit ours, Commit theirs, MergeTre
 
             options = options ?? new MergeTreeOptions();
 
+            // We throw away the index after looking at the conflicts, so we'll never need the REUC
+            // entries to be there
+            GitMergeFlag mergeFlags = GitMergeFlag.GIT_MERGE_NORMAL | GitMergeFlag.GIT_MERGE_SKIP_REUC;
+            if (options.FindRenames)
+            {
+                mergeFlags |= GitMergeFlag.GIT_MERGE_FIND_RENAMES;
+            }
+            if (options.FailOnConflict)
+            {
+                mergeFlags |= GitMergeFlag.GIT_MERGE_FAIL_ON_CONFLICT;
+            }
+
+
             var mergeOptions = new GitMergeOpts
             {
                 Version = 1,
                 MergeFileFavorFlags = options.MergeFileFavor,
-                MergeTreeFlags = options.FindRenames ? GitMergeFlag.GIT_MERGE_FIND_RENAMES
-                                                     : GitMergeFlag.GIT_MERGE_NORMAL,
+                MergeTreeFlags = mergeFlags,
                 RenameThreshold = (uint)options.RenameThreshold,
                 TargetLimit = (uint)options.TargetLimit,
             };
 
+            bool earlyStop;
             using (var oneHandle = Proxy.git_object_lookup(repo.Handle, ours.Id, GitObjectType.Commit))
             using (var twoHandle = Proxy.git_object_lookup(repo.Handle, theirs.Id, GitObjectType.Commit))
-            using (var indexHandle = Proxy.git_merge_commits(repo.Handle, oneHandle, twoHandle, mergeOptions))
+            using (var indexHandle = Proxy.git_merge_commits(repo.Handle, oneHandle, twoHandle, mergeOptions, out earlyStop))
             {
                 MergeTreeResult mergeResult;
 
+                // Stopped due to FailOnConflict so there's no index or conflict list
+                if (earlyStop)
+                {
+                    return new MergeTreeResult(new Conflict[] { });
+                }
+
                 if (Proxy.git_index_has_conflicts(indexHandle))
                 {
                     List<Conflict> conflicts = new List<Conflict>();

LibGit2Sharp/ObjectDatabase.cs

@@ -1575,11 +1575,17 @@ private MergeResult NormalMerge(GitAnnotatedCommitHandle[] annotatedCommits, Sig
                 TargetLimit = (uint)options.TargetLimit,
             };
 
+            bool earlyStop;
             using (GitCheckoutOptsWrapper checkoutOptionsWrapper = new GitCheckoutOptsWrapper(options))
             {
                 var checkoutOpts = checkoutOptionsWrapper.Options;
 
-                Proxy.git_merge(Handle, annotatedCommits, mergeOptions, checkoutOpts);
+                Proxy.git_merge(Handle, annotatedCommits, mergeOptions, checkoutOpts, out earlyStop);
+            }
+
+            if (earlyStop)
+            {
+                return new MergeResult(MergeStatus.Conflicts);
             }
 
             if (Index.IsFullyMerged)