Implement Reflect for Box<dyn Reflect>

Author: franciscoaguirre

crates/bevy_reflect/src/lib.rs

@@ -370,4 +370,19 @@ mod tests {
             std::any::type_name::<TestTupleStruct>()
         );
     }
+
+    #[test]
+    fn box_dyn_reflect() {
+        #[derive(Reflect)]
+        struct Foo {
+            a: u32,
+        }
+
+        let boxed: Box<dyn Reflect> = Box::new(Foo { a: 1 });
+
+        assert_eq!(
+            boxed.type_name(),
+            "bevy_reflect::tests::box_dyn_reflect::Foo"
+        );
+    }
 }

crates/bevy_reflect/src/list.rs

@@ -46,11 +46,11 @@ impl DynamicList {
 
 impl List for DynamicList {
     fn get(&self, index: usize) -> Option<&dyn Reflect> {
-        self.values.get(index).map(|value| &**value)
+        self.values.get(index)
     }
 
     fn get_mut(&mut self, index: usize) -> Option<&mut dyn Reflect> {
-        self.values.get_mut(index).map(|value| &mut **value)
+        self.values.get_mut(index).map(|value| &mut *value)
     }
 
     fn len(&self) -> usize {

crates/bevy_reflect/src/reflect.rs

@@ -1,5 +1,9 @@
 use crate::{serde::Serializable, List, Map, Struct, Tuple, TupleStruct};
-use std::{any::Any, fmt::Debug};
+use std::{
+    any::Any,
+    fmt::Debug,
+    ops::{Deref, DerefMut},
+};
 
 pub use bevy_utils::AHasher as ReflectHasher;
 
@@ -86,3 +90,49 @@ impl dyn Reflect {
         self.any_mut().downcast_mut::<T>()
     }
 }
+
+unsafe impl Reflect for Box<dyn Reflect> {
+    fn type_name(&self) -> &str {
+        self.deref().type_name()
+    }
+
+    fn any(&self) -> &dyn Any {
+        self.deref().any()
+    }
+
+    fn any_mut(&mut self) -> &mut dyn Any {
+        self.deref_mut().any_mut()
+    }
+
+    fn apply(&mut self, value: &dyn Reflect) {
+        self.deref_mut().apply(value)
+    }
+
+    fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> {
+        self.deref_mut().set(value)
+    }
+
+    fn reflect_ref(&self) -> ReflectRef {
+        self.deref().reflect_ref()
+    }
+
+    fn reflect_mut(&mut self) -> ReflectMut {
+        self.deref_mut().reflect_mut()
+    }
+
+    fn clone_value(&self) -> Box<dyn Reflect> {
+        self.deref().clone_value()
+    }
+
+    fn reflect_hash(&self) -> Option<u64> {
+        self.deref().reflect_hash()
+    }
+
+    fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool> {
+        self.deref().reflect_partial_eq(value)
+    }
+
+    fn serializable(&self) -> Option<Serializable> {
+        self.deref().serializable()
+    }
+}