Implement Reflect for Box<dyn Reflect>

Author: franciscoaguirre

crates/bevy_reflect/src/lib.rs

@@ -1868,6 +1868,21 @@ bevy_reflect::tests::Test {
         assert_eq!("123", format!("{:?}", foo));
     }
 
+    #[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"
+        );
+    }
+
     #[test]
     fn recursive_typed_storage_does_not_hang() {
         #[derive(Reflect)]

crates/bevy_reflect/src/list.rs

@@ -225,11 +225,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 insert(&mut self, index: usize, element: Box<dyn Reflect>) {

crates/bevy_reflect/src/reflect.rs

@@ -6,6 +6,7 @@ use crate::{
 use std::{
     any::{Any, TypeId},
     fmt::Debug,
+    ops::{Deref, DerefMut},
 };
 
 use crate::utility::NonGenericTypeInfoCell;
@@ -326,3 +327,49 @@ impl dyn Reflect {
         self.as_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()
+    }
+}