macro-v 0.1.4

Attribute macro for making the visibility of the `macro_rules!` macro the same as other items.
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
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121

use std::{
    collections::hash_map::RandomState,
    hash::{BuildHasher, Hasher},
};

use proc_macro2::TokenStream;
use quote::{format_ident, quote};
use syn::{
    braced,
    parse::{Parse, ParseStream},
    Attribute, Ident, Meta, Token, Visibility,
};

pub(crate) struct MacroDefinition {
    attrs: Vec<Attribute>,
    macro_rules: Ident,
    bang_token: Token![!],
    name: Ident,
    tokens: TokenStream,
}

impl Parse for MacroDefinition {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let attrs = input.call(Attribute::parse_outer)?;

        let macro_rules = input.parse::<Ident>()?;
        if macro_rules != "macro_rules" {
            return Err(syn::Error::new(
                macro_rules.span(),
                "expected `macro_rules`",
            ));
        }

        let bang_token = input.parse::<Token![!]>()?;

        let name = input.parse::<Ident>()?;

        let tokens;
        braced!(tokens in input);

        Ok(Self {
            attrs,
            macro_rules,
            bang_token,
            name,
            tokens: tokens.parse()?,
        })
    }
}

pub(crate) fn generate(vis: Visibility, macro_def: MacroDefinition) -> syn::Result<TokenStream> {
    let MacroDefinition {
        attrs,
        macro_rules,
        bang_token,
        name,
        tokens,
    } = macro_def;

    let real_name = format_ident!("__{}_{}", name, RandomState::new().build_hasher().finish());

    let mut has_doc_hidden = false;

    for attr in attrs.iter() {
        if has_doc_hidden {
            break;
        }

        if !attr.path().is_ident("doc") {
            continue;
        }

        if matches!(attr.meta, Meta::List(_)) {
            attr.parse_nested_meta(|meta| {
                if meta.path.is_ident("hidden") {
                    has_doc_hidden = true;
                    return Ok(());
                }
                Ok(())
            })?;
        }
    }

    let (origin_doc_attr, reexport_doc_attr) = if has_doc_hidden {
        (
            quote! {},
            quote! {
                #[doc(hidden)]
            },
        )
    } else {
        (
            quote! {
                #[doc(hidden)]
            },
            quote! {
                #[doc(inline)]
            },
        )
    };

    let export = if let Visibility::Public(_) = vis {
        quote! {
            #[macro_export]
        }
    } else {
        quote! {}
    };

    let expand = quote! {
        #origin_doc_attr
        #(#attrs)*
        #export
        #macro_rules #bang_token #real_name { #tokens }

        #reexport_doc_attr
        #vis use #real_name as #name;
    };

    Ok(expand)
}