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
65
66
67
68
69
70
71
72
73
74
75

use crate::{attr, Ident, Push, StaticBorrow, Type, Value, ValueNode, WIP};
use std::fmt::{self, Debug, Display};
use std::vec;
use syn::Attribute;

#[derive(Debug, Clone)]
pub struct Fields<T> {
    pub(crate) fields: vec::IntoIter<Field<T>>,
}

impl<T> Iterator for Fields<T> {
    type Item = Field<T>;

    fn next(&mut self) -> Option<Self::Item> {
        self.fields.next()
    }
}

#[derive(Debug, Clone)]
pub(crate) enum Accessor {
    Name(Ident),
    Index(usize),
}

#[derive(Clone)]
pub struct Field<T> {
    pub(crate) accessor: Accessor,
    pub(crate) element: T,
    pub(crate) attrs: Vec<Attribute>,
}

impl<T: Debug> Debug for Field<T> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.debug_struct("Field")
            .field("accessor", &self.accessor)
            .field("element", &self.element)
            .field("attrs", attr::debug(&self.attrs))
            .finish()
    }
}

impl Display for Accessor {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        use crate::Accessor::*;
        match self {
            Name(ident) => Display::fmt(ident, f),
            Index(i) => Display::fmt(i, f),
        }
    }
}

impl Field<Value> {
    pub fn get_name(&self) -> Value {
        let node = ValueNode::Str(self.accessor.to_string());
        Value {
            index: WIP.with_borrow_mut(|wip| wip.values.index_push(node)),
        }
    }

    pub fn get_attrs(&self) -> &[Attribute] {
        &self.attrs
    }
}

impl Field<Type> {
    pub fn get_name(&self) -> String {
        self.accessor.to_string()
    }
}

impl Field<Value> {
    pub fn get_value(&self) -> Value {
        self.element
    }
}