enum-helper-derive 0.2.0

Procedural macro implementation for enum-helper
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

use proc_macro2::Span;
use quote::format_ident;

use crate::{
    ctxt::Ctxt,
    enum_kind::{
        Ir, VariantIr,
        attr::{EnumAttr, VariantAttr},
    },
};

pub fn parse_ir(input: &syn::DeriveInput) -> syn::Result<Ir<'_>> {
    let syn::Data::Enum(data_enum) = &input.data else {
        return Err(syn::Error::new(
            Span::call_site(),
            "EnumKind only supports enum",
        ));
    };

    let cx = Ctxt::new();

    let enum_attr = EnumAttr::from_attrs(&cx, &input.attrs);

    let mut variants = Vec::new();

    for variant in &data_enum.variants {
        let v_ir = parse_variant_ir(&cx, variant);
        variants.push(v_ir);
    }

    if variants.is_empty() {
        let e = syn::Error::new(Span::call_site(), "EnumKind requires at least one variant");
        cx.syn_error(e);
    }

    let ident = &input.ident;

    let kind_ident = match enum_attr.name.get() {
        Some(n) => n.clone(),
        None => format_ident!("{}Kind", ident),
    };

    cx.check()?;

    Ok(Ir {
        ident: &input.ident,
        vis: &input.vis,
        generics: &input.generics,
        variants,
        kind_ident,
        attrs: enum_attr.attr,
        default_derive: !enum_attr.no_default_derive.get(),
    })
}

fn parse_variant_ir<'a>(cx: &Ctxt, variant: &'a syn::Variant) -> VariantIr<'a> {
    let ident = &variant.ident;

    let attr = VariantAttr::from_attrs(cx, &variant.attrs);

    let kind_name = match attr.rename.get() {
        Some(n) => n.clone(),
        None => ident.clone(),
    };

    VariantIr {
        ident,
        fields: &variant.fields,
        kind_name,
        attrs: attr.attr,
    }
}