wowlab_engine_macros_impl/

lower_parse.rs

use syn::{
    DeriveInput, Field, Ident, LitStr, Path, Token, Type,
    parse::{Parse, ParseStream},
    punctuated::Punctuated,
};

pub(crate) enum LowerFieldMode {
    Copy,
    NameIdx(Path),
    Convert(Path),
    Skip,
}

pub(crate) struct LowerNamedFn {
    pub(crate) field: Ident,
    pub(crate) func: Path,
}

impl Parse for LowerNamedFn {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let field: Ident = input.parse()?;

        input.parse::<Token![=]>()?;
        let func: Path = input.parse()?;

        Ok(Self { field, func })
    }
}

pub(crate) struct LowerInfoField {
    pub(crate) field: Ident,
    pub(crate) func: Option<Path>,
}

impl Parse for LowerInfoField {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let field: Ident = input.parse()?;
        let func = if input.peek(Token![=]) {
            input.parse::<Token![=]>()?;

            Some(input.parse()?)
        } else {
            None
        };

        Ok(Self { field, func })
    }
}

pub(crate) struct LowerContainer {
    pub(crate) data: Path,
    pub(crate) ctx: Path,
    pub(crate) extra: Vec<LowerNamedFn>,
    pub(crate) info: Option<LowerInfoSpec>,
    pub(crate) finalize: Option<LowerFinalizeSpec>,
}

pub(crate) struct LowerInfoSpec {
    pub(crate) ty: Path,
    pub(crate) ctx: Path,
    pub(crate) fields: Vec<LowerInfoField>,
}

pub(crate) struct LowerFinalizeSpec {
    pub(crate) source: Path,
    pub(crate) method: Ident,
    pub(crate) args: Vec<LowerFinalizeArg>,
    pub(crate) renames: Vec<LowerFieldRename>,
}

pub(crate) struct LowerFinalizeArg {
    pub(crate) field: Ident,
    pub(crate) ty: Type,
}

impl Parse for LowerFinalizeArg {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let field = input.parse()?;

        input.parse::<Token![:]>()?;

        Ok(Self {
            field,
            ty: input.parse()?,
        })
    }
}

pub(crate) struct LowerFieldRename {
    pub(crate) field: Ident,
    pub(crate) source: Ident,
}

impl Parse for LowerFieldRename {
    fn parse(input: ParseStream) -> syn::Result<Self> {
        let field = input.parse()?;

        input.parse::<Token![=]>()?;

        Ok(Self {
            field,
            source: input.parse()?,
        })
    }
}

#[derive(Default)]
struct LowerContainerDraft {
    data: Option<Path>,
    ctx: Option<Path>,
    extra: Option<Vec<LowerNamedFn>>,
    info_ty: Option<Path>,
    info_ctx: Option<Path>,
    info_fields: Option<Vec<LowerInfoField>>,
    finalize_source: Option<Path>,
    finalize_method: Option<Ident>,
    finalize_args: Option<Vec<LowerFinalizeArg>>,
    finalize_renames: Option<Vec<LowerFieldRename>>,
}

trait ParseNestedMetaListExt {
    fn parse_nested_meta_list<T>(&self) -> syn::Result<Punctuated<T, Token![,]>>
    where
        T: Parse;
}

impl ParseNestedMetaListExt for syn::meta::ParseNestedMeta<'_> {
    fn parse_nested_meta_list<T>(&self) -> syn::Result<Punctuated<T, Token![,]>>
    where
        T: Parse,
    {
        let content;

        syn::parenthesized!(content in self.input);

        content.parse_terminated(T::parse, Token![,])
    }
}

// #t(fn: rust_alloc_in_loop) diagnostics allocate only while rejecting invalid macro input.
fn reject_duplicate_named_fns(entries: &[LowerNamedFn], label: &str) -> syn::Result<()> {
    for (index, entry) in entries.iter().enumerate() {
        if entries
            .iter()
            .take(index)
            .any(|earlier| earlier.field == entry.field)
        {
            return Err(syn::Error::new_spanned(
                &entry.field,
                format!("duplicate `{}` in `{label}`", entry.field),
            ));
        }
    }

    Ok(())
}

// #t(fn: rust_alloc_in_loop) diagnostics allocate only while rejecting invalid macro input.
// #t(rust_similar_fns) Info-field duplicate diagnostics intentionally mirror named-function diagnostics but operate on a distinct parsed entry type and label contract.
fn reject_duplicate_info_fields(entries: &[LowerInfoField]) -> syn::Result<()> {
    for (index, entry) in entries.iter().enumerate() {
        if entries
            .iter()
            .take(index)
            .any(|earlier| earlier.field == entry.field)
        {
            return Err(syn::Error::new_spanned(
                &entry.field,
                format!("duplicate `{}` in `info_fields`", entry.field),
            ));
        }
    }

    Ok(())
}

pub(crate) fn parse_lower_container(input: &DeriveInput) -> syn::Result<LowerContainer> {
    let mut draft = LowerContainerDraft::default();
    let mut saw_lower_attr = false;

    for attr in &input.attrs {
        if !attr.path().is_ident("lower") {
            continue;
        }

        if saw_lower_attr {
            return Err(syn::Error::new_spanned(
                attr,
                "duplicate #[lower(...)] container attribute",
            ));
        }

        saw_lower_attr = true;
        attr.parse_nested_meta(|meta| {
            attr_keys!(
                meta,
                unknown = "unknown `lower` container key, expected `data`, `ctx`, `extra`, \
                    `info`, `info_ctx`, `info_fields`, `finalize`, `finalize_method`, \
                    `finalize_args`, or `finalize_rename`";
                "data" => (draft.data.is_some(), "duplicate `data` lower container key") {
                let lit: LitStr = meta.value()?.parse()?;
                draft.data = Some(lit.parse()?);
                },
                "ctx" => (draft.ctx.is_some(), "duplicate `ctx` lower container key") {
                let lit: LitStr = meta.value()?.parse()?;
                draft.ctx = Some(lit.parse()?);
                },
                "info" => (draft.info_ty.is_some(), "duplicate `info` lower container key") {
                let lit: LitStr = meta.value()?.parse()?;
                draft.info_ty = Some(lit.parse()?);
                },
                "info_ctx" => (
                    draft.info_ctx.is_some(),
                    "duplicate `info_ctx` lower container key"
                ) {
                let lit: LitStr = meta.value()?.parse()?;
                draft.info_ctx = Some(lit.parse()?);
                },
                "extra" => (draft.extra.is_some(), "duplicate `extra` lower container key") {
                let entries = meta
                    .parse_nested_meta_list::<LowerNamedFn>()?
                    .into_iter()
                    .collect::<Vec<_>>();

                reject_duplicate_named_fns(&entries, "extra")?;
                draft.extra = Some(entries);
                },
                "info_fields" => (
                    draft.info_fields.is_some(),
                    "duplicate `info_fields` lower container key"
                ) {
                let entries = meta
                    .parse_nested_meta_list::<LowerInfoField>()?
                    .into_iter()
                    .collect::<Vec<_>>();

                    reject_duplicate_info_fields(&entries)?;
                    draft.info_fields = Some(entries);
                },
                "finalize" => (
                    draft.finalize_source.is_some(),
                    "duplicate `finalize` lower container key"
                ) {
                    let lit: LitStr = meta.value()?.parse()?;
                    draft.finalize_source = Some(lit.parse()?);
                },
                "finalize_method" => (
                    draft.finalize_method.is_some(),
                    "duplicate `finalize_method` lower container key"
                ) {
                    let lit: LitStr = meta.value()?.parse()?;
                    draft.finalize_method = Some(lit.parse()?);
                },
                "finalize_args" => (
                    draft.finalize_args.is_some(),
                    "duplicate `finalize_args` lower container key"
                ) {
                    draft.finalize_args = Some(
                        meta.parse_nested_meta_list::<LowerFinalizeArg>()?
                            .into_iter()
                            .collect()
                    );
                },
                "finalize_rename" => (
                    draft.finalize_renames.is_some(),
                    "duplicate `finalize_rename` lower container key"
                ) {
                    draft.finalize_renames = Some(
                        meta.parse_nested_meta_list::<LowerFieldRename>()?
                            .into_iter()
                            .collect()
                    );
                }
            )
        })?;
    }

    finish_lower_container(input, saw_lower_attr, draft)
}

fn finish_lower_container(
    input: &DeriveInput,
    saw_lower_attr: bool,
    mut draft: LowerContainerDraft,
) -> syn::Result<LowerContainer> {
    if !saw_lower_attr {
        return Err(syn::Error::new_spanned(
            &input.ident,
            "#[derive(LowerData)] requires a #[lower(data = \"...\", ctx = \"...\")] attribute",
        ));
    }

    let data = draft.data.take().ok_or_else(|| {
        syn::Error::new_spanned(
            &input.ident,
            "#[lower(...)] missing required `data = \"...\"`",
        )
    })?;
    let ctx = draft.ctx.take().ok_or_else(|| {
        syn::Error::new_spanned(
            &input.ident,
            "#[lower(...)] missing required `ctx = \"...\"`",
        )
    })?;
    let info = finish_info(input, &mut draft)?;
    let finalize = finish_finalize(input, &mut draft)?;

    Ok(LowerContainer {
        data,
        ctx,
        extra: draft.extra.unwrap_or_default(),
        info,
        finalize,
    })
}

fn finish_info(
    input: &DeriveInput,
    draft: &mut LowerContainerDraft,
) -> syn::Result<Option<LowerInfoSpec>> {
    let info = match (draft.info_ty.take(), draft.info_ctx.take()) {
        (Some(ty), Some(ctx)) => Some(LowerInfoSpec {
            ty,
            ctx,
            fields: draft.info_fields.take().unwrap_or_default(),
        }),
        (Some(_), None) => {
            return Err(syn::Error::new_spanned(
                &input.ident,
                "#[lower(info = \"...\")] requires `info_ctx = \"...\"`",
            ));
        }
        (None, Some(_)) => {
            return Err(syn::Error::new_spanned(
                &input.ident,
                "#[lower(info_ctx = \"...\")] requires `info = \"...\"`",
            ));
        }
        (None, None) => {
            if draft.info_fields.is_some() {
                return Err(syn::Error::new_spanned(
                    &input.ident,
                    "#[lower(info_fields(...))] requires `info = \"...\"` and `info_ctx = \"...\"`",
                ));
            }

            None
        }
    };

    Ok(info)
}

fn finish_finalize(
    input: &DeriveInput,
    draft: &mut LowerContainerDraft,
) -> syn::Result<Option<LowerFinalizeSpec>> {
    if let Some(source) = draft.finalize_source.take() {
        return Ok(Some(LowerFinalizeSpec {
            source,
            method: draft
                .finalize_method
                .take()
                .unwrap_or_else(|| Ident::new("from_draft", input.ident.span())),
            args: draft.finalize_args.take().unwrap_or_default(),
            renames: draft.finalize_renames.take().unwrap_or_default(),
        }));
    }

    if draft.finalize_method.is_some()
        || draft.finalize_args.is_some()
        || draft.finalize_renames.is_some()
    {
        return Err(syn::Error::new_spanned(
            &input.ident,
            "finalize configuration requires `finalize = \"SourceType\"`",
        ));
    }

    Ok(None)
}

pub(crate) fn parse_lower_field_mode(field: &Field) -> syn::Result<LowerFieldMode> {
    let mut mode: Option<LowerFieldMode> = None;
    let mut saw_lower = false;

    for attr in &field.attrs {
        if !attr.path().is_ident("lower") {
            continue;
        }

        saw_lower = true;
        attr.parse_nested_meta(|meta| {
            attr_keys!(
                meta,
                unknown = "unknown `lower` field mode, expected `copy`, `name_idx = fn`, \
                    `convert = fn`, or `skip`";
                "copy" => (
                    mode.is_some(),
                    "duplicate `#[lower(...)]` mode on field"
                ) {
                    mode = Some(LowerFieldMode::Copy);
                },
                "skip" => (
                    mode.is_some(),
                    "duplicate `#[lower(...)]` mode on field"
                ) {
                    mode = Some(LowerFieldMode::Skip);
                },
                "name_idx" => (
                    mode.is_some(),
                    "duplicate `#[lower(...)]` mode on field"
                ) {
                    mode = Some(LowerFieldMode::NameIdx(meta.value()?.parse()?));
                },
                "convert" => (
                    mode.is_some(),
                    "duplicate `#[lower(...)]` mode on field"
                ) {
                    mode = Some(LowerFieldMode::Convert(meta.value()?.parse()?));
                }
            )
        })?;
    }

    if !saw_lower {
        return Err(syn::Error::new_spanned(
            field,
            "every field must carry a `#[lower(copy | name_idx = fn | convert = fn | skip)]` \
             attribute (a new field without one is a deliberate compile error)",
        ));
    }

    mode.ok_or_else(|| {
        syn::Error::new_spanned(field, "empty `#[lower()]` attribute: specify a field mode")
    })
}

#[cfg(test)]
mod tests {
    use googletest::prelude::*;

    use super::*;

    #[gtest]
    fn lower_container_rejects_info_fields_without_info_contract() -> Result<()> {
        let input: DeriveInput = syn::parse_quote! {
            #[lower(
                data = "RecordData",
                ctx = "LowerContext",
                info_fields(value)
            )]
            struct RecordDef {
                #[lower(copy)]
                value: i32,
            }
        };

        let error = parse_lower_container(&input).err().or_fail()?;

        verify_that!(
            error.to_string(),
            eq("#[lower(info_fields(...))] requires `info = \"...\"` and `info_ctx = \"...\"`")
        )
    }

    #[gtest]
    fn lower_container_rejects_duplicate_extra_targets() -> Result<()> {
        let input: DeriveInput = syn::parse_quote! {
            #[lower(
                data = "RecordData",
                ctx = "LowerContext",
                extra(value = first, value = second)
            )]
            struct RecordDef {
                #[lower(skip)]
                source: i32,
            }
        };

        let error = parse_lower_container(&input).err().or_fail()?;

        verify_that!(error.to_string(), eq("duplicate `value` in `extra`"))
    }
}