Como o git se funde após a escolha da cereja?

Vamos imaginar que temos um masterramo.

Então criamos um newbranch

git checkout -b newbranch

e faça dois novos commits para newbranch: commit1 e commit2

Então nós mudamos para dominar e fazer cherry-pick

git checkout master
git cherry-pick hash_of_commit1

Examinando gitk, vemos que o commit1 e sua versão escolhida com cereja têm hashes diferentes; portanto, tecnicamente, eles são dois commits diferentes.

Finalmente, nos fundimos newbranchem master:

git merge newbranch

e veja que esses dois commits com hashes diferentes foram mesclados sem problemas, embora impliquem que as mesmas alterações devam ser aplicadas duas vezes; portanto, um deles deve falhar.

O git realmente faz uma análise inteligente do conteúdo do commit durante a mesclagem e decide que as alterações não devem ser aplicadas duas vezes ou esses commit são marcados internamente como vinculados?

Resposta curta

Não se preocupe, o Git cuidará disso.

Resposta longa

Diferentemente do SVN ¹ , o Git não armazena confirmações no formato delta, mas é baseado em instantâneos ^2,3 . Enquanto o SVN tentaria ingenuamente aplicar cada confirmação mesclada como um patch (e falhar, pelo motivo exato que você descreveu), o Git geralmente é capaz de lidar com esse cenário.

Ao mesclar, o Git tentará combinar os instantâneos de ambos os commit HEAD em um novo instantâneo. Se uma parte do código ou arquivo for idêntica nos dois instantâneos (ou seja, porque um commit já foi escolhido de maneira correta), o Git não tocará nele.

Fontes

¹ Skip-Deltas no Subversion
² Noções básicas sobre Git
³ O modelo de objeto Git

Após essa mesclagem, você pode ter confirmados na história duas vezes.

Solução para evitar isso, cito um artigo que recomenda que ramificações com confirmações duplicadas (escolhidas com cerejeira) usem rebase antes da mesclagem:

git mesclar após git cherry-pick: evitando confirmações duplicadas

Imagine que temos o ramo mestre e um ramo b:

   o---X   <-- master
    \
     b1---b2---b3---b4   <-- b

Agora precisamos urgentemente dos commits b1 e b3 no master, mas não os demais commits em b. Então, o que fazemos é fazer o checkout do ramo principal e escolher cereja confirma b1 e b3:

$ git checkout master
$ git cherry-pick "b1's SHA"
$ git cherry-pick "b3's SHA"

O resultado seria:

   o---X---b1'---b3'   <-- master
    \
     b1---b2---b3---b4   <-- b

Digamos que fazemos outro commit no master e obtemos:

   o---X---b1'---b3'---Y   <-- master
    \
     b1---b2---b3---b4   <-- b

Se agora mesclarmos o ramo b no master:

$ git merge b

Obteríamos o seguinte:

   o---X---b1'---b3'---Y--- M  <-- master
     \                     /
      b1----b2----b3----b4   <-- b

Isso significa que as alterações introduzidas por b1 e b3 apareceriam duas vezes na história. Para evitar isso, podemos reorganizar em vez de mesclar:

$ git rebase master b

O que renderia:

   o---X---b1'---b3'---Y   <-- master
                        \
                         b2'---b4'   <-- b

Finalmente:

$ git checkout master
$ git merge b

nos dá:

   o---X---b1'---b3'---Y---b2'---b4'   <-- master, b

Correções de edição supostas pelo comentário de David Lemon