Validated Code Translation for Projects with External Libraries

1. O Problema

A tradução de código de sistemas legados (especificamente de Go para Rust) é uma tarefa crítica para a migração para linguagens seguras em termos de memória. No entanto, as abordagens existentes baseadas em Grandes Modelos de Linguagem (LLMs) enfrentam dois obstáculos principais quando os programas-fonte dependem de bibliotecas externas:

1. Alucinação de APIs e Falha na Resolução de Imports: Os LLMs frequentemente inventam APIs que não existem na linguagem de destino (Rust) ou selecionam bibliotecas incorretas. Além disso, mesmo que a API correta seja identificada, o modelo falha em gerar as instruções de importação (use statements) necessárias para torná-la utilizável, especialmente em Rust, onde a visibilidade e os re-exports de traits são complexos e não locais.
2. Validação de Equivalência Semântica com Tipos Opaques: Validar se a função traduzida é semanticamente equivalente à original é extremamente difícil quando os dados envolvem tipos definidos por bibliotecas externas. Esses tipos são frequentemente "opacos" (campos privados), não possuem interfaces de serialização estáveis e não podem ser acessados diretamente. Técnicas anteriores que assumem que os tipos de entrada são estruturalmente idênticos ou que todos os campos são acessíveis falham nesses cenários, impedindo testes diferenciais eficazes.

2. Metodologia

Os autores propõem o CrossCrate, um framework de tradução e validação que combina recuperação aumentada por geração (RAG) com uma pipeline de validação cruzada de linguagens. A abordagem é dividida em três estágios principais:

A. Mapeamento de Bibliotecas entre Linguagens (Stage 1)

Para mitigar a alucinação de APIs, o sistema utiliza um mecanismo de RAG (Retrieval-Augmented Generation):

• Construção de Base de Conhecimento: Para cada crate Rust alvo, é construída uma base de conhecimento indexada que mapeia APIs públicas, suas documentações e, crucialmente, os caminhos de importação válidos (incluindo re-exports e traits necessários).
• Recuperação Contextual: Ao traduzir uma chamada de função Go, o sistema extrai a API usada, consulta a base de conhecimento para encontrar a API Rust semântica correspondente e recupera as instruções de importação exatas necessárias para compilação.

B. Geração da Tradução (Stage 2)

O LLM traduz as funções e tipos individualmente, mas é guiado pelo contexto enriquecido do estágio anterior. O prompt inclui:

• A assinatura da função Go.
• Sugestões de APIs Rust recuperadas (top-k).
• Os caminhos de importação corretos e documentação associada.
  Isso garante que o código gerado seja não apenas idiomaticamente correto, mas também compilável.

C. Validação Cruzada com Tipos Opaques (Stage 3)

Esta é a contribuição mais inovadora para a validação. Como Go e Rust não compartilham representação de valores ou runtime, o sistema sintetiza adaptadores para permitir a execução cruzada:

1. Representação Intermediária (IDF): Um esquema Protobuf (TProto) é sintetizado a partir dos tipos Go. Este esquema atua como um "carreador" neutro de linguagem.
2. Sintetização de Adaptadores: O sistema gera código de "cola" (glue code) que converte:
   • Tipos Go originais $\to$ Carreador Protobuf (Go).
   • Carreador Protobuf (Rust) $\to$ Tipos Rust traduzidos.
   • Crucialmente: Essas conversões são sintetizadas exclusivamente usando APIs públicas das bibliotecas, evitando acesso direto a campos privados de tipos opacos.
3. Verificação de Round-Trip: Antes de testar a equivalência, o sistema valida que a conversão Go $\to$ Protobuf $\to$ Go preserva os valores (propriedade de round-trip).
4. Teste Diferencial I/O: Com os adaptadores validados, o sistema executa os mesmos casos de teste (inputs) no código Go original e na tradução Rust, comparando as saídas observáveis após a conversão de volta para o formato original.

3. Principais Contribuições

• Primeira Abordagem Validada para Bibliotecas Externas: É o primeiro método capaz de traduzir e validar funções que utilizam tipos de bibliotecas externas opacos e estruturalmente dissimilares entre Go e Rust.
• Resolução de Imports via RAG: Introduz um pipeline de recuperação que resolve não apenas qual API usar, mas como importá-la corretamente em Rust, lidando com a complexidade de traits e re-exports.
• Adaptadores Baseados em APIs Públicas: Desenvolve uma técnica para sintetizar adaptadores de conversão de dados que respeitam as invariâncias e a opacidade das bibliotecas, permitindo testes diferenciais onde métodos anteriores falhavam.
• Framework de Validação Modular: Um pipeline que separa a tradução da validação, permitindo regeneração seletiva (ex: regenerar apenas o corpo da função se a validação falhar, mantendo os tipos e adaptadores).

4. Resultados Experimentais

O sistema foi avaliado em 6 repositórios Go reais com dependências externas não triviais (incluindo criptografia, derivação de chaves e parsing de tempo), como age, pbkdf2 e argon2-hashing.

• Taxa de Sucesso: O método alcançou uma taxa média de sucesso de 95,83% tanto para compilação quanto para equivalência I/O.
• Comparação com Baselines:
  • Em comparação com a abordagem sem RAG (apenas LLM puro), a taxa de sucesso aumentou drasticamente (de ~41% para ~96% em compilação).
  • Em comparação com o estado da arte Oxidizer (que hard-code mapeamentos de crates), o CrossCrate superou significativamente, especialmente em casos com muitas dependências (ex: no repositório age, o Oxidizer teve 0% de sucesso, enquanto o CrossCrate atingiu 75-80%).
• Impacto do RAG e Imports: A ablação mostrou que remover a resolução de imports ou a base de conhecimento RAG reduz a taxa de sucesso para 0% em funções que dependem de bibliotecas externas, provando que a geração de código compilável depende criticamente desses componentes.

5. Significância

Este trabalho representa um avanço significativo na automação da migração de sistemas críticos. Ao resolver o problema dos tipos opacos de bibliotecas externas e a complexidade de importação do Rust, o framework torna viável a tradução de projetos reais de grande escala que seriam anteriormente intratáveis para ferramentas de tradução automática. A capacidade de validar a equivalência semântica sem acesso aos campos internos das bibliotecas abre caminho para a adoção segura de Rust em sistemas legados complexos, garantindo que a funcionalidade seja preservada mesmo em cenários de dependências externas intensas.