auto_enums_derive 0.6.3

This library provides an attribute macro like a wrapper of `#[derive]`, implementing the supported traits and passing unsupported traits to `#[derive]`.
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

use proc_macro2::TokenStream;

use crate::utils::*;

pub(crate) const NAME: &[&str] = &["Transpose"];

// Implementing this with `Into` requires many type annotations.
pub(crate) fn derive(data: &Data, items: &mut Vec<ItemImpl>) -> Result<()> {
    check_fields(data)?;

    items.push(transpose_option(data)?);
    items.push(transpose_result(data)?);
    items.push(transpose_ok(data)?);
    items.push(transpose_err(data)?);

    Ok(())
}

fn check_fields(data: &Data) -> Result<()> {
    let generics = data.generics();
    let fields = data.fields();
    let comma = if generics.params.empty_or_trailing() { quote!(,) } else { TokenStream::new() };

    if quote!(#generics).to_string() == quote!(<#(#fields),*#comma>).to_string() {
        Ok(())
    } else {
        Err(error!(data.span, "all fields need to be generics"))
    }
}

fn transpose_option(data: &Data) -> Result<ItemImpl> {
    let ident = data.ident();
    let fields = data.fields();

    let mut items = data.impl_with_capacity(1)?;

    let ty_generics = fields.iter().map(|f| quote!(::core::option::Option<#f>));
    *items.self_ty() = parse_quote!(#ident<#(#ty_generics),*>)?;

    let transpose = data.variants().iter().map(|v| quote!(#ident::#v(x) => x.map(#ident::#v)));

    items.push_item(parse_quote! {
        #[inline]
        fn transpose(self) -> ::core::option::Option<#ident<#(#fields),*>> {
            match self { #(#transpose,)* }
        }
    }?);

    Ok(items.build_item())
}

fn transpose_result(data: &Data) -> Result<ItemImpl> {
    let fields = data.fields();

    let mut items = data.impl_with_capacity(1)?;

    let err_fields: &Vec<_> = &(0..fields.len())
        .map(|i| {
            let id = format_ident!("__E{}", i);
            items.push_generic_param(param_ident!("{}", id));
            id
        })
        .collect();

    let ident = data.ident();
    let ty_generics =
        fields.iter().zip(err_fields.iter()).map(|(f, ef)| quote!(::core::result::Result<#f, #ef>));
    *items.self_ty() = parse_quote!(#ident<#(#ty_generics),*>)?;

    let transpose = data
        .variants()
        .iter()
        .map(|v| quote!(#ident::#v(x) => x.map(#ident::#v).map_err(#ident::#v)));

    items.push_item(parse_quote! {
        #[inline]
        fn transpose(self) -> ::core::result::Result<#ident<#(#fields),*>, #ident<#(#err_fields),*>> {
            match self { #(#transpose,)* }
        }
    }?);

    Ok(items.build_item())
}

fn transpose_ok(data: &Data) -> Result<ItemImpl> {
    let ident = data.ident();
    let fields = data.fields();

    let mut items = data.impl_with_capacity(1)?;

    items.push_generic_param(param_ident!("__E"));

    let ty_generics = fields.iter().map(|f| quote!(::core::result::Result<#f, __E>));
    *items.self_ty() = parse_quote!(#ident<#(#ty_generics),*>)?;

    let transpose = data.variants().iter().map(|v| quote!(#ident::#v(x) => x.map(#ident::#v)));
    items.push_item(parse_quote! {
        #[inline]
        fn transpose_ok(self) -> ::core::result::Result<#ident<#(#fields),*>, __E> {
            match self { #(#transpose,)* }
        }
    }?);

    Ok(items.build_item())
}

fn transpose_err(data: &Data) -> Result<ItemImpl> {
    let ident = data.ident();
    let fields = data.fields();

    let mut items = data.impl_with_capacity(1)?;

    items.push_generic_param(param_ident!("__T"));

    let ty_generics = fields.iter().map(|f| quote!(::core::result::Result<__T, #f>));
    *items.self_ty() = parse_quote!(#ident<#(#ty_generics),*>)?;

    let transpose = data.variants().iter().map(|v| quote!(#ident::#v(x) => x.map_err(#ident::#v)));
    items.push_item(parse_quote! {
        #[inline]
        fn transpose_err(self) -> ::core::result::Result<__T, #ident<#(#fields),*>> {
            match self { #(#transpose,)* }
        }
    }?);

    Ok(items.build_item())
}