mux_attrs 0.1.0

Attribute multiplexing
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

use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::{Data, DeriveInput, Error, Fields, Ident, Path, Result, parse2, spanned::Spanned};

use crate::attrs::FromAttr;

pub fn derive(input: TokenStream) -> Result<TokenStream> {
    let input: DeriveInput = parse2(input)?;

    let attrs = input
        .attrs
        .iter()
        .filter_map(FromAttr::new)
        .collect::<Result<Vec<_>>>()?;
    let [attr] = attrs.try_into().map_err(|_| {
        Error::new(
            Span::call_site(),
            "There must be exactly one `from` attribute",
        )
    })?;

    let dst = input.ident.clone();

    let mut accum = quote! {};
    for src in attr.types {
        if src.get_ident().map(Ident::to_string) != Some(dst.to_string()) {
            let impl_ = derive_single(input.clone(), src)?;
            accum = quote! {
                #accum
                #impl_
            }
        }
    }
    Ok(accum)
}

fn derive_single(input: DeriveInput, src: Path) -> Result<TokenStream> {
    let dst = input.ident;

    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();

    let struct_init = match input.data {
        Data::Struct(data) => {
            let fields = list_fields(data.fields);
            let ty_generics = ty_generics.as_turbofish();
            quote! {
                let #src #ty_generics #fields = value;
                Self #fields
            }
        }
        Data::Enum(data) => {
            let mut accum = quote! {};
            for variant in data.variants {
                let ident = variant.ident;
                let fields = list_fields(variant.fields);
                accum = quote! {
                    #accum
                    #src::#ident #fields => Self::#ident #fields,
                };
            }
            quote! {
                match value {
                    #accum
                }
            }
        }
        Data::Union(_) => {
            return Err(Error::new(Span::call_site(), "Unions are not supported"));
        }
    };

    Ok(quote! {
        impl #impl_generics From<#src #ty_generics> for #dst #ty_generics #where_clause {
            fn from(value: #src #ty_generics) -> Self {
                #struct_init
            }
        }
    })
}

fn list_fields(fields: Fields) -> TokenStream {
    match fields {
        Fields::Named(fields) => {
            let mut accum = quote! {};
            for field in fields.named {
                let ident = field.ident;
                accum = quote! { #accum #ident, };
            }
            quote! { { #accum } }
        }
        Fields::Unnamed(fields) => {
            let mut accum = quote! {};
            for (i, field) in fields.unnamed.into_iter().enumerate() {
                let ident = Ident::new(&format!("t{i}"), field.span());
                accum = quote! { #accum #ident, };
            }
            quote! { ( #accum ) }
        }
        Fields::Unit => {
            quote! {}
        }
    }
}