JIYIK CN >

You can undo this using the solutions in this article git stash pop with merge conflicts. We show you how to abort an erroneous stash pop operation and return to a clean state.

But we also demonstrated a git stash popway to resolve the conflict and undo the new good merge.

Git Stash Pop Merge Conflicts - The Problem

In a fast-paced developer workflow, it's common to hide the current state and jump to other features when new ideas come to mind.

When we finish working on a new feature, we git stash popapply the stashed changes using the command. But sometimes, this back-and-forth workflow leads to merge conflicts.

In this case, you might want to do one of two things.

1. Abort a bad merge and return to a previous clean state.
2. You may want to edit the files/directories locally or pull from the remote repository to resolve the merge conflicts. You can then merge the correct changes with a new commit.

Let’s look at both solutions.

Undo Git Stash Pop With Conflicts - Abort a bad merge to return to a clean state

If you want to remove changes from a bad stash pop operation, you should use any of the following commands. These methods will abort all changes that caused merge conflicts and return to a previous healthy state.

git reset --merge

First, let's look at the setup. We have a master branch with some files, like this:

Then we forked a local branch new_branch from it. We modified some files in this branch and committed these changes.

We now make some changes to file1.txt and file2.txt. Then we store these changes.

$ git stash -u -m "Modify file1 and file2 in new_branch"

git stashThere are a few options here. The -u flag lets us hide untracked changes.

The -m flag has the same meaning - it allows us to add semantic messages to our storage.

Now, we make some changes to the same file1.txt and file2.txt in our master branch. These files have different versions in our master and new_branch.

If we apply stash in the master branch, the different versions of file1 and file2 will conflict.

If we check our repository now, we'll find strange files in it due to the bad merge attempt.

We can use the reset command with some options to undo a failed stash pop.

$ git reset --merge

git resetRecently learned about the --merge option. The --merge option is similar to the default --mixed option, but it only applies to files affected by the merge operation.

In our case, we see the result of this command is git undo bad stash pop.

git checkout -f

We can see the same results as above using the command by passing the -f flag.git checkout

$ git checkout -f

Without any arguments, git checkoutthe command assumes the default HEAD argument. Our last commit was good, with no bad stash pop merge conflicts, so this command wipes the slate clean.

The -f flag is used for the --force option. It helps ensure a healthy repository state by ignoring unmerged commits and untracked files.

If you just want to wipe the above two methods clean, it is best to undo git stash pop if there is a conflict.

But if you want to resolve the commit with a fresh good merge, you need to use the following approach.

Undo Git Stash Pop by resolving bad conflicts

You need to edit the files and directories nicely in sync across all branches to resolve conflicts.

You can do this locally with a few commands, or you can pull it in from a remote repository. We’ll look at both solutions.

Resolving Git Undo Failed Stash Pop conflicts - for local branches

We have the same setup as above. But this time, we will resolve the conflicts between main and new_branch and reapply our stash to get the desired result.

We start by removing the file changes that caused the stash pop conflict. The changes we made to file1 and file2 in master after we forked caused the problem.

We reset master to the commit before that one and made the wrong changes to our file1 and file2.

git reset <good_commit_hash>

git checkout HEAD .

We also rollback our work area using the checkout. command. Note the trailing dot , which selects all files to ensure that all conflicts are resolved.

You can also use:

$ git reset HEAD file1.txt file2.txt

Because in our example, we know that the two related files are file1.txt and file2.txt .

In this form, git checkoutthe command sets the working directory to align with HEAD, which is the last good commit without conflicts.

We now see that the commit has disappeared from our master branch.

We have now successfully applied the stashed changes.

$ git stash pop

Git Undo Bad Stash Pop - Resolve conflicts by pulling from a remote repository

If your workflow is set up so that the remote repository is in the most unhealthy state possible, you can resolve bad repository conflicts by pulling in from the remote.

Let's first set up a concrete use case for this solution.

We see that our local remote is behind our remote master by 1 commit. Suppose we now create a new local branch to track the remote master and store some changes in it.

$ git fetch --all

$ git switch -c new_branch_tracking_remote_master origin/master

We have some changes stored on this branch.

git stash -m "Change file5.txt in local branch"

Now we realize that we want to make these changes on a new local branch. We fork a new local branch from our local master .

git checkout master

git branch local_branch_2

We see that this branch is 1 commit behind, and it does not have the file5.txt file. If we pop our stash now, it will result in a nasty merge conflict.

To resolve the conflict, in this case we pull the remote master into our local master. We first need to fetch the remote repository.

$ git fetch --all

We then merged our local master with the remote master.

$ git merge origin/master

We now see that our local host is in sync with the remote host by pulling the latest changes. You can also see that the critical file5.txt is included.

We will now rebase your local branch, local-branch2, on top of the updated local master.

First, check your local branch.

$ git checkout local_branch_2

Now, rebase on your local master branch.

$ git rebase master

This makes our local_branch_2 healthy and ready to receive stashed changes.

We now apply our stashed changes.

$ git stash pop

This time we see that the stashed changes were successfully applied.

We have resolved the conflict and merged the stashed changes successfully.