darling 0.24.0

A proc-macro library for reading attributes into structs when implementing custom derives.
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 darling::ast;
use darling::FromDeriveInput;
use darling::FromField;
use darling_macro::FromTypeParam;
use darling_macro::FromVariant;
use proc_macro2::Span;
use syn::parse_quote;
use syn::Ident;

#[derive(FromVariant)]
struct Variant {
    #[darling(with = |ident| Ok(format!("!{ident}")))]
    ident: String,
}

#[derive(FromField)]
struct Field {
    #[darling(with = darling::util::require_ident)]
    ident: syn::Ident,
}

#[derive(FromTypeParam)]
struct TypeParam {
    #[darling(with = |ident| Ok(format!("!{ident}")))]
    ident: String,
}

#[derive(FromDeriveInput)]
struct Input {
    #[darling(with = |ident| Ok(format!("!{ident}")))]
    ident: String,
    data: darling::ast::Data<Variant, Field>,
    generics: darling::ast::Generics<ast::GenericParam<TypeParam>>,
}

#[test]
fn field_with() {
    let di = Input::from_derive_input(&parse_quote! {
        struct Demo<T> {
            hello: T
        }
    })
    .unwrap();

    let fields = di.data.take_struct().unwrap();
    let first_field = fields.into_iter().next().unwrap();

    assert_eq!(
        first_field.ident,
        Ident::new("hello", Span::call_site()),
        "FromField"
    );

    assert_eq!(
        di.generics.type_params().next().unwrap().ident,
        "!T",
        "FromTypeParam"
    );

    assert_eq!(di.ident, "!Demo", "FromDeriveInput");

    let di = Input::from_derive_input(&parse_quote! {
        enum Demo {
            Hello
        }
    })
    .unwrap();

    let variants = di.data.take_enum().unwrap();

    assert_eq!(variants.first().unwrap().ident, "!Hello", "FromVariant");
}