}
-# xxx allow merge separately from laundering
+# xxx allow merge resolution separately from laundering, before git merge
#
-# xxx docs highlight forbidden things
-# xxx docs list allowable things ?
-# xxx docs explicitly forbid some rebase
+# xxx general gdr docs highlight forbidden things
+# xxx general gdr docs list allowable things ?
+# xxx general gdr docs explicitly forbid some rebase
#
# xxx provide a way for the user to help
# xxx (eg, provide wreckage provide way to continue)
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)
# $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:
# if the answer is no longer wanted.
my ($anchor, $breakwater);
+ $breakwater = $head if $claimed_bw;
my $clogonly;
my $cl;
my $found_pm;
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};
} 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)")
$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}",
}
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
push @brw_cl, {
%$cl,
SpecialMethod => 'MergeCreateMergedBreakwaters',
- $xmsg->('construct merged breakwater from vanilla merge'),
+ $xmsg->('constructed from vanilla merge',
+ ' merged-breakwater'),
};
push @upp_cl, {
%$cl,
$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 {