spire_enum_macros 0.2.2

Procedural macros to facilitate enum usage, such as when delegating implementations, extracting variant types, or creating enum tables.
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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

mod expressions;
mod generics;
mod items;
mod paths;
mod patterns;
mod types;

use std::collections::HashSet;

use syn::*;

#[cfg(test)]
mod tests;

#[derive(Debug, Clone, Default)]
pub struct IdentMap {
    pub tys: HashSet<String>,
    pub traits: HashSet<String>,
    pub lifetimes: HashSet<String>,
    pub constants: HashSet<String>,
    pub ambiguous_paths: HashSet<String>,
}

impl IdentMap {
    pub fn new(input: &impl CollectIdents) -> Self {
        let mut map = Self::default();
        input.collect_idents(&mut map);
        map.filter_solved_ambiguous();
        map
    }

    pub fn filter_solved_ambiguous(&mut self) {
        for ident in &self.tys {
            self.ambiguous_paths.remove(ident);
        }

        for ident in &self.traits {
            self.ambiguous_paths.remove(ident);
        }

        for ident in &self.constants {
            self.ambiguous_paths.remove(ident);
        }
    }

    pub fn insert_ty(&mut self, id: &Ident) {
        self.tys.insert(id.to_string());
    }
    pub fn insert_trait(&mut self, id: &Ident) {
        self.traits.insert(id.to_string());
    }
    pub fn insert_lifetime(&mut self, id: &Ident) {
        self.lifetimes.insert(id.to_string());
    }
    pub fn insert_constant(&mut self, id: &Ident) {
        self.constants.insert(id.to_string());
    }
    pub fn insert_ambiguous(&mut self, id: &Ident) {
        self.ambiguous_paths.insert(id.to_string());
    }
}

macro_rules! match_collect {
	($Map:expr, $This: ident => $Enum: ident { $($Var: ident),* $(,)? .. }) => {{
	    match $This {
			$( $Enum::$Var(var) => var.collect_idents($Map), )*
			_ => {},
		}
    }};

	($Map:expr, $This: ident => $Enum: ident { $($Var: ident),* $(,)? ..panic }) => {{
	    match $This {
			$( $Enum::$Var(var) => var.collect_idents($Map), )*
			_ => panic!("Unsupported variant: {:?}", $This),
		}
    }};

	($Map:expr, $This: ident => $Enum: ident { $($Var: ident),* $(,)? }) => {{
	    match $This {
			$( $Enum::$Var(var) => var.collect_idents($Map), )*
		}
    }};
}

macro_rules! collect {
    ($Map:expr, $($Expr: expr),*) => {{
	    $( $Expr.collect_idents($Map); )*
    }};
}

pub(crate) use collect;
pub(crate) use match_collect;

pub trait CollectIdents {
    fn collect_idents(&self, map: &mut IdentMap);
}

impl CollectIdents for Lifetime {
    fn collect_idents(&self, map: &mut IdentMap) {
        let Self {
            apostrophe: _,
            ident,
        } = self;
        map.insert_lifetime(ident);
    }
}

impl<T: CollectIdents> CollectIdents for Option<T> {
    fn collect_idents(&self, map: &mut IdentMap) {
        if let Some(t) = self {
            collect!(map, t);
        }
    }
}

impl<T: CollectIdents> CollectIdents for Box<T> {
    fn collect_idents(&self, map: &mut IdentMap) {
        let t = &**self;
        collect!(map, t);
    }
}

impl<T: CollectIdents, Token> CollectIdents for punctuated::Punctuated<T, Token> {
    fn collect_idents(&self, map: &mut IdentMap) {
        for item in self {
            collect!(map, item);
        }
    }
}

impl<T: CollectIdents> CollectIdents for Vec<T> {
    fn collect_idents(&self, map: &mut IdentMap) {
        for item in self {
            collect!(map, item);
        }
    }
}