mapstruct-derive-lib 0.4.0

A derive macro for mapstruct
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

use syn::parse::{Parse, ParseStream};

use crate::transformer::Transformer;
use crate::variant::VariantChange;

pub struct EnumChange {
    changes: Vec<VariantChange>,
}

impl Parse for EnumChange {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let content;
        syn::braced!(content in input);
        let changes = content.parse_terminated(VariantChange::parse, syn::Token![,])?;
        let changes = changes.into_iter().collect();
        Ok(EnumChange { changes })
    }
}


impl Transformer for EnumChange {
    type Item = syn::DataEnum;
    type CreateIter = std::option::IntoIter<Self::Item>;

    fn create(&self) -> syn::Result<Self::CreateIter> {
        Ok(None.into_iter())
    }

    fn transform(&self, item: &mut Self::Item) -> syn::Result<bool> {
        #[derive(Copy, Clone, PartialEq)]
        enum VariantChange {
            Original,
            Added,
            Changed,
            Removed,
        }

        let mut new_variants = item.variants.iter()
            .cloned()
            .map(|field| (field, VariantChange::Original))
            .collect::<Vec<_>>();

        for variant_change in &self.changes {
            let mut applied = false;
            for variant in variant_change.create()? {
                new_variants.push((variant, VariantChange::Added));
                applied = true;
            }

            for (variant, change) in &mut new_variants {
                let do_remove = variant_change.remove(variant)?;
                if do_remove && change != &VariantChange::Original {
                    // Already changed
                    return Err(syn::Error::new_spanned(
                        variant,
                        "Cannot change field twice"
                    ));
                }
                let transform = variant_change.transform(variant)?;
                if transform && change != &VariantChange::Original {
                    // Already changed
                    return Err(syn::Error::new_spanned(
                        variant,
                        "Cannot change field twice"
                    ));
                }

                if transform {
                    if do_remove {
                        return Err(syn::Error::new_spanned(
                            variant,
                            "Cannot change field twice"
                        ));
                    } else {
                        *change = VariantChange::Changed;
                        applied = true;
                    }
                } else if do_remove {
                    *change = VariantChange::Removed;
                    applied = true;
                }
            }

            if !applied {
                return Err(syn::Error::new(
                    variant_change.span(),
                    "No variant matched the given change"
                ));
            }
        }

        item.variants = new_variants.into_iter()
            .filter_map(|field| match field {
                (field, VariantChange::Original) => Some(field),
                (field, VariantChange::Added) => Some(field),
                (field, VariantChange::Changed) => Some(field),
                (_, VariantChange::Removed) => None,
            })
            .collect();

        Ok(true)
    }

    fn remove(&self, _: &Self::Item) -> syn::Result<bool> {
        Ok(false)
    }
}