Resumo Técnico: Em Linha com o Contexto: Geração de Código em Nível de Repositório via Incorporação de Contexto

Declaração do Problema

A geração de código em nível de repositório exige que Modelos de Linguagem de Grande Escala (LLMs) compreendam bases de código inteiras, raciocinando sobre dependências complexas entre funções, classes e módulos. Diferentemente da geração em nível de função, esta tarefa exige consistência com o design do repositório, convenções de codificação e relações inter-funcionais intrincadas.

As abordagens atuais enfrentam limitações significativas:

• Geração Aumentada por Recuperação (RAG): Baseia-se em similaridade textual superficial, que frequentemente recupera trechos lexicalmente similares, mas funcionalmente irrelevantes, falhando em capturar as dependências semânticas que governam a semântica em nível de repositório.
• Seleção Baseada em Contexto: Métodos que simplesmente preprendem código recuperado ou utilizam análise estática (por exemplo, grafos de fluxo de controle) frequentemente negligenciam o papel específico da função-alvo dentro de seu ambiente de chamada real. Eles falham em representar sistematicamente como uma função é usada por seus chamadores (a montante) ou como depende de suas chamadas (a jusante), levando a erros em vinculação de variáveis, tipos de retorno e uso de APIs.

Metodologia: InlineCoder

Os autores propõem o InlineCoder, um framework que reformula a geração em nível de repositório em uma tarefa tratável em nível de função, incorporando a função inacabada em seu grafo de chamadas. A ideia central é que o comportamento de uma função é restrito por seus chamadores a montante (cenários de uso) e sua implementação depende de suas chamadas a jusante (dependências).

O framework opera por meio de um pipeline de três estágios:

1. Geração de Rascunho (Criação de Âncora)

Dada uma assinatura de função, o InlineCoder primeiro gera uma implementação preliminar (a "âncora" ou "rascunho").

• Entrada: Um prompt base contendo a assinatura-alvo, descrição em linguagem natural e todas as instruções de importação e dependências referenciadas diretamente do repositório.
• Saída: Uma implementação de rascunho e uma lista de chamadas de API utilizadas dentro dela.
• Propósito: Este rascunho serve a dois papéis: (1) atua como uma semente para identificar dependências a jusante (chamadas) e (2) fornece uma linha de base para estimativa de confiança baseada em perplexidade.

2. Incorporação de Contexto (Enriquecimento Bidirecional)

O rascunho impulsiona um processo de incorporação bidirecional para construir um contexto abrangente:

• Incorporação a Montante: O sistema identifica todos os chamadores da função-alvo no repositório. Em seguida, ele incorpora a implementação do rascunho diretamente nessas funções chamadoras. Isso envolve uma transformação de quatro etapas:
  1. Substituição de Parâmetros: Mapeamento de argumentos do chamador para parâmetros do chamado.
  2. Normalização de Retorno: Conversão de instruções return para atribuições de variáveis (resultado = ...) para se adequar ao fluxo do chamador.
  3. Redirecionamento de Atribuição: Vinculação do resultado da chamada às variáveis do chamador.
  4. Expansão Incorporada: Substituição da chamada de função no chamador pelo corpo do rascunho transformado.
     Resultado: Isso converte relações de chamada distribuídas em uma visão linearizada e orientada à execução, expondo restrições de entrada/saída e padrões de uso.
• Recuperação a Jusante: O sistema extrai chamadas de função da AST do rascunho e das chamadas previstas pelo LLM. Ele realiza recuperação baseada em substring para encontrar implementações de função correspondentes no repositório. Essas chamadas recuperadas são integradas ao prompt para fornecer contexto preciso de dependência.

3. Geração de Código Consciente do Contexto

O estágio final integra o rascunho, o contexto incorporado a montante e o contexto recuperado a jusante em um prompt unificado.

• Mecanismo de Confiança: O sistema calcula a perplexidade (PPL) do rascunho inicial. Com base em limites de PPL, atribui um nível de confiança (Alta, Média, Baixa) e gera orientações específicas em linguagem natural para o LLM:
  • Alta Confiança: Confiar estritamente no rascunho.
  • Confiança Média: Modificar ou melhorar parcialmente o rascunho.
  • Baixa Confiança: Reavaliar criticamente e potencialmente regenerar do zero.
• Saída Final: O LLM gera o corpo final da função, guiado pelo prompt enriquecido que inclui a assinatura-alvo, uso incorporado a montante, dependências a jusante e instruções baseadas em confiança.

Contribuições Principais

1. Framework Inovador: A proposta do InlineCoder, que situa funções-alvo tanto em contextos a montante (chamadores) quanto a jusante (chamadas) por meio de um mecanismo de incorporação de grafo de chamadas.
2. Incorporação Sem Precedentes: Os autores afirmam ser os primeiros a incorporar uma função diretamente no contexto de seus chamadores, permitindo que o LLM infira o propósito pretendido e os padrões de uso de forma mais profunda do que a simples recuperação.
3. Avaliação Abrangente: Experimentos extensivos demonstrando melhorias consistentes sobre baselines de última geração em diversos domínios e múltiplos LLMs base.

Resultados Experimentais

O framework foi avaliado nos benchmarks DevEval e RepoExec usando três LLMs base: DeepSeek-V3, Qwen3-Coder e GPT5-mini.

• Ganhos de Desempenho: O InlineCoder superou substancialmente as baselines (incluindo In-File, Vanilla, RepoCoder, GraphCoder e DRACO).
  • No RepoExec, alcançou ganhos relativos médios de 29,73% em Correspondência Exata (EM), 20,82% em Similaridade de Edição (ES) e 49,34% em BLEU em comparação com a baseline mais forte.
  • No DevEval, mostrou melhorias consistentes, com ganhos relativos médios de 5,13% em EM, 10,86% em ES e 10,67% em BLEU.
• Estudos de Ablação: A remoção de qualquer componente (incorporação a montante, recuperação a jusante, geração de rascunho ou orientação de confiança) resultou em degradação de desempenho. A implementação de rascunho foi identificada como o componente mais crítico.
• Análise Qualitativa:
  • Instruções de Retorno: O InlineCoder melhorou a precisão na geração de instruções de retorno em 2,07% (EM) sobre as baselines, atribuído a uma melhor compreensão do contexto a montante.
  • Chamadas de Função: Melhorou a precisão das instruções de chamada de função em 4,27% (EM), demonstrando melhor resolução de dependências a jusante.
• Generalização de Domínio: O método performou de forma robusta em 10 domínios de software diferentes (por exemplo, Banco de Dados, Segurança, Processamento de Texto), alcançando os melhores resultados em 9/10 domínios para EM e em todos os 10 para ID.F1. O desempenho foi ligeiramente inferior no domínio Científico-Engenharia, onde as invocações entre funções são naturalmente esparsas.

Significado e Afirmações

O artigo afirma que o InlineCoder aborda a limitação fundamental das estratégias de recuperação existentes, indo além da similaridade superficial para capturar as dependências estruturais e semânticas de um repositório. Ao reformular o problema por meio da incorporação de contexto, o método transforma o raciocínio complexo em nível de repositório em uma tarefa mais gerenciável em nível de função, onde o modelo pode ver explicitamente como o código se encaixa no sistema mais amplo.

Os autores enfatizam que sua abordagem não requer ajuste fino extensivo; em vez disso, aproveita as capacidades de raciocínio de LLMs existentes por meio de uma estratégia de prompt cuidadosamente projetada que integra restrições de uso a montante e dependências a jusante. Os resultados destacam a eficácia do framework na geração de código que não é apenas sintaticamente correto, mas também semanticamente consistente com o design e as dependências do repositório.