apollo-configuration-macros 0.1.1

Supporting macros for apollo-configuration (internal, do not use directly)
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 syn::spanned::Spanned as _;

use crate::ir::VariantDefinition;
use crate::ir::VariantFields;
use crate::parse::PartitionedAttrs;
use crate::parse::parse_named_field;
use crate::parse::partition_attrs;

/// The arguments to a `#[config]` variant attribute.
#[derive(Default)]
struct VariantArgs {
    /// Whether this variant is marked as the default.
    is_default: bool,
}

/// Parse a `#[config]` variant attribute.
fn parse_config_attribute(attr: &syn::Attribute) -> syn::Result<VariantArgs> {
    let mut args = VariantArgs::default();

    // Support plain `#[config]` w/o arguments
    if let syn::Meta::Path(_) = &attr.meta {
        return Ok(args);
    }

    attr.parse_nested_meta(|meta| {
        let ident = meta.path.require_ident()?;
        match ident.to_string().as_str() {
            "default" => {
                args.is_default = true;
            }
            _ => return Err(meta.error("unrecognized config attribute for variant")),
        }
        Ok(())
    })?;

    Ok(args)
}

pub(crate) fn parse_variant(input: syn::Variant) -> syn::Result<VariantDefinition> {
    let syn::Variant {
        attrs,
        ident,
        fields,
        discriminant: _,
    } = input;

    let PartitionedAttrs {
        config: config_attrs,
        cfg: cfg_attrs,
        other: attrs,
    } = partition_attrs(attrs);

    let args = match config_attrs.as_slice() {
        [] => Default::default(),
        [attr] => parse_config_attribute(attr)?,
        [_attr, extra, ..] => {
            return Err(syn::Error::new(
                extra.span(),
                "only one #[config] attribute is allowed per variant",
            ));
        }
    };

    // Parse fields based on variant type
    let parsed_fields = match fields {
        syn::Fields::Unit => VariantFields::Unit,
        syn::Fields::Unnamed(fields) => VariantFields::Tuple(fields),
        syn::Fields::Named(fields) => {
            let field_definitions = fields
                .named
                .into_iter()
                .map(parse_named_field)
                .collect::<Result<Vec<_>, _>>()?;
            VariantFields::Struct(field_definitions)
        }
    };

    Ok(VariantDefinition {
        name: ident,
        attrs,
        cfg_attrs,
        fields: parsed_fields,
        is_default: args.is_default,
    })
}