WIP

Author: makspll

crates/bevy_mod_scripting_core/src/bindings/function/type_dependencies.rs

@@ -8,57 +8,20 @@ use crate::{
     bindings::{ReflectReference, WorldGuard},
     error::InteropError,
 };
-use bevy::reflect::{FromReflect, GetTypeRegistration, TypeRegistry, Typed};
-use std::collections::HashMap;
+use bevy::reflect::{FromReflect, GetTypeRegistration, TypeRegistration, TypeRegistry, Typed};
+use bevy_mod_scripting_derive::{impl_get_type_dependencies, GetTypeDependencies};
+use std::{collections::HashMap, hash::Hash};
 
 /// Functionally identical to [`GetTypeRegistration`] but without the 'static bound
 pub trait GetTypeDependencies {
+    /// In the majority of the implementations, this will be `Self`
+    /// However some types might be `facades` for other types, in which case this will be the underlying type
+    type Underlying;
+
     /// Registers the type dependencies of the implementing type with the given [`TypeRegistry`].
     fn register_type_dependencies(registry: &mut TypeRegistry);
 }
 
-#[macro_export]
-/// A macro for implementing [`GetTypeDependencies`] for types with no type dependencies.
-macro_rules! no_type_dependencies {
-    ($($path:path),*) => {
-        $(
-            impl $crate::bindings::function::type_dependencies::GetTypeDependencies for $path {
-                fn register_type_dependencies(_registry: &mut bevy::reflect::TypeRegistry) {}
-            }
-        )*
-    };
-}
-
-#[macro_export]
-/// A macro for implementing [`GetTypeDependencies`] for types that only depend on themselves.
-macro_rules! self_type_dependency_only {
-    ($($path:ty),*) => {
-        $(
-            impl $crate::bindings::function::type_dependencies::GetTypeDependencies for $path {
-                fn register_type_dependencies(registry: &mut bevy::reflect::TypeRegistry) {
-                    registry.register::<$path>();
-                }
-            }
-        )*
-    };
-}
-
-macro_rules! recursive_type_dependencies {
-    ($( ($path:ty where $($bound:ident : $($bound_val:path);*),* $(,,const $const:ident : $const_ty:ty)? $(=> with $self_:ident)?) ),* )  => {
-        $(
-            impl<$($bound : $($bound_val +)*),* , $(const $const : $const_ty )?> GetTypeDependencies for $path {
-                fn register_type_dependencies(registry: &mut TypeRegistry) {
-                    $(
-                        registry.register::<$bound>();
-                    )*
-                    $(
-                        registry.register::<$self_>();
-                    )?
-                }
-            }
-        )*
-    };
-}
 
 macro_rules! register_tuple_dependencies {
     ($($ty:ident),*) => {
@@ -72,6 +35,26 @@ macro_rules! register_tuple_dependencies {
     };
 }
 
+
+impl GetTypeDependencies for InteropError {
+    type Underlying = Self;
+
+    fn register_type_dependencies(registry: &mut TypeRegistry) {
+        todo!()
+    }
+}
+
+
+
+impl_get_type_dependencies!(
+    #[derive(GetTypeDependencies)]
+    #[get_type_dependencies(bms_core_path=crate)]
+    struct HashMap<K,V> {
+    
+    }
+);
+
+
 no_type_dependencies!(InteropError);
 no_type_dependencies!(WorldGuard<'static>);
 self_type_dependency_only!(FunctionCallContext, ReflectReference);
@@ -97,14 +80,17 @@ where
     }
 }
 
-impl <K, V> GetTypeDependencies for HashMap<K, V> 
+impl <Uk, Uv, K, V> GetTypeDependencies<HashMap<Uk,Uv>> for HashMap<K, V> 
 where 
-    K: GetTypeDependencies,
-    V: GetTypeDependencies
+    K: GetTypeDependencies<Uk>,
+    V: GetTypeDependencies<Uv>,
+    Uk: GetTypeRegistration + FromReflect + Eq + Hash + Typed,
+    Uv: GetTypeRegistration + FromReflect + Eq + Hash + Typed,
 {
     fn register_type_dependencies(registry: &mut TypeRegistry) {
         K::register_type_dependencies(registry);
         V::register_type_dependencies(registry);
+        TypeRegistration::of::<HashMap<Uk,Uv>>();
     }
 }
 

crates/bevy_mod_scripting_core/src/error.rs

@@ -18,6 +18,7 @@ use bevy::{
     prelude::Entity,
     reflect::{PartialReflect, Reflect},
 };
+use bevy_mod_scripting_derive::GetTypeDependencies;
 use std::{
     any::TypeId,
     borrow::Cow,
@@ -313,8 +314,9 @@ impl Display for MissingResourceError {
 
 impl std::error::Error for MissingResourceError {}
 
-#[derive(Debug, Clone, PartialEq, Reflect)]
+#[derive(Debug, Clone, PartialEq, Reflect, GetTypeDependencies)]
 #[reflect(opaque)]
+#[get_type_dependencies(bms_core_path=crate)]
 /// An error thrown when interoperating with scripting languages.
 pub struct InteropError(Arc<InteropErrorInner>);
 

crates/bevy_mod_scripting_derive/src/derive/get_type_dependencies.rs

@@ -0,0 +1,122 @@
+use proc_macro2::TokenStream;
+use quote::quote_spanned;
+use syn::{parse_quote, DeriveInput};
+
+
+
+
+/// Generate a GetTypeDependencies impl like below:
+/// For type:
+/// 
+/// ```rust,ignore
+/// #[derive(GetTypeDependencies)]
+/// #[get_type_dependencies(remote)]
+/// struct TargetType<T1: CustomBoundsT1, T2: CustomBoundsT2>{
+///     ...
+/// }
+/// ```
+/// 
+/// ```rust,ignore
+/// impl <T1,T2> GetTypeDependencies for TargetType 
+/// where
+///     T1: GetTypeDependencies,
+///     T2: GetTypeDependencies,
+///     T1::Underlying: bevy::reflect::GetTypeRegistration + CustomBoundsT1,
+///     T2::Underlying: bevy::reflect::GetTypeRegistration + CustomBoundsT2,    
+/// {
+///     type Underlying = TargetType<T1::Underlying, T2::Underlying>;
+///     pub fn get_type_dependencies(registry: &mut bevy::reflect::TypeRegistry) {
+///         T1::get_type_dependencies(registry);
+///         T2::get_type_dependencies(registry);
+/// 
+///         registry.register::<TargetType<T1::Underlying, T2::Underlying>>();
+///     }  
+/// }
+/// ```
+fn get_type_dependencies_from_input(derive_input: DeriveInput) -> TokenStream {
+    let args = match Args::parse(&derive_input.attrs) {
+        Ok(args) => args,
+        Err(error) => return error.to_compile_error(),
+    };
+
+    let bms_core = &args.bms_core_path;
+
+    // we enrich the where clause with our bounds
+    let mut where_conditions = Vec::default();
+
+    for param in derive_input.generics.type_params() {
+        let param_name = &param.ident;
+        where_conditions.push(
+            quote_spanned!(param.ident.span()=> #param_name: GetTypeDependencies),
+        );
+        where_conditions.push(
+            quote_spanned!(param.ident.span()=> #param_name::Underlying: bevy::reflect::GetTypeRegistration),
+        );
+    }
+
+    let (impl_generics, type_generics, _) = derive_input.generics.split_for_impl();
+    let name = &derive_input.ident;
+
+
+    let generic_names = derive_input.generics.type_params().map(|param| &param.ident).collect::<Vec<_>>();
+
+
+    quote_spanned! {derive_input.ident.span()=>
+        impl #impl_generics #bms_core::bindings::GetTypeDependencies for #name #type_generics where
+        #(
+            #where_conditions
+        ),*
+        {
+            type Underyling = #name<
+                #( #generic_names::Underlying ),*
+            >;
+            fn register_type_dependencies(registry: &mut bevy::reflect::TypeRegistry) {
+                #(
+                    <#generic_names as #bms_core::bindings::GetTypeDependencies>::register_type_dependencies(registry);
+                )*
+
+                registry.register::<#name<
+                    #( #generic_names::Underlying ),*
+                >>();
+            }
+        }
+    }
+}
+
+pub fn get_type_dependencies(input: TokenStream) -> TokenStream {
+    let derive_input: DeriveInput = match syn::parse2(input) {
+        Ok(input) => input,
+        Err(e) => return e.into_compile_error(),
+    };
+    
+   get_type_dependencies_from_input(derive_input)
+}
+
+
+
+
+struct Args {
+    bms_core_path: syn::Path,
+}
+
+impl Args {
+    fn parse(attrs: &[syn::Attribute]) -> syn::Result<Self> {
+        let mut bms_core_path = parse_quote!(bevy_mod_scripting_core);
+
+        for attr in attrs {
+            // find attr with name `get_type_dependencies`
+            // then parse its meta
+            if attr.path().is_ident("get_type_dependencies") {
+                attr.parse_nested_meta(|meta| {
+                    if meta.path.is_ident("bms_core_path") {
+                        let value = meta.value()?;
+                        bms_core_path = value.parse()?;
+                    }
+                    Ok(())
+                })?;
+            }
+        }
+
+        Ok(Self { bms_core_path })
+    }
+}

crates/bevy_mod_scripting_derive/src/derive/mod.rs

@@ -2,6 +2,7 @@ mod into_script;
 mod script_bindings;
 mod script_globals;
 mod typed_through;
+mod get_type_dependencies;
 
 use proc_macro2::{Span, TokenStream};
 use quote::{quote_spanned, ToTokens};
@@ -10,6 +11,7 @@ use syn::{Ident, ImplItemFn, ItemImpl};
 pub use self::{
     into_script::into_script, script_bindings::script_bindings, script_globals::script_globals,
     typed_through::typed_through,
+    get_type_dependencies::get_type_dependencies
 };
 
 pub(crate) fn impl_fn_to_namespace_builder_registration(fun: &ImplItemFn) -> TokenStream {

crates/bevy_mod_scripting_derive/src/lib.rs

@@ -2,6 +2,8 @@
 
 mod derive;
 
+
+
 #[proc_macro_derive(TypedThrough)]
 /// Default implementation for the `TypedThrough` trait
 pub fn typed_through(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
@@ -49,3 +51,20 @@ pub fn script_globals(
 ) -> proc_macro::TokenStream {
     derive::script_globals(args, input)
 }
+
+/// Derive macro for generating `GetTypeDependencies` implementations.
+#[proc_macro_derive(GetTypeDependencies, attributes(get_type_dependencies))]
+pub fn get_type_dependencies(
+    input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    derive::get_type_dependencies(input.into()).into()
+}
+
+/// Proc macro equivalent of `GetTypeDependencies` which does not generate a type, purely the impl.
+/// Useful for generating implementations against remote types.
+#[proc_macro]
+pub fn impl_get_type_dependencies(
+    input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
+    derive::get_type_dependencies(input.into()).into()
+}