add-macro-impl-from 0.1.1

Implementation of trait 'From<T>'
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

use crate::prelude::*;
use proc_macro2::{ TokenStream, Ident };
use venial::{ Enum, AttributeValue, EnumVariant, Fields };
use quote::quote;

// Implementation of trait 'From' for enumerations
pub(crate) fn impl_from_enum(data: Enum) -> Result<TokenStream> {
    let name = &data.name;
    let mut output = quote!{};

    // reading enum attributes:
    for attr in data.attributes.into_iter() {
        if !check_attr_name(&attr, "from") { continue }

        match attr.value {
            AttributeValue::Group(_, tokens) => {
                
                // parse attribute arguments:
                let (ty, expr) = parse_attr_arguments(&tokens)?;
    
                // generate tokens:
                output.extend(quote! {
                    impl ::core::convert::From<#ty> for #name {
                        fn from(v: #ty) -> Self {
                            #expr
                        }
                    }
                });
            },

            _ => return Err(Error::IncorrectAttribute)
        }
    }

    // reading enum variants attributes:
    for (variant, _) in data.variants.into_iter() {
        let value = handle_enum_variant(&name, variant)?;
        output.extend(value);
    }

    Ok(output)
}

// Handle the enumeration variants
fn handle_enum_variant(enum_name: &Ident, variant: &EnumVariant) -> Result<TokenStream> {
    let name = &variant.name;
    let mut output = quote!{};
    
    // reading attributes:
    for attr in variant.attributes.iter() {
        if !check_attr_name(&attr, "from") { continue }

        // parse attribute arguments:
        let (ty, expr) = match &attr.value {
            AttributeValue::Empty => {
                let ty = parse_enum_variant_first_field_type(&variant.fields)?;
                (ty, quote!{ v })
            },
    
            AttributeValue::Equals(_, tokens) => {
                let ty = parse_enum_variant_first_field_type(&variant.fields)?;
                let expr = parse_attr_argument(&tokens[0])?;

                (ty, expr)
            },

            AttributeValue::Group(_, tokens) => {
                if tokens.len() > 1 {
                    parse_attr_arguments(&tokens)?
                } else {
                    let ty = parse_attr_argument(&tokens[0])?;
                    (ty, quote!{ v })
                }
            }
        };

        // generate tokens:
        output.extend(quote! {
            impl ::core::convert::From<#ty> for #enum_name {
                fn from(v: #ty) -> Self {
                    Self::#name({#expr})
                }
            }
        })
    }

    Ok(output)
}


// Parsing the enum variant fiest field type
fn parse_enum_variant_first_field_type(fields: &Fields) -> Result<TokenStream> {
    let ty = match &fields {
        Fields::Tuple(tuple_fields) => {
            if let Some((field, _)) = &tuple_fields.fields.get(0) {
                let ty = &field.ty;
                quote!{ #ty }
            } else {
                return Err(Error::IncorrectAttributeVariant)   
            }
        },

        Fields::Named(named_fields) => {
            if let Some((field, _)) = &named_fields.fields.get(0) {
                let ty = &field.ty;
                quote!{ #ty }
            } else {
                return Err(Error::IncorrectAttributeVariant)   
            }
        },

        _ => return Err(Error::IncorrectAttributeVariant)
    };

    Ok(ty)
}