💻 computer science

AdaTrans: Automated C to Rust Transformation via Error-Adaptive Repair

O AdaTrans é um framework automatizado que utiliza recuperação orientada por estratégia, transformação adaptativa a erros e validação em múltiplos estágios para converter com sucesso código C em Rust seguro e compilável, alcançando altas taxas de aprovação enquanto minimiza construtos unsafe.

Autores originais: Xiaofan Liu, Zecan Li, Zhuang Zhao, Ziqi Shuai, Yanming Yang, Qi Xin, Jifeng Xuan

Publicado 2026-07-01

📖 6 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Xiaofan Liu, Zecan Li, Zhuang Zhao, Ziqi Shuai, Yanming Yang, Qi Xin, Jifeng Xuan

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

O Panorama Geral: Traduzindo uma Linguagem Perigosa em uma Linguagem Segura

Imagine que você tem uma biblioteca enorme de livros antigos escritos em C, uma linguagem de programação que é incrivelmente rápida e poderosa, mas também notoriamente perigosa. Em C, o autor (o programador) é o único responsável por manter o edifício seguro. Se ele esquecer de trancar uma porta (liberar memória) ou deixar uma janela aberta (ponteiro pendente/dangling pointer), toda a casa pode pegar fogo (travar ou ser hackeada).

Agora, imagine que você quer mover todos esses livros para um novo edifício feito de Rust. Rust é uma linguagem moderna que atua como um inspetor de obras super rigoroso. Ele não permite que você escreva um livro a menos que prove, página por página, que cada porta está trancada e cada janela está segura. Se você tentar dar um jeitinho de usar um hábito perigoso, o inspetor bate a porta na sua cara e diz: "Não, não é permitido".

O Problema:
Por décadas, mudar de C para Rust tem sido um pesadelo.

Trabalho Manual: Fazer isso à mão leva uma eternidade.
Ferramentas Antigas: Existem ferramentas automatizadas, mas elas costumam "trapacear". Elas escrevem o código, mas escondem as partes perigosas atrás de sinais de "unsafe" (inseguro), efetivamente ignorando o inspetor de obras.
A IA tem Dificuldades: A Inteligência Artificial (LLMs) atual consegue escrever código, mas são como escritores brilhantes que não entendem os códigos de construção rigorosos do Rust. Eles escrevem histórias belas que o inspetor rejeita imediatamente devido a uma minúscula violação de segurança.

A Solução: AdaTrans
Os autores criaram o AdaTrans, um sistema inteligente que não apenas adivinha; ele aprende com seus erros para traduzir código C em código Rust seguro. Pense nisso como um Arquiteto Mestre e uma Equipe de Inspetores trabalhando juntos em um ciclo.

Como o AdaTrans Funciona: A Dança de Três Etapas

O sistema funciona em um ciclo contínuo de Tentar → Verificar → Corrigir. Veja como ele lida com o processo:

1. A "Inspeção de Múltiplos Estágios" (Fase 1)

Quando a IA tenta traduzir um trecho de código C, o AdaTrans o submete imediatamente a dois testes:

A Verificação de Sintaxe: O código sequer parece um Rust válido? (ex: falta de ponto e vírgula).
A Verificação de Segurança e Lógica: Ele compila sem quebrar as regras estritas de segurança do Rust? E ele realmente faz o que o código C original fazia?
O Resultado: Se falhar, o sistema não diz apenas "Erro". Ele categoriza o erro. É um erro de digitação? Uma violação de segurança? Ou a lógica está simplesmente errada?

2. O "Bibliotecário Especializado" (Fase 2: RAG Baseado em Estratégia)

Este é o cérebro da operação. Em vez de apenas mostrar o erro bruto para a IA (que geralmente é confuso), o AdaTrans atua como um bibliotecário especializado.

Se o erro for um erro de digitação (Sintaxe), o bibliotecário entrega à IA uma folha de dicas de "Correção Gramatical".
Se o erro for sobre segurança (Ownership/Propriedade), o bibliotecário entrega um "Manual de Segurança Rust" com exemplos específicos de como lidar com a memória de forma segura.
Se o erro for de lógica (o código roda, mas dá a resposta errada), o bibliotecário dá à IA um comando de "Pensamento Criativo" para repensar todo o algoritmo.

A Analogia: Imagine que você está tentando consertar um carro.

Se o pneu estiver furado, você não chama um mecânico para reconstruir o motor; você apenas pega um kit de reparo de pneus.
Se o motor estiver fazendo um barulho estranho, você não apenas aperta um parafuso; você precisa de um diagnóstico profundo.
O AdaTrans garante que a IA receba a ferramenta certa para o problema específico.

3. A "Temperatura Adaptativa" (Fase 3: ESTS)

Este é o ingrediente secreto. Quando a IA tenta corrigir o código, ela precisa decidir o quão "criativa" ou "cautelosa" deve ser. O AdaTrans controla isso usando um controle de "temperatura":

Temperatura Baixa (Cautelosa): Para erros de digitação simples, a IA é instruída a ser muito precisa e seguir as regras. Sem suposições selvagens.
Temperatura Média (Equilibrada): Para erros de segurança, a IA é instruída a explorar algumas maneiras diferentes de organizar a memória, mas mantendo-se dentro das regras.
Temperatura Alta (Criativa): Se o código estiver logicamente errado (ex: o cálculo está incorreto), a IA é instruída a ser ousada e tentar estruturas completamente novas. Ela precisa sair de seu padrão de pensamento atual para encontrar a solução certa.

O Detector de "Travamento":
Se a IA continuar cometendo o mesmo erro repetidamente (como um cachorro correndo atrás do próprio rabo), o AdaTrans percebe essa "estagnação". Ele aperta um botão de RESET, descarta a tentativa atual e começa do zero a partir do código C original com uma folha limpa. Isso evita que a IA perca tempo em um beco sem saída.

Os Resultados: Funcionou?

Os autores testaram isso em 104 diferentes enigmas de programação (extraídos de competições do LeetCode que a IA ainda não tinha visto antes).

Taxa de Sucesso: O AdaTrans traduziu com sucesso cerca de 81% dos problemas em código Rust que era tanto seguro (sem blocos "unsafe" perigosos) quanto correto (passou em todos os testes).
Comparação:
- IA Antiga (Zero-shot): Sem este sistema especial, a IA acertou apenas cerca de 25% de primeira. Mesmo se você permitisse que ela tentasse 100 vezes aleatoriamente, ela só chegava a 70%. O AdaTrans chegou a 81% em um único processo inteligente e iterativo.
- Ferramentas Antigas: Ferramentas tradicionais (como o c2rust) podiam compilar o código, mas preenchiam-no com blocos "unsafe" (trapaceando as regras de segurança). O AdaTrans manteve o código 99% seguro.
- Outras Ferramentas de IA: Outras ferramentas de IA recentes tiveram dificuldade em passar dos 20% de sucesso porque não consegravam lidar com erros de lógica complexos.

A Conclusão

O AdaTrans prova que você não precisa escolher entre "tradução rápida" e "código seguro". Ao ensinar a IA a:

Ouvir o tipo específico de erro,
Consultar o conhecimento especializado para aquele erro, e
Ajustar seu nível de criatividade com base na dificuldade,

...ela consegue migrar com sucesso códigos antigos e perigosos para códigos modernos e seguros. É como dar à IA um mapa, uma bússola e um guia que sabe exatamente quando caminhar com cuidado e quando dar um salto de fé.

Resumo Técnico: AdaTrans

Problema
A transformação automatizada de código C para Rust permanece um desafio de engenharia significativo devido aos rigorosos sistemas de propriedade (ownership), empréstimo (borrowing) e tempo de vida (lifetime) do Rust. Embora os Modelos de Linguagem de Grande Escala (LLMs) mostrem promessa na geração de código, eles frequentemente produzem código Rust que viola regras de propriedade ou depende fortemente de blocos unsafe para contornar o verificador de empréstimos (borrow checker). As abordagens existentes sofrem de três limitações primárias: (1) LLMs de uso geral têm dificuldade em atravessar a barreira semântica entre o gerenciamento de memória manual do C e o sistema de tipos afins do Rust; (2) os métodos atuais subutilizam o feedback do compilador para reparo iterativo, tratando diagnósticos como questões sintáticas superficiais em vez de conflitos estruturais; e (3) sem verificação direcionada, o código gerado tende a contornar restrições de segurança em vez de satisfazê-las, levando à inequivalência funcional ou insegurança de memória.

Metodologia: O Framework AdaTrans
O AdaTrans é um framework de ponta a ponta projetado para a transformação ao nível de arquivo de módulos C autocontidos. Ele opera através de um pipeline de geração-verificação-reparo de três fases em ciclo fechado que adapta as estratégias de reparo com base no tipo específico de sinal de falha observado.

Validação de Múltiplas Etapas (Fase 1):
O framework emprega um oráculo determinístico para avaliar o código Rust candidato. Este pipeline primeiro invoca o compilador Rust (cargo build) para detectar erros de sintaxe, ligação (linking) e propriedade. Se o código compilar, ele prossegue para a execução dinâmica contra uma suíte de testes baseada em fuzzing para verificar a equivalência funcional (consistência de I/O) com o programa C original. Esta etapa extrai sinais de diagnóstico (códigos de erro do compilador e falhas de teste) para guiar os reparos subsequentes.
Geração Aumentada por Recuperação (RAG) Direcionada por Estratégia (Fase 2):
Para preencher a lacuna entre os diagnósticos brutos do compilador e o contexto de reparo estruturado, o AdaTrans utiliza um Grafo de Violação-Reparo de Rust (RVFG). Este grafo mapeia assinaturas específicas de erro do compilador (ex: E0597) para âncoras semânticas, que incluem:
- Templates de Reparo: Meta-prompts específicos de função (ex: correção de sintaxe, raciocínio de propriedade, reflexão algorítmica).
- Trechos de Conhecimento: Documentação oficial do Rust relevante para a categoria do erro.
  Este mecanismo garante que o LLM receba orientação direcionada em vez de mensagens de erro brutas, afastando-o de atalhos unsafe e direcionando-o para soluções idiomáticas.
Estratégia de Transformação Estratificada por Erro (ESTS) (Fase 3):
O AdaTrans classifica os sinais de diagnóstico em quatro categorias semânticas e ajusta o comportamento de amostragem (temperatura) do LLM adequadamente:
- Sintática-Ligação (SL): Erros rígidos (ex: falta de ponto e vírgula) são abordados com amostragem de baixa entropia ( $\theta=0.1$ ) para correções precisas e determinísticas.
- Semântica de Memória (MS): Conflitos de propriedade e tempo de vida são abordados com amostragem de entropia moderada ( $\theta=0.5$ ) para explorar padrões alternativos de gerenciamento de memória (ex: clonagem vs. empréstimo).
- Lógica-Comportamento (LB): Falhas funcionais (compila, mas com saída errada) são abordadas com amostragem de alta entropia ( $\theta=1.2$ ) para escapar de ótimos locais e disparar reestruturação algorítmica significativa.
- Fallback Ambíguo (AF): Erros não vistos retornam à exploração de base.
  Adicionalmente, um mecanismo de Escape de Estagnação de Loop Local reinicia a trajetória de reparo se a mesma categoria de erro persistir por mais de três iterações consecutivas, evitando loops infinitos.

Principais Contribuições

Um Framework Direcionado pelo Feedback do Compilador: O AdaTrans introduz um pipeline de três fases especificamente projetado para migração controlada ao nível de arquivo, integrando diagnósticos do compilador e feedback de execução em um loop de reparo unificado.
Reparo Operacional Estratificado por Erro (ESTS): O artigo propõe uma estratégia que categoriza erros e ajusta dinamicamente a diversidade de geração (temperatura) para corresponder à rigidez da restrição, equilibrando a explotação para correções de sintaxe com a exploração para mutações algorítmicas.
RAG Direcionado por Estratégia: Um mecanismo de recuperação inovador que mapeia assinaturas de erro para templates de reparo específicos e conhecimento de domínio, fornecendo orientação estruturada além das mensagens brutas do compilador.
Estudo Empírico de Trade-offs entre Correção e Segurança: Os autores fornecem uma avaliação rigorosa da correção da transformação versus segurança de memória sob um backbone de LLM fixo.

Resultados Experimentais
O framework foi avaliado em um conjunto de dados de 104 problemas algorítmicos de competições semanais do LeetCode (lançados após o corte de conhecimento do LLM para mitigar a contaminação). A avaliação comparou o AdaTrans contra três ferramentas baseadas em LLM existentes (EvoC2Rust, Tymcrat, PtrTrans), um baseline de LLM zero-shot e o transpiler tradicional c2rust de nível de AST.

Desempenho: O AdaTrans alcançou uma taxa média de passagem de compilação de 95,51% e uma taxa média de solução de 81,09% ao longo de três execuções independentes.
Comparação: O AdaTrans melhorou a taxa de solução em relação à ferramenta baseada em LLM mais forte (Tymcrat) em 59,94 pontos percentuais. Também superou o baseline de LLM zero-shot (pass@100) em 10,51 pontos percentuais, utilizando significativamente menos tokens (aproximadamente 1/3 do custo).
Segurança: O framework manteve uma taxa média de arquivos unsafe de 1,19%, um contraste marcante com o c2rust, que produziu código unsafe em 100% de suas saídas compiláveis (97,94% das linhas de código).
Ablação: Remover o módulo ESTS reduziu a taxa de solução em ~12%, e remover o módulo RAG reduziu-a em ~10%. Remover ambos causou uma queda de ~34%, demonstrando seu efeito sinérgico.

Significância e Alegações
O artigo afirma que o AdaTrans demonstra que adaptar as estratégias de reparo às características semânticas dos diagnósticos do compilador pode reconciliar com sucesso a correção da transformação com a segurança de memória. Ao isolar o núcleo semântico da transformação ao nível de arquivo, os autores mostram que o reparo iterativo guiado por estratégias estratificadas por erro e recuperação de conhecimento direcionada pode alcançar alta equivalência funcional sem depender de blocos unsafe. O trabalho sugere que, embora os LLMs de uso geral tenham dificuldade com a natureza não local da propriedade do Rust, uma abordagem estruturada e direcionada por feedback pode navegar efetivamente pela barreira semântica entre C e Rust. Os autores posicionam isso como um passo em direção à migração segura e automatizada de bases de código C legadas, particularmente para módulos autocontidos onde a equivalência funcional pode ser rigorosamente verificada.