29

IntelliJ has a feature that's very cool in theory, called Smart Checkout. This feature kicks in when you're changing branches and you have files in the current branch that you've modified but haven't committed.

Instead of forcing you to commit, stash or shelve your changes, it stashes them for you, switches branches, then runs stash pop in the new branch.

I guess this is what you'd want sometimes, but I ran this when switching to the wrong branch.

So, now my master branch is all full of changes that belong in another branch, some files are reporting merge conflicts, and I have all kinds of pain.

What I want to accomplish is:

  1. Cleanly remove the changes from the master branch.
  2. Move them back to the branch where I was working.

Is there a way to do this?

Pang
  • 9,564
  • 146
  • 81
  • 122
mlissner
  • 17,359
  • 18
  • 106
  • 169
  • 2
    By the way, losing these changes is pretty anguishing....several day's work. I'd love to get them back. – mlissner Aug 31 '15 at 19:47
  • 2
    this kind of magic is exactly why i prefer using IDE VCS integration only for read operations and always add, stash, commit, etc on the command line. anyway, you can recover stashed changes (there are many questions related to it here on SO, e.g. http://stackoverflow.com/questions/89332/how-to-recover-a-dropped-stash-in-git) easily using git utilities. – ThiefMaster Aug 31 '15 at 19:49
  • Using a tool like Atlassian Sourcetree will warn you that your local changes would be overwritten by the checkout, which would avoid this situation! I think the command like git tool may do the same thing but I'm not 100% sure. – mvd Aug 31 '15 at 20:05
  • See: http://stackoverflow.com/questions/8515729/aborting-a-stash-pop-in-git – Jonathan.Brink Aug 31 '15 at 20:08
  • 3
    I had the same issue. I expected that this feature would stash the changes, and switch to new branch. Then when I go back to old branch, it would remember what it stashed. – vaughan Jan 31 '18 at 13:50

4 Answers4

12

Here's at least a partial answer that works if you had a merge conflict during the stash pop. As mentioned in my question, stash is used by the Smart Checkout feature to stash your local changes, and then to apply them to the new branch after it is checked out.

The way IntelliJ does this is by using stash in the branch you're presently in, and then using stash pop in the branch you're switching to.

When the changes are stashed, they get put onto a stack of stashed changes, at the top. Then, when stash pop runs, those changes are popped off the stack and applied.

At least, in most cases, that's what happens. If there's a merge conflict, however, IntelliJ informs you of such and the stash is kept. You can see the stack of stashes by running:

git stash list

If the stash you want is still listed, what you can do is simply checkout the branch you were originally on. Reset it, then do stash apply, which is like stash pop, but doesn't remove the stash from the list. So:

git checkout $original-branch
git reset HARD
git stash apply

Then, if all is well, you can remove the stash with:

git stash drop

Since this answer is pretty rough and only covers one situation, I'm marking it as a community wiki. Improvements very much welcome.

Pang
  • 9,564
  • 146
  • 81
  • 122
mlissner
  • 17,359
  • 18
  • 106
  • 169
7

As the merge failed because of conflicts, the stash isn't removed from the stack, preserving the uncommitted changes. In this case, the git stash list command should show the stash.

First force checkout the original branch. This ignores the merge conflicts.

git checkout -f $original-branch

Then reset the working directory to remove any changes made by the attempted merge.

git reset --hard HEAD

After that, apply the stashed changes. This doesn't remove the stash from the stack.

git stash apply

Confirm that you have all the needed changes and then remove the stash.

git stash drop
NorbiPeti
  • 91
  • 2
  • 8
  • I just wanted to return to my old branch, but the merge conflicts wouldn't let me. Force checkout was the key. – Noumenon Mar 17 '20 at 19:03
7

I'm coming late to the party but I got a little scared after thinking I lost this morning's work due to an IntelliJ Smart Checkout. So I looked to see if there was a fix and this question came up first.

Sadly, my git stash list was empty (probably because I tried merging the conflicting files) so I couldn't use the suggestions given in the other answers.

I started looking in the local history (right click in editor > Local History > Show History) of the project root folder to try and get all the missing changes and noticed a change called Uncommitted_changes_before_Checkout_at_27_04_2022_12_06__Changes.xml. As you can see in the screen capture, this file is located in the .idea/shelf folder of your project.

It's associated with an almost eponymous folder "Uncommitted_changes_before_Update_at_27_04_2022_12_06_[Changes]" and both aren't deleted anytime soon after the Smart Checkout since I had an other pair dated from 20/04/2022.

The folder contains a shelved.patch file which regroups all your changes in the format shown on the screen capture (I assure you my morning's work wasn't just adding a console.log).

This shelved.patch file is used by IntelliJ's shelf feature, which allows you to see all those changes and reapply them as needed. You can access the shelf from the menu bar (Git > Uncommitted Changes > Show shelf)

IntelliJ shelving all my local changes also happened after an error during an update: Merge Error: unable to write ./git/index.

The project updated properly after the shelving and I could unshelf the changes I wanted.

Batman
  • 282
  • 3
  • 12
1

I was really bummed when none of the suggestions here worked for me. git stash list showed nothing.

Then I looked through the PyCharm "shelf" tab (under the Commit tab) again and looked under the section titled "Recently deleted". Lo and behold my files were all there. I was able to just right-click and do "Unshelve", and those changes showed up as changes ready to stage on the Commit tab.

Whew.

trpt4him
  • 1,646
  • 21
  • 34