grep: fix "--" rev/pathspec disambiguation

If we see "git grep pattern rev -- file" then we apply the
usual rev/pathspec disambiguation rules: any "rev" before
the "--" must be a revision, and we do not need to apply the
verify_non_filename() check.

But there are two bugs here:

1. We keep a seen_dashdash flag to handle this case, but
we set it in the same left-to-right pass over the
arguments in which we parse "rev".

So when we see "rev", we do not yet know that there is
a "--", and we mistakenly complain if there is a
matching file.

We can fix this by making a preliminary pass over the
arguments to find the "--", and only then checking the rev
arguments.

2. If we can't resolve "rev" but there isn't a dashdash,
that's OK. We treat it like a path, and complain later
if it doesn't exist.

But if there _is_ a dashdash, then we know it must be a
rev, and should treat it as such, complaining if it
does not resolve. The current code instead ignores it
and tries to treat it like a path.

This patch fixes both bugs, and tries to comment the parsing
flow a bit better.

It adds tests that cover the two bugs, but also some related
situations (which already worked, but this confirms that our
fixes did not break anything).

Signed-off-by: Jeff King <peff@peff.net>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/grep.c b/builtin/grep.c
index 461347adb07a3e504e7c0719cd3e39ed08cadd02..e83b33bdaa784320211fe8f1e17f2cbdccfe7f25 100644 (file)
--- a/builtin/grep.c
+++ b/builtin/grep.c
@@ -1149,7 +1149,22 @@ int cmd_grep(int argc, const char **argv, const char *prefix)
 
        compile_grep_patterns(&opt);
 
 
        compile_grep_patterns(&opt);
 

-       /* Check revs and then paths */
+       /*
+        * We have to find "--" in a separate pass, because its presence
+        * influences how we will parse arguments that come before it.
+        */
+       for (i = 0; i < argc; i++) {
+               if (!strcmp(argv[i], "--")) {
+                       seen_dashdash = 1;
+                       break;
+               }
+       }
+
+       /*
+        * Resolve any rev arguments. If we have a dashdash, then everything up
+        * to it must resolve as a rev. If not, then we stop at the first
+        * non-rev and assume everything else is a path.
+        */

        for (i = 0; i < argc; i++) {
                const char *arg = argv[i];
                unsigned char sha1[20];
        for (i = 0; i < argc; i++) {
                const char *arg = argv[i];
                unsigned char sha1[20];


@@ -1158,13 +1173,14 @@ int cmd_grep(int argc, const char **argv, const char *prefix)
 
                if (!strcmp(arg, "--")) {
                        i++;
 
                if (!strcmp(arg, "--")) {
                        i++;

-                       seen_dashdash = 1;

                        break;
                }
 
                        break;
                }
 

-               /* Stop at the first non-rev */
-               if (get_sha1_with_context(arg, 0, sha1, &oc))
+               if (get_sha1_with_context(arg, 0, sha1, &oc)) {
+                       if (seen_dashdash)
+                               die(_("unable to resolve revision: %s"), arg);

                        break;
                        break;

+               }

 
                object = parse_object_or_die(sha1, arg);
                if (!seen_dashdash)
 
                object = parse_object_or_die(sha1, arg);
                if (!seen_dashdash)


@@ -1172,7 +1188,10 @@ int cmd_grep(int argc, const char **argv, const char *prefix)
                add_object_array_with_path(object, arg, &list, oc.mode, oc.path);
        }
 
                add_object_array_with_path(object, arg, &list, oc.mode, oc.path);
        }
 

-       /* The rest are paths */
+       /*
+        * Anything left over is presumed to be a path. But in the non-dashdash
+        * "do what I mean" case, we verify and complain when that isn't true.
+        */

        if (!seen_dashdash) {
                int j;
                for (j = i; j < argc; j++)
        if (!seen_dashdash) {
                int j;
                for (j = i; j < argc; j++)

diff --git a/t/t7810-grep.sh b/t/t7810-grep.sh
index 2c1f7373e6bce9497a45894133757f58a3e084af..a6011f9b1d60f36a2e7d998482a14c9b3df0adde 100755 (executable)
--- a/t/t7810-grep.sh
+++ b/t/t7810-grep.sh
@@ -982,6 +982,39 @@ test_expect_success 'grep -e -- -- path' '
        test_cmp expected actual
 '
 
        test_cmp expected actual
 '
 

+test_expect_success 'dashdash disambiguates rev as rev' '
+       test_when_finished "rm -f master" &&
+       echo content >master &&
+       echo master:hello.c >expect &&
+       git grep -l o master -- hello.c >actual &&
+       test_cmp expect actual
+'
+
+test_expect_success 'dashdash disambiguates pathspec as pathspec' '
+       test_when_finished "git rm -f master" &&
+       echo content >master &&
+       git add master &&
+       echo master:content >expect &&
+       git grep o -- master >actual &&
+       test_cmp expect actual
+'
+
+test_expect_success 'report bogus arg without dashdash' '
+       test_must_fail git grep o does-not-exist
+'
+
+test_expect_success 'report bogus rev with dashdash' '
+       test_must_fail git grep o hello.c --
+'
+
+test_expect_success 'allow non-existent path with dashdash' '
+       # We need a real match so grep exits with success.
+       tree=$(git ls-tree HEAD |
+              sed s/hello.c/not-in-working-tree/ |
+              git mktree) &&
+       git grep o "$tree" -- not-in-working-tree
+'
+

 test_expect_success 'grep --no-index pattern -- path' '
        rm -fr non &&
        mkdir -p non/git &&
 test_expect_success 'grep --no-index pattern -- path' '
        rm -fr non &&
        mkdir -p non/git &&