annotated-derive 0.2.0

The derive macros of annotated; use them through the annotated crate
Documentation
use syn::{DataEnum, DeriveInput, Error, Fields, Ident, Variant};

use crate::serde_names::{SerdeEnum, SerdeVariant, Tag};
use crate::validated_struct::{Place, StructCheck, ValidatedField};
use crate::written_rule::{StructRule, written_enum_rules};

pub struct ValidatedEnum<'a> {
    pub input: &'a DeriveInput,
    pub variants: Vec<ValidatedVariant<'a>>,
    pub is_reporting_all: bool,
    pub enum_checks: Vec<StructCheck>,
}

pub struct ValidatedVariant<'a> {
    pub ident: &'a Ident,
    pub fields: Vec<ValidatedField<'a>>,
    pub content_place: Place,
}

impl<'a> ValidatedEnum<'a> {
    pub fn from_input(input: &'a DeriveInput, data: &'a DataEnum) -> syn::Result<Self> {
        let serde_enum = SerdeEnum::from_input(input)?;
        let variants = data
            .variants
            .iter()
            .zip(serde_enum.variants)
            .map(|(variant, serde_variant)| ValidatedVariant::from_variant(variant, serde_variant, &serde_enum.tag))
            .collect::<syn::Result<_>>()?;
        let enum_rules = written_enum_rules(&input.attrs)?;
        let is_reporting_all = enum_rules.iter().any(|rule| matches!(rule, StructRule::ReportAll));
        let enum_checks = enum_rules
            .into_iter()
            .filter_map(|rule| match rule {
                StructRule::Custom(custom) => Some(StructCheck {
                    check: custom.check,
                    field: None,
                    message: custom.message,
                    span: custom.span,
                }),
                StructRule::ReportAll => None,
            })
            .collect();
        Ok(Self {
            input,
            variants,
            is_reporting_all,
            enum_checks,
        })
    }
}

impl<'a> ValidatedVariant<'a> {
    fn from_variant(variant: &'a Variant, serde_variant: SerdeVariant, tag: &Tag) -> syn::Result<Self> {
        refuse_rules_on_the_variant(variant)?;
        let content_place = match tag {
            _ if serde_variant.is_untagged => Place::OfItsParent,
            Tag::External => Place::Named(serde_variant.name),
            Tag::Adjacent { content, .. } => Place::Named(content.clone()),
            Tag::Internal { .. } | Tag::Untagged => Place::OfItsParent,
        };
        let is_newtype = matches!(&variant.fields, Fields::Unnamed(fields) if fields.unnamed.len() == 1);
        let fields = variant
            .fields
            .iter()
            .zip(serde_variant.fields)
            .enumerate()
            .map(|(index, (field, serde_field))| {
                let place = match &field.ident {
                    Some(_) => Place::of_a_named_field(&serde_field),
                    None if is_newtype => Place::OfItsParent,
                    None => Place::Indexed(index),
                };
                ValidatedField::from_field(field, index, serde_field, place)
            })
            .collect::<syn::Result<_>>()?;
        Ok(Self {
            ident: &variant.ident,
            fields,
            content_place,
        })
    }
}

fn refuse_rules_on_the_variant(variant: &Variant) -> syn::Result<()> {
    let Some(rules) = variant
        .attrs
        .iter()
        .find(|attribute| attribute.path().is_ident("validate"))
    else {
        return Ok(());
    };
    Err(Error::new_spanned(
        rules.path(),
        "`#[validate(...)]` goes on a variant's fields, or on the enum for `custom` and `report_all`",
    ))
}