enum-conversion-derive 0.0.1

Prodedural macros for deriving From and TryFrom traits on enums.
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

mod impls;
mod parse_attributes;
mod parse_enum;
mod templates;

extern crate proc_macro;

use std::collections::HashMap;

use proc_macro::TokenStream;
use quote::ToTokens;
use syn::DeriveInput;
use tera::{Context, Tera};

use crate::parse_attributes::{parse_custom_error_config, ErrorConfig};

const ENUM_CONV_LIFETIME: &str = "'enum_conv";

use crate::parse_enum::{
    create_marker_enums, fetch_fields_from_enum, fetch_impl_generics,
    fetch_name_with_generic_params, get_marker,
};

#[proc_macro_attribute]
#[allow(non_snake_case)]
pub fn EnumConversions(args: TokenStream, input: TokenStream) -> TokenStream {
    let error_config = parse_custom_error_config(args.into());
    let enum_ast = syn::parse(input).unwrap();

    impl_conversions(error_config, enum_ast)
}

#[proc_macro_attribute]
#[allow(non_snake_case)]
pub fn DeriveTryFrom(_: TokenStream, input: TokenStream) -> TokenStream {
    input
}

/// Implements ContainsVariant, GetVariant, SetVariant, and CreateVariantFrom traits
fn impl_conversions(error_config: ErrorConfig, mut ast: DeriveInput) -> TokenStream {
    let tera = templates::templater();
    let name = &ast.ident.to_string();
    let (fullname, lifetimes) = fetch_name_with_generic_params(&ast);
    let impl_generics = fetch_impl_generics(&ast, ENUM_CONV_LIFETIME, &lifetimes);

    let field_map = fetch_fields_from_enum(&mut ast);
    let mut tokens: TokenStream = ast.to_token_stream().to_string().parse().unwrap();

    tokens.extend::<TokenStream>(create_marker_enums(name, &field_map).parse().unwrap());
    tokens.extend::<TokenStream>(
        impls::impl_get_variant(name, &fullname, &impl_generics, &field_map, &tera)
            .parse()
            .unwrap(),
    );
    tokens.extend::<TokenStream>(
        impls::impl_try_from(
            name,
            &fullname,
            &impl_generics,
            &error_config,
            &field_map,
            &tera,
        )
        .parse()
        .unwrap(),
    );
    tokens.extend::<TokenStream>(
        impls::impl_try_to(
            name,
            &fullname,
            &impl_generics,
            &error_config,
            &field_map,
            &tera,
        )
        .parse()
        .unwrap(),
    );
    tokens.extend::<TokenStream>(
        impls::impl_from(&fullname, &impl_generics, &field_map, &tera)
            .parse()
            .unwrap(),
    );
    tokens
}