wowlab_engine_macros_impl/

codegen.rs

use quote::quote;
use syn::{
    Data, DeriveInput, Field, Fields, Ident, Type, Visibility, ext::IdentExt,
    punctuated::Punctuated, token::Comma,
};

use crate::parse::{ExprAttr, SlotAttr, parse_named_field_attr, parse_trait_crate_attr};

const OFFSET_IDENT_CAPACITY: usize = 32;

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum DescriptorFieldAbi {
    Float,
    Int,
}

impl DescriptorFieldAbi {
    const fn rust_type_name(self) -> &'static str {
        match self {
            Self::Float => "f64",
            Self::Int => "i32",
        }
    }
}

fn default_dbc_support_path() -> syn::Path {
    syn::parse_quote!(crate::parsers::dbc::macro_support)
}

fn dbc_trait_path(support_path: &syn::Path, trait_name: &str) -> proc_macro2::TokenStream {
    let trait_ident = Ident::new(trait_name, proc_macro2::Span::call_site());

    quote! { #support_path::#trait_ident }
}

// Syntactic last-segment check: a type alias to f64 is missed, but that only affects dump_fields formatting, not the ABI.
fn is_f64(ty: &Type) -> bool {
    let Type::Path(type_path) = ty else {
        return false;
    };

    type_path
        .path
        .segments
        .last()
        .is_some_and(|seg| seg.ident == "f64" && seg.arguments.is_none())
}

fn primitive_descriptor_abi(ty: &Type) -> Option<DescriptorFieldAbi> {
    let mut ty = ty;

    loop {
        match ty {
            Type::Group(group) => ty = &group.elem,
            Type::Paren(paren) => ty = &paren.elem,
            _ => break,
        }
    }

    let Type::Path(type_path) = ty else {
        return None;
    };
    let segment = type_path.path.segments.last()?;

    if !segment.arguments.is_none() {
        return None;
    }

    match segment.ident.to_string().as_str() {
        "f64" => Some(DescriptorFieldAbi::Float),
        "i32" => Some(DescriptorFieldAbi::Int),
        _ => None,
    }
}

fn expected_descriptor_abi(expr: &ExprAttr) -> syn::Result<DescriptorFieldAbi> {
    match expr.field_type_ident.to_string().as_str() {
        "Float" => Ok(DescriptorFieldAbi::Float),
        "Int" | "Bool" => Ok(DescriptorFieldAbi::Int),
        other => Err(syn::Error::new_spanned(
            &expr.field_type_ident,
            format!(
                "unsupported descriptor FieldType `{other}`; expected `Float`, `Int`, or `Bool`"
            ),
        )),
    }
}

fn validate_descriptor_field_abi(expr: &ExprAttr, field_ty: &Type) -> syn::Result<()> {
    let expected = expected_descriptor_abi(expr)?;
    let declared = expr.field_type_ident.to_string();
    let field_name = expr.field_ident.to_string();
    let Some(actual) = primitive_descriptor_abi(field_ty) else {
        return Err(syn::Error::new_spanned(
            field_ty,
            format!(
                "field `{field_name}` uses unsupported Rust ABI type `{}` for descriptor FieldType \
                 `{declared}`; expected `f64` for `Float` or `i32` for `Int`/`Bool`",
                quote!(#field_ty)
            ),
        ));
    };

    if actual != expected {
        return Err(syn::Error::new_spanned(
            field_ty,
            format!(
                "descriptor FieldType `{declared}` for field `{field_name}` requires Rust ABI type \
                 `{}`, found `{}`",
                expected.rust_type_name(),
                actual.rust_type_name(),
            ),
        ));
    }

    Ok(())
}

fn find_named_field<'a>(input: &'a DeriveInput, field_name: &Ident) -> syn::Result<&'a Field> {
    let Data::Struct(data_struct) = &input.data else {
        return Err(syn::Error::new_spanned(
            &input.ident,
            "this derive can only be applied to structs",
        ));
    };
    let Fields::Named(named) = &data_struct.fields else {
        return Err(syn::Error::new_spanned(
            &input.ident,
            "this derive requires a struct with named fields",
        ));
    };

    named
        .named
        .iter()
        .find(|f| f.ident.as_ref() == Some(field_name))
        .ok_or_else(|| {
            syn::Error::new_spanned(
                field_name,
                format!(
                    "struct `{}` has no field named `{}`",
                    input.ident, field_name
                ),
            )
        })
}

pub(crate) fn expand_has_id(input: &DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
    let name = &input.ident;
    let field_ident =
        parse_named_field_attr(input, "id_field")?.unwrap_or_else(|| Ident::new("ID", name.span()));
    let _ = find_named_field(input, &field_ident)?;

    let support_path =
        parse_trait_crate_attr(input, "has_id")?.unwrap_or_else(default_dbc_support_path);
    let trait_path = dbc_trait_path(&support_path, "HasId");
    let (impl_generics, type_generics, where_clause) = input.generics.split_for_impl();

    Ok(quote! {
        impl #impl_generics #trait_path for #name #type_generics #where_clause {
            fn id(&self) -> i32 {
                self.#field_ident
            }
        }
    })
}

pub(crate) fn expand_has_fk(input: &DeriveInput) -> syn::Result<proc_macro2::TokenStream> {
    let name = &input.ident;
    let field_ident = parse_named_field_attr(input, "fk_field")?.ok_or_else(|| {
        syn::Error::new_spanned(
            name,
            "#[derive(HasFk)] requires #[fk_field = \"FieldName\"]",
        )
    })?;
    let _ = find_named_field(input, &field_ident)?;

    let support_path =
        parse_trait_crate_attr(input, "has_fk")?.unwrap_or_else(default_dbc_support_path);
    let trait_path = dbc_trait_path(&support_path, "HasFk");
    let (impl_generics, type_generics, where_clause) = input.generics.split_for_impl();

    Ok(quote! {
        impl #impl_generics #trait_path for #name #type_generics #where_clause {
            fn fk(&self) -> i32 {
                self.#field_ident
            }
        }
    })
}

pub(crate) fn offset_const_name(field_name: &Ident) -> Ident {
    let mut buf = String::with_capacity(OFFSET_IDENT_CAPACITY);

    buf.push_str("OFF_");

    for ch in field_name.unraw().to_string().chars() {
        for upper in ch.to_uppercase() {
            buf.push(upper);
        }
    }

    Ident::new(&buf, field_name.span())
}

// #t(fn: rust_cyclomatic_complexity) validates a declarative slot grammar with independent attribute branches.
// #t(fn: rust_collection_new_in_loop, rust_clone_in_loop) emitted fields must own per-field attribute tokens.
pub(crate) fn expand_define_slot(
    item: &syn::ItemStruct,
    impl_body: Option<&proc_macro2::TokenStream>,
) -> syn::Result<proc_macro2::TokenStream> {
    let name = &item.ident;
    let vis = &item.vis;

    if !item.generics.params.is_empty() || item.generics.where_clause.is_some() {
        return Err(syn::Error::new_spanned(
            &item.generics,
            "define_slot! does not support generic slot types because each registered slot must \
             have one static size and layout",
        ));
    }

    let mut slot_attr: Option<SlotAttr> = None;
    let mut struct_attrs = Vec::with_capacity(item.attrs.len());

    for attr in &item.attrs {
        if attr.path().is_ident("slot") {
            if slot_attr.is_some() {
                return Err(syn::Error::new_spanned(
                    attr,
                    "duplicate #[slot(...)] attribute",
                ));
            }

            slot_attr = Some(crate::parse::parse_slot_attr(attr)?);
        } else if attr.path().is_ident("derive") {
            return Err(syn::Error::new_spanned(
                attr,
                "define_slot! already injects #[derive(Clone, Copy, Debug, Default)]; \
                 remove this #[derive(...)] (extra derives are not supported)",
            ));
        } else if attr.path().is_ident("repr") {
            return Err(syn::Error::new_spanned(
                attr,
                "define_slot! owns #[repr(C)]; additional #[repr(...)] attributes are not supported",
            ));
        } else {
            struct_attrs.push(attr);
        }
    }

    let fields = match &item.fields {
        Fields::Named(f) => &f.named,
        other => {
            return Err(syn::Error::new_spanned(
                other,
                "define_slot! requires a struct with named fields, got tuple or unit struct",
            ));
        }
    };

    let mut expr_attrs: Vec<ExprAttr> = Vec::new();
    let mut stripped_fields: Punctuated<Field, Comma> = Punctuated::new();

    for field in fields {
        let field_ident = field
            .ident
            .as_ref()
            .ok_or_else(|| syn::Error::new_spanned(field, "define_slot! fields must be named"))?;

        let mut clean_attrs = Vec::with_capacity(field.attrs.len());

        for attr in &field.attrs {
            if attr.path().is_ident("expr") {
                if slot_attr.is_none() {
                    return Err(syn::Error::new_spanned(
                        attr,
                        "#[expr(...)] requires a #[slot(...)] attribute on the struct",
                    ));
                }

                let expr = crate::parse::parse_expr_attr(attr, field_ident)?;

                validate_descriptor_field_abi(&expr, &field.ty)?;
                expr_attrs.push(expr);
            } else {
                clean_attrs.push(attr.clone());
            }
        }

        let mut stripped = field.clone();

        stripped.attrs = clean_attrs;
        stripped_fields.push(stripped);
    }

    let field_items = build_field_items(name, fields)?;
    let off_consts = &field_items.offset_consts;
    let offset_idents = &field_items.offset_idents;
    let field_sizes_aligns = &field_items.sizes_and_alignments;
    let field_types = &field_items.field_types;
    let dump_lines = build_dump_lines(name, fields)?;
    let dump_fields_ident = Ident::new("dump_fields", name.span());

    let impl_block = impl_body.map(|body| {
        quote! {
            impl #name {
                #body
            }
        }
    });

    let submissions = if let Some(ref slot) = slot_attr {
        build_submissions(name, slot, &expr_attrs)
    } else {
        Vec::new()
    };

    Ok(quote! {
        #impl_block

        #[repr(C)]
        #[derive(
            Clone,
            Copy,
            Debug,
            Default,
            crate::_private::bytemuck::Zeroable,
            crate::_private::bytemuck::Pod,
        )]
        #(#struct_attrs)*
        #vis struct #name {
            #stripped_fields
        }

        impl #name {
            pub const SIZE: usize = ::std::mem::size_of::<Self>();
            #(#off_consts)*

            /// Append human-readable field name/value pairs to the output string.
            pub fn #dump_fields_ident(&self, out: &mut ::std::string::String) {
                use ::std::fmt::Write as _;
                #(#dump_lines)*
            }
        }

        const _: () = {
            fn assert_field_is_pod<T: crate::_private::bytemuck::Pod>() {}
            #(let _ = assert_field_is_pod::<#field_types>;)*

            ::wowlab_buffer_contract::assert_repr_c_layout(
                &[#(#name::#offset_idents),*],
                #name::SIZE,
                &[#(#field_sizes_aligns),*],
            );
        };

        #(#submissions)*
    })
}

// #t(fn: rust_alloc_in_loop) generated descriptor text is allocated once per declared expression.
fn build_submissions(
    name: &Ident,
    slot: &SlotAttr,
    expr_attrs: &[ExprAttr],
) -> Vec<proc_macro2::TokenStream> {
    let mut items = Vec::with_capacity(expr_attrs.len() + 1);
    let kind_ident = &slot.kind_ident;
    let slot_kind_tokens = quote! { ::wowlab_buffer_contract::SlotKind::#kind_ident };
    let key_domain_tokens = if let Some(kd) = &slot.key_domain {
        quote! { Some(#kd) }
    } else {
        quote! { None }
    };

    let domain_str = &slot.domain;

    items.push(quote! {
        crate::_private::inventory::submit! {
            ::wowlab_buffer_contract::SlotDescriptor {
                name: #domain_str,
                size: #name::SIZE,
                kind: #slot_kind_tokens,
            }
        }
    });

    for expr in expr_attrs {
        let domain = &slot.domain;
        let expr_name = &expr.name;
        let field_type_ident = &expr.field_type_ident;
        let eval_kind_ident = &expr.eval_kind_ident;
        let field_type_tokens = quote! { ::wowlab_buffer_contract::FieldType::#field_type_ident };
        let eval_kind_tokens = quote! { ::wowlab_buffer_contract::EvalKind::#eval_kind_ident };
        let description = format!("{}.{}", domain.value(), expr_name.value());

        let off_ident = offset_const_name(&expr.field_ident);
        let field_offset_tokens = quote! { #name::#off_ident };

        items.push(quote! {
            crate::_private::inventory::submit! {
                ::wowlab_buffer_contract::FieldDescriptor {
                    domain: #domain,
                    name: #expr_name,
                    field_type: #field_type_tokens,
                    eval_kind: #eval_kind_tokens,
                    field_offset: #field_offset_tokens,
                    slot_size: #name::SIZE,
                    slot_kind: #slot_kind_tokens,
                    description: #description,
                    key_domain: #key_domain_tokens,
                }
            }
        });
    }

    items
}

// #t(fn: rust_alloc_in_loop) proc-macro expansion materializes one diagnostic label per field.
fn build_dump_lines(
    struct_name: &Ident,
    fields: &Punctuated<Field, Comma>,
) -> syn::Result<Vec<proc_macro2::TokenStream>> {
    let mut lines = Vec::with_capacity(fields.len());

    for field in fields {
        let field_name = field.ident.as_ref().ok_or_else(|| {
            syn::Error::new_spanned(
                field,
                format!("build_dump_lines({struct_name}): all fields must be named"),
            )
        })?;
        let name_str = field_name.to_string();

        if name_str.starts_with('_') {
            continue;
        }

        let line = if is_f64(&field.ty) {
            quote! {
                let _ = writeln!(out, "  {:<24} {:.4}", #name_str, self.#field_name);
            }
        } else {
            quote! {
                let _ = writeln!(out, "  {:<24} {}", #name_str, self.#field_name);
            }
        };

        lines.push(line);
    }

    Ok(lines)
}

struct FieldItems {
    offset_consts: Vec<proc_macro2::TokenStream>,
    offset_idents: Vec<Ident>,
    sizes_and_alignments: Vec<proc_macro2::TokenStream>,
    field_types: Vec<proc_macro2::TokenStream>,
}

// #t(fn: rust_alloc_in_loop) proc-macro expansion materializes spanned diagnostics for invalid fields.
fn build_field_items(
    struct_name: &Ident,
    fields: &Punctuated<Field, Comma>,
) -> syn::Result<FieldItems> {
    let cap = fields.len();
    let mut off_consts = Vec::with_capacity(cap);
    let mut offset_idents = Vec::with_capacity(cap);
    let mut field_sizes_aligns = Vec::with_capacity(cap);
    let mut field_types = Vec::with_capacity(cap);

    for field in fields {
        let field_name = field.ident.as_ref().ok_or_else(|| {
            syn::Error::new_spanned(
                field,
                format!("define_slot!({struct_name}): all fields must be named"),
            )
        })?;
        let field_ty = &field.ty;
        let field_vis = &field.vis;

        let upper_name = offset_const_name(field_name);

        let const_vis = match field_vis {
            Visibility::Public(_) => quote! { pub },
            _ => quote! {},
        };

        off_consts.push(quote! {
            #const_vis const #upper_name: usize = ::std::mem::offset_of!(Self, #field_name);
        });

        offset_idents.push(upper_name);

        field_sizes_aligns.push(quote! {
            (::std::mem::size_of::<#field_ty>(), ::std::mem::align_of::<#field_ty>())
        });
        field_types.push(quote! { #field_ty });
    }

    Ok(FieldItems {
        offset_consts: off_consts,
        offset_idents,
        sizes_and_alignments: field_sizes_aligns,
        field_types,
    })
}

#[cfg(test)]
mod tests;