revision: make get_commit_action() a pure predicate

get_commit_action() reads as a predicate that decides whether a commit
is shown or ignored, but for a line-level log without parent rewriting it
also called line_log_process_commit(), which mutates the tracked line
ranges.  That hidden side effect made it unsafe to call as a plain query.

get_commit_action() has only two callers: simplify_commit(), the normal
walk driver, and graph_is_interesting() in graph.c.  The latter runs only
under --graph, which forces rewrite_parents (and therefore
want_ancestry()), so the "-L without ancestry" branch that holds the side
effect was already unreachable from it.

Move the line-level processing to simplify_commit(), which runs it before
calling get_commit_action().  Extract the leading "ignore regardless of
content" checks into commit_early_ignore() so the same gate applies in
both places, and so the tracked ranges are still adjusted for a commit
that later, cheaper conditions will ignore.  commit_early_ignore() only
reads object flags and pack membership, so running it again from
get_commit_action() is a harmless repeat.

get_commit_action() is now side-effect free and safe to use as a
predicate, independent of whether the line-level ranges were processed.
Update the line-log.c file header, which pointed the lazy walk at
get_commit_action(), to name simplify_commit().

Suggested-by: Junio C Hamano <gitster@pobox.com>
Signed-off-by: Michael Montalbo <mmontalbo@gmail.com>

Author: mmontalbo

line-log.c

@@ -37,7 +37,7 @@
  *     and rewrites the parent links.
  *
  *   - Lazy, for a plain "git log -L": each commit is processed on demand
- *     during the walk, from get_commit_action() in revision.c.
+ *     during the walk, from simplify_commit() in revision.c.
  *
  * Both share line_log_process_commit(), which processes
  * one commit and reports whether it changed a tracked range.

revision.c

@@ -4159,37 +4159,40 @@ static timestamp_t comparison_date(const struct rev_info *revs,
 		commit->date;
 }
 
-enum commit_action get_commit_action(struct rev_info *revs, struct commit *commit)
+/*
+ * Which commits are ignored regardless of content, and before any
+ * line-level log processing.  Extracted so the line-log walk driver
+ * (simplify_commit) can apply the same gate before it calls
+ * line_log_process_commit().
+ */
+static int commit_early_ignore(struct rev_info *revs, struct commit *commit)
 {
 	if (commit->object.flags & SHOWN)
-		return commit_ignore;
+		return 1;
 	if (revs->maximal_only && (commit->object.flags & CHILD_VISITED))
-		return commit_ignore;
+		return 1;
 	if (revs->unpacked && has_object_pack(revs->repo, &commit->object.oid))
-		return commit_ignore;
-	if (revs->no_kept_objects) {
-		if (has_object_kept_pack(revs->repo, &commit->object.oid,
-					 revs->keep_pack_cache_flags))
-			return commit_ignore;
-	}
+		return 1;
+	if (revs->no_kept_objects &&
+	    has_object_kept_pack(revs->repo, &commit->object.oid,
+				 revs->keep_pack_cache_flags))
+		return 1;
 	if (commit->object.flags & UNINTERESTING)
+		return 1;
+	return 0;
+}
+
+/*
+ * A pure predicate: should this commit be shown, ignored, or does it
+ * error?  Line-level log filtering for the no-parent-rewriting case
+ * mutates the tracked ranges, so it is done by simplify_commit() before
+ * it calls us; keeping this function side-effect free lets callers such
+ * as the commit graph use it as a plain query.
+ */
+enum commit_action get_commit_action(struct rev_info *revs, struct commit *commit)
+{
+	if (commit_early_ignore(revs, commit))
 		return commit_ignore;
-	if (revs->line_level_traverse && !want_ancestry(revs)) {
-		/*
-		 * In case of line-level log with parent rewriting
-		 * prepare_revision_walk() already took care of all line-level
-		 * log filtering, and there is nothing left to do here.
-		 *
-		 * If parent rewriting was not requested, then this is the
-		 * place to perform the line-level log filtering.  Notably,
-		 * this check, though expensive, must come before the other,
-		 * cheaper filtering conditions, because the tracked line
-		 * ranges must be adjusted even when the commit will end up
-		 * being ignored based on other conditions.
-		 */
-		if (!line_log_process_commit(revs, commit))
-			return commit_ignore;
-	}
 	if (revs->min_age != -1 &&
 	    comparison_date(revs, commit) > revs->min_age)
 			return commit_ignore;
@@ -4298,7 +4301,24 @@ struct commit_list *get_saved_parents(struct rev_info *revs, const struct commit
 
 enum commit_action simplify_commit(struct rev_info *revs, struct commit *commit)
 {
-	enum commit_action action = get_commit_action(revs, commit);
+	enum commit_action action;
+
+	/*
+	 * Line-level log without parent rewriting is filtered here, as the
+	 * walk reaches each commit; with parent rewriting,
+	 * prepare_revision_walk() already did it via line_log_filter().  Run
+	 * it before get_commit_action() (a pure predicate), under the same
+	 * commit_early_ignore() gate: a SHOWN or UNINTERESTING commit is not
+	 * processed, but the tracked ranges must still be carried across a
+	 * commit that later, cheaper conditions will ignore, so this must
+	 * come first.
+	 */
+	if (revs->line_level_traverse && !want_ancestry(revs) &&
+	    !commit_early_ignore(revs, commit) &&
+	    !line_log_process_commit(revs, commit))
+		return commit_ignore;
+
+	action = get_commit_action(revs, commit);
 
 	if (action == commit_show &&
 	    revs->prune && revs->dense && want_ancestry(revs)) {