wowlab_engine_macros_impl/

lower.rs

use quote::quote;
use syn::{Data, DeriveInput, Fields, Ident, Path, PathArguments};

use crate::lower_parse::{LowerFieldMode, parse_lower_container, parse_lower_field_mode};

struct FieldSpec {
    ident: Ident,
    mode: LowerFieldMode,
}

pub(crate) fn expand_lower_data(input: &DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
    let Data::Struct(data_struct) = &input.data else {
        return Err(syn::Error::new_spanned(
            &input.ident,
            "#[derive(LowerData)] can only be applied to structs",
        ));
    };

    let Fields::Named(named) = &data_struct.fields else {
        return Err(syn::Error::new_spanned(
            &input.ident,
            "#[derive(LowerData)] requires a struct with named fields",
        ));
    };

    let def_ident = &input.ident;
    let container = parse_lower_container(input)?;
    let field_specs: Vec<FieldSpec> = named
        .named
        .iter()
        .map(|field| {
            let ident = field
                .ident
                .clone()
                .ok_or_else(|| syn::Error::new_spanned(field, "field must be named"))?;
            let mode = parse_lower_field_mode(field)?;

            Ok(FieldSpec { ident, mode })
        })
        .collect::<syn::Result<_>>()?;

    reject_duplicate_data_initializers(&field_specs, &container.extra)?;

    let data_ty = &container.data;
    let data_expr = expression_path(data_ty);
    let ctx_ty = &container.ctx;
    let (impl_generics, type_generics, where_clause) = input.generics.split_for_impl();
    let data_inits = data_initializers(&field_specs, &container.extra);

    let into_data = quote! {
        impl #impl_generics #def_ident #type_generics #where_clause {
            /// Lower this builder def into its `Copy` engine-side data struct.
            ///
            /// Generated by `#[derive(LowerData)]`.
            pub(crate) fn into_data(&self, ctx: &mut #ctx_ty) -> #data_ty {
                #data_expr {
                    #(#data_inits,)*
                }
            }
        }
    };
    let into_info = container
        .info
        .as_ref()
        .map_or_else(proc_macro2::TokenStream::new, |info| {
            info_impl(input, data_ty, info)
        });
    let finalize = container.finalize.as_ref().map_or_else(
        || Ok(proc_macro2::TokenStream::new()),
        |finalize| finalize_impl(input, &field_specs, finalize),
    )?;

    Ok(quote! {
        #into_data
        #into_info
        #finalize
    })
}

fn data_initializers(
    fields: &[FieldSpec],
    extra: &[crate::lower_parse::LowerNamedFn],
) -> Vec<proc_macro2::TokenStream> {
    let field_initializers = fields.iter().filter_map(|spec| {
        let ident = &spec.ident;

        match &spec.mode {
            LowerFieldMode::Copy => Some(quote!(#ident: self.#ident)),
            LowerFieldMode::Skip => None,
            LowerFieldMode::NameIdx(resolve) => Some(quote!(name_idx: #resolve(&self.#ident, ctx))),
            LowerFieldMode::Convert(func) => Some(quote!(#ident: #func(self, ctx))),
        }
    });
    let extra_initializers = extra.iter().map(|entry| {
        let field = &entry.field;
        let func = &entry.func;

        quote!(#field: #func(self, ctx))
    });

    field_initializers.chain(extra_initializers).collect()
}

fn info_impl(
    input: &DeriveInput,
    data_ty: &Path,
    info: &crate::lower_parse::LowerInfoSpec,
) -> proc_macro2::TokenStream {
    let info_ty = &info.ty;
    let info_expr = expression_path(info_ty);
    let info_ctx = &info.ctx;
    let info_inits = info.fields.iter().map(|named_field| {
        let field = &named_field.field;

        named_field.func.as_ref().map_or_else(
            || quote!(#field: self.#field),
            |func| quote!(#field: #func(self, ctx)),
        )
    });
    let (impl_generics, _, where_clause) = input.generics.split_for_impl();

    quote! {
        impl #impl_generics #data_ty #where_clause {
            /// Lower this engine-side data struct into its introspection-facing info struct.
            ///
            /// Generated by `#[derive(LowerData)]` on the corresponding `*Def`.
            pub(crate) fn into_info(&self, ctx: &#info_ctx) -> #info_ty {
                #info_expr {
                    #(#info_inits,)*
                }
            }
        }
    }
}

fn finalize_impl(
    input: &DeriveInput,
    fields: &[FieldSpec],
    finalize: &crate::lower_parse::LowerFinalizeSpec,
) -> syn::Result<proc_macro2::TokenStream> {
    validate_finalize_fields(fields, finalize)?;

    let source = &finalize.source;
    let method = &finalize.method;
    let args = finalize.args.iter().map(|arg| {
        let field = &arg.field;
        let ty = &arg.ty;

        quote!(#field: #ty)
    });
    let field_inits = fields.iter().map(|spec| {
        let field = &spec.ident;

        if finalize.args.iter().any(|arg| arg.field == *field) {
            quote!(#field)
        } else if let Some(rename) = finalize
            .renames
            .iter()
            .find(|rename| rename.field == *field)
        {
            let source_field = &rename.source;

            quote!(#field: source.#source_field)
        } else {
            quote!(#field: source.#field)
        }
    });
    let def_ident = &input.ident;
    let (impl_generics, type_generics, where_clause) = input.generics.split_for_impl();

    Ok(quote! {
        impl #impl_generics #def_ident #type_generics #where_clause {
            /// Finalize an owned builder draft into this definition.
            ///
            /// Generated by `#[derive(LowerData)]`.
            pub(crate) fn #method(source: #source, #(#args,)*) -> Self {
                Self {
                    #(#field_inits,)*
                }
            }
        }
    })
}

fn expression_path(path: &Path) -> Path {
    let mut path = path.clone();

    if let Some(last) = path.segments.last_mut()
        && let PathArguments::AngleBracketed(arguments) = &mut last.arguments
    {
        arguments.colon2_token = Some(syn::token::PathSep::default());
    }

    path
}

// #t(fn: rust_alloc_in_loop) diagnostics allocate only while rejecting invalid macro input.
fn reject_duplicate_data_initializers(
    fields: &[FieldSpec],
    extra: &[crate::lower_parse::LowerNamedFn],
) -> syn::Result<()> {
    let mut saw_name_idx = false;

    for spec in fields {
        if matches!(&spec.mode, LowerFieldMode::NameIdx(_)) {
            if saw_name_idx {
                return Err(syn::Error::new_spanned(
                    &spec.ident,
                    "multiple `name_idx` modes would generate duplicate `name_idx` initializers",
                ));
            }

            saw_name_idx = true;
        }
    }

    for entry in extra {
        let duplicates_field = fields.iter().any(|spec| match &spec.mode {
            LowerFieldMode::Copy | LowerFieldMode::Convert(_) => spec.ident == entry.field,
            LowerFieldMode::NameIdx(_) => entry.field == "name_idx",
            LowerFieldMode::Skip => false,
        });

        if duplicates_field {
            return Err(syn::Error::new_spanned(
                &entry.field,
                format!(
                    "`extra` initializer `{}` duplicates a field initializer",
                    entry.field
                ),
            ));
        }
    }

    Ok(())
}

fn validate_finalize_fields(
    fields: &[FieldSpec],
    finalize: &crate::lower_parse::LowerFinalizeSpec,
) -> syn::Result<()> {
    for (index, arg) in finalize.args.iter().enumerate() {
        if !fields.iter().any(|field| field.ident == arg.field) {
            return Err(syn::Error::new_spanned(
                &arg.field,
                "finalize argument is not a target field",
            ));
        }

        if finalize
            .args
            .iter()
            .take(index)
            .any(|earlier| earlier.field == arg.field)
        {
            return Err(syn::Error::new_spanned(
                &arg.field,
                "duplicate finalize argument",
            ));
        }
    }

    for (index, rename) in finalize.renames.iter().enumerate() {
        if !fields.iter().any(|field| field.ident == rename.field) {
            return Err(syn::Error::new_spanned(
                &rename.field,
                "finalize rename is not a target field",
            ));
        }

        if finalize
            .renames
            .iter()
            .take(index)
            .any(|earlier| earlier.field == rename.field)
            || finalize.args.iter().any(|arg| arg.field == rename.field)
        {
            return Err(syn::Error::new_spanned(
                &rename.field,
                "duplicate finalize initializer",
            ));
        }
    }

    Ok(())
}

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

    use super::*;

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

        let output = expand_lower_data(&input).or_fail()?;
        let expected = quote! {
            impl RecordDef {
                /// Lower this builder def into its `Copy` engine-side data struct.
                ///
                /// Generated by `#[derive(LowerData)]`.
                pub(crate) fn into_data(&self, ctx: &mut LowerContext) -> RecordData {
                    RecordData {
                        value: self.value,
                    }
                }
            }
        };

        verify_that!(output.to_string(), eq(&expected.to_string()))
    }

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

        let output = expand_lower_data(&input).or_fail()?;
        let expected = quote! {
            impl<T> RecordDef<T>
            where
                T: Copy,
            {
                /// Lower this builder def into its `Copy` engine-side data struct.
                ///
                /// Generated by `#[derive(LowerData)]`.
                pub(crate) fn into_data(&self, ctx: &mut LowerContext) -> RecordData<T> {
                    RecordData::<T> {
                        value: self.value,
                    }
                }
            }
        };

        verify_that!(output.to_string(), eq(&expected.to_string()))
    }

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

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

        verify_that!(
            error.to_string(),
            eq("`extra` initializer `value` duplicates a field initializer")
        )
    }

    #[gtest]
    fn multiple_name_idx_modes_are_rejected_before_generating_duplicate_fields() -> Result<()> {
        let input: DeriveInput = syn::parse_quote! {
            #[lower(data = "RecordData", ctx = "LowerContext")]
            struct RecordDef {
                #[lower(name_idx = resolve_first)]
                first_name: String,
                #[lower(name_idx = resolve_second)]
                second_name: String,
            }
        };

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

        verify_that!(
            error.to_string(),
            eq("multiple `name_idx` modes would generate duplicate `name_idx` initializers")
        )
    }

    #[gtest]
    fn lower_data_generates_finalize_direction() -> Result<()> {
        let input: DeriveInput = syn::parse_quote! {
            #[lower(
                data = "RecordData",
                ctx = "LowerContext",
                finalize = "RecordDraft",
                finalize_args(id: u32),
                finalize_rename(value = draft_value)
            )]
            struct RecordDef {
                #[lower(copy)]
                id: u32,
                #[lower(copy)]
                value: i32,
                #[lower(copy)]
                ordinary: bool,
            }
        };

        let output = expand_lower_data(&input).or_fail()?.to_string();

        verify_that!(output, contains_substring("fn from_draft"))?;
        verify_that!(output, contains_substring("Self { id ,"))?;
        verify_that!(output, contains_substring("value : source . draft_value"))?;

        verify_that!(output, contains_substring("ordinary : source . ordinary"))
    }
}