engcon_macros 0.1.0

Helpful macros to define contracts on data-structure level
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
117
118
119
120
121
122
123
124
125
126
127
128

use proc_macro::TokenStream;
use quote::format_ident;
use quote::quote;

use super::IntermediateCode;

pub(super) fn codegen(ic: IntermediateCode) -> TokenStream {
    let type_name = ic.self_type;
    let type_name_as_str = type_name.to_string();

    let mut code = Vec::new();

    // 1. implement contract helper methods:
    let mut free_contract_functions = Vec::new();
    let mut free_args: Vec<proc_macro2::Ident> = Vec::new();
    let mut contract_functions = Vec::new();
    let mut contract_function_calls = Vec::new();
    for field in ic.field_infos {
        let field_name = field.field_name;
        let ty = field.ty;
        let field_name_str = field_name.to_string();
        let fn_name = format_ident!("contract_{}", field_name);
        let mut rules = Vec::new();
        let mut free_rules = Vec::new();

        let mut num_args = 0;
        for rule in field.rules {
            let op = rule.cmp_op;
            let right = rule.rigth;
            let op_str = quote! {#op}.to_string();
            let right_str = quote! {#right}.to_string();

            if rule.right_is_field_on_self {
                let ch = char::from_u32(97 + num_args).expect("valid char");
                let arg = syn::Ident::new(ch.to_string().as_str(), proc_macro2::Span::call_site());
                free_args.push(arg.clone());
                num_args += 1;

                free_rules.push(quote! {
                    if !(value #op #arg) {
                        let inject_msg = format!("value={}: '{}' {} '{}'", value, #field_name_str, #op_str, #right_str);
                        return Err(ValidationError::new(inject_msg, #type_name_as_str.to_owned()));
                    }
                });
            } else {
                free_rules.push(quote! {
                    if !(value #op #right) {
                        let inject_msg = format!("value={}: '{}' {} '{}'", value, #field_name_str, #op_str, #right_str);
                        return Err(ValidationError::new(inject_msg, #type_name_as_str.to_owned()));
                    }
                });
            }

            rules.push(quote! {
                if !(self.#field_name #op #right) {
                    let inject_msg = format!("value={}: '{}' {} '{}'", self.#field_name, #field_name_str, #op_str, #right_str);
                    return Err(ValidationError::new(inject_msg, #type_name_as_str.to_owned()));
                }
            });
        }

        free_contract_functions.push(quote! {
            #[inline]
            pub fn #fn_name(value: #ty, #(#free_args: #ty,)*) -> Result<(), ValidationError> {
                #(#free_rules)*
                Ok(())
            }
        });
        free_args.clear();

        contract_functions.push(quote! {
            #[inline]
            pub fn #fn_name(&self) -> Result<(), ValidationError> {
                #(#rules)*
                Ok(())
            }
        });

        contract_function_calls.push(quote! {
            self.#fn_name()?;
        });
    }

    code.push(quote! {
        #(#free_contract_functions)*
    });

    code.push(quote! {
        impl #type_name {
            #(#contract_functions)*
        }
    });

    // 2. Implement the Validator trait
    code.push(quote! {
        #[automatically_derived]
        impl Validator for #type_name {
            fn validate(&self) -> Result<(), ValidationError> {
                #(#contract_function_calls)*
                Ok(())
            }
        }
    });

    // 3. Implmentation of TryFrom
    // todo: try to implement this generically, but blocked by error: see engcon/lib.rs
    code.push(quote! {
        #[automatically_derived]
        impl TryFrom<#type_name> for Validated<#type_name> {
            type Error = ValidationError;

            fn try_from(value: #type_name) -> Result<Self, Self::Error> {
                match value.validate() {
                    Ok(_) => {
                        let reval = unsafe { Validated::new_unchecked(value)};
                        Ok(reval)
                    }
                    Err(err) => Err(err)
                }
            }
        }
    });

    quote! {
        #(#code)*
    }
    .into()
}