Be more aggressive about marking trees uninteresting

We'll mark all the trees at the edges (as deep as we had to go to
realize that we have all the commits needed) as uninteresting.
Otherwise we'll occasionally list a lot of objects that were actually
available at the edge in a commit that we just never ended up parsing
because we could determine early that we had all relevant commits.

NOTE! The object listing is still just a _heuristic_.  It's guaranteed
to list a superset of the actual new objects, but there might be the
occasional old object in the list, just because the commit that
referenced it was much further back in the history.

For example, let's say that a recent commit is a revert of part of the
tree to much older state: since we didn't walk _that_ far back in the
commit history tree to list the commits necessary, git-rev-tree will
never have marked the old objects uninteresting, and we'll end up
listing them as "new".

That's ok.

diff --git a/rev-list.c b/rev-list.c
index fdb531caf6db4944f0612258697670eb00bc55ce..46a35d30e154d493d9f5c7b16af067023cdf01d5 100644 (file)
--- a/rev-list.c
+++ b/rev-list.c
@@ -241,8 +241,9 @@ static void mark_parents_uninteresting(struct commit *commit)
        }
 }
 
-static int everybody_uninteresting(struct commit_list *list)
+static int everybody_uninteresting(struct commit_list *orig)
 {
+       struct commit_list *list = orig;
        while (list) {
                struct commit *commit = list->item;
                list = list->next;
@@ -250,6 +251,29 @@ static int everybody_uninteresting(struct commit_list *list)
                        continue;
                return 0;
        }
+
+       /*
+        * Ok, go back and mark all the edge trees uninteresting,
+        * since otherwise we can have situations where a parent
+        * that was marked uninteresting (and we never even had
+        * to look at) had lots of objects that we don't want to
+        * include.
+        *
+        * NOTE! This still doesn't mean that the object list is
+        * "correct", since we may end up listing objects that
+        * even older commits (that we don't list) do actually
+        * reference, but it gets us to a minimal list (or very
+        * close) in practice.
+        */
+       if (!tree_objects)
+               return 1;
+
+       while (orig) {
+               struct commit *commit = orig->item;
+               if (!parse_commit(commit) && commit->tree)
+                       mark_tree_uninteresting(commit->tree);
+               orig = orig->next;
+       }
        return 1;
 }