Why does "git pull --rebase" require a clean git directory?

Hi,

"git pull --rebase" requires having NO uncommitted changes, even if the locally modified files haven't been updated upstream, or even if there are no changes to upstream at all. I know I could use --autostash, but that's inefficient and may be undesirable if it would create a conflict.

Would it be possible to change the behavior of "git pull --rebase" so that it only fails if the locally modified files conflict with the files modified upstream (similar to the default git pull behavior without --rebase)?

Thanks, Vitaly

On 2020-12-10 at 22:15:11, Shupak, Vitaly wrote:

I suspect the reason for the difference is in how the two pieces of code work. A merge in general can work in a dirty tree whereas a rebase cannot. That, in turn, is because the merge code merges two files internally and then writes them out to the working tree, whereas the rebase code, at least in some cases, doesn't contain the same precautions not to modify the working tree.

Moreover, a merge is a single operation, so it's safe to operate on a commit and then give up. A rebase consists of multiple operations, so we'd have to evaluate each operation and synthesize it, internally performing the merge (or apply) that's a part of it, in order to determine if it would conflict. Otherwise, we'd have to just try it and somehow abort cleanly in the middle without otherwise dirtying the working tree. Right now, that abort step involves a reset --hard, which is going to blow away your data.

So is it possible to do? Sure. Is it easy? Not especially with the current code. So certainly it could be done if it were important to someone, but it will likely be a good bit of work.

Sorry this wasn't the news you were hoping for. I'd love to have some easy solution that I could offer to send in a patch for this weekend to solve this, but unfortunately it's not that easy.

Thanks for the explanation. It seems like some optimizations may still be possible. For example, if the pull could be done with a fast-forward merge, then you don't need to rebase at all. This could be an option like pull.rebase=noffonly.

-----Original Message-----
From: brian m. carlson <sandals@crustytoothpaste.net> 
Sent: Thursday, December 10, 2020 10:42 PM
To: Shupak, Vitaly <Vitaly.Shupak@deshaw.com>
Cc: git@vger.kernel.org
Subject: Re: Why does "git pull --rebase" require a clean git directory?

On 2020-12-10 at 22:15:11, Shupak, Vitaly wrote:

I suspect the reason for the difference is in how the two pieces of code work.  A merge in general can work in a dirty tree whereas a rebase cannot.  That, in turn, is because the merge code merges two files internally and then writes them out to the working tree, whereas the rebase code, at least in some cases, doesn't contain the same precautions not to modify the working tree.

Moreover, a merge is a single operation, so it's safe to operate on a commit and then give up.  A rebase consists of multiple operations, so we'd have to evaluate each operation and synthesize it, internally performing the merge (or apply) that's a part of it, in order to determine if it would conflict.  Otherwise, we'd have to just try it and somehow abort cleanly in the middle without otherwise dirtying the working tree.  Right now, that abort step involves a reset --hard, which is going to blow away your data.

So is it possible to do?  Sure.  Is it easy?  Not especially with the current code.  So certainly it could be done if it were important to someone, but it will likely be a good bit of work.

Sorry this wasn't the news you were hoping for. I'd love to have some easy solution that I could offer to send in a patch for this weekend to solve this, but unfortunately it's not that easy. -- brian m. carlson (he/him or they/them) Houston, Texas, US

On 2020-12-11 at 21:23:23, Shupak, Vitaly wrote:

Yeah, I agree that if our operation is a fast-forward, that could be done in a pretty straightforward way. It's still a little tricky because of how the current code works (the fast-forward logic is in the sequencer, which gets called after the check), but it's something that we could add more easily.

Shupak, Vitaly writes:

It isn't just about whether upstream has changed those same files, but also would fail if any of your commits have.

If that creates a conflict, then the pull would definitely fail if it had been attempted.