flexpiler_derive 0.2.0

Derive macro project for main crate 'flexpiler'
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

use crate::core::definition;
use crate::core::intermediary;
use crate::core::error;

pub struct DataContext {
    pub ident: syn::Ident,
    pub field_ident_vec: Vec<syn::Ident>,
    pub field_type_vec: Vec<proc_macro2::TokenStream>,
}


// Compiler needs to know that the Error returned by this lives longer than 'intermediary, namely 'definition.
pub struct ParameterEnumVariantComplex<'definition, 'intermediary> {
    pub enum_definition_ref: &'definition definition::Enum,
    pub variant_complex_enum_intermediary_ref: &'intermediary intermediary::enum_rustc::VariantComplex<'definition>,
}


impl<'a> std::convert::TryFrom<&'a definition::Struct> for DataContext {
    type Error = error::Error<'a>;

    fn try_from(struct_definition_ref: &'a definition::Struct) -> std::result::Result<Self, Self::Error> {
        let mut field_ident_vec = Vec::new();
        let mut field_type_vec = Vec::new();

        for field_ref in struct_definition_ref.data_struct.fields.iter() {
            let field_type_ref = &field_ref.ty;
            let field_ident_ref = match &field_ref.ident {
                &Some(ref value_ref) => value_ref,
                &None => {
                    return Err(
                        Self::Error::StructFieldUnnamed{
                            field_ref,
                        },
                    )
                }
            };
            field_ident_vec.push(format_ident!("{}_option", field_ident_ref));
            field_type_vec.push(quote!(Option< #field_type_ref >));
        }

        Ok(DataContext {
            ident: format_ident!("{}flexpilerContext", struct_definition_ref.ident),
            field_ident_vec,
            field_type_vec,
        })
    }
}


// Compiler needs to know that the Error returned by this lives longer than 'intermediary, namely 'definition.
impl<'definition, 'intermediary> std::convert::TryFrom<ParameterEnumVariantComplex<'definition, 'intermediary>> for DataContext {
    type Error = error::Error<'definition>;

    fn try_from(parameter: ParameterEnumVariantComplex<'definition, 'intermediary>) -> std::result::Result<Self, Self::Error> {
        let mut field_ident_vec = Vec::new();
        let mut field_type_vec = Vec::new();

        for (field_ident_ref, field_type_ref) in parameter.variant_complex_enum_intermediary_ref.field_ident_ref_vec.iter()
            .zip(parameter.variant_complex_enum_intermediary_ref.field_type_ref_vec.iter()) {
            field_ident_vec.push(format_ident!("{}_option", field_ident_ref));
            field_type_vec.push(quote!(Option< #field_type_ref >));
        }

        let enum_ident_ref = &parameter.enum_definition_ref.ident;

        Ok(DataContext {
            ident: format_ident!("{}{}flexpilerContext",
                parameter.enum_definition_ref.ident,
                parameter.variant_complex_enum_intermediary_ref.ident_ref
            ),
            field_ident_vec,
            field_type_vec,
        })
    }
}