Resumo Técnico: Gerando Analisadores de Código Complexos a partir de Perguntas em Linguagem Natural

Declaração do Problema

O desenvolvimento de software frequentemente envolve desenvolvedores fazendo perguntas analíticas sobre bases de código para entender a estrutura global, semântica e possíveis erros. No entanto, responder a essas perguntas em sistemas de grande escala (milhões de linhas de código distribuídas em milhares de arquivos) apresenta desafios significativos:

1. Limitações das Ferramentas Padrão: Ferramentas como grep ou recursos de busca de IDEs são limitados a correspondência de padrões sintáticos ou locais e não podem realizar o raciocínio interprocedural ou a análise semântica exigida por consultas complexas (por exemplo, encontrar métodos que chamam métodos sobrescritos dentro de construtores).
2. Limitações dos Modelos de Linguagem de Grande Escala (LLMs): Embora os LLMs ofereçam uma interface natural, eles lutam com bases de código grandes devido a restrições de janela de contexto, limites de recursos e à falta de uma visão estruturada e persistente do código. Promptar diretamente os LLMs frequentemente leva a saídas inconsistentes, alucinações ou resultados vazios. Além disso, gerar consultas de análise de programa complexas (especificamente em CodeQL) é difícil devido à escassez de dados de treinamento e às semânticas "delicadas" da linguagem, onde variações mínimas podem levar a consultas sintaticamente inválidas ou semanticamente degeneradas.

Metodologia: O Sistema Merlin

Os autores apresentam o Merlin, um sistema que integra Modelos de Linguagem de Grande Escala com CodeQL, um framework de análise de programa declarativo. O Merlin traduz perguntas em linguagem natural em consultas CodeQL executáveis, fundamentando as respostas nos resultados da análise estática em vez da representação interna de texto do LLM.

O sistema opera por meio de um fluxo de trabalho composto por três componentes principais:

1. Pré-processamento da Pergunta

Antes da geração da consulta, o Merlin prepara dois artefatos-chave:

• Geração de Auto-teste: O LLM é instruído a gerar exemplos de código concretos (casos de teste) que devem ou não satisfazer o objetivo do usuário. Estes servem como um "teste decisivo" para detectar consultas degeneradas (aquelas que produzem resultados vazios apesar de serem sintaticamente corretas) antes de serem executadas na base de código completa.
• Recuperação Iterativa de Documentação: Em vez de pedir ao LLM para listar diretamente as construções CodeQL necessárias (o que leva a alucinações), o Merlin usa um loop iterativo baseado em RAG. Primeiro, ele extrai palavras-chave da pergunta do usuário e, em seguida, pede ao LLM para mapeá-las para construções CodeQL. O sistema valida essas construções contra a documentação oficial do CodeQL, fornecendo feedback sobre construções inexistentes e iterando até que um conjunto válido seja estabelecido.

2. Depuração de Consultas Baseada em RAG

O LLM gera uma consulta CodeQL inicial com base no objetivo do usuário, no esquema de saída, nos auto-testes e na documentação recuperada. Esta consulta é compilada usando o compilador CodeQL.

• Se o compilador retornar erros de sintaxe, o Merlin extrai as mensagens de erro, recupera documentação relevante para as construções específicas envolvidas e instrui o LLM a revisar a consulta.
• Este loop continua até que uma consulta sintaticamente válida seja produzida.

3. Verificação Semântica via Consultas Assistivas

Mesmo consultas sintaticamente válidas podem falhar em capturar a semântica pretendida (por exemplo, serem excessivamente seletivas e retornar resultados vazios). Para abordar isso, o Merlin emprega Consultas Assistivas:

• Se uma consulta falhar no auto-teste (retornar resultados vazios), o sistema instrui o LLM a gerar uma consulta "assistiva" auxiliar.
• Essas consultas são projetadas para serem permissivas (por exemplo, imprimindo tipos ou propriedades intermediárias) para expor por que a consulta original falhou.
• Os resultados da consulta assistiva são alimentados de volta ao LLM para diagnosticar o defeito semântico e refinar a consulta original.
• Este loop "compilar-testar-assistir" se repete até que a consulta produza resultados não vazios nos auto-testes.

Finalmente, a consulta validada é executada sobre toda a base de código, e os resultados são apresentados ao usuário em formato tabular, acompanhados pela consulta CodeQL gerada como justificativa.

Contribuições Principais

1. Sistema Merlin: Uma arquitetura inovadora que integra LLMs com analisadores de programa (CodeQL) para responder a perguntas em linguagem natural de livre forma sobre grandes bases de código de forma confiável.
2. Técnicas de Depuração Inovadoras:
   • Um procedimento iterativo baseado em RAG para gerar consultas sintaticamente corretas apesar da escassez de dados de treinamento em CodeQL.
   • Uma técnica de auto-teste usando exemplos de código gerados automaticamente para detectar consultas degeneradas.
   • Consultas assistivas que funcionam como instruções de impressão diagnósticas para expor e explicar falhas semânticas em consultas candidatas.
3. Avaliação Empírica: Uma avaliação abrangente incluindo benchmarks, uma pesquisa e um estudo com usuários demonstrando a eficácia do sistema.

Resultados

Avaliação Experimental (Benchmarks)

Os autores avaliaram o Merlin contra 182 perguntas em linguagem natural derivadas do SpotBugs (142 detectores) e do GitHub Security Lab (40 consultas) em 13 grandes bases de código.

• Recall: O Merlin superou significativamente as abordagens de linha de base (resposta direta do LLM, geração LLM-para-CodeQL sem depuração). O Merlin alcançou um recall macro de 0,62 e um recall micro de 0,64, comparado a linhas de base que frequentemente lutavam com recall (por exemplo, GPT-4o/CQL teve 0,08 de recall micro).
• Precisão e Descoberta: Enquanto as linhas de base frequentemente perdiam problemas, o Merlin não apenas reproduziu os resultados dos analisadores de referência, mas também identificou localizações previamente desconhecidas. Uma pesquisa com usuários confirmou que muitas dessas descobertas "novas" eram trechos de código genuinamente relevantes que outras ferramentas haviam perdido, sugerindo que o Merlin alcança maior precisão e recall do que as ferramentas de referência quando o julgamento humano é a verdade fundamental.
• Eficiência de Recursos: Diferentemente das linhas de base que exigem o upload de bases de código inteiras para LLMs (atingindo limites de arquivo e janelas de contexto), o Merlin sintetiza consultas independentemente da base de código, resultando em comprimentos de prompt e custos computacionais significativamente menores.

Estudo com Usuários

Um estudo intra-sujeito com 18 participantes (13 estudantes, 5 profissionais) encarregados de encontrar e corrigir violações de padrões de codificação SEI CERT revelou:

• Precisão: O acesso ao Merlin aumentou a precisão da tarefa em média de 3,8×. A melhoria foi mais pronunciada para tarefas complexas (Tarefa T1: 5,6×; Tarefa T3: 4,9×) e menor para tarefas solucionáveis por simples grep (Tarefa T2: 1,6×).
• Eficiência: Os participantes que usaram o Merlin concluíram as tarefas 31% mais rápido em média.
• Mudança Comportamental: O Merlin deslocou as estratégias dos usuários de correspondência de padrões intensiva em trabalho (regex, busca por palavras-chave) para raciocínio de alto nível. Também reduziu a dependência de IA externa para a fase de "descoberta", embora os autores observem um risco de os usuários confiarem excessivamente nas saídas do Merlin.

Significado e Alegações

O artigo afirma que o Merlin conecta com sucesso a lacuna entre a interface em linguagem natural dos LLMs e o raciocínio rigoroso e estruturado dos analisadores de programa. Ao abordar os desafios específicos de gerar consultas de análise complexas e de baixo recurso (CodeQL) por meio de depuração iterativa e auto-teste, o Merlin permite que desenvolvedores realizem análises exaustivas, auditáveis e repetíveis em grandes bases de código.

Os autores enfatizam que o Merlin não é meramente um chatbot, mas um sistema que produz saídas certificáveis (a consulta CodeQL gerada), permitindo que desenvolvedores verifiquem a lógica por trás dos resultados. Esta abordagem supera a não confiabilidade do raciocínio puramente baseado em LLM e a rigidez das ferramentas tradicionais de análise estática, oferecendo uma solução prática para tarefas modernas de engenharia de software que exigem compreensão semântica profunda do código.

O artigo mantém-se modesto quanto ao seu escopo, reconhecendo que atualmente se concentra na descoberta de erros e perguntas analíticas, e que trabalhos futuros são necessários para suportar fluxos de trabalho mais amplos de desenvolvedores, depuração interativa e perguntas não analíticas.