Evaluating and Improving Automated Repository-Level Rust Issue Resolution with LLM-based Agents

Probleemstelling

De programmeertaal Rust staat bekend om zijn hoge prestaties en veiligheidsgaranties (geen geheugenfouten of data-races), maar heeft een steile leercurve en complexe syntaxis, vooral vanwege het strikte type- en eigendomssysteem (ownership). Hoewel Large Language Model (LLM)-gebaseerde agents succesvol zijn gebleken bij het oplossen van softwareproblemen in talen zoals Python, blijft de automatisering van issue-resolutie in Rust beperkt. Dit komt door twee hoofdredenen:

1. Gebrek aan benchmarks: Er ontbreekt een grote, repository-level benchmark specifiek voor Rust. Bestaande benchmarks focussen vaak op granulaire taken (zoals transpilatie) of bevatten slechts een klein aantal Rust-taken vergeleken met Python.
2. Technische uitdagingen: Agents worstelen met het begrijpen van de complexe code-structuur van hele repositories en het naleven van de strikte semantische regels van Rust (types en traits). Daarnaast is het reproduceren van bugs (issue reproduction) in Rust vaak een kritieke bottleneck.

Methodologie

De auteurs hanteren een drieledige aanpak: het bouwen van een benchmark, het uitvoeren van een uitgebreide empirische studie, en het ontwikkelen van een nieuwe agent-architectuur.

1. Rust-SWE-bench (De Benchmark)

De auteurs hebben Rust-SWE-bench ontwikkeld, de eerste grote benchmark voor repository-level Rust-taken.

• Datacollectie: Er zijn 500 hoogwaardige taken geselecteerd uit 34 populaire open-source Rust-repositories (met >1.000 GitHub-sterren).
• Validatieproces:
  • Selectie van Pull Requests (PR's) die gekoppeld zijn aan opgeloste GitHub-issues en testbestanden wijzigen.
  • Fail-to-Pass verificatie: Er wordt gecontroleerd of de test suite faalt vóór de patch en slaagt na de patch.
  • Manuele inspectie: Handmatige controle op issue-kwaliteit, determinisme en het ontbreken van "solution leakage" (waar de oplossing al in de beschrijving staat).
• Kenmerken: De taken zijn complexer dan in Python-benchmarks, met gemiddeld 139 regels code per patch en een grote variatie in domeinen (van CLI-tools tot webframeworks).

2. Empirische Studie

Er is een studie uitgevoerd met vier representatieve agents (SWE-agent, OpenHands+CodeAct, Agentless, AutoCodeRover) en vier state-of-the-art LLM's (Claude-Sonnet-3.7, GPT-4o, OpenAI o4-mini, Qwen3).

• Observaties:
  • Agents met een ReAct-architectuur (Thought-Act-Observe) presteerden het beste.
  • De belangrijkste beperkingen waren: het niet kunnen modelleren van de repository-brede code-structuur (wat leidt tot import- en scope-fouten) en het niet kunnen voldoen aan Rust's strikte type- en trait-semantiek.
  • Reproductie is cruciaal: 44,5% van de taken faalde al in het stadium van het reproduceren van de bug, wat de volgende stappen onmogelijk maakte.

3. RustForger (De Oplossing)

Geïnspireerd door de bevindingen, hebben de auteurs RustForger ontwikkeld, een nieuwe agent-architectuur die twee kerncomponenten combineert:

• Geautomatiseerde Testomgeving: De agent creëert een geïsoleerde "sandbox" (een nieuw Cargo-project) en importeert het doelproject als lokale afhankelijkheid. Dit omvat het opzetten van een schone build-omgeving om dependency-conflicten te voorkomen.
• Cross-Project Dynamic Tracing (Trace Command): Dit is het innovatieve deel. RustForger gebruikt Rust's metaprogrammeringscapaciteiten (procedural macros) om automatisch instrumentatie in de broncode in te voegen via AST-modificatie.
  • De agent voert tests uit in de geïsoleerde werkruimte.
  • Het verzamelt runtime-control-flow data (invoer/uitvoer van functies) zonder vast te zitten aan de complexe build-systemen van het originele project.
  • Deze dynamische data helpt de agent om de exacte oorzaak van de bug te vinden en een correcte patch te genereren.

Kernbijdragen

1. Rust-SWE-bench: Een nieuwe, grote benchmark met 500 geverifieerde, real-world Rust-taken die de kloof in de literatuur voor repository-level Rust-evaluatie dicht.
2. Uitgebreide Analyse: Een diepgaande studie die aantoont dat huidige agents worstelen met Rust's semantische complexiteit en dat issue-reproductie de grootste bottleneck is.
3. RustForger: Een nieuw framework dat geautomatiseerde testomgevingen combineert met dynamische tracing via AST-instrumentatie, specifiek ontworpen voor de unieke eigenschappen van Rust.

Resultaten

De evaluatie toont aan dat RustForger aanzienlijk beter presteert dan bestaande baselines:

• Oplossingspercentage: RustForger in combinatie met Claude-Sonnet-3.7 lost 28,6% van de taken op. Dit is een verbetering van 34,9% ten opzichte van de sterkste baseline (OpenHands met Claude-Sonnet-3.7, die 21,2% oplost).
• Unieke Oplossingen: RustForger lost 46 taken die door geen enkele andere agent (met welke LLM dan ook) opgelost konden worden.
• Kostenefficiëntie: Ondanks de complexiteit, is RustForger kostenefficiënter. Bij gebruik van de goedkopere model OpenAI o4-mini bereikt het een oplospercentage van 16,4%, wat hoger is dan de sterkste baselines met duurdere modellen.
• Reproductie: RustForger verbetert het succespercentage van issue-reproductie aanzienlijk (van 55,5% bij OpenHands naar 67,3% bij RustForger met Claude-Sonnet-3.7).
• Ablatie-studie: Het tonen aan dat zowel de geïsoleerde werkruimte als de dynamische tracing essentieel zijn voor de verbeterde prestaties.

Betekenis en Impact

Dit paper is van groot belang voor de gemeenschap van software-engineering en AI:

• Standaardisatie: Het biedt een robuuste standaard (Rust-SWE-bench) voor het evalueren van AI-tools in de Rust-ecosysteem, wat essentieel is voor toekomstig onderzoek.
• Doorbraak in Rust-automatisering: Het bewijst dat het combineren van LLM's met specifieke taalgebaseerde instrumentatie (zoals Rust-macros voor tracing) de beperkingen van pure tekstgeneratie kan overwinnen.
• Praktische Toepassing: De methodiek van "geïsoleerde sandbox + dynamische tracing" biedt een blauwdruk voor het oplossen van complexe bugs in andere strikt getypeerde of complexe talen, niet alleen Rust.
• Toekomstperspectief: Het resultaat suggereert dat geavanceerde agents, zelfs met minder krachtige modellen, zeer competitief kunnen zijn op complexe repository-level taken als ze goed zijn uitgerust met runtime-inzichten.