Visualizador de Expansión de Macros de Rust
Descubre a qué se expanden las macros de Rust. Nuestro Visualizador de Expansión de Macros de Rust detecta y visualiza más de 20 tipos de macros, incluidas println!, vec!, format!, definiciones macro_rules!, macros de atributo #[derive()] y macros procedurales personalizadas. Cada detección incluye la forma expandida, una explicación detallada y el número de línea de origen. Gratis, privado y sin registro.
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!
¿Por qué usar nuestro Visualizador de Expansión de Macros de Rust?
- Detección exhaustiva de macros: detecta automáticamente más de 20 tipos de macros de Rust: macros integradas (println!, vec!, format!, concat!, stringify!), declaraciones (macro_rules!), macros de atributo (#[derive(...)]) y macros procedurales personalizadas. Cada detección incluye el nombre de la macro, sus argumentos y el número de línea de origen, para que veas con total claridad cómo se usan las macros en tu código.
- Expansión simulada y detección de recursión: visualiza a qué se expande cada macro con formas expandidas simuladas. Las macros integradas muestran su código equivalente, las definiciones macro_rules! muestran sus brazos de coincidencia y las macros recursivas se marcan con indicadores de profundidad. Comprende exactamente cómo funciona el código de Rust con muchas plantillas en tiempo de compilación.
- Explicaciones didácticas y contexto: cada macro detectada incluye una explicación detallada de su finalidad, su funcionamiento y lo que produce en tiempo de compilación. Perfecto para aprender el sistema de macros de Rust: entiende la diferencia entre macro_rules! declarativas, macros procedurales y macros integradas del compilador con ejemplos reales.
- 100 % local en el navegador y privado: todo el análisis de macros de Rust se ejecuta por completo en tu navegador. Tu código de Rust, todas las macros detectadas, las visualizaciones de expansión y los resultados nunca salen de tu dispositivo. Sin subidas a servidores, sin llamadas a API, sin almacenamiento de datos y sin rastreo. Ideal para analizar código propietario o hacer análisis competitivo.
¿Qué es la expansión de macros de Rust?
La expansión de macros de Rust es el proceso, en tiempo de compilación, de transformar las invocaciones de macros en código Rust real. Cuando el compilador de Rust encuentra una llamada a macro como println!("Hola, ", nombre), la sustituye por código generado antes de que prosigan la comprobación de tipos y la compilación. En Rust hay tres tipos de macros: las declarativas (macro_rules!), que usan coincidencia de patrones; las procedurales, que ejecutan código Rust arbitrario en tiempo de compilación (como #[derive(Serialize)]); y las macros integradas del compilador (como println!, vec! y format!), que forman parte del propio compilador. Entender la expansión de macros es esencial para depurar, revisar código y aprender patrones avanzados de Rust.
Cómo funciona nuestro Visualizador de Expansión de Macros de Rust
El visualizador analiza el código fuente de Rust mediante coincidencia de patrones consciente del lenguaje para identificar los distintos tipos de macros. Las macros integradas como println!, vec!, format! y concat! se detectan por sus nombres conocidos y la estructura de sus argumentos: cada una tiene un simulador de expansión a medida que muestra el código generado equivalente. Las definiciones macro_rules! se detectan y sus brazos de coincidencia se analizan para mostrar los pares patrón-transcriptor. Los atributos #[derive(...)] se analizan para enumerar las implementaciones de traits que se generan. Las macros personalizadas se identifican como cualquier identificador seguido de ! que no sea una macro integrada conocida. Las macros recursivas se detectan buscando invocaciones autorreferenciales dentro de una definición. Todo el procesamiento se ejecuta localmente en tu navegador sin interacción con ningún servidor.
Las macros de Rust frente a otros lenguajes
El sistema de macros de Rust es radicalmente distinto del preprocesador de C/C++. A diferencia del #define de C, que es una simple sustitución de texto, las macros de Rust operan a nivel de tokens y respetan los límites sintácticos. Esto significa que las macros de Rust son higiénicas (no capturan accidentalmente variables del ámbito que las llama), admiten coincidencia de patrones sobre estructuras sintácticas y se integran con el sistema de tipos de Rust. Las macros procedurales de Rust son aún más potentes: reciben un flujo de tokens en tiempo de compilación y producen un nuevo flujo de tokens, lo que permite generar código avanzado para serialización (serde), frameworks web (actix-web, rocket) y ORM de bases de datos (diesel, sqlx). Esto hace que las macros de Rust sean seguras, componibles y mucho más capaces que las macros de preprocesador tradicionales o incluso que las plantillas de C++.
Privacidad, seguridad y limitaciones
Esta herramienta se ejecuta por completo en tu navegador con JavaScript del lado del cliente. El código de Rust que pegues, todas las macros detectadas, las visualizaciones de expansión y los resultados del análisis nunca se suben a ningún servidor. Sin embargo, conviene conocer algunas limitaciones importantes. La herramienta ofrece expansiones simuladas para las macros integradas y análisis estructural para las definiciones macro_rules!, pero no ejecuta macros procedurales ni expande por completo macros recursivas con estado en tiempo de ejecución. La forma expandida es una aproximación didáctica, no la salida exacta del compilador. Para una expansión precisa de macros, usa cargo expand o rustc -Z macro-backtrace. Es posible que la herramienta no detecte macros de crates externos a menos que sus patrones de llamada estén incluidos en el código analizado.
Preguntas frecuentes
La herramienta detecta más de 20 tipos de macros de Rust, incluidas macros integradas (println!, vec!, format!, concat!, stringify!, assert!, matches!, panic!, todo!), definiciones macro_rules! con sus brazos de coincidencia, macros de atributo #[derive(...)] con la lista de traits, macros personalizadas tipo función y macros de atributo personalizadas. También detecta patrones de macros recursivas con seguimiento de profundidad.
La herramienta analiza el código fuente de Rust mediante coincidencia de patrones consciente del lenguaje para identificar distintos tipos de macros. Cada macro integrada tiene un simulador de expansión a medida que muestra el código generado equivalente. Las definiciones macro_rules! se analizan para extraer sus brazos de coincidencia. Los atributos #[derive] muestran qué implementaciones de traits se generan. Las macros personalizadas se identifican por su nombre y patrón de invocación. Todo el procesamiento se ejecuta localmente en tu navegador sin interacción con ningún servidor.
No. Las macros procedurales no se pueden expandir en el navegador porque requieren ejecutar el código real del crate de macro procedural dentro del compilador de Rust en tiempo de compilación. En su lugar, la herramienta muestra una explicación genérica de lo que se espera que haga la macro procedural según su nombre y contexto. Para obtener la expansión exacta de una macro procedural, usa cargo expand o rustc -Z macro-backtrace.
La visualización de la expansión ofrece aproximaciones didácticas. Las macros integradas como println! y vec! tienen expansiones precisas basadas en su comportamiento documentado. Las definiciones macro_rules! muestran un análisis estructural. Para obtener la expansión exacta, usa cargo expand, que ejecuta el compilador real. Esta herramienta está pensada para el aprendizaje, la revisión de código y el análisis rápido, no como sustituto de las herramientas a nivel de compilador.
Cuando una macro macro_rules! se invoca a sí misma dentro de su propia expansión, se marca como recursiva. La herramienta cuenta cuántos niveles de autorreferencia encuentra y muestra la profundidad. Las macros recursivas son habituales en Rust para implementar máquinas de estados, estructuras de datos recursivas y ciertos patrones de DSL.
Por supuesto. El Visualizador de Expansión de Macros de Rust se ejecuta por completo en tu navegador. Tu código de Rust, todas las macros detectadas, las visualizaciones de expansión y los resultados del análisis nunca salen de tu dispositivo. Sin subidas a servidores, sin llamadas a API, sin seguimiento analítico, sin cookies y sin recogida de datos de ningún tipo.
Sí: 100 % gratuita, sin registro, sin cuenta y sin límites de uso. Analiza tanto código de Rust como necesites, tantas veces como quieras. No hay planes premium, cargos ocultos ni límites de velocidad. La herramienta se ejecuta por completo en tu navegador.