git-debrebase: keycommits: Handle merged-breakwater commits

[dgit.git] / git-debrebase

diff --git a/git-debrebase b/git-debrebase
index c463f4ace5e2c5ba319d815291b922ce0780e540..672551d5e921ea30ad7728952b2602e5e98c7299 100755 (executable)
--- a/git-debrebase
+++ b/git-debrebase
@@ -810,8 +810,23 @@ sub classify ($) {
     return $classify->("VanillaMerge");
 }
 
-sub keycommits ($;$$$$) {
-    my ($head, $furniture, $unclean, $trouble, $fatal) = @_;
+sub keycommits ($;$$$$$);
+
+sub mergedbreakwaters_anchor ($) {
+    my ($cl) = @_;
+    my $best_anchor;
+    foreach my $p (@{ $cl->{Parents} }) {
+       my ($panchor, $pbw) = keycommits $p->{CommitId},
+           undef,undef,undef,undef, 1;
+       $best_anchor = $panchor
+           if !defined $best_anchor
+           or is_fast_fwd $best_anchor, $panchor;
+    }
+    return $best_anchor;
+}
+
+sub keycommits ($;$$$$$) {
+    my ($head, $furniture, $unclean, $trouble, $fatal, $claimed_bw) = @_;
     # => ($anchor, $breakwater)
 
     # $unclean->("unclean-$tagsfx", $msg, $cl)
@@ -827,6 +842,8 @@ sub keycommits ($;$$$$) {
     # $fatal is for unprocessable commits, and should normally cause
     #    a failure.  If ignored, agaion, (undef, undef) is returned.
     #
+    # If $claimed_bw, this is supposed to be a breakwater commit.
+    #
     # If a callback is undef, fail is called instead.
     # If a callback is defined but false, the situation is ignored.
     # Callbacks may say:
@@ -834,6 +851,7 @@ sub keycommits ($;$$$$) {
     # if the answer is no longer wanted.
 
     my ($anchor, $breakwater);
+    $breakwater = $head if $claimed_bw;
     my $clogonly;
     my $cl;
     my $found_pm;
@@ -846,6 +864,13 @@ sub keycommits ($;$$$$) {
        return unless $cb;
        $cb->("unclean-$tagsfx", $why, $cl, $mainwhy);
     };
+    my $found_anchor = sub {
+       ($anchor) = @_;
+       $breakwater //= $clogonly;
+       $breakwater //= $head;
+       no warnings qw(exiting);
+       last;
+    };
     for (;;) {
        $cl = classify $head;
        my $ty = $cl->{Type};
@@ -859,10 +884,7 @@ sub keycommits ($;$$$$) {
        } elsif ($ty eq 'Anchor' or
                 $ty eq 'TreatAsAnchor' or
                 $ty eq 'BreakwaterStart') {
-           $anchor = $head;
-           $breakwater //= $clogonly;
-           $breakwater //= $head;
-           last;
+           $found_anchor->($head);
        } elsif ($ty eq 'Upstream') {
            $x->($unclean, 'ordering',
  "packaging change ($breakwater) follows upstream change"," (eg $head)")
@@ -894,6 +916,8 @@ sub keycommits ($;$$$$) {
            $x->($trouble, 'vanillamerge',
                 "found vanilla merge"," ($head)");
            return (undef,undef);
+       } elsif ($ty eq 'MergedBreakwaters') {
+           $found_anchor->(mergedbreakwaters_anchor $cl);
        } else {
            $x->($fatal, 'unprocessable',
                 "found unprocessable commit, cannot cope: $cl->{Why}",
@@ -1082,8 +1106,16 @@ sub walk ($;$$$) {
            }
            die "$ty ?";
        } elsif ($ty eq 'VanillaMerge' or $ty eq 'MergedBreakwaters') {
-           # xxx need to handle ffq if one side was unstitched
-           # wait both of them may be!
+           # User may have merged unstitched branch(es).  We will
+           # have now lost what ffq-prev was then (since the later
+           # pseudomerge may introduce further changes).  The effect
+           # of resolving such a merge is that we may have to go back
+           # further in history to find a merge base, since the one
+           # which was reachable via ffq-prev is no longer findable.
+           # This is suboptimal, but if it all works we'll have done
+           # the right thing.
+           # xxx we should warn the user in the docs about this
+
            my $ok=1;
            my $best_anchor;
            # We expect to find a dominating anchor amongst the
@@ -1207,7 +1239,8 @@ sub walk ($;$$$) {
            push @brw_cl, {
                 %$cl,
                 SpecialMethod => 'MergeCreateMergedBreakwaters',
-                $xmsg->('construct merged breakwater from vanilla merge'),
+                $xmsg->('constructed from vanilla merge',
+                       ' merged-breakwater'),
             };
            push @upp_cl, {
                 %$cl,
@@ -1288,7 +1321,16 @@ sub walk ($;$$$) {
                    $cl->{MergeInterchangeBaseInfo},
                    @{ $cl->{Parents} };
                $last_anchor = $cl->{MergeBestAnchor};
-               # xxx need to check the tree somehow
+               my $check_differs = get_differs $build, $cl->{CommitId};
+               # Breakwater changes which were in each side of the
+               # merge should be in MergeCreateMergedBreakwaters
+               # output.  Upstream changes are exactly the result
+               # of merge_series.  So the only difference should
+               # be potential laundry results.
+               $nomerge->(sprintf
+                    "merge misresolved: tree is not the same (%s %s d.%#x)",
+                          $cl->{CommitId}, $build, $check_differs)
+                   if $check_differs & ~D_PAT_ADD;
                print "Merge resolution successful.\n";
                next;
            } else {