subenum 1.0.1

A proc-macro to create subsets of enums, that can be converted to and from.
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

use std::collections::HashMap;

use syn::{GenericParam, Generics, Ident, Lifetime, TypeParamBound, WherePredicate};

use crate::extractor::Extractor;

/// A type or lifetime param, potentially used as a generic.
/// E.g. the 'a in `'a: 'b + 'c` or the T in `T: U + V`.
#[derive(Clone, Debug, Hash, PartialEq, Eq)]
pub enum Param {
    Lifetime(Lifetime),
    Ident(Ident),
}

impl From<Ident> for Param {
    fn from(value: Ident) -> Self {
        Param::Ident(value)
    }
}

impl From<Lifetime> for Param {
    fn from(value: Lifetime) -> Self {
        Param::Lifetime(value)
    }
}

impl Param {
    /// Given a set of `Generics`, finds the first `GenericParam` and
    /// `WherePredicate` where it appears.
    pub fn find<'b>(
        &self,
        generics: &'b Generics,
    ) -> (Option<&'b GenericParam>, Option<&'b WherePredicate>) {
        match self {
            Param::Lifetime(lt) => find_lt(lt, generics),
            Param::Ident(ty) => find_ident(ty, generics),
        }
    }

    /// Given a param and a map of bounds, will find all params that we may
    /// need.
    /// Example:
    /// Given `T` and bounds `T: U, U: V, V: W + X, W, X, Y: Z, Z`
    /// Will return `T, U, V, W, X`.
    pub fn find_relevant(&self, bound_map: &HashMap<Param, Vec<TypeParamBound>>) -> Vec<Param> {
        match bound_map.get(self) {
            Some(bounds) => bounds
                .iter()
                .flat_map(|bound| match bound {
                    TypeParamBound::Trait(tr) => {
                        // TODO: Handle BoundLifetimes (`for<'a, 'b, 'c>`)
                        tr.path
                            .get_ident()
                            .into_iter()
                            .cloned()
                            .flat_map(|ident| Param::from(ident).find_relevant(bound_map))
                            .collect()
                    }
                    TypeParamBound::Lifetime(lifetime) => {
                        Param::from(lifetime.clone()).find_relevant(bound_map)
                    }
                })
                .chain([self.clone()].into_iter())
                .collect(),
            None => Vec::new(),
        }
    }
}
fn find_lt<'a>(
    lt: &Lifetime,
    generics: &'a Generics,
) -> (Option<&'a GenericParam>, Option<&'a WherePredicate>) {
    let generic_param = generics.params.iter().find(|p| match p {
        GenericParam::Lifetime(lt_def) => &lt_def.lifetime == lt,
        _ => false,
    });

    let predicate = generics
        .where_clause
        .iter()
        .flat_map(|wh| wh.predicates.iter())
        .find(|pred| match pred {
            WherePredicate::Lifetime(pred_lt) => &pred_lt.lifetime == lt,
            _ => false,
        });

    (generic_param, predicate)
}

fn find_ident<'a>(
    ident: &Ident,
    generics: &'a Generics,
) -> (Option<&'a GenericParam>, Option<&'a WherePredicate>) {
    let generic_param = generics.params.iter().find(|p| match p {
        GenericParam::Type(ty_param) => &ty_param.ident == ident,
        _ => false,
    });

    let predicate = generics
        .where_clause
        .iter()
        .flat_map(|wh| wh.predicates.iter())
        .find(|pred| match pred {
            WherePredicate::Type(pred_ty) => pred_ty
                .bounded_ty
                .extract_idents()
                .iter()
                .any(|id| id == ident),
            _ => false,
        });

    (generic_param, predicate)
}