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

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

pub struct LetStmtBuilder {
    mut_token: Option<syn::Token![mut]>,
    name: syn::Ident,
    value: Option<syn::Expr>,
}

impl LetStmtBuilder {
    pub fn new(name: &syn::Ident) -> Self {
        Self {
            mut_token: None,
            name: name.clone(),
            value: None,
        }
    }

    pub fn set_mut(mut self) -> Self {
        self.mut_token = Some(Default::default());
        self
    }

    pub fn value(mut self, value: syn::Expr) -> Self {
        self.value = Some(value);
        self
    }

    pub fn build(self) -> syn::Stmt {
        let name = self.name;
        let value = self.value.unwrap_or_else(|| syn::parse_quote!(Default::default()));
        syn::parse_quote!(let #name = #value;)
    }
}

pub struct FnCallBuilder {
    caller: Option<syn::Expr>,
    fn_ident: syn::Ident,
    args: Vec<syn::Expr>
}

impl FnCallBuilder {
    pub fn new(fn_ident: syn::Ident) -> Self {
        Self {
            caller: None,
            fn_ident,
            args: Vec::new()
        }
    }

    pub fn caller<T: ToTokens>(mut self, caller: T) -> Self {
        let caller = caller.into_token_stream();
        self.caller = Some(parse_quote!(#caller));
        self
    }

    pub fn arg<T: ToTokens>(mut self, arg: T) -> Self {
        let arg = arg.into_token_stream();
        self.args.push(parse_quote!(#arg));
        self
    }

    pub fn build(self) -> syn::Expr {
        let caller = self.caller.map(|caller| quote!(#caller.));
        let fn_ident = self.fn_ident;
        let args = self.args;
        parse_quote!(#caller #fn_ident(#(#args),*))
    }
}

pub struct MatchBuilder {
    expr: syn::Expr,
    arms: Vec<syn::Arm>
}

impl MatchBuilder {
    pub fn new(expr: syn::Expr) -> Self {
        Self {
            expr,
            arms: Vec::new()
        }
    }

    pub fn arm<T: ToTokens>(mut self, pat: T, expr: syn::Expr) -> Self {
        let pat = pat.into_token_stream();
        self.arms.push(parse_quote!(#pat => #expr));
        self
    }

    pub fn arms<T: ToTokens>(mut self, arms: Vec<T>) -> Self {
        let arms = arms
            .into_iter()
            .map(|arm| arm.into_token_stream())
            .map(|arm| parse_quote!(#arm))
            .collect::<Vec<_>>();
        self.arms.extend(arms);
        self
    }

    pub fn build(self) -> syn::Expr {
        let expr = self.expr;
        let arms = self.arms;
        parse_quote!(match #expr { #(#arms),* })
    }
}

pub struct StructBuilder {
    struct_ty: syn::Type,
    fields: Vec<syn::FieldValue>
}

impl StructBuilder {
    pub fn new(struct_ty: syn::Type) -> Self {
        Self {
            struct_ty,
            fields: Vec::new()
        }
    }

    pub fn field<T: ToTokens>(mut self, ident: syn::Ident, value: T) -> Self {
        let value = value.into_token_stream();
        self.fields.push(parse_quote!(#ident: #value));
        self
    }

    pub fn fields<T: ToTokens>(mut self, fields: Vec<(syn::Ident, T)>) -> Self {
        let fields = fields.iter()
            .map(|(ident, value)| {
                let value = value.into_token_stream();
                parse_quote!(#ident: #value)
            })
            .collect::<Vec<_>>();
        self.fields.extend(fields);
        self
    }

    pub fn build(self) -> syn::Expr {
        let struct_ty = self.struct_ty;
        let fields = self.fields;
        parse_quote!(#struct_ty { #(#fields),* })
    }
}