Visualizador de Expansão de Macros Rust
Descubra no que as macros Rust se expandem. Nosso Visualizador de Expansão de Macros Rust detecta e exibe mais de 20 tipos de macros, incluindo println!, vec!, format!, definições macro_rules!, macros de atributo #[derive()] e macros procedurais personalizadas. Cada detecção inclui a forma expandida, uma explicação detalhada e o número da linha de origem. Grátis, privado e sem cadastro.
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 que usar nosso Visualizador de Expansão de Macros Rust?
- Detecção abrangente de macros: detecta automaticamente mais de 20 tipos de macros Rust: macros integradas (println!, vec!, format!, concat!, stringify!), declarações (macro_rules!), macros de atributo (#[derive(...)]) e macros procedurais personalizadas. Cada detecção inclui o nome da macro, os argumentos e o número da linha de origem, para visibilidade completa do uso de macros no seu código Rust.
- Expansão simulada e detecção de recursão: visualize no que cada macro se expande com formas expandidas simuladas. As macros integradas mostram o código equivalente, as definições macro_rules! mostram seus braços de correspondência e as macros recursivas são sinalizadas com indicadores de profundidade. Entenda exatamente como funciona o código Rust cheio de templates em tempo de compilação.
- Explicações didáticas e contexto: cada macro detectada inclui uma explicação detalhada do seu propósito, do seu funcionamento e do que ela produz em tempo de compilação. Perfeito para aprender o sistema de macros do Rust: entenda a diferença entre macro_rules! declarativas, macros procedurais e macros integradas do compilador, com exemplos reais.
- 100 % local no navegador e privado: toda a análise de macros Rust é executada inteiramente no seu navegador. Seu código Rust, todas as macros detectadas, as visualizações de expansão e os resultados da análise nunca saem do seu dispositivo. Sem envio para servidores, sem chamadas de API, sem armazenamento de dados e sem rastreamento. Ideal para analisar código proprietário ou fazer análise competitiva.
O que é expansão de macros Rust?
A expansão de macros Rust é o processo, em tempo de compilação, de transformar invocações de macros em código Rust real. Quando o compilador Rust encontra uma chamada de macro como println!("Olá, ", nome), ele a substitui por código gerado antes que a verificação de tipos e a compilação continuem. Existem três tipos de macros em Rust: as declarativas (macro_rules!), que usam correspondência de padrões; as procedurais, que executam código Rust arbitrário em tempo de compilação (como #[derive(Serialize)]); e as macros integradas ao compilador (como println!, vec! e format!), que fazem parte do próprio compilador. Entender a expansão de macros é essencial para depurar, revisar código e aprender padrões avançados de Rust.
Como funciona nosso Visualizador de Expansão de Macros Rust
O visualizador analisa o código-fonte Rust usando correspondência de padrões ciente da linguagem para identificar os diferentes tipos de macros. Macros integradas como println!, vec!, format! e concat! são detectadas pelos nomes conhecidos e pela estrutura dos argumentos: cada uma tem um simulador de expansão sob medida que mostra o código gerado equivalente. As definições macro_rules! são detectadas e seus braços de correspondência são analisados para mostrar os pares padrão-transcritor. Os atributos #[derive(...)] são analisados para listar as implementações de traits geradas. Macros personalizadas são identificadas como qualquer identificador seguido de ! que não seja uma macro integrada conhecida. Macros recursivas são detectadas procurando invocações autorreferenciais dentro de uma definição. Todo o processamento é executado localmente no seu navegador, sem interação com servidor.
Macros Rust versus outras linguagens
O sistema de macros do Rust é radicalmente diferente do pré-processador de C/C++. Ao contrário do #define de C, que é uma simples substituição de texto, as macros Rust operam no nível dos tokens e respeitam fronteiras sintáticas. Isso significa que as macros Rust são higiênicas (não capturam variáveis do escopo chamador por acidente), oferecem correspondência de padrões sobre estruturas sintáticas e se integram ao sistema de tipos do Rust. As macros procedurais do Rust são ainda mais poderosas: recebem um fluxo de tokens em tempo de compilação e produzem um novo fluxo de tokens, o que permite geração avançada de código para serialização (serde), frameworks web (actix-web, rocket) e ORMs de banco de dados (diesel, sqlx). Isso torna as macros Rust seguras, componíveis e muito mais capazes do que macros de pré-processador tradicionais ou até do que templates de C++.
Privacidade, segurança e limitações
Esta ferramenta é executada inteiramente no seu navegador com JavaScript do lado do cliente. O código Rust que você colar, todas as macros detectadas, as visualizações de expansão e os resultados da análise nunca são enviados a nenhum servidor. No entanto, há limitações importantes a conhecer. A ferramenta fornece expansões simuladas para macros integradas e análise estrutural para definições macro_rules!, mas não executa macros procedurais nem expande totalmente macros recursivas com estado de execução. A forma expandida é uma aproximação didática, não a saída exata do compilador. Para uma expansão precisa de macros, use cargo expand ou rustc -Z macro-backtrace. A ferramenta pode não detectar macros de crates externos, a menos que seus padrões de chamada estejam incluídos no código analisado.
Perguntas frequentes
A ferramenta detecta mais de 20 tipos de macros Rust, incluindo macros integradas (println!, vec!, format!, concat!, stringify!, assert!, matches!, panic!, todo!), definições macro_rules! com seus braços de correspondência, macros de atributo #[derive(...)] com a lista de traits, macros personalizadas do tipo função e macros de atributo personalizadas. Ela também detecta padrões de macros recursivas com rastreamento de profundidade.
A ferramenta analisa o código-fonte Rust usando correspondência de padrões ciente da linguagem para identificar os diferentes tipos de macros. Cada macro integrada tem um simulador de expansão sob medida que mostra o código gerado equivalente. As definições macro_rules! são analisadas para extrair seus braços de correspondência. Os atributos #[derive] mostram quais implementações de traits são geradas. As macros personalizadas são identificadas pelo nome e pelo padrão de invocação. Todo o processamento é executado localmente no seu navegador, sem interação com servidor.
Não. Macros procedurais não podem ser expandidas no navegador porque exigem executar o código real do crate de macro procedural dentro do compilador Rust em tempo de compilação. Em vez disso, a ferramenta mostra uma explicação genérica do que a macro procedural deve fazer, com base no nome e no contexto. Para a expansão exata de macros procedurais, use cargo expand ou rustc -Z macro-backtrace.
A visualização da expansão oferece aproximações didáticas. Macros integradas como println! e vec! têm expansões precisas, baseadas no comportamento documentado. As definições macro_rules! mostram análise estrutural. Para a expansão exata, use cargo expand, que executa o compilador de verdade. Esta ferramenta foi feita para aprendizado, revisão de código e análise rápida, não como substituta de ferramentas em nível de compilador.
Quando uma macro macro_rules! invoca a si mesma dentro da própria expansão, ela é sinalizada como recursiva. A ferramenta conta quantos níveis de autorreferência foram encontrados e exibe a profundidade. Macros recursivas são comuns em Rust para implementar máquinas de estado, estruturas de dados recursivas e certos padrões de DSL.
Com certeza. O Visualizador de Expansão de Macros Rust é executado inteiramente no seu navegador. Seu código Rust, todas as macros detectadas, as visualizações de expansão e os resultados da análise nunca saem do seu dispositivo. Sem envio para servidores, sem chamadas de API, sem rastreamento analítico, sem cookies e sem coleta de dados de qualquer tipo.
Sim: 100 % grátis, sem cadastro, sem conta e sem limites de uso. Analise quanto código Rust precisar, quantas vezes quiser. Não há planos premium, cobranças ocultas nem limites de requisições. A ferramenta é executada inteiramente no seu navegador.