reflect 0.0.15

The "but I thought Rust doesn't have reflection?" memorial brand new way of defining procedural macros.
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

use quote::ToTokens;
use ref_cast::RefCast;
use std::fmt::{self, Debug};
use syn::{AttrStyle, Attribute, Meta};

#[allow(clippy::ptr_arg)]
pub fn debug(attrs: &Vec<Attribute>) -> &impl Debug {
    Wrapper::ref_cast(attrs)
}

#[derive(RefCast)]
#[repr(transparent)]
struct Wrapper<T>(T);

impl Debug for Wrapper<Vec<Attribute>> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_list()
            .entries(self.0.iter().map(Wrapper::ref_cast))
            .finish()
    }
}

impl Debug for Wrapper<Attribute> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("#")?;
        match self.0.style {
            AttrStyle::Outer => {}
            AttrStyle::Inner(_) => f.write_str("!")?,
        }
        f.write_str("[")?;
        for (i, segment) in self.0.path().segments.iter().enumerate() {
            if i > 0 || self.0.path().leading_colon.is_some() {
                f.write_str("::")?;
            }
            write!(f, "{}", segment.ident)?;
        }
        match &self.0.meta {
            Meta::Path(_) => {}
            Meta::List(meta) => write!(f, "({})", meta.tokens)?,
            Meta::NameValue(meta) => write!(f, " = {}", meta.value.to_token_stream())?,
        }
        f.write_str("]")?;
        Ok(())
    }
}

#[test]
fn test_debug() {
    use syn::parse_quote;

    let attrs = vec![
        parse_quote!(#[derive(Debug)]),
        parse_quote!(#[doc = "..."]),
        parse_quote!(#[rustfmt::skip]),
    ];

    let actual = format!("{:#?}", debug(&attrs));
    let expected = "[\
                    \n    #[derive(Debug)],\
                    \n    #[doc = \"...\"],\
                    \n    #[rustfmt::skip],\
                    \n]";
    assert_eq!(actual, expected);
}