clvm-derive 0.36.1

Derive macros for implementing CLVM 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

use syn::{DataEnum, Ident};

use super::{ClvmOptions, Repr, VariantInfo, parse_clvm_options, parse_variant};

pub struct EnumInfo {
    pub variants: Vec<VariantInfo>,
    pub discriminant_type: Option<Ident>,
    pub is_untagged: bool,
    pub default_repr: Repr,
    pub crate_name: Option<Ident>,
}

pub fn parse_enum(mut options: ClvmOptions, data_enum: &DataEnum) -> EnumInfo {
    assert!(
        options.constant.is_none(),
        "`constant` only applies to fields"
    );

    assert!(
        options.default.is_none(),
        "`default` only applies to fields"
    );

    assert!(!options.rest, "`rest` only applies to fields");

    let repr = Repr::expect(options.repr);

    if repr == Repr::Transparent {
        assert!(
            !options.untagged,
            "`transparent` enums are implicitly untagged"
        );

        options.untagged = true;
    }

    let mut variants = Vec::new();

    for variant in &data_enum.variants {
        let variant_options = parse_clvm_options(&variant.attrs);
        let variant_repr = variant_options.repr;

        assert!(
            !(repr == Repr::Atom && variant_repr.is_some()),
            "cannot override `atom` representation for individual enum variants"
        );

        assert!(
            repr != Repr::Atom || variant.fields.is_empty(),
            "cannot have fields in an `atom` enum variant"
        );

        assert!(
            options.untagged || variant_repr.is_none(),
            "cannot specify representation for individual enum variants in a tagged enum"
        );

        let mut variant_info = parse_variant(&variant_options, variant);

        if (repr == Repr::Transparent && variant_repr.is_none())
            || variant_repr == Some(Repr::Transparent)
        {
            assert!(
                variant_info.fields.len() == 1,
                "`transparent` enum variants must have exactly one field"
            );

            variant_info.fields[0].rest = true;
            variant_info.repr = Some(Repr::ProperList);
        }

        variants.push(variant_info);
    }

    EnumInfo {
        variants,
        discriminant_type: options.enum_repr,
        is_untagged: options.untagged,
        default_repr: repr,
        crate_name: options.crate_name,
    }
}