💻 computer science

AdaTrans: Automated C to Rust Transformation via Error-Adaptive Repair

AdaTrans is een geautomatiseerd framework dat strategie-gestuurde retrieval, fout-adaptieve transformatie en meerfasige validatie inzet om C-code succesvol te converteren naar veilige, compileerbare Rust, waarbij hoge slaagpercentages worden behaald terwijl unsafe constructies worden geminimaliseerd.

Oorspronkelijke auteurs: Xiaofan Liu, Zecan Li, Zhuang Zhao, Ziqi Shuai, Yanming Yang, Qi Xin, Jifeng Xuan

Gepubliceerd 2026-07-01

📖 6 min leestijd🧠 Diepgaand

CC BY 4.0

Oorspronkelijke auteurs: Xiaofan Liu, Zecan Li, Zhuang Zhao, Ziqi Shuai, Yanming Yang, Qi Xin, Jifeng Xuan

Oorspronkelijk artikel gelicentieerd onder CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dit is een AI-gegenereerde uitleg van het onderstaande artikel. Het is niet geschreven of goedgekeurd door de auteurs. Raadpleeg het oorspronkelijke artikel voor technische nauwkeurigheid. Lees de volledige disclaimer

Het Grote Plaatje: Een gevaarlijke taal vertalen naar een veilige taal

Stel je voor dat je een enorme bibliotheek hebt met oude boeken geschreven in C, een programmeertaal die ongelooflijk snel en krachtig is, maar ook berucht gevaarlijk. In C is de auteur (de programmeur) de enige die verantwoordelijk is voor de veiligheid van het gebouw. Als ze vergeten een deur op slot te doen (geheugen vrijmaken) of een raam open laten staan (een dangling pointer), kan het hele huis afbranden (crashen of gehackt worden).

Stel je nu voor dat je al deze boeken wilt verplaatsen naar een nieuw gebouw gemaakt van Rust. Rust is een moderne taal die werkt als een superstrenge bouwinspecteur. De inspecteur laat je geen boek schrijven tenzij je per pagina bewijst dat elke deur op slot zit en elk raam beveiligd is. Als je probeert een gevaarlijke gewoonte binnensluipen, slaat de inspecteur de deur in je gezicht en zegt: "Nee, niet toegestaan."

Het Probleem:
Decennialang was de overstap van C naar Rust een nachtmerrie.

Handarbeid: Het handmatig doen kost eeuwen.
Oude Tools: Geautomatiseerde tools bestaan wel, maar ze bedriegen vaak. Ze schrijven de code, maar verbergen de gevaarlijke delen achter "unsafe"-tekens, waardoor ze de bouwinspecteur effectief negeren.
AI heeft het zwaar: Nieuwe Kunstmatige Intelligentie (LLM's) kunnen code schrijven, maar ze zijn als briljante schrijvers die de strikte bouwvoorschriften van Rust niet begrijpen. Ze schrijven prachtige verhalen die de inspecteur direct afkeurt vanwege een minuscule veiligheidschending.

De Oplossing: AdaTrans
De auteurs hebben AdaTrans gebouwd, een slim systeem dat niet alleen gokt, maar leert van zijn fouten om C-code te vertalen naar veilige Rust-code. Denk aan een Meesterarchitect en een Team Inspecteurs die samenwerken in een lus.

Hoe AdaTrans werkt: De Drie-Stappen Dans

Het systeem werkt in een continue cyclus van Proberen → Controleren → Herstellen. Zo gaat het om met het proces:

1. De "Multi-Stage Inspectie" (Fase 1)

Wanneer de AI probeert een stuk C-code te vertalen, voert AdaTrans het onmiddellijk door twee tests:

De Syntax Check: Ziet de code er überhaupt uit als geldige Rust? (bijv. een ontbrekende puntkomma).
De Veiligheids- & Logica Check: Compileert het zonder de strikte veiligheidsregels van Rust te breken? En doet het ook echt wat de originele C-code deed?
Het Resultaat: Als het mislukt, zegt het systeem niet alleen "Error". Het categoriseert de fout. Is het een typefout? Een veiligheidschending? Of is de logica simpelweg fout?

2. De "Gespecialiseerde Bibliothecaris" (Fase 2: Strategy-Driven RAG)

Dit is het brein van de operatie. In plaats van de AI alleen de ruwe foutmelding te tonen (die vaak verwarrend is), werkt AdaTrans als een gespecialiseerde bibliothecaris.

Als de fout een typefout is (Syntax), geeft de bibliothecaris de AI een "Grammatica Fix"-spiekbriefje.
Als de fout over veiligheid gaat (Ownership), overhandigt de bibliothecaris een "Rust Veiligheidsmanual" met specifieke voorbeelden van hoe geheugen veilig beheerd kan worden.
Als de fout over logica gaat (de code draait, maar geeft het verkeerde antwoord), geeft de bibliothecaris de AI een "Creatief Denken"-prompt om het hele algoritme opnieuw te overwegen.

De Analogie: Stel je voor dat je een auto probeert te repareren.

Als de band lek is, bel je geen monteur om de motor te herbouwen; je pakt gewoon een bandenplakset.
Als de motor een vreemd geluid maakt, draai je niet alleen een boutje aan; je hebt een diepe diagnose nodig.
AdaTrans zorgt ervoor dat de AI het juiste gereedschap krijgt voor het specifieke probleem.

3. De "Adaptieve Temperatuur" (Fase 3: ESTS)

Dit is het geheime ingrediënt. Wanneer de AI probeert de code te herstellen, moet het beslissen hoe "creatief" of "voorzichtig" het moet zijn. AdaTrans regelt dit met een "temperatuur"-draaiknop:

Lage Temperatuur (Voorzichtig): Bij eenvoudige typefouten krijgt de AI de opdracht om zeer precies te zijn en zich aan de regels te houden. Geen wilde gokken.
Medium Temperatuur (Gebalanceerd): Bij veiligheidsfouten krijgt de AI de opdracht om verschillende manieren te verkennen om het geheugen te organiseren, maar binnen de regels te blijven.
Hoge Temperatuur (Creatief): Als de code logisch fout is (bijv. de wiskunde klopt niet), krijgt de AI de opdracht om wild te zijn en compleet nieuwe structuren te proberen. Het moet uit zijn huidige denkpatroon breken om de juiste oplossing te vinden.

De "Stuck" Detector:
Als de AI steeds dezelfde fout blijft maken (zoals een hond die achter zijn eigen staart aanrent), merkt AdaTrans deze "stagnatie" op. Het drukt op een RESET-knop, gooit de huidige poging weg en begint opnieuw vanaf de originele C-code met een schone lei. Dit voorkomt dat de AI tijd verspilt aan een doodlopend spoor.

De Resultaten: Werkt het?

De auteurs hebben dit getest op 104 verschillende programmeerpuzzels (afkomstig van LeetCode-wedstrijden die de AI nog niet had gezien).

Succespercentage: AdaTrans slaagde erin om ongeveer 81% van de problemen te vertalen naar Rust-code die zowel veilig (geen gevaarlijke "unsafe" blokken) als correct (voldoet aan alle tests) was.
Vergelijking:
- Oude AI (Zero-shot): Zonder dit speciale systeem kreeg de AI slechts ongeveer 25% bij de eerste poging goed. Zelfs als je het 100 keer willekeurig zou laten proberen, kwam het slechts tot 70%. AdaTrans haalde 81% in één enkel, slim, iteratief proces.
- Oude Tools: Traditionele tools (zoals c2rust) konden de code compileren, maar vulden deze met "unsafe"-blokken (het omzeilen van de veiligheidsregels). AdaTrans hield de code 99% veilig.
- Andere AI-tools: Andere recente AI-tools hadden moeite om boven de 20% succes te komen omdat ze complexe logische fouten niet konden afhandelen.

De Kernboodschap

AdaTrans bewijst dat je niet hoeft te kiezen tussen "snelle vertaling" en "veilige code". Door de AI te leren om:

Naar het specifieke type fout te luisteren,
De juiste expertkennis te raadplegen voor die fout, en
Het creativiteitsniveau aan te passen op basis van de moeilijkheidsgraad,

...kan het succesvol gevaarlijke oude code migreren naar moderne, veilige code. Het is alsof je de AI een kaart, een kompas en een gids geeft die precies weet wanneer hij voorzichtig moet lopen en wanneer hij een sprong van het diepe moet wagen.

Technische Samenvatting: AdaTrans

Probleemstelling
De geautomatiseerde transformatie van C-code naar Rust blijft een aanzienlijke technische uitdaging vanwege de strikte eigenschaps-, lening- en lifetime-systemen van Rust. Hoewel Large Language Models (LLM's) veelbelovend zijn voor codegeneratie, produceren ze vaak Rust-code die de eigenschapsregels schendt of zwaar leunt op unsafe blokken om de borrow checker te omzeilen. Bestaande benaderingen lijden onder drie primaire beperkingen: (1) algemene LLM's worstelen met de semantische barrière tussen het handmatige geheugenbeheer van C en het affine type-systeem van Rust; (2) huidige methoden maken onvoldoende gebruik van compiler-feedback voor iteratieve reparatie, waarbij diagnostiek vaak als oppervlakkige syntactische problemen wordt behandeld in plaats van als structurele conflicten; en (3) zonder gerichte verificatie heeft gegenereerde code de neiging om veiligheidsbeperkingen te omzeilen in plaats van eraan te voldoen, wat leidt tot functionele inequivalentie of geheugenonveiligheid.

Methodologie: Het AdaTrans-framework
AdaTrans is een end-to-end framework ontworpen voor de transformatie op fileniveau van zelfstandige C-modules. Het werkt via een gesloten lus, een driefasige generate-verify-repair pijplijn die reparatiestrategieën aanpast op basis van het specifieke type waargenomen foutsignaal.

Multi-Stage Validatie (Fase 1):
Het framework gebruikt een deterministische oracle om kandidaat Rust-code te evalueren. Deze pijplijn roept eerst de Rust-compiler (cargo build) aan om syntaxis-, koppelings- en eigenschapsfouten te detecteren. Als de code compileert, gaat deze door naar dynamische executie tegen een fuzz-gebaseerde testsuite om functionele equivalentie (I/O-consistentie) met het originele C-programma te verifiëren. Deze fase extraheert diagnostische signalen (compiler foutcodes en testfouten) om daaropvolgende reparaties te sturen.
Strategie-gestuurde Retrieval-Augmented Generation (RAG) (Fase 2):
Om de kloof tussen ruwe compiler-diagnostiek en gestructureerde reparatiecontext te overbruggen, maakt AdaTrans gebruik van een Rust Violation-Fix Graph (RVFG). Deze graaf koppelt specifieke compiler-foutsignatures (bijv. E0597) aan semantische ankers, die bestaan uit:
- Repair Templates: Rol-specifieke meta-prompts (bijv. syntaxiscorrectie, eigenschapsredenering, algoritmische reflectie).
- Knowledge Snippets: Officiële Rust-documentatie die relevant is voor de foutcategorie.
  Dit mechanisme zorgt ervoor dat de LLM gerichte begeleiding ontvangt in plaats van ruwe foutmeldingen, waardoor het wordt weggeleid van unsafe shortcuts en richting idiomatische oplossingen wordt gestuurd.
Error-Stratified Transformation Strategy (ESTS) (Fase 3):
AdaTrans classificeert diagnostische signalen in vier semantische categorieën en past de sampling-behavior (temperatuur) van de LLM dienovereenkomstig aan:
- Syntactic-Linking (SL): Rigide fouten (bijv. ontbrekende puntkomma's) worden aangepakt met lage-entropie sampling ( $\theta=0.1$ ) voor precieze, deterministische fixes.
- Memory-Semantic (MS): Eigenschaps- en lifetime-conflicten worden aangepakt met gemiddelde-entropie sampling ( $\theta=0.5$ ) om alternatieve geheugenbeheerpatronen te verkennen (bijv. klonen versus lenen).
- Logic-Behavioral (LB): Functionele fouten (compileert maar geeft verkeerde output) worden aangepakt met hoge-entropie sampling ( $\theta=1.2$ ) om lokale optima te verlaten en significante algoritmische herstructurering te triggeren.
- Ambiguous-Fallback (AF): Ongeziene fouten vallen terug op baseline exploratie.
  Daarnaast beschikt het framework over een Local-Loop Stagnation Escape mechanisme dat het reparatie-traject reset als dezelfde foutcategorie meer dan drie opeenvolgende iteraties persisteert, om oneindige lussen te voorkomen.

Belangrijkste Bijdragen

Een Compiler-Feedback-Gestuurd Framework: AdaTrans introduceert een driefasige pijplijn die specifiek is ontworpen voor gecontroleerde migratie op fileniveau, waarbij compiler-diagnostiek en executie-feedback worden geïntegreerd in een verenigde reparatielus.
Operationele Error-Stratified Repair (ESTS): Het artikel stelt een strategie voor die fouten categoriseert en de generatie-diversiteit (temperatuur) dynamisch aanpast aan de rigiditeit van de beperking, waarbij een balans wordt gevonden tussen exploitatie voor syntaxisfixes en exploratie voor algoritmische mutaties.
Strategie-gestuurde RAG: Een nieuw retrieval-mechanisme dat foutsignatures koppelt aan specifieke reparatie-templates en domeinkennis, wat gestructureerde begeleiding biedt die verder gaat dan ruwe compiler-berichten.
Empirische Studie van Correctheid-Veiligheid Trade-offs: De auteurs bieden een rigoureuze evaluatie van transformatie-correctheid versus geheugenveiligheid onder een vaste LLM-backbone.

Experimentele Resultaten
Het framework werd geëvalueerd op een dataset van 104 algoritmische problemen uit LeetCode Weekly Contests (uitgebracht na de kennis-cutoff van de LLM om contaminatie te minimaliseren). De evaluatie vergeleken AdaTrans met drie bestaande LLM-gebaseerde tools (EvoC2Rust, Tymcrat, PtrTrans), een zero-shot LLM baseline, en de traditionele AST-level transpiler c2rust.

Prestaties: AdaTrans behaalde een gemiddelde compilation pass rate van 95,51% en een gemiddelde solve rate van 81,09% over drie onafhankelijke runs.
Vergelijking: AdaTrans verbeterde de solve rate ten opzichte van de sterkste bestaande LLM-gebaseerde tool (Tymcrat) met 59,94 procentpunten. Het presteerde ook beter dan de zero-shot LLM baseline (pass@100) met 10,51 procentpunten, terwijl het aanzienlijk minder tokens gebruikte (ongeveer 1/3 van de kosten).
Veiligheid: Het framework behield een gemiddelde unsafe file rate van 1,19%, een scherp contrast met c2rust, dat unsafe code produceerde in 100% van zijn compileerbare outputs (97,94% van de regels code).
Ablatie: Het verwijderen van de ESTS-module verminderde de solve rate met ~12%, en het verwijderen van de RAG-module verminderde deze met ~10%. Het verwijderen van beide veroorzaakte een daling van ~34%, wat hun synergetische effect aantoont.

Betekenis en Claims
Het artikel claimt dat AdaTrans aantoont dat het aanpassen van reparatiestrategieën aan de semantische kenmerken van compiler-diagnostiek succesvol de transformatie-correctheid kan verzoenen met geheugenveiligheid. Door de semantische kern van transformatie op fileniveau te isoleren, laten de auteurs zien dat iteratieve reparatie, geleid door error-stratified strategieën en gerichte kennisretrieval, een hoge functionele equivalentie kan bereiken zonder afhankelijk te zijn van unsafe blokken. Het werk suggereert dat hoewel algemene LLM's moeite hebben met de niet-lokale aard van Rust-eigenschappen, een gestructureerde, feedback-gestuurde aanpak effectief de semantische barrière tussen C en Rust kan overbruggen. De auteurs positioneren dit als een stap naar een veiligere, geautomatiseerde migratie van legacy C-codebases, met name voor zelfstandige modules waar functionele equivalentie rigoureus geverifieerd kan worden.