Sharing merge conflict resolution between multiple developers on GIT?

Question

At $dayjob we maintain internal forks of the a number of upstream repositories.

Unsurprisingly updating these forks can be extremely problematic, especially when it's only one person doing the merge. Fortunately most of us are in the same physical location so it is possible to drag in someone who knows more about the code than the person merging but I can't see that scaling with remote developers.

Is there any way where we could share the conflict resolution around but still end up with a single merge commit. I'm thinking of something like the following workflow

developer A:
git merge $upstream

git mergetool ...

git commit -m "WIP: Merge upstream" --something-like--all-but-not

developer B:
git pull developer_A
git reset HEAD^

git push

Any thoughts on if something like this is currently possible? Is this something other git users would find useful?

Answer 1

One idea that immediately comes to me is to use something like "rerere" (not its implementation and storage, but the underlying idea) enhanced with the trick I use to fix-up merges in my daily integration cycle (look for "merge-fix" in howto/maintain-git.txt in Documentation/).

developer A:
git merge $upstream

And then commit this immediately, together with conflict markers (i.e. "commit -a"), and discard it with "reset --hard HEAD^" *after* storing it somewhere safe. And then redo the same merge, resolve the conflicts and commit the usual way.

The difference between the final conflict resolution and the original conflicted state can be used as a reference for others to redo the same conflict resolution later elsewhere. That can most easily be done by creating a commit that records the final state whose parent is the one you recorded the initial conflicted state.

So, the "recording" phase may go something like this:

 git checkout $this
 git merge $that
 git commit -a -m 'merge-fix/$this-$that preimage'
 git branch merge-fix/$this-$that
 git reset --hard HEAD^
 git merge $that
 edit
 git commit -a -m 'merge $that to $this'
 git checkout merge-fix/$this-$that
 git read-tree -m -u HEAD $this
 git commit -a -m 'merge-fix/$this-$that postimage'

The rough idea is "git show merge-fix/$this-$that" will show the "patch" you can apply on top of the conflicted state other people would get by running "git merge $that" while on "$this" branch.

"rerere" essentially does the above recording (and replaying) per-path and it comes with a clever indexing scheme to identify which previous conflict resolution would apply to the conflicts you see in your working tree.