Re: [RFC/PATCH] Make --full-history consider more merges

> If simplify_history is set, and we do want ancestry, then it doesn't
> matter about the TREESAME definition because it shows all merges,
> regardless of the TREESAME flag. Thus adding "--parents" to the above
> command means it can find it, but only because it drags _every_ merge
> into consideration. Should that be necessary?
>
> Futher, if we add simplify_merges, then TREESAME becomes a problem.
> After merge simplification, we can be left with a single-parent
> commit that doesn't match its parent but is skipped due to its
> TREESAME flag being set: it was TREESAME to a parent that got dropped.
>
> I think the correction is that TREESAME for a commit needs to be
> redefined to be "this commit matches all its (remaining) parents",
> rather than "this commit matches at least 1 of its (remaining)
> parents". And when we eliminate parents, we have to check for the
> flag changing, but we should have been doing that anyway.

> If we redefine TREESAME, then recalculation becomes necessary to
> handle the "normal" case - the merge will not initially be TREESAME,
> as it differs from B and C. But once B and C are eliminated, we
> should then determine that the commit is TREESAME from matching
> its remaining parent A. Simplification should only ever "increase"
> the sameness, so we can avoid recalculation if TREESAME is already
> set. Without this recalculation, 6016.7 fails.
>
> So I believe that if reduce_heads() does eliminate any parents, and
> TREESAME wasn't set, then we have to recalculate TREESAME, by
> running over the remaining parents. A call to
> try_to_simplify_commit() does the job, but it feels hacky, and
> obviously it's slow. It would be nice if we could remember
> "per-parent TREESAME" flags, and shuffle them when we change
> parents, but that could be fiddly.
>
> Also if limit_to_ancestry() did eliminate parents from outside the
> ancestry, as per the NEEDSWORK comment, then that would also want
> to do the TREESAME recalculation. (And it could conceivably be very
> useful, helping pick up only the merges that went against your base
> commit).

>  revision.c | 15 ++++++++++++---
>  1 file changed, 12 insertions(+), 3 deletions(-)
>
> diff --git a/revision.c b/revision.c
> index eb98128..15d2f3b 100644
> --- a/revision.c
> +++ b/revision.c
> @@ -432,7 +432,7 @@ static int rev_same_tree_as_empty(struct rev_info *revs, struct commit *commit)
>  static void try_to_simplify_commit(struct rev_info *revs, struct commit *commit)
>  {
>      struct commit_list **pp, *parent;
> -    int tree_changed = 0, tree_same = 0, nth_parent = 0;
> +    int tree_changed = 0, nth_parent = 0;
>
>      /*
>       * If we don't do pruning, everything is interesting
> @@ -474,7 +474,6 @@ static void try_to_simplify_commit(struct rev_info *revs, struct commit *commit)
>                  sha1_to_hex(p->object.sha1));
>          switch (rev_compare_tree(revs, p, commit)) {
>          case REV_TREE_SAME:
> -            tree_same = 1;
>              if (!revs->simplify_history || (p->object.flags & UNINTERESTING)) {
>                  /* Even if a merge with an uninteresting
>                   * side branch brought the entire change
> @@ -516,7 +515,7 @@ static void try_to_simplify_commit(struct rev_info *revs, struct commit *commit)
>          }
>          die("bad tree compare for commit %s", sha1_to_hex(commit->object.sha1));
>      }
> -    if (tree_changed && !tree_same)
> +    if (tree_changed)
>          return;
>      commit->object.flags |= TREESAME;
>  }
> @@ -2042,9 +2041,19 @@ static struct commit_list **simplify_one(struct rev_info *revs, struct commit *c
>       */
>      if (1 < cnt) {
>          struct commit_list *h = reduce_heads(commit->parents);
> +        int orig_cnt = commit_list_count(commit->parents);
>          cnt = commit_list_count(h);
>          free_commit_list(commit->parents);
>          commit->parents = h;
> +        if (cnt < orig_cnt && !(commit->object.flags & TREESAME)) {
> +            /* Rewrite will likely change the TREESAME state. Eg in
> +             * example above, X could be TREESAME or not to its
> +             * remaining single parent, depending on how the merge
> +             * was resolved - most likely it is now TREESAME, but
> +             * it may not be.
> +             */
> +            try_to_simplify_commit(revs, commit);
> +        }
>      }
>
>      /*