spire_enum_macros 0.2.1

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

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) {
		self.ambiguous_paths
			.extract_if(|id| {
				// Dont check lifetimes, paths don't contain `'`
				self.tys.contains(id) || self.traits.contains(id) || self.constants.contains(id)
			})
			.count();
	}

	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);
		}
	}
}