infinite-errors-macros 0.2.0

Generic error handling framework with static backtraces. Proc macro package
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

use pretty_assertions::assert_eq;
use quote::quote;
use syn::{parse_quote, ItemFn};

#[test]
fn err_context_empty_fn() {
    let output = err_context(quote! {fn f() {}});

    assert_err_context_output(output, quote! {fn f()}, quote! {});
}

#[test]
fn err_context_empty_async_fn() {
    let output = err_context(quote! {async fn f() {}});

    assert_err_context_output(output, quote! {async fn f()}, quote! {});
}

#[test]
fn err_context_empty_generic_fn() {
    let output = err_context(quote! {fn f<T>() {}});

    assert_err_context_output(output, quote! {fn f<T>()}, quote! {});
}

#[test]
fn err_context_empty_async_generic_fn() {
    let output = err_context(quote! {async fn f<T>() {}});

    assert_err_context_output(output, quote! {async fn f<T>()}, quote! {});
}

#[test]
fn err_context_empty_fn_with_attribute() {
    let output = err_context(quote! {#[attr] fn f() {}});

    assert_err_context_output(output, quote! {#[attr] fn f()}, quote! {});
}

#[test]
fn err_context_fn() {
    let output = err_context(
        quote! {fn try_something(s: &str) -> Result<String> { try_try(s.to_string()) }},
    );

    assert_err_context_output(
        output,
        quote! {fn try_something(s: &str) -> Result<String>},
        quote! {try_try(s.to_string())},
    );
}

fn err_context(item: proc_macro2::TokenStream) -> proc_macro2::TokenStream {
    super::err_context_impl(quote! {ErrorKind::SomeContext}, item)
}

fn assert_err_context_output(
    output: proc_macro2::TokenStream,
    decl: proc_macro2::TokenStream,
    body: proc_macro2::TokenStream,
) {
    let parsed_decl: ItemFn = parse_quote! {#decl {}};
    let (left, right) = if parsed_decl.sig.asyncness.is_some() {
        (quote! {async move}, quote! {.await})
    } else {
        (quote! {move | |}, quote! {()})
    };

    assert_eq!(
        output.to_string(),
        quote! {
                #decl {
                ::infinite_errors::ErrorContext::err_context(
                    (#left {
                        #body
                    })#right,
                    ErrorKind::SomeContext
                )
            }
        }
        .to_string()
    );
}