Technische Samenvatting: Genereren van Complexe Code-analysatoren uit Natuurlijke Taalvragen

Probleemstelling

Softwareontwikkeling houdt vaak in dat ontwikkelaars analytische vragen stellen over codebases om de globale structuur, semantiek en potentiële bugs te begrijpen. Het beantwoorden van deze vragen in systemen op grote schaal (miljoenen regels code verspreid over duizenden bestanden) vormt echter aanzienlijke uitdagingen:

1. Beperkingen van Standaardtools: Tools zoals grep of zoekfuncties in IDE's zijn beperkt tot syntactische of lokale patroonmatching en kunnen de interprocedurale redenering of semantische analyse uitvoeren die nodig is voor complexe queries (bijvoorbeeld het vinden van methoden die overridable methoden aanroepen binnen constructoren).
2. Beperkingen van Grootte Taalmodellen (LLM's): Hoewel LLM's een natuurlijke interface bieden, worstelen ze met grote codebases vanwege beperkingen in het contextvenster, resourcebeperkingen en het ontbreken van een gestructureerd, persistent overzicht van de code. Het direct prikken van LLM's leidt vaak tot inconsistente output, hallucinaties of lege resultaten. Bovendien is het genereren van complexe programma-analyse queries (specifiek in CodeQL) moeilijk vanwege de schaarste aan trainingsdata en de "delicate" semantiek van de taal, waarbij kleine variaties kunnen leiden tot syntactisch ongeldige of semantisch gedegenereerde queries.

Methodologie: Het Merlin-systeem

De auteurs presenteren Merlin, een systeem dat Large Language Models integreert met CodeQL, een declaratief programma-analyseframework. Merlin vertaalt vragen in natuurlijke taal naar uitvoerbare CodeQL-queries, waarbij de antwoorden worden verankerd in de resultaten van statische analyse in plaats van in de interne tekstrepresentatie van de LLM.

Het systeem werkt via een workflow die bestaat uit drie hoofdbestanddelen:

1. Voorverwerking van Vragen

Voordat de query wordt gegenereerd, bereidt Merlin twee belangrijke artefacten voor:

• Zelftestgeneratie: De LLM wordt geprompt om concrete codevoorbeelden (testcases) te genereren die wel of niet aan het doel van de gebruiker moeten voldoen. Deze dienen als een "litmus test" om gedegenereerde queries (die ondanks syntactische correctie lege resultaten opleveren) te detecteren voordat ze op de volledige codebase worden uitgevoerd.
• Iteratieve Documentatieopvraging: In plaats van de LLM te vragen om direct de benodigde CodeQL-constructen op te sommen (wat leidt tot hallucinaties), gebruikt Merlin een iteratieve RAG-gebaseerde lus. Het extraheert eerst trefwoorden uit de vraag van de gebruiker, waarna de LLM deze in kaart brengt naar CodeQL-constructen. Het systeem valideert deze constructen tegen de officiële CodeQL-documentatie, geeft feedback over niet-bestaande constructen en herhaalt dit totdat een geldige set is vastgesteld.

2. RAG-gebaseerde Query-debugging

De LLM genereert een initiële CodeQL-query op basis van het doel van de gebruiker, het outputschema, de zelftests en de opgevraagde documentatie. Deze query wordt gecompileerd met de CodeQL-compiler.

• Als de compiler syntaxisfouten retourneert, extrahert Merlin de foutberichten, haalt relevante documentatie op voor de specifieke betrokken constructen en prompt de LLM om de query te herzien.
• Deze lus gaat door totdat een syntactisch geldige query is geproduceerd.

3. Semantische Verificatie via Assisterende Queries

Zelfs syntactisch geldige queries kunnen falen in het vastleggen van de beoogde semantiek (bijvoorbeeld door te selectief te zijn en lege resultaten terug te geven). Om dit aan te pakken, hanteert Merlin Assisterende Queries:

• Als een query de zelftest niet haalt (lege resultaten retourneert), vraagt het systeem de LLM om een aanvullende "assisterende" query te genereren.
• Deze queries zijn ontworpen om permissief te zijn (bijvoorbeeld het afdrukken van typen of tussenliggende eigenschappen) om bloot te leggen waarom de oorspronkelijke query faalde.
• De resultaten van de assisterende query worden teruggevoerd naar de LLM om de semantische fout te diagnosticeren en de oorspronkelijke query te verfijnen.
• Deze "compileer-test-assisteer"-lus herhaalt zich totdat de query niet-lege resultaten oplevert op de zelftests.

Tot slot wordt de gevalideerde query uitgevoerd over de volledige codebase en worden de resultaten in een tabelvorm aan de gebruiker gepresenteerd, vergezeld van de gegenereerde CodeQL-query als rechtvaardiging.

Belangrijkste Bijdragen

1. Merlin-systeem: Een nieuwe architectuur die LLM's integreert met programmanaalysatoren (CodeQL) om vrij geformuleerde vragen in natuurlijke taal over grote codebases betrouwbaar te beantwoorden.
2. Nieuwe Debuggingtechnieken:
   • Een RAG-gebaseerde iteratieve procedure voor het genereren van syntactisch correcte queries ondanks de schaarste aan CodeQL-trainingsdata.
   • Een zelftesttechniek die automatisch gegenereerde codevoorbeelden gebruikt om gedegenereerde queries te detecteren.
   • Assisterende queries die fungeren als diagnostische printstatements om semantische fouten in kandidaat-queries bloot te leggen en uit te leggen.
3. Empirische Evaluatie: Een uitgebreide evaluatie met benchmarks, een enquête en een gebruikersstudie die de effectiviteit van het systeem aantonen.

Resultaten

Experimentele Evaluatie (Benchmarks)

De auteurs evalueerden Merlin tegen 182 vragen in natuurlijke taal die zijn afgeleid van SpotBugs (142 detectoren) en het GitHub Security Lab (40 queries) over 13 grote codebases.

• Recall: Merlin presteerde aanzienlijk beter dan baseline-aanpakken (direct LLM-beantwoorden, LLM-naar-CodeQL-generatie zonder debugging). Merlin behaalde een macro-recall van 0,62 en micro-recall van 0,64, vergeleken met baselines die vaak worstelden met recall (bijvoorbeeld GPT-4o/CQL had 0,08 micro-recall).
• Precisie en Ontdekking: Waar baselines vaak problemen misten, identificeerde Merlin niet alleen de resultaten van referentie-analysatoren, maar ook voorheen onbekende locaties. Een gebruikersenquête bevestigde dat veel van deze "nieuwe" bevindingen echt relevante codefragmenten waren die andere tools hadden gemist, wat suggereert dat Merlin een hogere precisie en recall bereikt dan de referentietools wanneer menselijk oordeel de grondwaarheid is.
• Resource-efficiëntie: In tegenstelling tot baselines die het uploaden van volledige codebases naar LLM's vereisen (wat de limieten van bestanden en contextvensters bereikt), synthetiseert Merlin queries onafhankelijk van de codebase, wat resulteert in aanzienlijk kortere promptlengtes en lagere rekenkosten.

Gebruikersstudie

Een within-subject studie met 18 deelnemers (13 studenten, 5 professionals) die de taak kregen om schendingen van SEI CERT-coderingsstandaarden te vinden en te herstellen, onthulde:

• Nauwkeurigheid: Toegang tot Merlin verhoogde de taaknauwkeurigheid met gemiddeld 3,8×. De verbetering was het meest uitgesproken voor complexe taken (Taak T1: 5,6×; Taak T3: 4,9×) en minder voor taken die met een simpele grep op te lossen waren (Taak T2: 1,6×).
• Efficiëntie: Deelnemers die Merlin gebruikten, voltooiden taken gemiddeld 31% sneller.
• Gedragsverandering: Merlin verschuift gebruikersstrategieën van arbeidsintensieve patroonmatching (regex, trefwoordzoekopdrachten) naar hoog niveau redeneren. Het verminderde ook de afhankelijkheid van externe AI voor de "vind"-fase, hoewel de auteurs een risico opmerken dat gebruikers de output van Merlin te zeer vertrouwen.

Betekenis en Claims

Het artikel stelt dat Merlin succesvol de kloof overbrugt tussen de natuurlijke taalinterface van LLM's en de rigoureuze, gestructureerde redenering van programmanaalysatoren. Door de specifieke uitdagingen van het genereren van complexe, low-resource analysequeries (CodeQL) aan te pakken via iteratieve debugging en zelftesten, stelt Merlin ontwikkelaars in staat om exhaustieve, controleerbare en herhaalbare analyses uit te voeren op grote codebases.

De auteurs benadrukken dat Merlin niet zomaar een chatbot is, maar een systeem dat certificeerbare output produceert (de gegenereerde CodeQL-query), waardoor ontwikkelaars de logica achter de resultaten kunnen verifiëren. Deze aanpak overwint de onbetrouwbaarheid van puur LLM-gebaseerde redenering en de starheid van traditionele statische analysetools, en biedt een praktische oplossing voor moderne software-engineeringtaken die een diep semantisch begrip van code vereisen.

Het artikel blijft bescheiden wat betreft de reikwijdte, en erkent dat het momenteel gericht is op het vinden van bugs en analytische vragen, en dat toekomstig werk nodig is om bredere ontwikkelwerkstromen, interactieve debugging en niet-analytische vragen te ondersteunen.