errify-macros 0.3.0

Function error context provider (macros)
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

use proc_macro2::TokenStream;
use quote::{quote, ToTokens};
use syn::{parse_quote, spanned::Spanned, Block, Expr, ExprClosure, ImplItemFn, ReturnType};

use crate::input::{Args, Context, ImmediateContext, Input, LazyContext};

pub struct Output {
    func: ImplItemFn,
}

impl Output {
    pub fn from_ast(args: Args, input: Input) -> syn::Result<Self> {
        let inner_fn: ExprClosure = {
            let constness = &input.func.sig.constness;
            let unsafety = &input.func.sig.unsafety;
            let async_block = if input.func.sig.asyncness.is_some() {
                quote! { async move }
            } else {
                quote! { /* non async */ }
            };
            let block = input.func.block;

            parse_quote! {
                #constness move | | { #async_block { #unsafety { #block } } }
            }
        };

        let call_expr: Expr = {
            let output = match &input.func.sig.output {
                ReturnType::Default => {
                    return Err(syn::Error::new(
                        input.func.sig.output.span(),
                        "Result<...> only supported",
                    ))
                }
                ReturnType::Type(_, ty) => ty,
            };
            if input.func.sig.asyncness.is_some() {
                parse_quote! {
                    {
                        let __errify_fn = #inner_fn;
                        let __errify_fn_res: #output = (__errify_fn)().await;
                        __errify_fn_res
                    }
                }
            } else {
                parse_quote! {
                    {
                        let __errify_fn = #inner_fn;
                        let __errify_fn_res: #output = (__errify_fn)();
                        __errify_fn_res
                    }
                }
            }
        };

        let cx_expr = apply_context(&call_expr, &args.cx);

        let outer_fn: ImplItemFn = {
            let attrs = &input.func.attrs;
            let vis = &input.func.vis;
            let defaultness = &input.func.defaultness;
            let constness = &input.func.sig.constness;
            let asyncness = &input.func.sig.asyncness;
            let unsafety = &input.func.sig.unsafety;
            let inputs = &input.func.sig.inputs;
            let abi = &input.func.sig.abi;
            let ident = &input.func.sig.ident;
            let (generics_impl, _generics_ty, generics_where) =
                input.func.sig.generics.split_for_impl();
            let ret = &input.func.sig.output;
            let block: Block = parse_quote! {
                {
                    #cx_expr
                }
            };

            parse_quote! {
                #(#attrs)*
                #vis #defaultness #constness #asyncness #unsafety #abi fn #ident #generics_impl ( #inputs ) #ret #generics_where #block
            }
        };

        Ok(Self { func: outer_fn })
    }
}

impl ToTokens for Output {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        self.func.to_tokens(tokens)
    }
}

pub fn apply_context(call_expr: &Expr, cx: &Context) -> Expr {
    match cx {
        Context::Immediate(ImmediateContext::Literal { lit, args }) => parse_quote! {
            {
                let __errify_cx = ::errify::format_cx!(#lit, #args);
                let __errify_res = #call_expr;
                match __errify_res {
                    ::errify::__private::Ok(v) => ::errify::__private::Ok(v),
                    ::errify::__private::Err(err) => ::errify::__private::Err(::errify::WrapErr::wrap_err(err, __errify_cx)),
                }
            }
        },
        Context::Immediate(ImmediateContext::Expr { expr }) => parse_quote! {
            {
                let __errify_cx = #expr;
                let __errify_res = #call_expr;
                match __errify_res {
                    ::errify::__private::Ok(v) => ::errify::__private::Ok(v),
                    ::errify::__private::Err(err) => ::errify::__private::Err(::errify::WrapErr::wrap_err(err, __errify_cx)),
                }
            }
        },
        Context::Lazy(LazyContext::Closure { def }) => parse_quote! {
            {
                let __errify_cx = #def;
                let __errify_res = #call_expr;
                match __errify_res {
                    ::errify::__private::Ok(v) => ::errify::__private::Ok(v),
                    ::errify::__private::Err(err) => ::errify::__private::Err(::errify::WrapErr::wrap_err(err, (__errify_cx)())),
                }
            }
        },
        Context::Lazy(LazyContext::Function { path }) => parse_quote! {
            {
                let __errify_res = #call_expr;
                match __errify_res {
                    ::errify::__private::Ok(v) => ::errify::__private::Ok(v),
                    ::errify::__private::Err(err) => ::errify::__private::Err(::errify::WrapErr::wrap_err(err, #path())),
                }
            }
        },
    }
}