{"id":107940,"date":"2023-03-15T07:00:00","date_gmt":"2023-03-15T14:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=107940"},"modified":"2023-03-15T09:26:30","modified_gmt":"2023-03-15T16:26:30","slug":"20230315-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20230315-00\/?p=107940\/","title":{"rendered":"How can I create a git feature branch that can merge into multiple other branches?"},"content":{"rendered":"

A customer had a git repo that had two branches, let’s call them dev_apple<\/code> and dev_banana<\/code>. These branches were very similar, differing only in a choice of fruit. The customer wanted to create a new branch, call it feature<\/code>, in which they could develop a feature that was not fruit-dependent. When finished, they could then create two pull requests, one to merge feature<\/code> into dev_apple<\/code> and another to merge feature<\/code> into dev_banana<\/code>. Is this possible?<\/p>\n

Yes, it’s possible, and we already explored how it works as a side effect of an earlier investigation into merging as a substitute for cherry-picking<\/a>.<\/p>\n

Suppose the repo looks like this:<\/p>\n

\u00a0<\/div>\n
\u00a0<\/div>\n\n\n\n\n\n\n\n\n\n
 <\/td>\n <\/td>\napple
\nred<\/td>\n<\/tr>\n
 <\/td>\n <\/td>\nA1<\/td>\n <\/td>\ndev_apple<\/td>\n<\/tr>\n
fruit
\nred<\/td>\n		\u2199\ufe0e<\/td>\n<\/tr>\n
M<\/td>\n<\/tr>\n
 <\/td>\n\u2196\ufe0e<\/td>\n<\/tr>\n
 <\/td>\n <\/td>\nB1<\/td>\n <\/td>\ndev_banana<\/td>\n<\/tr>\n
 <\/td>\n <\/td>\nbanana
\nred<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

At some starting commit M<\/code>, the code said “fruit red”. From the commit, the dev_apple<\/code> branch commited a change to change the code to read “apple red”. Meanwhile, from the same starting commit, the dev_banana<\/code> branch commit a change to change the code to “banana red”.<\/p>\n

Your goal is to create some branch feature<\/code> that changes red<\/code> to blue<\/code>, and then merge that branch into both the dev_apple<\/code> and dev_banana<\/code> branches. The expected result of the merge is that red<\/code> changes to blue<\/code>, but the fruit in each branch remains unchanged. Merging into dev_apple<\/code> produces “apple blue”, and merging into dev_banana<\/code> produces “banana blue”.<\/p>\n

You already know how to do this: Create a patch branch that starts at the common ancestor of the two dev<\/code> branches, which in our example is the initial commit M<\/code>.<\/p>\n\n\n\n\n\n\n\n\n\n
 <\/td>\n <\/td>\napple
\nred<\/td>\n<\/tr>\n
 <\/td>\n <\/td>\nA1<\/td>\n <\/td>\n <\/td>\n <\/td>\ndev_apple<\/td>\n<\/tr>\n
fruit
\nred<\/td>\n		\u2199\ufe0e<\/td>\n <\/td>\n <\/td>\nfruit
\nblue<\/td>\n<\/tr>\n
M<\/td>\n\u2190 \u2190 \u2190<\/td>\nF<\/td>\n <\/td>\nfeature<\/td>\n<\/tr>\n
 <\/td>\n\u2196\ufe0e<\/td>\n<\/tr>\n
 <\/td>\n <\/td>\nB1<\/td>\n <\/td>\n <\/td>\n <\/td>\ndev_banana<\/td>\n<\/tr>\n
 <\/td>\n <\/td>\nbanana
\nred<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

In this scenario, the patch branch is what we’re calling the feature<\/code> branch. In that branch, we can make a commit that makes the changes we want to apply to both of the dev<\/code> branches, namely, changing the code to “fruit blue”.<\/p>\n

Once we’re happy with the work we’ve done in the feature<\/code> branch (which could consists of several commits), we can create pull requests to merge the changes into both of the dev<\/code> branches.<\/p>\n\n\n\n\n\n\n\n\n\n
 <\/td>\n <\/td>\napple
\nred<\/td>\n		 <\/td>\n <\/td>\n <\/td>\napple
\nblue<\/td>\n<\/tr>\n
 <\/td>\n <\/td>\nA1<\/td>\n\u2190 \u2190 \u2190<\/td>\nA2<\/td>\n <\/td>\ndev_apple<\/td>\n<\/tr>\n
fruit
\nred<\/td>\n		\u2199\ufe0e<\/td>\n <\/td>\n <\/td>\nfruit
\nblue<\/td>\n		\u2199\ufe0e<\/td>\n<\/tr>\n
M<\/td>\n\u2190 \u2190 \u2190<\/td>\nF<\/td>\n <\/td>\n <\/td>\n <\/td>\nfeature<\/td>\n<\/tr>\n
 <\/td>\n\u2196\ufe0e<\/td>\n <\/td>\n <\/td>\n <\/td>\n\u2196\ufe0e<\/td>\n<\/tr>\n
 <\/td>\n <\/td>\nB1<\/td>\n\u2190 \u2190 \u2190<\/td>\nB2<\/td>\n <\/td>\ndev_banana<\/td>\n<\/tr>\n
 <\/td>\n <\/td>\nbanana
\nred<\/td>\n		 <\/td>\n <\/td>\n <\/td>\nbanana
\nblue<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

The result of these merges is that the dev_apple<\/code> branch says “apple blue” and the dev_banana<\/code> branch says “banana blue”, as desired.<\/p>\n

Note that this trick assumes that the most recent common ancestor of the dev_apple<\/code> and dev_banana<\/code> branches is not too old, or at least not so old that the code you want to change isn’t even present. In our case, we’re in good shape because the common ancestor commit M<\/code> does have the word “red” that we want to change to “blue”.<\/p>\n

The customer was satisfied with this recommendation. My guess is that the split into dev_apple<\/code> and dev_banana<\/code> was relatively recent and temporary, and the expectation was that the two dev<\/code> branches would eventually merge back together once the fruit discrepancy was resolved.<\/p>\n

\n