refactor(engine-macros): split up into multiple modules

4 files changed, 312 insertions, 0 deletions

diff --git a/engine-macros/src/reflection/enum_impl.rs b/engine-macros/src/reflection/enum_impl.rs
new file mode 100644
index 0000000..0d9ff8b
--- /dev/null
+++ b/engine-macros/src/reflection/enum_impl.rs
@@ -0,0 +1,125 @@
+use quote::quote;
+
+use crate::reflection::field::{generate as generate_field, ReflectionFieldGenOptions};
+use crate::util::find_engine_crate_path;
+
+pub fn generate(input: syn::ItemEnum) -> proc_macro2::TokenStream
+{
+    let engine_crate_path = find_engine_crate_path().unwrap();
+
+    let input_ident = input.ident;
+
+    let (impl_generics, type_generics, where_clause) = input.generics.split_for_impl();
+
+    let variants = input.variants.iter().map(|variant| {
+        let variant_name =
+            syn::LitStr::new(&variant.ident.to_string(), variant.ident.span());
+
+        let fields = match &variant.fields {
+            syn::Fields::Unit => quote! { None },
+            syn::Fields::Named(named_fields) => {
+                let fields = named_fields.named.iter().enumerate().map(
+                    |(variant_field_index, variant_field)| {
+                        generate_field(
+                            variant_field,
+                            variant_field_index,
+                            &engine_crate_path,
+                            ReflectionFieldGenOptions {
+                                field_vis_override: None,
+                                include_byte_offset: false,
+                            },
+                        )
+                    },
+                );
+
+                quote! {
+                    Some(#engine_crate_path::reflection::EnumVariantFields::Named {
+                        fields: &[#(#fields),*]
+                    })
+                }
+            }
+            syn::Fields::Unnamed(unnamed_fields) => {
+                let fields = unnamed_fields.unnamed.iter().enumerate().map(
+                    |(variant_field_index, variant_field)| {
+                        generate_field(
+                            variant_field,
+                            variant_field_index,
+                            &engine_crate_path,
+                            ReflectionFieldGenOptions {
+                                field_vis_override: None,
+                                include_byte_offset: false,
+                            },
+                        )
+                    },
+                );
+
+                quote! {
+                    Some(#engine_crate_path::reflection::EnumVariantFields::Unnamed {
+                        fields: &[#(#fields),*]
+                    })
+                }
+            }
+        };
+
+        quote! {
+            #engine_crate_path::reflection::EnumVariant {
+                name: #variant_name,
+                fields: #fields
+            }
+        }
+    });
+
+    let variant_lookup_match_arms =
+        input.variants.iter().enumerate().map(|(index, variant)| {
+            let variant_ident = &variant.ident;
+
+            let pattern = match variant.fields {
+                syn::Fields::Unit => quote! { Self::#variant_ident },
+                syn::Fields::Named(_) => quote! { Self::#variant_ident { .. } },
+                syn::Fields::Unnamed(_) => quote! { Self::#variant_ident(..) },
+            };
+
+            quote! {
+                #pattern => &enum_reflection.variants[#index]
+            }
+        });
+
+    let is_unit_only = input
+        .variants
+        .iter()
+        .all(|variant| matches!(variant.fields, syn::Fields::Unit));
+
+    quote! {
+        unsafe impl #impl_generics #engine_crate_path::reflection::Reflection for
+            #input_ident #type_generics #where_clause
+        {
+            const TYPE_REFLECTION: &#engine_crate_path::reflection::Type =
+                &const {
+                    #engine_crate_path::reflection::Type::Enum(
+                        #engine_crate_path::reflection::Enum {
+                            variants: &[#(#variants),*],
+                            is_unit_only: #is_unit_only
+                        }
+                    )
+                };
+        }
+
+        unsafe impl #impl_generics #engine_crate_path::reflection::EnumReflectionExt for
+            #input_ident #type_generics #where_clause
+        {
+            fn get_variant_reflection(&self)
+                -> &'static #engine_crate_path::reflection::EnumVariant
+            {
+                let enum_reflection = unsafe {
+                    <Self as #engine_crate_path::reflection::Reflection>::TYPE_REFLECTION
+                        .as_enum()
+                        .unwrap_unchecked()
+                };
+
+                match self {
+                    #(#variant_lookup_match_arms),*
+                }
+            }
+        }
+    }
+}
diff --git a/engine-macros/src/reflection/field.rs b/engine-macros/src/reflection/field.rs
new file mode 100644
index 0000000..489d165
--- /dev/null
+++ b/engine-macros/src/reflection/field.rs
@@ -0,0 +1,96 @@
+use quote::{quote, ToTokens};
+
+use crate::reflection::visibility::generate as generate_visibility;
+
+pub struct ReflectionFieldGenOptions
+{
+    pub field_vis_override: Option<syn::Visibility>,
+    pub include_byte_offset: bool,
+}
+
+pub fn generate(
+    field: &syn::Field,
+    field_index: usize,
+    engine_crate_path: &syn::Path,
+    options: ReflectionFieldGenOptions,
+) -> proc_macro2::TokenStream
+{
+    let field_ident = &field.ident;
+
+    let field_type = &field.ty;
+
+    let field_name = if let Some(field_ident) = field_ident {
+        let field_name = syn::LitStr::new(&field_ident.to_string(), field_ident.span());
+
+        quote! { Some(#field_name) }
+    } else {
+        quote! { None }
+    };
+
+    let field_byte_offset = if options.include_byte_offset {
+        if let Some(field_ident) = field_ident {
+            quote! { Some(std::mem::offset_of!(Self, #field_ident)) }
+        } else {
+            quote! { Some(std::mem::offset_of!(Self, #field_index)) }
+        }
+    } else {
+        quote! { None }
+    };
+
+    // since std::any::type_name as const is not stable yet
+    let field_type_name = field_type.to_token_stream().to_string();
+
+    let field_vis = options.field_vis_override.as_ref().unwrap_or(&field.vis);
+
+    let field_reflection_vis = generate_visibility(field_vis, &engine_crate_path);
+
+    quote! {
+        #engine_crate_path::reflection::Field {
+            name: #field_name,
+            index: #field_index,
+            layout: std::alloc::Layout::new::<#field_type>(),
+            byte_offset: #field_byte_offset,
+            type_id: std::any::TypeId::of::<#field_type>(),
+            type_name: #field_type_name,
+            get_type: #engine_crate_path::reflection::FnWithDebug::new(|| {
+                struct SpecializationTarget<Field>(std::marker::PhantomData<Field>);
+
+                trait FieldHasReflection
+                {
+                    fn field_type_reflection(&self)
+                        -> Option<&'static #engine_crate_path::reflection::Type>;
+                }
+
+                trait FieldDoesNotHaveReflection
+                {
+                    fn field_type_reflection(&self)
+                        -> Option<&'static #engine_crate_path::reflection::Type>;
+                }
+
+                impl<Field> FieldDoesNotHaveReflection for &SpecializationTarget<Field>
+                {
+                    fn field_type_reflection(&self)
+                        -> Option<&'static #engine_crate_path::reflection::Type>
+                    {
+                        None
+                    }
+                }
+
+                impl<Field> FieldHasReflection for SpecializationTarget<Field>
+                where
+                    Field: #engine_crate_path::reflection::Reflection
+                {
+                    fn field_type_reflection(&self)
+                        -> Option<&'static #engine_crate_path::reflection::Type>
+                    {
+                        Some(Field::type_reflection())
+                    }
+                }
+
+                (&SpecializationTarget::<#field_type>(std::marker::PhantomData))
+                    .field_type_reflection()
+            }),
+            visibility: #field_reflection_vis
+        }
+    }
+}
diff --git a/engine-macros/src/reflection/struct_impl.rs b/engine-macros/src/reflection/struct_impl.rs
new file mode 100644
index 0000000..57e3e21
--- /dev/null
+++ b/engine-macros/src/reflection/struct_impl.rs
@@ -0,0 +1,46 @@
+use quote::quote;
+
+use crate::reflection::field::{generate as generate_field, ReflectionFieldGenOptions};
+use crate::util::find_engine_crate_path;
+
+pub fn generate(input: syn::ItemStruct) -> proc_macro2::TokenStream
+{
+    let engine_crate_path = find_engine_crate_path().unwrap();
+
+    let input_ident = input.ident;
+
+    let (impl_generics, type_generics, where_clause) = input.generics.split_for_impl();
+
+    let fields = input
+        .fields
+        .into_iter()
+        .enumerate()
+        .map(|(field_index, field)| {
+            generate_field(
+                &field,
+                field_index,
+                &engine_crate_path,
+                ReflectionFieldGenOptions {
+                    field_vis_override: None,
+                    include_byte_offset: true,
+                },
+            )
+        });
+
+    quote! {
+        unsafe impl #impl_generics #engine_crate_path::reflection::Reflection for
+            #input_ident #type_generics #where_clause
+        {
+            const TYPE_REFLECTION: &#engine_crate_path::reflection::Type =
+                &const {
+                    #engine_crate_path::reflection::Type::Struct(
+                        #engine_crate_path::reflection::Struct {
+                            fields: &[
+                                #(#fields),*
+                            ]
+                        }
+                    )
+                };
+        }
+    }
+}
diff --git a/engine-macros/src/reflection/visibility.rs b/engine-macros/src/reflection/visibility.rs
new file mode 100644
index 0000000..c9e8524
--- /dev/null
+++ b/engine-macros/src/reflection/visibility.rs
@@ -0,0 +1,45 @@
+use quote::quote;
+
+use crate::util::syn_path_to_string;
+
+pub fn generate(
+    visibility: &syn::Visibility,
+    engine_crate_path: &syn::Path,
+) -> proc_macro2::TokenStream
+{
+    match visibility {
+        syn::Visibility::Public(_) => {
+            quote! { #engine_crate_path::reflection::Visibility::Pub }
+        }
+        syn::Visibility::Restricted(vis_restricted) => {
+            let vis_scope = if vis_restricted.in_token.is_some() {
+                let in_path = syn_path_to_string(&vis_restricted.path);
+
+                quote! {
+                    #engine_crate_path::reflection::VisibilityScope::In(
+                        std::borrow::Cow::Borrowed(#in_path)
+                    )
+                }
+            } else {
+                let Some(scope) = vis_restricted.path.get_ident() else {
+                    unreachable!();
+                };
+
+                if scope == "crate" {
+                    quote! { #engine_crate_path::reflection::VisibilityScope::Crate }
+                } else if scope == "super" {
+                    quote! { #engine_crate_path::reflection::VisibilityScope::Super }
+                } else if scope == "self" {
+                    quote! { #engine_crate_path::reflection::VisibilityScope::SelfModule }
+                } else {
+                    unreachable!();
+                }
+            };
+
+            quote! { #engine_crate_path::reflection::Visibility::PubScoped(#vis_scope) }
+        }
+        syn::Visibility::Inherited => {
+            quote! { #engine_crate_path::reflection::Visibility::Private }
+        }
+    }
+}