odra-macros 2.6.0

Macros for Odra-based smart contracts.
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use quote::{ToTokens, TokenStreamExt};
use syn::parse_quote;

use crate::{ir::FnIR, ModuleImplIR, ModuleStructIR};

pub mod impl_item;
mod parts;
pub mod struct_item;

pub struct FactoryModuleItem {
    is_factory: bool,
    factory_module_ident: syn::Ident,
}

impl TryFrom<&ModuleStructIR> for FactoryModuleItem {
    type Error = syn::Error;

    fn try_from(ir: &ModuleStructIR) -> Result<Self, Self::Error> {
        Ok(Self {
            is_factory: ir.is_factory(),
            factory_module_ident: ir.factory_module_ident(),
        })
    }
}

impl ToTokens for FactoryModuleItem {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        let is_factory = self.is_factory;
        if !is_factory {
            return;
        }

        let factory_module_ident = &self.factory_module_ident;

        tokens.append_all(quote::quote! {
            #[automatically_derived]
            #[odra::factory]
            pub struct #factory_module_ident;
        });
    }
}

pub struct FactoryModuleImplItem {
    is_factory: bool,
    factory_module_ident: syn::Ident,
    functions: Vec<FnIR>
}

impl TryFrom<&ModuleImplIR> for FactoryModuleImplItem {
    type Error = syn::Error;

    fn try_from(ir: &ModuleImplIR) -> Result<Self, Self::Error> {
        let functions = ir.functions()?;
        // functions.push(ir.factory_fn());
        Ok(Self {
            is_factory: ir.is_factory(),
            factory_module_ident: ir.factory_module_ident()?,
            functions
        })
    }
}

impl ToTokens for FactoryModuleImplItem {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        let is_factory = self.is_factory;
        if !is_factory {
            return;
        }
        let factory_module_ident = &self.factory_module_ident;

        let functions = &self
            .functions
            .iter()
            .filter_map(|f| match f {
                FnIR::Impl(fn_impl_ir) => Some(fn_impl_ir),
                _ => None
            })
            .map(|f| {
                syn::ImplItemFn {
                    block: parse_quote!({
                        self.env().revert(OdraError::ExecutionError(ExecutionError::FactoryModuleCall));
                    }),
                    ..f.raw()
                }
            })
            .collect::<Vec<_>>();

        tokens.append_all(quote::quote! {
            #[automatically_derived]
            #[odra::factory]
            impl #factory_module_ident {
                #(#functions)*
            }
        });
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use crate::test_utils::{self, mock};

    #[test]
    fn test_factory_module_item_generation() {
        let ir = mock::factory_module_definition();
        let actual = FactoryModuleItem::try_from(&ir).expect("A valid FactoryModuleItem");

        let expected = quote::quote! {
            #[automatically_derived]
            #[odra::factory]
            pub struct CounterPackFactory;
        };
        test_utils::assert_eq(actual, expected);
    }

    #[test]
    fn test_non_factory_module_item_generation() {
        let ir = mock::module_definition();
        let actual = FactoryModuleItem::try_from(&ir).expect("A valid FactoryModuleItem");

        let expected = quote::quote! {};
        test_utils::assert_eq(actual, expected);
    }

    #[test]
    fn test_factory_module_impl_item_generation() {
        let ir = mock::module_factory_on();
        let actual = FactoryModuleImplItem::try_from(&ir).expect("A valid FactoryModuleImplItem");

        let expected = quote::quote! {
            #[automatically_derived]
            #[odra::factory]
            impl Erc20Factory {
                /// Returns the total supply of the token.
                pub fn total_supply(&self) -> U256 {
                    self.env().revert(OdraError::ExecutionError(ExecutionError::FactoryModuleCall));
                }
                /// Pay to mint.
                #[odra(payable)]
                pub fn pay_to_mint(&mut self) {
                    self.env().revert(OdraError::ExecutionError(ExecutionError::FactoryModuleCall));
                }
            }
        };
        test_utils::assert_eq(actual, expected);
    }
}