comfund_macro_impl 0.1.1

Implementation of `comfund` 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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

pub trait PartitionSynErr<T> {
    fn partition_syn_err(self, error: &mut Option<syn::Error>) -> Vec<T>;
}

impl<T, I: Iterator<Item = Result<T, syn::Error>>> PartitionSynErr<T> for I {
    fn partition_syn_err(self, error: &mut Option<syn::Error>) -> Vec<T> {
        self.filter_map(|item| match item {
            Ok(item) => Some(item),
            Err(err) => {
                error.combine(err);
                None
            }
        })
        .collect()
    }
}

pub trait CombineSynErr {
    fn combine(&mut self, err: syn::Error);
}

impl CombineSynErr for Option<syn::Error> {
    fn combine(&mut self, err: syn::Error) {
        if let Some(val) = self {
            val.combine(err);
        } else {
            *self = Some(err)
        }
    }
}

macro_rules! combine_err {
    ($errors:ident, $token:expr, $message:expr) => {
        $crate::extensions::CombineSynErr::combine(
            &mut $errors,
            ::syn::Error::new_spanned(($token), ($message)),
        )
    };
}
pub(crate) use combine_err;

macro_rules! combine_results {
    ($($result:ident),*) => {{
        let mut ___err = None;
        $(
            let $result = match $result {
                Err(err) => {
                    $crate::extensions::CombineSynErr::combine(
                        &mut ___err,
                        err
                    );
                    None
                },
                Ok(res) => Some(res)
            };
        )*

        if let Some(err) = ___err {
            Err(err)
        } else {
            Ok((
                $($result.unwrap(),)*
            ))
        }
    }};
}
pub(crate) use combine_results;

pub trait CollectSynResults<T> {
    fn collect_syn_results<C: Default + Extend<T>>(self) -> syn::Result<C>;
}

impl<T, I: Iterator<Item = syn::Result<T>>> CollectSynResults<T> for I {
    fn collect_syn_results<C: Default + Extend<T>>(self) -> syn::Result<C> {
        let mut coll = C::default();

        let mut errors = None;

        for item in self {
            match item {
                Ok(res) => {
                    if errors.is_none() {
                        coll.extend(Some(res));
                    }
                }
                Err(err) => errors.combine(err),
            }
        }

        if let Some(errors) = errors {
            Err(errors)
        } else {
            Ok(coll)
        }
    }
}