expandable 0.1.1

What if we could check declarative macros before using them?
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100

// Architecture invariant: this module contains the definition of various AST
// nodes that are used to represent the parsed Rust code.

use proc_macro2::{Delimiter, Ident, TokenStream, extra::DelimSpan};
use syn::{
    Token, bracketed,
    parse::{Parse, ParseStream, discouraged::AnyDelimiter},
    token::Bracket,
};

pub(crate) struct ItemMacroRules {
    #[allow(dead_code)]
    attrs: Vec<Attribute>,
    #[allow(dead_code)]
    macro_rules: inner::macro_rules,
    #[allow(dead_code)]
    bang: Token![!],
    #[allow(dead_code)]
    name: Ident,
    #[allow(dead_code)]
    delim: MacroDelimiter,
    pub(crate) tokens: TokenStream,
}

impl Parse for ItemMacroRules {
    fn parse(input: ParseStream) -> syn::Result<ItemMacroRules> {
        let tokens;
        Ok(ItemMacroRules {
            attrs: Attribute::parse_outer(input)?,
            macro_rules: input.parse()?,
            bang: input.parse()?,
            name: input.parse()?,
            delim: {
                let (delimiter, content) = parse_delimited(input)?;
                tokens = content;
                delimiter
            },
            tokens,
        })
    }
}

#[allow(dead_code)]
struct Attribute {
    pound: Token![#],
    bracket: Bracket,
    inner: TokenStream,
}

impl Parse for Attribute {
    fn parse(input: ParseStream) -> syn::Result<Attribute> {
        let tokens;
        Ok(Attribute {
            pound: input.parse()?,
            bracket: bracketed!(tokens in input),
            inner: tokens.parse()?,
        })
    }
}

impl Attribute {
    fn parse_outer(input: ParseStream) -> syn::Result<Vec<Attribute>> {
        let mut attrs = Vec::new();

        while input.peek(Token![#]) {
            attrs.push(input.parse()?);
        }

        Ok(attrs)
    }
}

fn parse_delimited(input: ParseStream) -> syn::Result<(MacroDelimiter, TokenStream)> {
    let (delim, span, inner) = input.parse_any_delimiter()?;
    let delim = match delim {
        Delimiter::Parenthesis => MacroDelimiter { _inner: span },
        Delimiter::Brace => MacroDelimiter { _inner: span },
        Delimiter::Bracket => MacroDelimiter { _inner: span },
        Delimiter::None => {
            return Err(syn::Error::new(
                span.join(),
                "`expandable` does not support « None delimiters »",
            ));
        }
    };

    let inner = inner.parse()?;

    Ok((delim, inner))
}

struct MacroDelimiter {
    _inner: DelimSpan,
}

mod inner {
    // The `custom_keyword` macro defines a `pub` item, which is not allowed at
    // the root of the `proc_macro` crates.
    syn::custom_keyword!(macro_rules);
}