Upgrade reflection API's

makspll · makspll · commit 528257eec1b3 · 2024-11-06T22:41:42.000Z
diff --git a/crates/bevy_script_api/src/common/bevy/mod.rs b/crates/bevy_script_api/src/common/bevy/mod.rs
@@ -7,12 +7,12 @@ use bevy::{
         world::{Command, EntityRef, World},
     },
     prelude::{
-        AppTypeRegistry, BuildWorldChildren, Children, DespawnChildrenRecursive, DespawnRecursive,
+        AppTypeRegistry, BuildChildren, Children, DespawnChildrenRecursive, DespawnRecursive,
         Entity, Parent, ReflectComponent, ReflectDefault, ReflectResource,
     },
     reflect::{
-        DynamicArray, DynamicEnum, DynamicList, DynamicMap, DynamicStruct, DynamicTuple,
-        DynamicTupleStruct, TypeRegistration,
+        DynamicArray, DynamicEnum, DynamicList, DynamicMap, DynamicSet, DynamicStruct,
+        DynamicTuple, DynamicTupleStruct, TypeRegistration,
     },
 };
 use bevy_mod_scripting_core::{prelude::ScriptError, world::WorldPointer};
@@ -169,35 +169,35 @@ impl ScriptWorld {
 
     pub fn push_child(&self, parent: Entity, child: Entity) {
         let mut w = self.write();
-        if let Some(mut entity) = w.get_entity_mut(parent) {
-            entity.push_children(&[child]);
+        if let Ok(mut entity) = w.get_entity_mut(parent) {
+            entity.add_children(&[child]);
         }
     }
 
     pub fn remove_children(&self, parent: Entity, children: &[Entity]) {
         let mut w = self.write();
 
-        if let Some(mut entity) = w.get_entity_mut(parent) {
+        if let Ok(mut entity) = w.get_entity_mut(parent) {
             entity.remove_children(children);
         }
     }
 
     pub fn insert_children(&self, parent: Entity, index: usize, children: &[Entity]) {
         let mut w = self.write();
 
-        if let Some(mut entity) = w.get_entity_mut(parent) {
+        if let Ok(mut entity) = w.get_entity_mut(parent) {
             entity.insert_children(index, children);
         }
     }
 
     pub fn despawn_children_recursive(&self, entity: Entity) {
         let mut w = self.write();
-        DespawnChildrenRecursive { entity }.apply(&mut w);
+        DespawnChildrenRecursive { entity, warn: true }.apply(&mut w);
     }
 
     pub fn despawn_recursive(&self, entity: Entity) {
         let mut w = self.write();
-        DespawnRecursive { entity }.apply(&mut w);
+        DespawnRecursive { entity, warn: true }.apply(&mut w);
     }
 
     pub fn get_type_by_name(&self, type_name: &str) -> Option<ScriptTypeRegistration> {
@@ -225,7 +225,7 @@ impl ScriptWorld {
 
         let mut entity_ref = w
             .get_entity_mut(entity)
-            .ok_or_else(|| ScriptError::Other(format!("Entity is not valid {:#?}", entity)))?;
+            .map_err(|e| ScriptError::Other(format!("Entity is not valid {:#?}. {e}", entity)))?;
 
         let component_data = comp_type.data::<ReflectComponent>().ok_or_else(|| {
             ScriptError::Other(format!("Not a component {}", comp_type.short_name()))
@@ -243,13 +243,14 @@ impl ScriptWorld {
             bevy::reflect::TypeInfo::List(_) => component_data.insert(&mut entity_ref, &DynamicList::default(), &registry_lock),
             bevy::reflect::TypeInfo::Array(_) => component_data.insert(&mut entity_ref, &DynamicArray::new(Box::new([])), &registry_lock),
             bevy::reflect::TypeInfo::Map(_) => component_data.insert(&mut entity_ref, &DynamicMap::default(), &registry_lock),
-            bevy::reflect::TypeInfo::Value(_) => component_data.insert(&mut entity_ref,
+            bevy::reflect::TypeInfo::Set(set_info) => component_data.insert(&mut entity_ref, &DynamicSet::default(), &registry_lock),
+            bevy::reflect::TypeInfo::Opaque(_) => component_data.insert(&mut entity_ref,
                 comp_type.data::<ReflectDefault>().ok_or_else(||
                     ScriptError::Other(format!("Component {} is a value or dynamic type with no `ReflectDefault` type_data, cannot instantiate sensible value",comp_type.short_name())))?
                     .default()
-                    .as_ref(),
+                    .as_partial_reflect(),
                     &registry_lock),
-            bevy::reflect::TypeInfo::Enum(_) => component_data.insert(&mut entity_ref, &DynamicEnum::default(), &registry_lock)
+            bevy::reflect::TypeInfo::Enum(_) => component_data.insert(&mut entity_ref, &DynamicEnum::default(), &registry_lock),
         };
         // if we do not drop the lock here, line below will complain registry is still borrowed at drop
         drop(registry_lock);
@@ -273,7 +274,7 @@ impl ScriptWorld {
 
         let entity_ref = w
             .get_entity(entity)
-            .ok_or_else(|| ScriptError::Other(format!("Entity is not valid {:#?}", entity)))?;
+            .map_err(|e| ScriptError::Other(format!("Entity is not valid {:#?}. {e}", entity)))?;
 
         let component_data = comp_type.data::<ReflectComponent>().ok_or_else(|| {
             ScriptError::Other(format!("Not a component {}", comp_type.short_name()))
@@ -296,7 +297,7 @@ impl ScriptWorld {
 
         let entity_ref = w
             .get_entity(entity)
-            .ok_or_else(|| ScriptError::Other(format!("Entity is not valid {:#?}", entity)))?;
+            .map_err(|e| ScriptError::Other(format!("Entity is not valid {:#?}. {e}", entity)))?;
 
         Ok(component_data.reflect(entity_ref).is_some())
     }
@@ -310,7 +311,7 @@ impl ScriptWorld {
 
         let mut entity_ref = w
             .get_entity_mut(entity)
-            .ok_or_else(|| ScriptError::Other(format!("Entity is not valid {:#?}", entity)))?;
+            .map_err(|e| ScriptError::Other(format!("Entity is not valid {:#?}. {e}", entity)))?;
 
         let component_data = comp_type.data::<ReflectComponent>().ok_or_else(|| {
             ScriptError::Other(format!("Not a component {}", comp_type.short_name()))
diff --git a/crates/bevy_script_api/src/common/std.rs b/crates/bevy_script_api/src/common/std.rs
@@ -1,6 +1,6 @@
 use std::marker::PhantomData;
 
-use bevy::reflect::{FromReflect, GetTypeRegistration, TypePath};
+use bevy::reflect::{FromReflect, GetTypeRegistration, TypePath, Typed};
 
 use crate::{error::ReflectionError, ReflectReference, ValueIndex};
 
@@ -26,7 +26,7 @@ impl<T> std::fmt::Debug for ScriptVec<T> {
     }
 }
 
-impl<T: std::fmt::Display + FromReflect + GetTypeRegistration + TypePath> std::fmt::Display
+impl<T: std::fmt::Display + FromReflect + GetTypeRegistration + TypePath + Typed> std::fmt::Display
     for ScriptVec<T>
 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -41,7 +41,7 @@ impl<T: std::fmt::Display + FromReflect + GetTypeRegistration + TypePath> std::f
     }
 }
 
-impl<T: FromReflect + TypePath + GetTypeRegistration> ScriptVec<T> {
+impl<T: FromReflect + TypePath + GetTypeRegistration + Typed> ScriptVec<T> {
     pub fn new_ref(ref_: ReflectReference) -> Self {
         Self {
             ref_,
@@ -118,7 +118,7 @@ impl<T: FromReflect> Iterator for ScriptVecIterator<T> {
     }
 }
 
-impl<T: FromReflect + TypePath + GetTypeRegistration> IntoIterator for ScriptVec<T> {
+impl<T: FromReflect + TypePath + GetTypeRegistration + Typed> IntoIterator for ScriptVec<T> {
     type Item = ReflectReference;
 
     type IntoIter = ScriptVecIterator<T>;
diff --git a/crates/bevy_script_api/src/lua/bevy/mod.rs b/crates/bevy_script_api/src/lua/bevy/mod.rs
@@ -9,7 +9,7 @@ use crate::lua::{
 };
 use crate::providers::bevy_ecs::LuaEntity;
 use crate::{impl_from_lua_with_clone, impl_tealr_type};
-use bevy::hierarchy::BuildWorldChildren;
+use bevy::hierarchy::BuildChildren;
 use bevy::prelude::{AppTypeRegistry, ReflectResource};
 use bevy_mod_scripting_core::prelude::*;
 use bevy_mod_scripting_lua::{prelude::IntoLua, tealr};
@@ -288,8 +288,8 @@ impl TealData for LuaWorld {
                     .map(|e| e.inner())
                     .collect::<Result<Vec<_>, _>>()?;
 
-                if let Some(mut entity) = w.get_entity_mut(parent.inner()?) {
-                    entity.push_children(&children);
+                if let Ok(mut entity) = w.get_entity_mut(parent.inner()?) {
+                    entity.add_children(&children);
                 }
 
                 Ok(())
diff --git a/crates/bevy_script_api/src/lua/std.rs b/crates/bevy_script_api/src/lua/std.rs
@@ -106,7 +106,8 @@ impl<
             + GetTypeRegistration
             + TypePath
             + for<'a> FromLuaProxy<'a>
-            + Clone,
+            + Clone
+            + bevy::reflect::Typed,
     > LuaProxyable for Option<T>
 {
     fn ref_to_lua(self_: ReflectReference, lua: &Lua) -> mlua::Result<Value> {
@@ -246,6 +247,7 @@ impl<
             + GetTypeRegistration
             + TypePath
             + LuaProxyable
+            + bevy::reflect::Typed
             + for<'a> FromLuaProxy<'a>
             + for<'a> IntoLuaProxy<'a>
             + std::fmt::Debug,
@@ -274,6 +276,7 @@ impl<
             + GetTypeRegistration
             + TypePath
             + LuaProxyable
+            + bevy::reflect::Typed
             + for<'a> FromLuaProxy<'a>
             + for<'a> IntoLuaProxy<'a>
             + std::fmt::Debug,
@@ -294,6 +297,7 @@ impl<
             + GetTypeRegistration
             + TypePath
             + LuaProxyable
+            + bevy::reflect::Typed
             + for<'a> FromLuaProxy<'a>
             + for<'a> IntoLuaProxy<'a>,
     > TealData for LuaVec<T>
@@ -384,6 +388,7 @@ impl<
             + GetTypeRegistration
             + TypePath
             + LuaProxyable
+            + bevy::reflect::Typed
             + for<'a> FromLuaProxy<'a>
             + for<'a> IntoLuaProxy<'a>
             + std::fmt::Debug,
@@ -446,6 +451,7 @@ impl<
             + GetTypeRegistration
             + TypePath
             + LuaProxyable
+            + bevy::reflect::Typed
             + std::fmt::Debug,
     > FromLuaProxy<'lua> for Vec<T>
 {
diff --git a/crates/bevy_script_api/src/lua/util.rs b/crates/bevy_script_api/src/lua/util.rs
@@ -287,6 +287,12 @@ macro_rules! impl_tealr_generic{
 
         }
 
+        impl ::bevy::reflect::Typed for $name {
+            fn type_info() -> &'static ::bevy::reflect::TypeInfo {
+                panic!("This should never be called, I am a dummy implementation")
+            }
+        }
+
         impl ::bevy::reflect::TypePath for $name {
             fn short_type_path() -> &'static str{
                 panic!("This should never be called, I am a dummy implementation")
@@ -297,69 +303,94 @@ macro_rules! impl_tealr_generic{
             }
         }
 
-        impl ::bevy::reflect::Reflect for $name {
 
-            fn try_apply(&mut self, _: &(dyn bevy::prelude::Reflect + 'static)) -> std::result::Result<(), bevy::reflect::ApplyError> {
+        impl ::bevy::reflect::PartialReflect for $name {
+            fn get_represented_type_info(&self) -> std::option::Option<&'static bevy::reflect::TypeInfo> {
                 panic!("This should never be called, I am a dummy implementation");
             }
 
-            fn into_any(self: Box<Self>) -> Box<dyn std::any::Any> {
+            fn into_partial_reflect(self: Box<Self>) -> Box<dyn ::bevy::reflect::PartialReflect> {
                 panic!("This should never be called, I am a dummy implementation");
             }
 
-            fn as_any(&self) -> &dyn std::any::Any {
+            fn as_partial_reflect(&self) -> &dyn ::bevy::reflect::PartialReflect {
                 panic!("This should never be called, I am a dummy implementation");
             }
 
-            fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+            fn as_partial_reflect_mut(&mut self) -> &mut dyn ::bevy::reflect::PartialReflect {
                 panic!("This should never be called, I am a dummy implementation");
             }
 
-            fn as_reflect(&self) -> &dyn ::bevy::reflect::Reflect {
+            fn try_into_reflect(self: Box<Self>) -> std::result::Result<std::boxed::Box<(dyn bevy::prelude::Reflect + 'static)>, std::boxed::Box<(dyn bevy::prelude::PartialReflect + 'static)>> {
                 panic!("This should never be called, I am a dummy implementation");
             }
 
-            fn as_reflect_mut(&mut self) -> &mut dyn ::bevy::reflect::Reflect {
+            fn try_as_reflect(&self) -> std::option::Option<&(dyn bevy::prelude::Reflect + 'static)> {
                 panic!("This should never be called, I am a dummy implementation");
             }
 
-            fn apply(&mut self, _: &dyn ::bevy::reflect::Reflect) {
+            fn try_as_reflect_mut(&mut self) -> std::option::Option<&mut (dyn bevy::prelude::Reflect + 'static)> {
                 panic!("This should never be called, I am a dummy implementation");
             }
 
-            fn set(&mut self, _: Box<dyn ::bevy::reflect::Reflect>) -> Result<(), Box<dyn ::bevy::reflect::Reflect>> {
+            fn try_apply(&mut self, value: &dyn ::bevy::prelude::PartialReflect) -> std::result::Result<(), ::bevy::reflect::ApplyError> {
                 panic!("This should never be called, I am a dummy implementation");
             }
 
-            fn reflect_ref(&self) -> bevy::reflect::ReflectRef {
+            fn reflect_ref(&self) -> ::bevy::reflect::ReflectRef {
                 panic!("This should never be called, I am a dummy implementation");
             }
 
-            fn reflect_mut(&mut self) -> bevy::reflect::ReflectMut {
+            fn reflect_mut(&mut self) -> ::bevy::reflect::ReflectMut {
                 panic!("This should never be called, I am a dummy implementation");
             }
 
-            fn clone_value(&self) -> Box<dyn ::bevy::reflect::Reflect> {
+            fn reflect_owned(self: Box<Self>) -> ::bevy::reflect::ReflectOwned {
                 panic!("This should never be called, I am a dummy implementation");
             }
 
-            fn into_reflect(self: Box<Self>) -> Box<dyn ::bevy::reflect::Reflect> {
+            fn clone_value(&self) -> Box<dyn ::bevy::prelude::PartialReflect + 'static> {
                 panic!("This should never be called, I am a dummy implementation");
             }
+        }
 
-            fn reflect_owned(self: Box<Self>) -> ::bevy::reflect::ReflectOwned {
+
+        impl ::bevy::reflect::Reflect for $name {
+
+            fn into_any(self: Box<Self>) -> Box<dyn std::any::Any> {
                 panic!("This should never be called, I am a dummy implementation");
             }
 
-            fn get_represented_type_info(&self) -> std::option::Option<&'static bevy::reflect::TypeInfo> {
+            fn as_any(&self) -> &dyn std::any::Any {
+                panic!("This should never be called, I am a dummy implementation");
+            }
+
+            fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+                panic!("This should never be called, I am a dummy implementation");
+            }
+
+            fn as_reflect(&self) -> &dyn ::bevy::reflect::Reflect {
+                panic!("This should never be called, I am a dummy implementation");
+            }
+
+            fn as_reflect_mut(&mut self) -> &mut dyn ::bevy::reflect::Reflect {
+                panic!("This should never be called, I am a dummy implementation");
+            }
+
+            fn set(&mut self, _: Box<dyn ::bevy::reflect::Reflect>) -> Result<(), Box<dyn ::bevy::reflect::Reflect>> {
+                panic!("This should never be called, I am a dummy implementation");
+            }
+
+            fn into_reflect(self: Box<Self>) -> Box<dyn ::bevy::reflect::Reflect> {
                 panic!("This should never be called, I am a dummy implementation");
             }
         }
 
         impl ::bevy::reflect::FromReflect for $name {
-            fn from_reflect(_: &(dyn bevy::prelude::Reflect + 'static)) -> std::option::Option<Self> {
+            fn from_reflect(_: &(dyn bevy::prelude::PartialReflect + 'static)) -> std::option::Option<Self> {
                 panic!("This should never be called, I am a dummy implementation");
             }
+
         }
 
         impl ::bevy::reflect::GetTypeRegistration for $name {
diff --git a/crates/bevy_script_api/src/rhai/std.rs b/crates/bevy_script_api/src/rhai/std.rs
@@ -121,6 +121,7 @@ impl<
             + TypePath
             + Clone
             + FromRhaiProxy
+            + bevy::reflect::Typed
             + GetTypeRegistration,
     > RhaiProxyable for Option<T>
 {
@@ -249,11 +250,24 @@ impl<T: ToRhaiProxy> ToRhaiProxy for Option<T> {
 
 /// Composite trait composing the various traits required for a type `T` to be used as part of a RhaiVec<T>
 pub trait RhaiVecElem:
-    FromReflect + GetTypeRegistration + TypePath + RhaiProxyable + FromRhaiProxy + Clone
+    FromReflect
+    + GetTypeRegistration
+    + TypePath
+    + RhaiProxyable
+    + FromRhaiProxy
+    + Clone
+    + bevy::reflect::Typed
 {
 }
-impl<T: FromReflect + GetTypeRegistration + TypePath + RhaiProxyable + FromRhaiProxy + Clone>
-    RhaiVecElem for T
+impl<
+        T: FromReflect
+            + GetTypeRegistration
+            + TypePath
+            + RhaiProxyable
+            + FromRhaiProxy
+            + Clone
+            + bevy::reflect::Typed,
+    > RhaiVecElem for T
 {
 }
 
diff --git a/crates/bevy_script_api/src/sub_reflect.rs b/crates/bevy_script_api/src/sub_reflect.rs
diff --git a/makefile b/makefile

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`use std::marker::PhantomData;`
`2`	`2`
`3`		`-use bevy::reflect::{FromReflect, GetTypeRegistration, TypePath};`
	`3`	`+use bevy::reflect::{FromReflect, GetTypeRegistration, TypePath, Typed};`
`4`	`4`
`5`	`5`	`use crate::{error::ReflectionError, ReflectReference, ValueIndex};`
`6`	`6`
`@@ -26,7 +26,7 @@ impl<T> std::fmt::Debug for ScriptVec<T> {`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`
`29`		`-impl<T: std::fmt::Display + FromReflect + GetTypeRegistration + TypePath> std::fmt::Display`
	`29`	`+impl<T: std::fmt::Display + FromReflect + GetTypeRegistration + TypePath + Typed> std::fmt::Display`
`30`	`30`	`for ScriptVec<T>`
`31`	`31`	`{`
`32`	`32`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`@@ -41,7 +41,7 @@ impl<T: std::fmt::Display + FromReflect + GetTypeRegistration + TypePath> std::f`
`41`	`41`	`}`
`42`	`42`	`}`
`43`	`43`
`44`		`-impl<T: FromReflect + TypePath + GetTypeRegistration> ScriptVec<T> {`
	`44`	`+impl<T: FromReflect + TypePath + GetTypeRegistration + Typed> ScriptVec<T> {`
`45`	`45`	`pub fn new_ref(ref_: ReflectReference) -> Self {`
`46`	`46`	`Self {`
`47`	`47`	`ref_,`
`@@ -118,7 +118,7 @@ impl<T: FromReflect> Iterator for ScriptVecIterator<T> {`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`
`121`		`-impl<T: FromReflect + TypePath + GetTypeRegistration> IntoIterator for ScriptVec<T> {`
	`121`	`+impl<T: FromReflect + TypePath + GetTypeRegistration + Typed> IntoIterator for ScriptVec<T> {`
`122`	`122`	`type Item = ReflectReference;`
`123`	`123`
`124`	`124`	`type IntoIter = ScriptVecIterator<T>;`
Original file line number	Diff line number	Diff line change
`@@ -287,6 +287,12 @@ macro_rules! impl_tealr_generic{`
`287`	`287`
`288`	`288`	`}`
`289`	`289`
	`290`	`+ impl ::bevy::reflect::Typed for $name {`
	`291`	`+ fn type_info() -> &'static ::bevy::reflect::TypeInfo {`
	`292`	`+ panic!("This should never be called, I am a dummy implementation")`
	`293`	`+ }`
	`294`	`+ }`
	`295`	`+`
`290`	`296`	`impl ::bevy::reflect::TypePath for $name {`
`291`	`297`	`fn short_type_path() -> &'static str{`
`292`	`298`	`panic!("This should never be called, I am a dummy implementation")`
`@@ -297,69 +303,94 @@ macro_rules! impl_tealr_generic{`
`297`	`303`	`}`
`298`	`304`	`}`
`299`	`305`
`300`		`- impl ::bevy::reflect::Reflect for $name {`
`301`	`306`
`302`		`- fn try_apply(&mut self, _: &(dyn bevy::prelude::Reflect + 'static)) -> std::result::Result<(), bevy::reflect::ApplyError> {`
	`307`	`+ impl ::bevy::reflect::PartialReflect for $name {`
	`308`	`+ fn get_represented_type_info(&self) -> std::option::Option<&'static bevy::reflect::TypeInfo> {`
`303`	`309`	`panic!("This should never be called, I am a dummy implementation");`
`304`	`310`	`}`
`305`	`311`
`306`		`- fn into_any(self: Box<Self>) -> Box<dyn std::any::Any> {`
	`312`	`+ fn into_partial_reflect(self: Box<Self>) -> Box<dyn ::bevy::reflect::PartialReflect> {`
`307`	`313`	`panic!("This should never be called, I am a dummy implementation");`
`308`	`314`	`}`
`309`	`315`
`310`		`- fn as_any(&self) -> &dyn std::any::Any {`
	`316`	`+ fn as_partial_reflect(&self) -> &dyn ::bevy::reflect::PartialReflect {`
`311`	`317`	`panic!("This should never be called, I am a dummy implementation");`
`312`	`318`	`}`
`313`	`319`
`314`		`- fn as_any_mut(&mut self) -> &mut dyn std::any::Any {`
	`320`	`+ fn as_partial_reflect_mut(&mut self) -> &mut dyn ::bevy::reflect::PartialReflect {`
`315`	`321`	`panic!("This should never be called, I am a dummy implementation");`
`316`	`322`	`}`
`317`	`323`
`318`		`- fn as_reflect(&self) -> &dyn ::bevy::reflect::Reflect {`
	`324`	`+ fn try_into_reflect(self: Box<Self>) -> std::result::Result<std::boxed::Box<(dyn bevy::prelude::Reflect + 'static)>, std::boxed::Box<(dyn bevy::prelude::PartialReflect + 'static)>> {`
`319`	`325`	`panic!("This should never be called, I am a dummy implementation");`
`320`	`326`	`}`
`321`	`327`
`322`		`- fn as_reflect_mut(&mut self) -> &mut dyn ::bevy::reflect::Reflect {`
	`328`	`+ fn try_as_reflect(&self) -> std::option::Option<&(dyn bevy::prelude::Reflect + 'static)> {`
`323`	`329`	`panic!("This should never be called, I am a dummy implementation");`
`324`	`330`	`}`
`325`	`331`
`326`		`- fn apply(&mut self, _: &dyn ::bevy::reflect::Reflect) {`
	`332`	`+ fn try_as_reflect_mut(&mut self) -> std::option::Option<&mut (dyn bevy::prelude::Reflect + 'static)> {`
`327`	`333`	`panic!("This should never be called, I am a dummy implementation");`
`328`	`334`	`}`
`329`	`335`
`330`		`- fn set(&mut self, _: Box<dyn ::bevy::reflect::Reflect>) -> Result<(), Box<dyn ::bevy::reflect::Reflect>> {`
	`336`	`+ fn try_apply(&mut self, value: &dyn ::bevy::prelude::PartialReflect) -> std::result::Result<(), ::bevy::reflect::ApplyError> {`
`331`	`337`	`panic!("This should never be called, I am a dummy implementation");`
`332`	`338`	`}`
`333`	`339`
`334`		`- fn reflect_ref(&self) -> bevy::reflect::ReflectRef {`
	`340`	`+ fn reflect_ref(&self) -> ::bevy::reflect::ReflectRef {`
`335`	`341`	`panic!("This should never be called, I am a dummy implementation");`
`336`	`342`	`}`
`337`	`343`
`338`		`- fn reflect_mut(&mut self) -> bevy::reflect::ReflectMut {`
	`344`	`+ fn reflect_mut(&mut self) -> ::bevy::reflect::ReflectMut {`
`339`	`345`	`panic!("This should never be called, I am a dummy implementation");`
`340`	`346`	`}`
`341`	`347`
`342`		`- fn clone_value(&self) -> Box<dyn ::bevy::reflect::Reflect> {`
	`348`	`+ fn reflect_owned(self: Box<Self>) -> ::bevy::reflect::ReflectOwned {`
`343`	`349`	`panic!("This should never be called, I am a dummy implementation");`
`344`	`350`	`}`
`345`	`351`
`346`		`- fn into_reflect(self: Box<Self>) -> Box<dyn ::bevy::reflect::Reflect> {`
	`352`	`+ fn clone_value(&self) -> Box<dyn ::bevy::prelude::PartialReflect + 'static> {`
`347`	`353`	`panic!("This should never be called, I am a dummy implementation");`
`348`	`354`	`}`
	`355`	`+ }`
`349`	`356`
`350`		`- fn reflect_owned(self: Box<Self>) -> ::bevy::reflect::ReflectOwned {`
	`357`	`+`
	`358`	`+ impl ::bevy::reflect::Reflect for $name {`
	`359`	`+`
	`360`	`+ fn into_any(self: Box<Self>) -> Box<dyn std::any::Any> {`
`351`	`361`	`panic!("This should never be called, I am a dummy implementation");`
`352`	`362`	`}`
`353`	`363`
`354`		`- fn get_represented_type_info(&self) -> std::option::Option<&'static bevy::reflect::TypeInfo> {`
	`364`	`+ fn as_any(&self) -> &dyn std::any::Any {`
	`365`	`+ panic!("This should never be called, I am a dummy implementation");`
	`366`	`+ }`
	`367`	`+`
	`368`	`+ fn as_any_mut(&mut self) -> &mut dyn std::any::Any {`
	`369`	`+ panic!("This should never be called, I am a dummy implementation");`
	`370`	`+ }`
	`371`	`+`
	`372`	`+ fn as_reflect(&self) -> &dyn ::bevy::reflect::Reflect {`
	`373`	`+ panic!("This should never be called, I am a dummy implementation");`
	`374`	`+ }`
	`375`	`+`
	`376`	`+ fn as_reflect_mut(&mut self) -> &mut dyn ::bevy::reflect::Reflect {`
	`377`	`+ panic!("This should never be called, I am a dummy implementation");`
	`378`	`+ }`
	`379`	`+`
	`380`	`+ fn set(&mut self, _: Box<dyn ::bevy::reflect::Reflect>) -> Result<(), Box<dyn ::bevy::reflect::Reflect>> {`
	`381`	`+ panic!("This should never be called, I am a dummy implementation");`
	`382`	`+ }`
	`383`	`+`
	`384`	`+ fn into_reflect(self: Box<Self>) -> Box<dyn ::bevy::reflect::Reflect> {`
`355`	`385`	`panic!("This should never be called, I am a dummy implementation");`
`356`	`386`	`}`
`357`	`387`	`}`
`358`	`388`
`359`	`389`	`impl ::bevy::reflect::FromReflect for $name {`
`360`		`- fn from_reflect(_: &(dyn bevy::prelude::Reflect + 'static)) -> std::option::Option<Self> {`
	`390`	`+ fn from_reflect(_: &(dyn bevy::prelude::PartialReflect + 'static)) -> std::option::Option<Self> {`
`361`	`391`	`panic!("This should never be called, I am a dummy implementation");`
`362`	`392`	`}`
	`393`	`+`
`363`	`394`	`}`
`364`	`395`
`365`	`396`	`impl ::bevy::reflect::GetTypeRegistration for $name {`