enum_traits_macros 4.0.0

Procedural macros adding functionality to enums. Derives traits from the crate `enum_traits`
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

use proc_macro2::TokenStream;
use syn::{Fields,FieldsNamed,FieldsUnnamed,Ident,Index,Member,Variant};

fn fields_to_ty_pat_expr(item_ident: &Ident,variant: &Variant) -> (TokenStream,TokenStream,TokenStream){(
	//Type
	match variant.fields{
		Fields::Unit => quote! { () },
		Fields::Unnamed(FieldsUnnamed{unnamed: ref fields,..}) |
		Fields::Named(FieldsNamed{named: ref fields,..}) => {
			match fields.len(){
				1 => {
					let ty = &fields.first().unwrap().ty;
					quote! { #ty }
				},
				_ => {
					let tys = fields.iter().map(|field| &field.ty);
					quote! { (#(#tys),*) }
				},
			}
		}
	},

	//Pattern
	match variant.fields{
		Fields::Unit => quote! { () },
		Fields::Unnamed(FieldsUnnamed{unnamed: ref fields,..}) |
		Fields::Named(FieldsNamed{named: ref fields,..}) => {
			match fields.len(){
				1 => quote! { x0 },
				_ => {
					let vars = fields.iter()
						.enumerate()
						.map(|(i,_field)| format_ident!("x{}",i));
					quote! { ( #(#vars),* ) }
				},
			}
		}
	},

	//Expression
	{
		let variant_ident = &variant.ident;
		match variant.fields{
			Fields::Unit => quote! { #item_ident::#variant_ident },
			Fields::Unnamed(FieldsUnnamed{unnamed: ref fields,..}) => {
				let args = fields.iter()
					.enumerate()
					.map(|(i,_field)| format_ident!("x{}",i));
				quote! { #item_ident::#variant_ident( #(#args),* ) }
			},
			Fields::Named(FieldsNamed{named: ref fields,..}) => {
				let args = fields.iter()
					.enumerate()
					.map(|(i,_field)| format_ident!("x{}",i));
				let field_names = fields.iter()
					.enumerate()
					.map(|(i,field)| match field.ident{
						Some(ref ident) => Member::Named(ident.clone()),
						None => Member::Unnamed(Index::from(i)),
					});
				quote! { #item_ident::#variant_ident{ #(#field_names : #args),* } }
			},
		}
	},
)}

pub fn gen_impl(item: syn::ItemEnum) -> TokenStream{
	let (impl_generics,ty_generics,where_clause) = item.generics.split_for_impl();
	let ident = item.ident;

	let impls = item.variants.iter().filter_map(|variant|{
		let (ty,pattern,expr) = fields_to_ty_pat_expr(&ident,&variant);
		::core::option::Option::Some(quote!{
			#[automatically_derived]
			impl #impl_generics ::core::convert::From<#ty> for #ident #ty_generics #where_clause{
				#[inline(always)]
				fn from(#pattern: #ty) -> Self{
					#expr
				}
			}
		})
	});

	quote!{#( #impls )*}
}