work out function type dependency registration basics

Author: maksymilian-mozolewski

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

@@ -3,7 +3,7 @@ use crate::{
     error::InteropError,
     prelude::ScriptValue,
 };
-use bevy::reflect::{FromReflect, GetTypeRegistration};
+use bevy::reflect::{FromReflect, GetTypeRegistration, Reflect};
 use std::{
     any::TypeId,
     ffi::OsString,
@@ -139,6 +139,7 @@ impl FromScript for ReflectReference {
 ///
 /// This can be used to retrieve a value out of a [`ScriptValue::Reference`] corresponding to the type `T`.
 /// You can also use this to return values from a script function to be allocated directly as a [`ScriptValue::Reference`].
+#[derive(Reflect)]
 pub struct Val<T>(pub T);
 
 impl<T> Val<T> {

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

@@ -10,6 +10,7 @@ use crate::{
     bindings::{ReflectReference, WorldGuard},
     error::InteropError,
     prelude::ScriptValue,
+    self_type_dependency_only,
 };
 
 use super::from::Val;
@@ -24,17 +25,22 @@ impl IntoScript for ScriptValue {
     }
 }
 
+self_type_dependency_only!(ScriptValue);
+
 impl IntoScript for () {
     fn into_script(self, _world: WorldGuard) -> Result<ScriptValue, InteropError> {
         Ok(ScriptValue::Unit)
     }
 }
 
+self_type_dependency_only!(());
+
 impl IntoScript for bool {
-    fn into_script(self, world: WorldGuard) -> Result<ScriptValue, InteropError> {
+    fn into_script(self, _world: WorldGuard) -> Result<ScriptValue, InteropError> {
         Ok(ScriptValue::Bool(self))
     }
 }
+self_type_dependency_only!(bool);
 
 macro_rules! impl_into_with_downcast {
     ($variant:tt as $cast:ty [$($ty:ty),*]) => {
@@ -51,6 +57,9 @@ macro_rules! impl_into_with_downcast {
 
 impl_into_with_downcast!(Integer as i64 [i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, usize, isize]);
 impl_into_with_downcast!(Float as f64 [f32, f64]);
+self_type_dependency_only!(
+    i8, i16, i32, i64, i128, u8, u16, u32, u64, u128, usize, isize, f32, f64
+);
 
 macro_rules! impl_into_stringlike {
     ($id:ident,[ $(($ty:ty => $conversion:expr)),*]) => {
@@ -76,12 +85,16 @@ impl_into_stringlike!(
     ]
 );
 
+self_type_dependency_only!(String, char, PathBuf, OsString);
+
 impl IntoScript for &'static str {
     fn into_script(self, _world: WorldGuard) -> Result<ScriptValue, InteropError> {
         Ok(ScriptValue::String(Cow::Borrowed(self)))
     }
 }
 
+self_type_dependency_only!(&'static str);
+
 impl IntoScript for ReflectReference {
     fn into_script(self, _world: WorldGuard) -> Result<ScriptValue, InteropError> {
         Ok(ScriptValue::Reference(self))

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

@@ -14,6 +14,7 @@ use bevy::{
         GetTypeRegistration, PartialReflect, TypeRegistration, TypeRegistry,
     },
 };
+use std::collections::HashMap;
 use std::sync::Arc;
 
 #[diagnostic::on_unimplemented(
@@ -28,25 +29,59 @@ pub trait GetInnerTypeDependencies {
     fn register_type_dependencies(registry: &mut TypeRegistry);
 }
 
-impl<T: GetTypeRegistration> GetInnerTypeDependencies for T {
-    fn register_type_dependencies(registry: &mut TypeRegistry) {
-        registry.register::<T>();
-    }
+#[macro_export]
+macro_rules! no_type_dependencies {
+    ($($path:path),*) => {
+        $(
+            impl GetInnerTypeDependencies for $path {
+                fn register_type_dependencies(_registry: &mut TypeRegistry) {}
+            }
+        )*
+    };
+}
+
+#[macro_export]
+macro_rules! self_type_dependency_only {
+    ($($path:ty),*) => {
+        $(
+            impl $crate::bindings::function::script_function::GetInnerTypeDependencies for $path {
+                fn register_type_dependencies(registry: &mut bevy::reflect::TypeRegistry) {
+                    registry.register::<$path>();
+                }
+            }
+        )*
+    };
 }
 
 macro_rules! recursive_type_dependencies {
-    ($(T: $path:path),*) => {
+    ($(($path:path where $($bound:ident : $bound_val:path),*)),*)  => {
         $(
-            impl<T: GetInnerTypeDependencies> GetInnerTypeDependencies for $path {
+            impl<$($bound : $bound_val),*> GetInnerTypeDependencies for $path {
                 fn register_type_dependencies(registry: &mut TypeRegistry) {
-                    T::register_type_dependencies(registry);
+                    $(
+                        registry.register::<$bound>();
+                    )*
                 }
             }
         )*
     };
 }
 
-recursive_type_dependencies!(T: Val<T>, T: Ref<'_, T>, T: Mut<'_, T>);
+no_type_dependencies!(ReflectReference, InteropError);
+self_type_dependency_only!(WorldCallbackAccess);
+
+recursive_type_dependencies!(
+    (Val<T> where T: GetTypeRegistration),
+    (Ref<'_, T>  where T: GetTypeRegistration),
+    (Mut<'_, T>  where T: GetTypeRegistration),
+    (Result<T, InteropError>  where T: GetTypeRegistration),
+    (Option<T>  where T: GetTypeRegistration),
+    (Vec<T>  where T: GetTypeRegistration)
+);
+
+recursive_type_dependencies!(
+    (HashMap<K,V> where K: GetTypeRegistration, V: GetTypeRegistration)
+);
 
 pub trait GetFunctionTypeDependencies<Marker> {
     fn register_type_dependencies(registry: &mut TypeRegistry);

crates/bevy_mod_scripting_core/src/bindings/reference.rs

@@ -20,7 +20,7 @@ use bevy::{
         change_detection::MutUntyped, component::ComponentId, entity::Entity,
         world::unsafe_world_cell::UnsafeWorldCell,
     },
-    prelude::{Component, Resource},
+    prelude::{Component, ReflectDefault, Resource},
     ptr::Ptr,
     reflect::{
         func::{args::ArgInfo, ArgValue},
@@ -34,15 +34,29 @@ use std::{any::TypeId, fmt::Debug, sync::Arc};
 /// An accessor to a `dyn PartialReflect` struct, stores a base ID of the type and a reflection path
 /// safe to build but to reflect on the value inside you need to ensure aliasing rules are upheld
 #[derive(Debug, Clone, PartialEq, Eq, Reflect)]
-#[reflect(opaque)]
+#[reflect(Default)]
 pub struct ReflectReference {
+    #[reflect(ignore)]
     pub base: ReflectBaseType,
     // TODO: experiment with Fixed capacity vec, boxed array etc, compromise between heap allocation and runtime cost
     // needs benchmarks first though
     /// The path from the top level type to the actual value we want to access
+    #[reflect(ignore)]
     pub reflect_path: ParsedPath,
 }
 
+impl Default for ReflectReference {
+    fn default() -> Self {
+        Self {
+            base: ReflectBaseType {
+                type_id: TypeId::of::<WorldCallbackAccess>(),
+                base_id: ReflectBase::World,
+            },
+            reflect_path: ParsedPath(vec![]),
+        }
+    }
+}
+
 /// Specifies where we should source the type id from when reflecting a ReflectReference
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum TypeIdSource {

crates/bevy_mod_scripting_core/src/error.rs

@@ -183,8 +183,7 @@ impl From<InteropError> for mlua::Error {
 }
 
 #[derive(Debug, Clone, PartialEq, Reflect)]
-#[reflect(opaque)]
-pub struct InteropError(Arc<InteropErrorInner>);
+pub struct InteropError(#[reflect(ignore)] Arc<InteropErrorInner>);
 
 impl std::error::Error for InteropError {}
 
@@ -609,3 +608,10 @@ impl DisplayWithWorld for InteropErrorInner {
         }
     }
 }
+
+/// Purely for purposes of the automatic [`GetTypeRegistration`] impl.
+impl Default for InteropErrorInner {
+    fn default() -> Self {
+        InteropErrorInner::StaleWorldAccess
+    }
+}

crates/bevy_mod_scripting_functions/src/core.rs

@@ -57,22 +57,16 @@ impl<S: 'static> RegisterScriptFunction for NamespaceBuilder<'_, S> {
 
 impl Plugin for CoreFunctionsPlugin {
     fn build(&self, app: &mut App) {
-        let function_registry = app
-            .world_mut()
-            .get_resource_or_init::<AppFunctionRegistry>();
+        let world = app.world_mut();
+        register_world_functions(world).expect("Failed to register world functions");
 
-        let mut function_registry = function_registry.write();
-
-        register_world_functions(&mut function_registry)
-            .expect("Failed to register world functions");
-
-        register_reflect_reference_functions(&mut function_registry)
+        register_reflect_reference_functions(world)
             .expect("Failed to register reflect reference functions");
 
-        register_script_type_registration_functions(&mut function_registry)
+        register_script_type_registration_functions(world)
             .expect("Failed to register script type registration functions");
 
-        register_script_query_builder_functions(&mut function_registry)
+        register_script_query_builder_functions(world)
             .expect("Failed to register script query builder functions");
     }
 }
@@ -189,9 +183,7 @@ fn register_world_functions(reg: &mut World) -> Result<(), FunctionRegistrationE
     Ok(())
 }
 
-fn register_reflect_reference_functions(
-    reg: &mut FunctionRegistry,
-) -> Result<(), FunctionRegistrationError> {
+fn register_reflect_reference_functions(reg: &mut World) -> Result<(), FunctionRegistrationError> {
     NamespaceBuilder::<ReflectReference>::new(reg)
         .overwrite_script_function(
             "display_ref",
@@ -285,7 +277,7 @@ fn register_reflect_reference_functions(
 }
 
 fn register_script_type_registration_functions(
-    registry: &mut FunctionRegistry,
+    registry: &mut World,
 ) -> Result<(), FunctionRegistrationError> {
     NamespaceBuilder::<ScriptTypeRegistration>::new(registry)
         .overwrite_script_function("type_name", |s: Ref<ScriptTypeRegistration>| s.type_name())
@@ -302,7 +294,7 @@ fn register_script_type_registration_functions(
 }
 
 fn register_script_query_builder_functions(
-    registry: &mut FunctionRegistry,
+    registry: &mut World,
 ) -> Result<(), FunctionRegistrationError> {
     NamespaceBuilder::<ScriptQueryBuilder>::new(registry)
         .overwrite_script_function(