💻 computer science

Documentation-Guided Agentic Codebase Migration from C to Rust

RustPrint est un cadre d'agents guidé par la documentation qui permet une migration évolutive au niveau du dépôt de C vers Rust en convertissant le code source en plans architecturaux pour orienter la planification, la vérification et la réparation itératives par des agents, atteignant un taux de réussite de compilation et une préservation des fonctionnalités supérieurs par rapport aux traducteurs existants basés sur les LLM.

Auteurs originaux : Minh Le-Anh, Anh Nguyen Hoang, Bach Le, Nghi D. Q. Bui

Publié 2026-05-15

📖 6 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Minh Le-Anh, Anh Nguyen Hoang, Bach Le, Nghi D. Q. Bui

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous possédiez une immense bibliothèque ancienne écrite dans un langage appelé C. C'est la fondation de nombreux systèmes critiques (comme les systèmes d'exploitation et les outils réseau), mais elle est construite sur un terrain instable. Les « briques » (la gestion de la mémoire) sont lâches, et si vous n'êtes pas extrêmement prudent, toute la structure peut s'effondrer ou être facilement infiltrée par des intrus (piratages de sécurité).

Vous souhaitez reconstruire cette bibliothèque entière en utilisant un nouveau langage moderne appelé Rust. Rust est comme une forteresse : il dispose de verrous de sécurité automatiques qui empêchent l'édifice de s'effondrer. Mais voici le problème : traduire une bibliothèque entière, brique par brique, est incroyablement difficile. Si vous traduisez simplement une pièce à la fois, vous perdez souvent les plans, oubliez comment les pièces sont connectées, ou vous vous retrouvez avec un bâtiment qui ressemble à du Rust mais qui se comporte comme un bâtiment C brisé.

RustPrint est une nouvelle « équipe d'architectes et de constructeurs » (un système d'agents IA) conçue pour résoudre ce problème. Au lieu de simplement traduire le code ligne par ligne, il utilise une stratégie astucieuse en trois étapes pour garantir que le nouvel édifice est sûr, fonctionnel et fidèle au design original.

Voici comment RustPrint fonctionne, en utilisant des analogies simples :

1. La phase « Plans » (Documentation en premier)

La plupart des outils de traduction tentent de traduire une phrase, puis la suivante, puis la suivante. RustPrint s'arrête et dit : « Attendez, lisons d'abord tout le livre. »

Ce qu'il fait : Il lit l'ensemble de l'ancien code source C et rédige un manuel d'instructions massif et détaillé (documentation) décrivant comment le système fonctionne, comment les parties sont connectées et pourquoi il a été construit de cette manière.
L'analogie : Imaginez que vous rénovez un vieux château. Au lieu de simplement remplacer les pierres, vous engagez d'abord un expert pour dessiner une carte parfaite et détaillée de la disposition du château, des passages secrets et de la logique structurelle. Cette carte devient le « plan » pour la nouvelle construction.
Pourquoi c'est important : Cela garantit que l'IA comprend l'intention du code, et non seulement la syntaxe. Cela empêche l'IA d'oublier comment deux pièces différentes doivent communiquer entre elles.

2. La phase « Construction » (Traduction par agents)

Une fois les plans prêts, RustPrint envoie une équipe d'agents IA spécialisés pour construire la nouvelle version en Rust.

Le Planificateur : Examine les plans et dit : « Nous devons construire la cuisine ici, la bibliothèque là-bas, et nous assurer que la plomberie est connectée. » Il crée un plan de construction étape par étape.
Le Constructeur : Construit les pièces (modules de code) une par une.
L'Inspecteur : Après chaque pièce construite, l'Inspecteur effectue un « contrôle de sécurité » (compilation). Si un mur est de travers ou si une fuite se produit (erreurs de code), le Constructeur le répare immédiatement avant de passer à la suite.
L'Agent de Sécurité : Vérifie spécifiquement les raccourcis « non sûrs ». Rust autorise le code non sûr uniquement si c'est absolument nécessaire, mais cet agent tente de les éliminer, garantissant que l'édifice final est une forteresse.

3. La phase « Contrôle Qualité » (La double vérification)

C'est ici que RustPrint devient vraiment intelligent. Il ne se contente pas de faire confiance au fait que le bâtiment est terminé ; il le vérifie par rapport à l'original.

La vérification « Miroir » : Une fois le nouvel édifice Rust construit, l'IA rédige un nouveau manuel d'instructions pour la version Rust. Elle compare ensuite ce nouveau manuel au manuel C original.
- Si le nouveau manuel manque une section (par exemple, « Le tunnel secret »), l'IA sait qu'elle a manqué une fonctionnalité et retourne la corriger.
Le « Test de résistance » : L'IA prend les tests originaux (comme les tests de résistance des murs du château) et les exécute sur le nouvel édifice Rust. Si un mur se fissure lors du test, l'IA ne se contente pas de le réparer ; elle détermine pourquoi le mur s'est fissuré et corrige le défaut de conception sous-jacent.

Les Résultats : Est-ce que ça a marché ?

Les chercheurs ont testé RustPrint sur 8 projets C réels à grande échelle (allant de petites bibliothèques à des systèmes massifs comptant plus de 80 000 lignes de code).

La Concurrence : D'autres outils (comme C2Rust ou des traducteurs IA simples) ont essayé de faire cela mais ont échoué. Soit ils n'ont pas pu terminer la construction (le code ne compilait pas), soit ils ont construit une structure qui ressemblait à du Rust mais qui était pleine de trous.
Le Succès de RustPrint :
- Il a terminé le travail : RustPrint a construit avec succès une version fonctionnelle et compilable de chaque projet individuel.
- Il a conservé les fonctionnalités : Il a préservé 93 % à 97 % des fonctionnalités originales (selon le modèle d'IA utilisé), tandis que les autres méthodes n'en conservaient qu'environ 50 %.
- Il a réussi les tests : Lorsqu'ils ont exécuté les tests originaux sur le nouveau code, RustPrint a réussi 95 % à 98 % d'entre eux. Les autres méthodes échouaient beaucoup plus souvent.
- Il était sûr : Le code résultant était presque entièrement exempt de raccourcis « non sûrs », le rendant beaucoup plus sécurisé que les tentatives précédentes.

La Conclusion

RustPrint prouve que pour migrer un système logiciel massif et complexe, vous ne pouvez pas être simplement un traducteur ; vous devez être un architecte. En forçant l'IA à rédiger un « plan » en premier, à comparer les plans et à exécuter des tests de résistance, RustPrint peut déplacer avec succès le code C hérité vers le monde sûr et moderne de Rust sans perdre l'âme du système original.

Note : L'article se concentre strictement sur la migration technique du code. Il ne prétend pas que cette méthode est prête à être utilisée immédiatement dans des dispositifs médicaux critiques pour la vie ou qu'elle résout tous les problèmes logiciels, mais plutôt qu'il s'agit d'un outil hautement efficace pour la tâche spécifique de la traduction de grandes bases de code C vers Rust.

Résumé technique : RustPrint – Migration de codebase guidée par la documentation d'agents, du C au Rust

Énoncé du problème

La migration des dépôts C hérités vers Rust est cruciale pour résoudre les vulnérabilités de sécurité mémoire inhérentes au modèle de pointeurs du C, mais elle reste un défi d'ingénierie majeur. Les outils de traduction existants (par exemple, C2Rust) opèrent souvent au niveau du fichier ou de la fonction, préservant les structures de style C et entraînant une utilisation massive de blocs unsafe, ou ils échouent à capturer l'intention architecturale, le flux de données et la logique de conception du système original. De plus, les approches actuelles basées sur les grands modèles de langage (LLM) peinent souvent avec les tâches à l'échelle du dépôt, échouant à produire des sorties compilables pour de grandes bases de code (11 000 à 84 000 lignes de code) en raison d'un manque de compréhension globale et de coordination entre les modules. Le problème fondamental est que la migration est essentiellement une tâche de compréhension de codebase nécessitant un modèle mental des structures de données partagées, des limites des modules et des invariants inter-fichiers, que les stratégies de traduction isolées ne peuvent pas retrouver.

Méthodologie : Le cadre RustPrint

RustPrint est un cadre multi-agents conçu pour la migration de dépôts du C vers Rust. Il introduit un paradigme piloté par la documentation où la documentation générée automatiquement sert de représentation intermédiaire (RI) pour guider la planification, la traduction et l'affinement. Le cadre fonctionne via un pipeline en cinq étapes :

1. Traduction de code guidée par la documentation

Au lieu de traduire le code unité par unité, RustPrint génère d'abord une documentation holistique du dépôt source en C à l'aide d'un module dédié DocGen.

Processus : Le dépôt source est regroupé au niveau des fichiers, puis élevé vers des abstractions de composants de plus haut niveau. Le module DocGen produit une documentation structurée ( $S_{doc}$ ) qui capture les fonctionnalités abstraites, les interactions entre modules et la logique de conception, plutôt que de simples descriptions syntaxiques.
Agents :
- Planificateur : Convertit $S_{doc}$ en un plan d'implémentation au niveau de la crate (IMPLEMENTATION_PLAN.md), résolvant les détails architecturaux et définissant les responsabilités des composants.
- Traducteur : Implémente chaque crate planifiée, en itérant avec cargo_check pour assurer la compilabilité et detect_unsafe pour minimiser les blocs unsafe.
- Synthétiseur : Effectue l'intégration au niveau du dépôt, résout les dépendances inter-crates et génère un README.md unifié.

2. Affinement de code piloté par les exigences

Pour assurer l'exhaustivité sémantique, RustPrint emploie un mécanisme d'affinement itératif qui compare la documentation du dépôt Rust généré ( $T_{doc}$ ) à la documentation source ( $S_{doc}$ ).

Mécanisme : Le système approxime la préservation fonctionnelle par l'équivalence de documentation : $CodeEquiv(S, T) \approx DocEquiv(S_{doc}, T_{doc})$ .
Agent : Le Raffineur d'exigences identifie les lacunes où $T_{doc}$ ne correspond pas à $S_{doc}$ (par exemple, fonctionnalités omises, API incohérentes). Il modifie le code traduit en utilisant str_replace_editor, vérifie la compilation et répare itérativement les fonctionnalités manquantes ou désalignées.

3. Révision de code consciente de l'exécution

Reconnaissant que la comparaison de documentation ne peut pas révéler toutes les erreurs d'exécution, le cadre ajoute une boucle de rétroaction pilotée par les tests.

Processus : La suite de tests source est traduite en Rust par le Traducteur de tests.
Agent : Le Réviseur d'exécution analyse les tests échoués en utilisant cargo_single_test. Il met à jour uniquement le code de production traduit (et non les tests) pour corriger les incohérences comportementales telles que les cas limites, les mises à jour d'état ou les incohérences de protocole qui survivent à l'alignement statique mais échouent lors d'une exécution concrète.

Contributions clés

Paradigme de migration piloté par la documentation : L'article propose d'utiliser la documentation de codebase générée automatiquement comme représentation intermédiaire pour la traduction au niveau du dépôt. Cette approche encode une compréhension de l'ensemble du codebase avant la traduction, permettant la génération de Rust idiomatique qui préserve l'intention architecturale plutôt que de simplement reproduire la structure syntaxique.
Affinement itératif guidé par la documentation : Un mécanisme qui évalue et améliore le code Rust généré en comparant sa documentation à la source, identifiant systématiquement les lacunes de couverture et favorisant l'alignement structurel.
Révision consciente de l'exécution : L'intégration d'une rétroaction pilotée par les tests permet au système de corriger itérativement les incohérences comportementales via l'exécution dynamique de tests, atteignant une correction fonctionnelle au-delà de ce que garantit la traduction statique.
Évaluation à grande échelle : Le cadre est évalué sur huit dépôts C réels allant de 11 000 à 84 000 lignes de code, abordant la limitation des travaux antérieurs qui se concentraient sur de petits benchmarks.

Résultats expérimentaux

L'évaluation a été menée sur huit dépôts en utilisant deux modèles de base : un modèle à poids ouverts (Kimi-K2-Instruct) et un modèle à poids fermés (GPT-5.4). Les références incluaient des outils traditionnels (C2Rust) et des agents basés sur LLM (Self-Repair, EvoC2Rust, et une référence agentic Claude Code).

Compilabilité des projets : RustPrint a compilé avec succès chaque dépôt cible sous les deux modèles de base. En revanche, les traducteurs LLM de référence (Self-Repair, EvoC2Rust) ont échoué à produire des dépôts compilables de bout en bout à cette échelle. C2Rust a compilé mais a conservé une utilisation massive d'unsafe.
Préservation des fonctionnalités : Mesurée via le score CodeWikiBench, RustPrint a nettement surpassé la référence Claude Code.
- Avec Kimi-K2-Instruct : RustPrint a atteint 93,26 % contre 52,52 % pour Claude Code.
- Avec GPT-5.4 : RustPrint a atteint 97,76 % contre 48,87 % pour Claude Code.
Correction fonctionnelle : En utilisant un protocole de croisé-évaluation (testant la sortie de RustPrint avec les tests de Claude Code et vice versa), RustPrint a démontré une robustesse supérieure.
- Kimi-K2-Instruct : 95,17 % de taux de réussite des tests (TPR) contre 79,85 % pour Claude Code.
- GPT-5.4 : 98,70 % de TPR contre 79,85 % pour Claude Code.
Sécurité : RustPrint a atteint des taux de sécurité élevés, minimisant les blocs unsafe. Avec GPT-5.4, il a atteint 99,41 % de taux de sécurité au niveau de l'API et 98,47 % au niveau des fichiers, surpassant les autres méthodes.

Importance et affirmations

L'article affirme que la coordination guidée par la documentation est une direction viable et efficace pour la migration de codebase à grande échelle. Les résultats suggèrent que traiter la migration comme un problème de coordination entre fichiers, interfaces et étapes de réparation — plutôt que comme une tâche brute de génération de code — est essentiel pour le succès à l'échelle du dépôt.

Les auteurs soulignent que :

La planification et l'affinement comptent plus que la traduction en un seul coup : La boucle itérative de génération de documentation, de comparaison avec la source et d'affinement basé sur la rétroaction d'exécution est cruciale pour gérer les dépendances complexes inter-modules.
La documentation agit comme un guide opérationnel : Elle n'est pas simplement un contexte de fond mais un plan fonctionnel qui pilote la récupération des exigences manquantes et l'alignement structurel.
La correction comportementale est réalisable : Les résultats des tests croisés indiquent que les gains ne sont pas seulement documentaires ; les dépôts traduits préservent le comportement d'exécution réel.

L'article conclut que, bien que l'étude actuelle représente un premier résultat solide sur des dépôts réalistes, l'approche laisse des voies claires pour une amélioration future, telles que la gestion de dépôts multi-langages, de dépendances externes plus profondes et de systèmes de construction moins standardisés. Les auteurs positionnent RustPrint comme une méthode pratique pour passer de la traduction de fichiers isolés à des tâches d'ingénierie de niveau dépôt complet basées sur LLM.