err_handler/
lib.rs

1//! # `err-handler` is a non-intrusive error handling marco that enhances your error handling
2//! If you need to handle errors externally or consolidate them in a single location, `err-handler` is your logical choice
3//! ```toml
4//! [dependencies]
5//! err-handler = "1.0.0"
6//! ```
7//! # Examples
8//! ```rust
9//! use thiserror::Error;
10//! use err_handler::err_handler;
11//! #[derive(Debug, Error)]
12//! enum Err {
13//!     #[error("err1")]
14//!     Err1,
15//!     #[error("err2")]
16//!     Err2,
17//! }
18//! // The ` err-handler` marco attribute can be any function name but must have a matching return type.
19//! #[err_handler(task_handler)]
20//! fn task(_v: i32) -> Result<i32, Err> {
21//!     Err(Err::Err1)
22//! }
23//! fn task_handler(e: Err) -> Result<i32, Err> {
24//!     match e {
25//!         Err::Err1 => Ok(100),
26//!         _ => Err(e)
27//!     }
28//! }
29//! // If a target function is asynchronous, then its error handling function must also be asynchronous.
30//! #[err_handler(crate::async_task_handler)]
31//! async fn async_task(_v: i32) -> Result<i32, Err> {
32//!     Err(Err::Err1)
33//! }
34//! async fn async_task_handler(e: Err) -> Result<i32, Err> {
35//!     match e {
36//!         Err::Err1 => Ok(100),
37//!         _ => Err(e)
38//!     }
39//! }
40//! #[tokio::main]
41//! async fn main() -> Result<(), Err> {
42//!     assert_eq!(task(0)?, 100);
43//!     assert_eq!(async_task(0).await?, 100);
44//!     Ok(())
45//! }
46//!
47//! ```
48//!
49
50use proc_macro2::Punct;
51use quote::{format_ident, quote, TokenStreamExt};
52use std::ops::Deref;
53use syn::punctuated::Punctuated;
54use syn::{parse_macro_input, FnArg, ItemFn, Pat, Token};
55
56type TokenStream1 = proc_macro::TokenStream;
57type TokenStream2 = proc_macro2::TokenStream;
58
59#[proc_macro_attribute]
60pub fn err_handler(attr: TokenStream1, item: TokenStream1) -> TokenStream1 {
61    ast_gen(attr, item)
62}
63
64fn ast_gen(attr: TokenStream1, input: TokenStream1) -> TokenStream1 {
65    let mut input = parse_macro_input!(input as ItemFn);
66
67    let vis = input.vis.clone();
68    let sig = input.sig.clone();
69
70    input.sig.ident = format_ident!("_{}", input.sig.ident);
71
72    input.sig.inputs = input
73        .sig
74        .inputs
75        .into_iter()
76        .filter(|v| {
77            if let FnArg::Receiver(_) = v {
78                return false;
79            }
80            true
81        })
82        .collect::<Punctuated<FnArg, Token![,]>>();
83
84    let punct = Punct::new(',', proc_macro2::Spacing::Alone);
85
86    let mut parameter = TokenStream2::default();
87    for arg in &input.sig.inputs {
88        if let FnArg::Typed(v) = arg {
89            if let Pat::Ident(ident) = v.pat.deref() {
90                if !parameter.is_empty() {
91                    parameter.append(proc_macro2::TokenTree::from(punct.clone()));
92                }
93                parameter.append(ident.ident.clone());
94            }
95        }
96    }
97
98    let new_ident = &input.sig.ident;
99    let handle = TokenStream2::from(attr);
100
101    let match_call = if sig.asyncness.is_some() {
102        quote! {
103            match #new_ident(#parameter).await {
104               Ok(v) => Ok(v),
105               Err(e) => #handle(e).await
106           }
107        }
108    } else {
109        quote! {
110            match #new_ident(#parameter) {
111               Ok(v) => Ok(v),
112               Err(e) => #handle(e)
113           }
114        }
115    };
116
117    let ast = quote! {
118        #vis #sig {
119            #input
120            #match_call
121        }
122    };
123    ast.into()
124}
err_handler/lib.rs

err_handler/
lib.rs
