error-path-macros 0.1.0

Attribute macros for automatically attaching error paths to Result-returning Rust functions and impl blocks.
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
148
149
150

use proc_macro::TokenStream;
use quote::{quote, ToTokens};
use syn::{parse_macro_input, ImplItem, ItemFn, ItemImpl, LitStr, ReturnType, Type};

/// Attach an error path to a single Result-returning function.
///
/// - `#[error_path]` uses the function name.
/// - `#[error_path("custom.path")]` uses the provided path.
#[proc_macro_attribute]
pub fn error_path(attr: TokenStream, item: TokenStream) -> TokenStream {
    let input = parse_macro_input!(item as ItemFn);

    let path = if attr.is_empty() {
        input.sig.ident.to_string()
    } else {
        parse_macro_input!(attr as LitStr).value()
    };

    expand_fn(input, path).into()
}

/// Attach error paths to every Result-returning method in an impl block.
///
/// - `#[error_path_impl]` uses the trait name for trait impls, otherwise the type name.
/// - `#[error_path_impl("custom.prefix")]` uses the provided prefix.
/// - `#[error_path_skip]` can be placed on methods that should not be wrapped.
#[proc_macro_attribute]
pub fn error_path_impl(attr: TokenStream, item: TokenStream) -> TokenStream {
    let mut input = parse_macro_input!(item as ItemImpl);

    let base_path = if attr.is_empty() {
        infer_impl_name(&input)
    } else {
        parse_macro_input!(attr as LitStr).value()
    };

    for item in &mut input.items {
        if let ImplItem::Fn(method) = item {
            if take_skip_attr(&mut method.attrs) {
                continue;
            }

            if !returns_result(&method.sig.output) {
                continue;
            }

            let base_path_lit = LitStr::new(&base_path, method.sig.ident.span());
            let method_path_lit =
                LitStr::new(&method.sig.ident.to_string(), method.sig.ident.span());
            let block = &method.block;

            if method.sig.asyncness.is_some() {
                method.block = syn::parse_quote!({
                    let __error_path_result = (async #block).await;
                    __error_path_result.map_err(|e| {
                        let e = ::error_path::WithErrorPath::with_error_path(e, #method_path_lit);
                        ::error_path::WithErrorPath::with_error_path(e, #base_path_lit)
                    })
                });
            } else {
                method.block = syn::parse_quote!({
                    let __error_path_result = (|| #block)();
                    __error_path_result.map_err(|e| {
                        let e = ::error_path::WithErrorPath::with_error_path(e, #method_path_lit);
                        ::error_path::WithErrorPath::with_error_path(e, #base_path_lit)
                    })
                });
            }
        }
    }

    quote!(#input).into()
}

/// Marker attribute for methods inside `#[error_path_impl]` blocks.
///
/// This attribute is consumed by `#[error_path_impl]`.
#[proc_macro_attribute]
pub fn error_path_skip(_attr: TokenStream, item: TokenStream) -> TokenStream {
    item
}

fn expand_fn(input: ItemFn, path: String) -> proc_macro2::TokenStream {
    let attrs = input.attrs;
    let vis = input.vis;
    let sig = input.sig;
    let block = input.block;
    let path_lit = LitStr::new(&path, sig.ident.span());

    if sig.asyncness.is_some() {
        quote! {
            #(#attrs)*
            #vis #sig {
                let __error_path_result = (async #block).await;
                __error_path_result.map_err(|e| {
                    ::error_path::WithErrorPath::with_error_path(e, #path_lit)
                })
            }
        }
    } else {
        quote! {
            #(#attrs)*
            #vis #sig {
                let __error_path_result = (|| #block)();
                __error_path_result.map_err(|e| {
                    ::error_path::WithErrorPath::with_error_path(e, #path_lit)
                })
            }
        }
    }
}

fn returns_result(output: &ReturnType) -> bool {
    let ReturnType::Type(_, output_type) = output else {
        return false;
    };
    let Type::Path(type_path) = output_type.as_ref() else {
        return false;
    };

    type_path
        .path
        .segments
        .last()
        .is_some_and(|segment| segment.ident.to_string().ends_with("Result"))
}

fn infer_impl_name(input: &ItemImpl) -> String {
    if let Some((_, trait_path, _)) = &input.trait_ {
        return trait_path
            .segments
            .last()
            .map(|seg| seg.ident.to_string())
            .unwrap_or_else(|| "impl".to_string());
    }

    input.self_ty.to_token_stream().to_string().replace(' ', "")
}

fn take_skip_attr(attrs: &mut Vec<syn::Attribute>) -> bool {
    let before = attrs.len();
    attrs.retain(|attr| {
        attr.path()
            .segments
            .last()
            .map(|seg| seg.ident != "error_path_skip")
            .unwrap_or(true)
    });
    attrs.len() != before
}