💻 computer science

Combining Example-Based and Rule-Based Program Transformations to Resolve Build Conflicts

Este artigo apresenta o BuCoR, uma nova ferramenta que combina transformações baseadas em regras e exemplos para detectar e resolver conflitos de compilação em fusões de software, demonstrando eficácia ao solucionar casos reais através de uma abordagem híbrida.

Autores originais: Sheikh Shadab Towqir, Fei He, Todd Mytkowicz, Na Meng

Publicado 2026-02-13

📖 4 min de leitura☕ Leitura rápida

CC BY 4.0

Autores originais: Sheikh Shadab Towqir, Fei He, Todd Mytkowicz, Na Meng

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine que você e seu amigo estão escrevendo o mesmo livro, cada um em uma cópia diferente. De repente, vocês decidem juntar as duas versões em um único manuscrito final. O problema? Vocês editaram a mesma página de formas diferentes.

Você mudou o nome do protagonista de "João" para "Pedro".
Seu amigo escreveu uma cena onde o personagem "João" aparece.

Quando tentam juntar os textos, o computador fica confuso: "Quem é o personagem? É o João ou o Pedro?". Isso é um conflito de construção (ou build conflict). Se o livro não fizer sentido, ele não pode ser publicado (o software não funciona).

Geralmente, os programadores têm que parar tudo, ler o texto, decidir o que fazer e corrigir manualmente. É chato, demorado e propenso a erros.

Aqui entra o BuCoR, o "herói" desta história. O BuCoR é uma ferramenta inteligente criada para resolver esses conflitos automaticamente. Ele funciona como um detetive literário que usa duas estratégias principais para consertar o livro:

1. A Estratégia do "Exemplo" (BuCoR-E): "Olha como fizemos antes!"

Imagine que, no passado, vocês já tiveram um problema parecido: mudaram o nome de um personagem e tiveram que atualizar todas as vezes que ele era mencionado.

O BuCoR-E olha para o histórico do projeto (os ramos de desenvolvimento) e procura por exemplos de como os desenvolvedores resolveram problemas parecidos antes.

A Analogia: É como se o BuCoR dissesse: "Ei, na página 50, quando mudamos o nome do vilão, o autor também mudou o nome do cachorro dele e corrigiu a frase 'o cachorro latiu para o vilão'. Vamos fazer a mesma coisa aqui!"
Ele aprende com o passado para criar um "padrão" de correção e aplica esse padrão ao novo conflito, mesmo que o contexto seja um pouco diferente.

2. A Estratégia das "Regras" (BuCoR-R): "Siga o Manual"

Às vezes, não há um exemplo perfeito no passado. Nesse caso, o BuCoR-R usa um manual de instruções com 16 regras pré-definidas para os erros mais comuns.

A Analogia: É como um manual de montagem de móveis. Se a peça A não encaixa na peça B porque o furo mudou, o manual diz: "Se o furo mudou, use o parafuso C".
Essas regras cobrem situações comuns, como: "Se alguém renomeou uma classe, atualize a importação", ou "Se alguém removeu um método, remova a chamada dele".

Como eles trabalham juntos?

O BuCoR é um time híbrido.

Primeiro, ele detecta onde o livro está "quebrado" (onde o código não compila).
Ele tenta usar o Exemplo (BuCoR-E) para ver se consegue imitar uma solução inteligente e criativa que já funcionou antes.
Se não houver exemplo, ele usa as Regras (BuCoR-R) para aplicar uma correção padrão e segura.
Se as duas estratégias sugerirem algo, o BuCoR compara e escolhe a melhor opção.

O Resultado?

Os pesquisadores testaram o BuCoR em 88 conflitos reais de projetos de código aberto.

Ele conseguiu gerar uma solução para 74% dos casos (o que é impressionante, já que antes as ferramentas quase não faziam nada).
Desses, ele acertou a solução correta (igual à que um humano faria) em 52% dos casos.

Em resumo:
O BuCoR é como um assistente de escrita superinteligente. Ele não apenas junta os textos; ele entende o contexto, olha para como vocês resolveram problemas parecidos no passado e segue regras lógicas para garantir que, quando o livro for publicado, o personagem "Pedro" (ou o código) funcione perfeitamente, sem que você precise passar horas corrigindo manualmente.

Ele combina a criatividade de aprender com exemplos com a segurança de seguir regras, tornando o processo de juntar códigos muito mais rápido e menos estressante para os programadores.

1. O Problema

No desenvolvimento de software colaborativo, sistemas de controle de versão (como Git) são essenciais. No entanto, quando desenvolvedores integram alterações de diferentes ramos (branches), ocorrem conflitos de mesclagem (merge conflicts).

Conflitos Textuais: Ocorrem quando edições sobrepostas acontecem no mesmo local do código.
Conflitos de Build e Teste: Ocorrem quando a integração ingênua das edições gera erros de compilação ou falhas de teste, mesmo que o código não tenha conflitos textuais diretos. Exemplo clássico: um ramo renomeia um método, enquanto o outro adiciona uma chamada a esse método com o nome antigo.

Limitações das Ferramentas Atuais:
Ferramentas existentes (como Gmerge e MrgBldBrkFixer) focam principalmente em detectar conflitos ou resolver apenas casos simples de renomeação de símbolos. Elas falham em:

Resolver conflitos complexos causados por mudanças na hierarquia de classes, adição/deleção de métodos ou parâmetros.
Sugerir edições complexas que alterem sistematicamente o uso de entidades e o contexto ao redor, limitando-se a substituições simples de nomes.

2. Metodologia: BuCoR

Os autores introduzem o BuCoR (BUild COnflict Resolver), uma ferramenta nova baseada em análise estática que combina duas estratégias complementares para resolver conflitos de build. O processo envolve quatro componentes principais:

A. Detecção de Conflitos e Construção de Gráfico

Entrada: O BuCoR analisa três versões do programa: a base ( $b$ ), o ramo esquerdo ( $l$ ) e o ramo direito ( $r$ ).
Análise Estática: Utiliza a ferramenta Bucond para modelar cada versão como um Gráfico de Entidades de Programa (PEG).
Detecção: Compara os PEGs para identificar edições conflitantes (ex: definição removida em um ramo vs. uso adicionado no outro).
Geração de Versão Ingênua: Executa um git-merge para criar uma versão mesclada automaticamente ( $A_m$ ), que contém os erros de build.
Grafo Interconectado: Cria um grafo de quatro vias conectando $b$ , $l$ , $r$ e $A_m$ para mapear o contexto e posicionar as correções.

B. Estratégia 1: Transformação Baseada em Exemplos (BuCoR-E)

Esta abordagem aprende com o histórico do projeto para resolver conflitos de forma contextual e específica.

Mineração de Exemplos: Identifica a mudança de definição (def-change) responsável pelo conflito e minera o ramo que a introduziu para encontrar edições exemplares ( $E$ ) onde desenvolvedores ajustaram usos anteriores para se adequar a essa mudança.
Inferência de Padrão:
- Refina a edição exemplar para extrair apenas as operações relevantes (usando análise de dependência de controle e dados).
- Abstrai o contexto irrelevante para criar um padrão de transformação ( $P$ ).
Aplicação de Padrão:
- Realiza correspondência de contexto (context matching) entre o padrão inferido e o código na versão mesclada ( $A_m$ ).
- Utiliza um algoritmo de correspondência "bottom-up" focado no uso da entidade alterada.
- Se houver correspondência, aplica as operações de edição do padrão para corrigir o código.

C. Estratégia 2: Transformação Baseada em Regras (BuCoR-R)

Esta abordagem utiliza regras pré-definidas para resolver conflitos comuns de forma estruturada.

Base de Regras: Implementou 16 regras de resolução baseadas em estudos empíricos anteriores e generalizações.
Cobertura: As regras cobrem tipos comuns como renomeação de classes/métodos, mudanças na hierarquia de herança (super/subclasses), remoção de imports e duplicação de definições.
Aplicação: Para cada conflito, o sistema verifica se uma regra se aplica e executa a transformação correspondente (ex: atualizar uma chamada para corresponder a uma nova assinatura).

3. Contribuições Principais

Novo Resolver Híbrido (BuCoR): A primeira ferramenta a combinar sistematicamente aprendizado baseado em exemplos (mineração de histórico) com regras estruturadas para resolver conflitos de build.
Abordagem Baseada em Exemplos Avançada (BuCoR-E): Diferente de ferramentas anteriores, utiliza análise de dependência para derivar padrões de resolução a partir de edições reais, realiza correspondência de contexto para personalização parcial/total e classifica as soluções candidatas.
Conjunto de Regras Abrangente (BuCoR-R): Implementa 16 regras que vão além da simples renomeação de símbolos, abordando conflitos de hierarquia e estrutura.
Avaliação Empírica Rigorosa: Avaliação em 88 conflitos reais de 30 projetos de código aberto, cobrindo 21 tipos distintos de conflitos.

4. Resultados Experimentais

O BuCoR foi testado em 88 conflitos reais de build:

Cobertura (Capacidade de gerar solução):
- O BuCoR gerou pelo menos uma solução para 65 dos 88 casos (74% de cobertura).
- O BuCoR-E contribuiu com 28 soluções; o BuCoR-R com 51. As estratégias são complementares.
Precisão (Correção da solução):
- O BuCoR corrigiu 34 conflitos (52% de precisão sobre o total de soluções geradas).
- BuCoR-E: 75% de precisão (21/28 corretas). É mais preciso em cenários não convencionais.
- BuCoR-R: 39% de precisão (20/51 corretas). Possui maior cobertura, mas menor precisão em casos complexos.
Comparação de Estratégias:
- O BuCoR-E é superior para conflitos que exigem edições específicas do projeto (ex: remoção de entidades, mudanças de parâmetros).
- O BuCoR-R é superior para conflitos convencionais (ex: mismatches de super/subclasses, duplicação).
Benchmark com LLMs: Em um teste extra, o modelo de linguagem o4-mini teve desempenho significativamente pior (25 correções vs. 34 do BuCoR) e limitações de token.

5. Significado e Impacto

Avanço na Automação: O BuCoR supera as limitações das ferramentas atuais que apenas detectam erros ou fazem renomeações simples. Ele propõe correções semânticas completas.
Produtividade do Desenvolvedor: Ao automatizar a resolução de conflitos complexos de build, reduz o tempo que desenvolvedores gastam em tarefas manuais e propensas a erros.
Direção Futura: O trabalho demonstra que a combinação de aprendizado baseado em exemplos (para flexibilidade) e regras (para consistência) é uma via promissora para ferramentas de mesclagem mais inteligentes.
Reprodutibilidade: O código e os dados foram disponibilizados como open-source, permitindo a comunidade científica validar e expandir a pesquisa.

Em resumo, o BuCoR representa um passo significativo na direção de ferramentas de integração de software totalmente automatizadas e inteligentes, capazes de lidar com a complexidade semântica dos conflitos de build modernos.