Fix parent rewriting in --early-output

We cannot tell a node that has been checked and found not to be
interesting (which does not have the TREECHANGE flag) from a
node that hasn't been checked if it is interesting or not,
without relying on something else, such as object->parsed.

But an object can get the "parsed" flag for other reasons.
Which means that "TREECHANGE" has the wrong polarity.

This changes the way how the path pruning logic marks an
uninteresting commits.  From now on, we consider a commit
interesting by default, and explicitly mark the ones we decided
to prune.  The flag is renamed to "TREESAME".

Then, this fixes the logic to show the early output with
incomplete pruning.  It basically says "a commit that has
TREESAME set is kind-of-UNINTERESTING", but obviously in a
different way than an outright UNINTERESTING commit.  Until we
parse and examine enough parents to determine if a commit
becomes surely "kind-of-UNINTERESTING", we avoid rewriting
the ancestry so that later rounds can fix things up.

Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin-fmt-merge-msg.c b/builtin-fmt-merge-msg.c
index 8a3c962f8920bb883287053c850adf78312ff19b..6163bd4975e3e361e36ffc89ea4c91d0edd02949 100644 (file)
--- a/builtin-fmt-merge-msg.c
+++ b/builtin-fmt-merge-msg.c
@@ -176,7 +176,7 @@ static void shortlog(const char *name, unsigned char *sha1,
        struct commit *commit;
        struct object *branch;
        struct list subjects = { NULL, NULL, 0, 0 };
-       int flags = UNINTERESTING | TREECHANGE | SEEN | SHOWN | ADDED;
+       int flags = UNINTERESTING | TREESAME | SEEN | SHOWN | ADDED;
 
        branch = deref_tag(parse_object(sha1), sha1_to_hex(sha1), 40);
        if (!branch || branch->type != OBJ_COMMIT)

diff --git a/builtin-log.c b/builtin-log.c
index d6845bc7f8363ccba67aa436e872962195e3e9b5..54ddaad0eccedd74be349d208fecb9a87b143047 100644 (file)
--- a/builtin-log.c
+++ b/builtin-log.c
@@ -89,7 +89,7 @@ static int estimate_commit_count(struct rev_info *rev, struct commit_list *list)
                struct commit *commit = list->item;
                unsigned int flags = commit->object.flags;
                list = list->next;
-               if ((flags & TREECHANGE) && !(flags & UNINTERESTING))
+               if (!(flags & (TREESAME | UNINTERESTING)))
                        n++;
        }
        return n;

diff --git a/builtin-rev-list.c b/builtin-rev-list.c
index 2dec8873f8a480898c993722ef8d12aec7906d25..0258ec43f96cfd20c06125a905c08227729c7249 100644 (file)
--- a/builtin-rev-list.c
+++ b/builtin-rev-list.c
@@ -142,7 +142,7 @@ static int count_distance(struct commit_list *entry)
 
                if (commit->object.flags & (UNINTERESTING | COUNTED))
                        break;
-               if (commit->object.flags & TREECHANGE)
+               if (!(commit->object.flags & TREESAME))
                        nr++;
                commit->object.flags |= COUNTED;
                p = commit->parents;
@@ -198,7 +198,7 @@ static inline int halfway(struct commit_list *p, int nr)
        /*
         * Don't short-cut something we are not going to return!
         */
-       if (!(p->item->object.flags & TREECHANGE))
+       if (p->item->object.flags & TREESAME)
                return 0;
        if (DEBUG_BISECT)
                return 0;
@@ -234,7 +234,7 @@ static void show_list(const char *debug, int counted, int nr,
                char *ep, *sp;
 
                fprintf(stderr, "%c%c%c ",
-                       (flags & TREECHANGE) ? 'T' : ' ',
+                       (flags & TREESAME) ? ' ' : 'T',
                        (flags & UNINTERESTING) ? 'U' : ' ',
                        (flags & COUNTED) ? 'C' : ' ');
                if (commit->util)
@@ -268,7 +268,7 @@ static struct commit_list *best_bisection(struct commit_list *list, int nr)
                int distance;
                unsigned flags = p->item->object.flags;
 
-               if (!(flags & TREECHANGE))
+               if (flags & TREESAME)
                        continue;
                distance = weight(p);
                if (nr - distance < distance)
@@ -308,7 +308,7 @@ static struct commit_list *best_bisection_sorted(struct commit_list *list, int n
                int distance;
                unsigned flags = p->item->object.flags;
 
-               if (!(flags & TREECHANGE))
+               if (flags & TREESAME)
                        continue;
                distance = weight(p);
                if (nr - distance < distance)
@@ -362,7 +362,7 @@ static struct commit_list *do_find_bisection(struct commit_list *list,
                p->item->util = &weights[n++];
                switch (count_interesting_parents(commit)) {
                case 0:
-                       if (flags & TREECHANGE) {
+                       if (!(flags & TREESAME)) {
                                weight_set(p, 1);
                                counted++;
                                show_list("bisection 2 count one",
@@ -435,7 +435,7 @@ static struct commit_list *do_find_bisection(struct commit_list *list,
                         * add one for p itself if p is to be counted,
                         * otherwise inherit it from q directly.
                         */
-                       if (flags & TREECHANGE) {
+                       if (!(flags & TREESAME)) {
                                weight_set(p, weight(q)+1);
                                counted++;
                                show_list("bisection 2 count one",
@@ -482,7 +482,7 @@ static struct commit_list *find_bisection(struct commit_list *list,
                        continue;
                p->next = last;
                last = p;
-               if (flags & TREECHANGE)
+               if (!(flags & TREESAME))
                        nr++;
                on_list++;
        }

diff --git a/revision.c b/revision.c
index 931f978af91786abcdb0ce6b2ae819c9e4e15902..5796153bbd0b01f94a9c33be16c3bccab86a19a5 100644 (file)
--- a/revision.c
+++ b/revision.c
@@ -311,17 +311,15 @@ static void try_to_simplify_commit(struct rev_info *revs, struct commit *commit)
        /*
         * If we don't do pruning, everything is interesting
         */
-       if (!revs->prune) {
-               commit->object.flags |= TREECHANGE;
+       if (!revs->prune)
                return;
-       }
 
        if (!commit->tree)
                return;
 
        if (!commit->parents) {
-               if (!rev_same_tree_as_empty(revs, commit->tree))
-                       commit->object.flags |= TREECHANGE;
+               if (rev_same_tree_as_empty(revs, commit->tree))
+                       commit->object.flags |= TREESAME;
                return;
        }
 
@@ -329,10 +327,8 @@ static void try_to_simplify_commit(struct rev_info *revs, struct commit *commit)
         * Normal non-merge commit? If we don't want to make the
         * history dense, we consider it always to be a change..
         */
-       if (!revs->dense && !commit->parents->next) {
-               commit->object.flags |= TREECHANGE;
+       if (!revs->dense && !commit->parents->next)
                return;
-       }
 
        pp = &commit->parents;
        while ((parent = *pp) != NULL) {
@@ -357,6 +353,7 @@ static void try_to_simplify_commit(struct rev_info *revs, struct commit *commit)
                        }
                        parent->next = NULL;
                        commit->parents = parent;
+                       commit->object.flags |= TREESAME;
                        return;
 
                case REV_TREE_NEW:
@@ -385,7 +382,8 @@ 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)
-               commit->object.flags |= TREECHANGE;
+               return;
+       commit->object.flags |= TREESAME;
 }
 
 static int add_parents_to_list(struct rev_info *revs, struct commit *commit, struct commit_list **list)
@@ -1354,7 +1352,9 @@ static enum rewrite_result rewrite_one(struct rev_info *revs, struct commit **pp
                                return rewrite_one_error;
                if (p->parents && p->parents->next)
                        return rewrite_one_ok;
-               if (p->object.flags & (TREECHANGE | UNINTERESTING))
+               if (p->object.flags & UNINTERESTING)
+                       return rewrite_one_ok;
+               if (!(p->object.flags & TREESAME))
                        return rewrite_one_ok;
                if (!p->parents)
                        return rewrite_one_noparents;
@@ -1427,7 +1427,7 @@ enum commit_action simplify_commit(struct rev_info *revs, struct commit *commit)
                return commit_ignore;
        if (revs->prune && revs->dense) {
                /* Commit without changes? */
-               if (!(commit->object.flags & TREECHANGE)) {
+               if (commit->object.flags & TREESAME) {
                        /* drop merges unless we want parenthood */
                        if (!revs->parents)
                                return commit_ignore;

diff --git a/revision.h b/revision.h
index a79851449c7b71770fc44481e9ba9b562c6a8b5e..992e1e9dd57eac528c3ecaf09987593d525da611 100644 (file)
--- a/revision.h
+++ b/revision.h
@@ -3,7 +3,7 @@
 
 #define SEEN           (1u<<0)
 #define UNINTERESTING   (1u<<1)
-#define TREECHANGE     (1u<<2)
+#define TREESAME       (1u<<2)
 #define SHOWN          (1u<<3)
 #define TMP_MARK       (1u<<4) /* for isolated cases; clean after use */
 #define BOUNDARY       (1u<<5)