this-error-from-box 0.1.1

Generates From impls for boxed thiserror enum variants
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

//! Procedural macro for automatic From implementation for #[from] Box<T>

use proc_macro::TokenStream;
use quote::quote;
use syn::{Data, DeriveInput, Fields, parse_macro_input};

#[proc_macro_attribute]
pub fn this_error_from_box(_attr: TokenStream, item: TokenStream) -> TokenStream {
    let input = parse_macro_input!(item as DeriveInput);
    let enum_name = &input.ident;
    let mut from_impls = Vec::new();

    if let Data::Enum(data_enum) = &input.data {
        for variant in &data_enum.variants {
            if let Fields::Unnamed(fields) = &variant.fields {
                if fields.unnamed.len() == 1 {
                    let field = &fields.unnamed[0];
                    let mut has_from = false;
                    for attr in &field.attrs {
                        if attr.path().is_ident("from") {
                            has_from = true;
                            break;
                        }
                    }
                    if has_from {
                        // Check if type is Box<T>
                        if let syn::Type::Path(type_path) = &field.ty {
                            let segments = &type_path.path.segments;
                            // Check if the path is really std::boxed::Box or alloc::boxed::Box
                            let is_std_box = {
                                let segs: Vec<_> = type_path.path.segments.iter().map(|s| s.ident.to_string()).collect();
                                (segs == ["std", "boxed", "Box"])
                                    || (segs == ["alloc", "boxed", "Box"])
                                    || (segs == ["Box"]) // fallback for just Box
                            };
                            if is_std_box {
                                if let syn::PathArguments::AngleBracketed(args) = &segments.last().unwrap().arguments {
                                    if args.args.len() == 1 {
                                        if let syn::GenericArgument::Type(inner_ty) = &args.args[0] {
                                            let variant_ident = &variant.ident;
                                            from_impls.push(quote! {
                                                impl ::std::convert::From<#inner_ty> for #enum_name {
                                                    fn from(e: #inner_ty) -> Self {
                                                        #enum_name::#variant_ident(::std::boxed::Box::new(e))
                                                    }
                                                }
                                            });
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    let expanded = quote! {
        #input
        #(#from_impls)*
    };
    TokenStream::from(expanded)
}