Re: bug?: stgit creates (unneccessary?) conflicts when pulling

From: Catalin Marinas <catalin.marinas@gmail.com>
Date: Feb 27, 2006, 22:17 UTC
Message-ID: <44037A5C.6080409@gmail.com>
In-Reply-To: <20060227204252.GA31836@diana.vm.bytemark.co.uk>

Karl Hasselström wrote:

> If I make a patch series where more than one patch touches the same
> line, I get a lot of merge errors when upstream has accepted them and
> I try to merge them back.

We discussed about this in the thread announcing pg (http://article.gmane.org/gmane.comp.version-control.git/16247). This is not easy to fix because StGIT pushes patches one by one and it stops at the first conflict. Pg was trying to merge two patches at once but this is not suitable for StGIT since the latter keeps the patches as single commits.

There is another problem - the same line might have been modified by a third-party patch merged into the kernel (and the conflict solved by the maintainer).

> This situation arises for every line that's modified in more than one
> patch, and for every such patch except the last one. And it's really
> annoying, since it's intuitively obvious that there aren't actually
> any conflicts, since upstream accepted my patches verbatim.

Because I found the same situation a bit annoying, I added the --reset option to resolved. If you know your patch was merged without modifications, just use "stg resolved --all --reset local".

An idea (untested, I don't even know whether it's feasible) would be to check which patches were merged by reverse-applying them starting with the last. In this situation, all the merged patches should just revert their changes. You only need to do a git-diff between the bottom and the top of the patch and git-apply the output (maybe without even modifying the tree). If this operation succeeds, the patch was integrated and you don't even need to push it. The tool could even fold two consecutive patches and reverse-apply them. The disadvantage might be the delay when pushing patches but we could enable this test only if an option is passed to the pull command.

If you really want to make StGIT behave intelligently, have a look at the patch commuting theory in Darcs. It tends to handle this kind of conflicts easily. StGIT also does some patch commuting but using the diff3 algorithm and asks the user to fix different conflicts.

Catalin