Visualiseur d'Expansion de Macros Rust
Découvrez en quoi les macros Rust s'étendent. Notre Visualiseur d'Expansion de Macros Rust détecte et affiche plus de 20 types de macros, dont println!, vec!, format!, les définitions macro_rules!, les macros d'attribut #[derive()] et les macros procédurales personnalisées. Chaque détection inclut la forme développée, une explication détaillée et le numéro de ligne source. Gratuit, privé et sans inscription.
Detect and visualize Rust macro expansions. Automatically identifies built-in macros (println!, vec!, format!, assert!), macro_rules! definitions, #[derive(...)] attribute macros, and custom proc macros. Shows expanded forms, explanations, and recursion detection. All processing is local - no server upload required.
Paste Rust code above and click Analyze Macros to detect and visualize macro expansions. The tool identifies built-in macros (println!, vec!, format!), macro_rules! definitions, #[derive] attributes, and custom procedural macros. Try loading an example to see how it works!
Pourquoi utiliser notre Visualiseur d'Expansion de Macros Rust ?
- Détection exhaustive des macros : détecte automatiquement plus de 20 types de macros Rust : macros intégrées (println!, vec!, format!, concat!, stringify!), déclarations (macro_rules!), macros d'attribut (#[derive(...)]) et macros procédurales personnalisées. Chaque détection inclut le nom de la macro, ses arguments et le numéro de ligne source, pour une visibilité complète sur l'usage des macros dans votre code Rust.
- Expansion simulée et détection de récursion : visualisez ce en quoi chaque macro s'étend grâce à des formes développées simulées. Les macros intégrées affichent leur code équivalent, les définitions macro_rules! montrent leurs bras de correspondance et les macros récursives sont signalées par des indicateurs de profondeur. Comprenez exactement comment fonctionne un code Rust riche en modèles à la compilation.
- Explications pédagogiques et contexte : chaque macro détectée inclut une explication détaillée de son rôle, de son fonctionnement et de ce qu'elle produit à la compilation. Idéal pour apprendre le système de macros de Rust : comprenez la différence entre les macro_rules! déclaratives, les macros procédurales et les macros intégrées du compilateur, avec des exemples concrets.
- 100 % local dans le navigateur et privé : toute l'analyse des macros Rust s'exécute entièrement dans votre navigateur. Votre code Rust, toutes les macros détectées, les visualisations d'expansion et les résultats d'analyse ne quittent jamais votre appareil. Aucun envoi vers un serveur, aucun appel d'API, aucun stockage de données et aucun suivi. Parfait pour analyser du code propriétaire ou faire une analyse concurrentielle.
Qu'est-ce que l'expansion de macros Rust ?
L'expansion de macros Rust est le processus, à la compilation, qui transforme les invocations de macros en code Rust réel. Lorsque le compilateur Rust rencontre un appel de macro comme println!("Bonjour, ", nom), il le remplace par du code généré avant que la vérification des types et la compilation ne se poursuivent. Il existe trois sortes de macros en Rust : les macros déclaratives (macro_rules!), qui utilisent la correspondance de motifs ; les macros procédurales, qui exécutent du code Rust arbitraire à la compilation (comme #[derive(Serialize)]) ; et les macros intégrées au compilateur (comme println!, vec! et format!), qui font partie du compilateur lui-même. Comprendre l'expansion des macros est essentiel pour déboguer, relire du code et apprendre les motifs Rust avancés.
Comment fonctionne notre Visualiseur d'Expansion de Macros Rust
Le visualiseur analyse le code source Rust à l'aide d'une correspondance de motifs tenant compte du langage afin d'identifier les différents types de macros. Les macros intégrées comme println!, vec!, format! et concat! sont détectées par leurs noms connus et la structure de leurs arguments : chacune dispose d'un simulateur d'expansion sur mesure qui montre le code généré équivalent. Les définitions macro_rules! sont détectées et leurs bras de correspondance sont analysés pour afficher les paires motif-transcripteur. Les attributs #[derive(...)] sont analysés pour lister les implémentations de traits générées. Les macros personnalisées sont identifiées comme tout identifiant suivi de ! qui n'est pas une macro intégrée connue. Les macros récursives sont détectées en recherchant les invocations de macro auto-référentielles dans une définition. Tout le traitement s'exécute localement dans votre navigateur, sans interaction avec un serveur.
Les macros Rust face aux autres langages
Le système de macros de Rust est fondamentalement différent du préprocesseur de C/C++. Contrairement au #define de C, qui est une simple substitution de texte, les macros Rust opèrent au niveau des jetons et respectent les frontières syntaxiques. Cela signifie que les macros Rust sont hygiéniques (elles ne capturent pas accidentellement des variables de la portée appelante), qu'elles prennent en charge la correspondance de motifs sur les structures syntaxiques et qu'elles s'intègrent au système de types de Rust. Les macros procédurales de Rust sont encore plus puissantes : elles reçoivent un flux de jetons à la compilation et produisent un nouveau flux de jetons, ce qui permet une génération de code avancée pour la sérialisation (serde), les frameworks web (actix-web, rocket) et les ORM de bases de données (diesel, sqlx). Les macros Rust sont donc sûres, composables et bien plus puissantes que les macros de préprocesseur traditionnelles, et même que les templates C++.
Confidentialité, sécurité et limites
Cet outil s'exécute entièrement dans votre navigateur grâce à JavaScript côté client. Le code Rust que vous collez, toutes les macros détectées, les visualisations d'expansion et les résultats d'analyse ne sont jamais envoyés à un serveur. Il existe toutefois des limites importantes à connaître. L'outil fournit des expansions simulées pour les macros intégrées et une analyse structurelle pour les définitions macro_rules!, mais il n'exécute pas les macros procédurales et ne développe pas complètement les macros récursives avec un état d'exécution. La forme développée est une approximation pédagogique, et non la sortie exacte du compilateur. Pour une expansion précise, utilisez cargo expand ou rustc -Z macro-backtrace. L'outil peut ne pas détecter les macros de crates externes, sauf si leurs motifs d'appel figurent dans le code analysé.
Foire aux questions
L'outil détecte plus de 20 types de macros Rust, notamment les macros intégrées (println!, vec!, format!, concat!, stringify!, assert!, matches!, panic!, todo!), les définitions macro_rules! avec leurs bras de correspondance, les macros d'attribut #[derive(...)] avec la liste des traits, les macros personnalisées de type fonction et les macros d'attribut personnalisées. Il détecte aussi les motifs de macros récursives avec suivi de la profondeur.
L'outil analyse le code source Rust à l'aide d'une correspondance de motifs tenant compte du langage pour identifier les différents types de macros. Chaque macro intégrée dispose d'un simulateur d'expansion sur mesure qui montre le code généré équivalent. Les définitions macro_rules! sont analysées pour en extraire les bras de correspondance. Les attributs #[derive] indiquent quelles implémentations de traits sont générées. Les macros personnalisées sont identifiées par leur nom et leur motif d'invocation. Tout le traitement s'exécute localement dans votre navigateur, sans interaction avec un serveur.
Non. Les macros procédurales ne peuvent pas être développées dans le navigateur, car elles nécessitent l'exécution du code réel du crate de macro procédurale au sein du compilateur Rust à la compilation. L'outil affiche à la place une explication générique de ce que la macro procédurale est censée faire, d'après son nom et son contexte. Pour une expansion exacte, utilisez cargo expand ou rustc -Z macro-backtrace.
La visualisation de l'expansion fournit des approximations pédagogiques. Les macros intégrées comme println! et vec! ont des expansions précises fondées sur leur comportement documenté. Les définitions macro_rules! affichent une analyse structurelle. Pour une expansion exacte, utilisez cargo expand, qui exécute le vrai compilateur. Cet outil est conçu pour l'apprentissage, la relecture de code et l'analyse rapide, et non comme substitut aux outils de niveau compilateur.
Lorsqu'une macro macro_rules! s'invoque elle-même dans sa propre expansion, elle est signalée comme récursive. L'outil compte le nombre de niveaux d'auto-référence trouvés et affiche la profondeur. Les macros récursives sont courantes en Rust pour implémenter des machines à états, des structures de données récursives et certains motifs de DSL.
Absolument. Le Visualiseur d'Expansion de Macros Rust s'exécute entièrement dans votre navigateur. Votre code Rust, toutes les macros détectées, les visualisations d'expansion et les résultats d'analyse ne quittent jamais votre appareil. Aucun envoi vers un serveur, aucun appel d'API, aucun suivi analytique, aucun cookie et aucune collecte de données, quelle qu'elle soit.
Oui : 100 % gratuit, sans inscription, sans compte et sans limite d'utilisation. Analysez autant de code Rust que nécessaire, autant de fois que vous le souhaitez. Aucune offre premium, aucun frais caché et aucune limitation de débit. L'outil s'exécute entièrement dans votre navigateur.