odra-codegen 0.7.1

Code generators for Odra IR.
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

use derive_more::From;
use odra_ir::module::{Constructor, Method, ModuleImpl};
use proc_macro2::TokenStream;
use quote::{format_ident, quote};

use crate::{
    generator::common::{self, build_ref},
    GenerateCode
};

#[derive(From)]
pub struct ContractReference<'a> {
    contract: &'a ModuleImpl
}

as_ref_for_contract_impl_generator!(ContractReference);

impl GenerateCode for ContractReference<'_> {
    fn generate_code(&self) -> TokenStream {
        let struct_ident = self.contract.ident();
        let ref_ident = format_ident!("{}Ref", struct_ident);

        let ref_entrypoints = build_entrypoints(self.contract.get_public_method_iter());

        let ref_constructors = build_constructors(self.contract.get_constructor_iter());

        let contract_ref = build_ref(&ref_ident, struct_ident);

        quote! {
            #contract_ref

            impl #ref_ident {
                #ref_entrypoints

                #ref_constructors
            }
        }
    }
}
// check git history for more context
fn build_entrypoints<'a, T>(methods: T) -> TokenStream
where
    T: Iterator<Item = &'a Method>
{
    methods
        .map(|entrypoint| {
            let attrs = &entrypoint.impl_item.attrs;
            let sig = &entrypoint.full_sig;
            let entrypoint_name = &entrypoint.ident.to_string();
            let fn_body =
                common::generate_fn_body(entrypoint.args.clone(), entrypoint_name, &entrypoint.ret);

            quote! {
                #(#attrs)*
                pub #sig {
                    #fn_body
                }
            }
        })
        .collect::<TokenStream>()
}

fn build_constructors<'a, T>(constructors: T) -> TokenStream
where
    T: Iterator<Item = &'a Constructor>
{
    constructors
        .map(|constructor| {
            let attrs = &constructor.impl_item.attrs;
            let sig = &constructor.full_sig;
            let constructor_name = constructor.ident.to_string();
            let fn_body = common::generate_fn_body(
                constructor.args.clone(),
                &constructor_name,
                &syn::ReturnType::Default
            );

            quote! {
                #(#attrs)*
                pub #sig {
                    #fn_body
                }
            }
        })
        .collect::<TokenStream>()
}