stash: fix stash application in sparse-checkouts

sparse-checkouts are built on the patterns in the
$GIT_DIR/info/sparse-checkout file, where commands have modified
behavior for paths that do not match those patterns.  The differences in
behavior, as far as the bugs concerned here, fall into three different
categories (with git subcommands that fall into each category listed):

  * commands that only look at files matching the patterns:
      * status
      * diff
      * clean
      * update-index
  * commands that remove files from the working tree that do not match
    the patterns, and restore files that do match them:
      * read-tree
      * switch
      * checkout
      * reset (--hard)
  * commands that omit writing files to the working tree that do not
    match the patterns, unless those files are not clean:
      * merge
      * rebase
      * cherry-pick
      * revert

There are some caveats above, e.g. a plain `git diff` ignores files
outside the sparsity patterns but will show diffs for paths outside the
sparsity patterns when revision arguments are passed.  (Technically,
diff is treating the sparse paths as matching HEAD.)  So, there is some
internal inconsistency among these commands.  There are also additional
commands that should behave differently in the face of sparse-checkouts,
as the sparse-checkout documentation alludes to, but the above is
sufficient for me to explain how `git stash` is affected.

What is relevant here is that logically 'stash' should behave like a
merge; it three-way merges the changes the user had in progress at stash
creation time, the HEAD at the time the stash was created, and the
current HEAD, in order to get the stashed changes applied to the current
branch.  However, this simplistic view doesn't quite work in practice,
because stash tweaks it a bit due to two factors: (1) flags like
--keep-index and --include-untracked (why we used two different verbs,
'keep' and 'include', is a rant for another day) modify what should be
staged at the end and include more things that should be quasi-merged,
(2) stash generally wants changes to NOT be staged.  It only provides
exceptions when (a) some of the changes had conflicts and thus we want
to use stages to denote the clean merges and higher order stages to
mark the conflicts, or (b) if there is a brand new file we don't want
it to become untracked.

stash has traditionally gotten this special behavior by first doing a
merge, and then when it's clean, applying a pipeline of commands to
modify the result.  This series of commands for
unstaging-non-newly-added-files came from the following commands:

    git diff-index --cached --name-only --diff-filter=A $CTREE >"$a"
    git read-tree --reset $CTREE
    git update-index --add --stdin <"$a"
    rm -f "$a"

Looking back at the different types of special sparsity handling listed
at the beginning of this message, you may note that we have at least one
of each type covered here: merge, diff-index, and read-tree.  The weird
mix-and-match led to 3 different bugs:

(1) If a path merged cleanly and it didn't match the sparsity patterns,
the merge backend would know to avoid writing it to the working tree and
keep the SKIP_WORKTREE bit, simply only updating it in the index.
Unfortunately, the subsequent commands would essentially undo the
changes in the index and thus simply toss the changes altogether since
there was nothing left in the working tree.  This means the stash is
only partially applied.

(2) If a path existed in the worktree before `git stash apply` despite
having the SKIP_WORKTREE bit set, then the `git read-tree --reset` would
print an error message of the form
      error: Entry 'modified' not uptodate. Cannot merge.
and cause stash to abort early.

(3) If there was a brand new file added by the stash, then the
diff-index command would save that pathname to the temporary file, the
read-tree --reset would remove it from the index, and the update-index
command would barf due to no such file being present in the working
copy; it would print a message of the form:
      error: NEWFILE: does not exist and --remove not passed
      fatal: Unable to process path NEWFILE
and then cause stash to abort early.

Basically, the whole idea of unstage-unless-brand-new requires special
care when you are dealing with a sparse-checkout.  Fix these problems
by applying the following simple rule:

  When we unstage files, if they have the SKIP_WORKTREE bit set,
  clear that bit and write the file out to the working directory.

  (*) If there's already a file present in the way, rename it first.

This fixes all three problems in t7012.13 and allows us to mark it as
passing.

Signed-off-by: Elijah Newren <newren@gmail.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>

diff --git a/builtin/stash.c b/builtin/stash.c
index 3c641cc5cd1d0405e737a860ff2c06f58a5ef16d..9839835daed7089fbefe95697d21fd4be0490547 100644 (file)
--- a/builtin/stash.c
+++ b/builtin/stash.c
@@ -363,12 +363,23 @@ static void unstage_changes_unless_new(struct object_id *orig_tree)
         * relevant trees, and the merge logic always stages whatever merges
         * cleanly.  We want to unstage those changes, unless it corresponds
         * to a file that didn't exist as of orig_tree.
+        *
+        * However, if any SKIP_WORKTREE path is modified relative to
+        * orig_tree, then we want to clear the SKIP_WORKTREE bit and write
+        * it to the worktree before unstaging.
         */
 
+       struct checkout state = CHECKOUT_INIT;
        struct diff_options diff_opts;
        struct lock_file lock = LOCK_INIT;
        int i;
 
+       /* If any entries have skip_worktree set, we'll have to check 'em out */
+       state.force = 1;
+       state.quiet = 1;
+       state.refresh_cache = 1;
+       state.istate = &the_index;
+
        /*
         * Step 1: get a difference between orig_tree (which corresponding
         * to the index before a merge was run) and the current index
@@ -395,7 +406,42 @@ static void unstage_changes_unless_new(struct object_id *orig_tree)
                                     strlen(p->two->path));
 
                /*
-                * Step 2: "unstage" changes, as long as they are still tracked
+                * Step 2: Place changes in the working tree
+                *
+                * Stash is about restoring changes *to the working tree*.
+                * So if the merge successfully got a new version of some
+                * path, but left it out of the working tree, then clear the
+                * SKIP_WORKTREE bit and write it to the working tree.
+                */
+               if (pos >= 0 && ce_skip_worktree(active_cache[pos])) {
+                       struct stat st;
+
+                       ce = active_cache[pos];
+                       if (!lstat(ce->name, &st)) {
+                               /* Conflicting path present; relocate it */
+                               struct strbuf new_path = STRBUF_INIT;
+                               int fd;
+
+                               strbuf_addf(&new_path,
+                                           "%s.stash.XXXXXX", ce->name);
+                               fd = xmkstemp(new_path.buf);
+                               close(fd);
+                               printf(_("WARNING: Untracked file in way of "
+                                        "tracked file!  Renaming\n "
+                                        "           %s -> %s\n"
+                                        "         to make room.\n"),
+                                      ce->name, new_path.buf);
+                               if (rename(ce->name, new_path.buf))
+                                       die("Failed to move %s to %s\n",
+                                           ce->name, new_path.buf);
+                               strbuf_release(&new_path);
+                       }
+                       checkout_entry(ce, &state, NULL, NULL);
+                       ce->ce_flags &= ~CE_SKIP_WORKTREE;
+               }
+
+               /*
+                * Step 3: "unstage" changes, as long as they are still tracked
                 */
                if (p->one->oid_valid) {
                        /*
@@ -417,7 +463,7 @@ static void unstage_changes_unless_new(struct object_id *orig_tree)
        diff_flush(&diff_opts);
 
        /*
-        * Step 3: write the new index to disk
+        * Step 4: write the new index to disk
         */
        repo_hold_locked_index(the_repository, &lock, LOCK_DIE_ON_ERROR);
        if (write_locked_index(&the_index, &lock,

diff --git a/t/t7012-skip-worktree-writing.sh b/t/t7012-skip-worktree-writing.sh
index a184ee97fb7c5e07ebac0347731a751abd3843b7..e5c6a038fbfccb3da7c3c179fa0c6c186de68d40 100755 (executable)
--- a/t/t7012-skip-worktree-writing.sh
+++ b/t/t7012-skip-worktree-writing.sh
@@ -149,7 +149,7 @@ test_expect_success '--ignore-skip-worktree-entries leaves worktree alone' '
                --diff-filter=D -- keep-me.t
 '
 
-test_expect_failure 'stash restore in sparse checkout' '
+test_expect_success 'stash restore in sparse checkout' '
        test_create_repo stash-restore &&
        (
                cd stash-restore &&