[Merged by Bors] - Make Reflect safe to implement

crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs

@@ -213,7 +213,7 @@ impl ReflectTraits {
         match &self.partial_eq {
             TraitImpl::Implemented => Some(quote! {
                 fn reflect_partial_eq(&self, value: &dyn #bevy_reflect_path::Reflect) -> Option<bool> {
-                    let value = value.any();
+                    let value = value.any_ref();
                     if let Some(value) = value.downcast_ref::<Self>() {
                         Some(std::cmp::PartialEq::eq(self, value))
                     } else {

crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs

@@ -26,7 +26,7 @@ pub(crate) fn impl_value(
     TokenStream::from(quote! {
         impl #impl_generics #bevy_reflect_path::FromReflect for #type_name #ty_generics #where_clause  {
             fn from_reflect(reflect: &dyn #bevy_reflect_path::Reflect) -> Option<Self> {
-                Some(reflect.any().downcast_ref::<#type_name #ty_generics>()?.clone())
+                Some(reflect.any_ref().downcast_ref::<#type_name #ty_generics>()?.clone())
             }
         }
     })

crates/bevy_reflect/bevy_reflect_derive/src/impls.rs

@@ -126,22 +126,32 @@ pub(crate) fn impl_struct(derive_data: &ReflectDeriveData) -> TokenStream {
             }
         }
 
-        // SAFE: any and any_mut both return self
-        unsafe impl #impl_generics #bevy_reflect_path::Reflect for #struct_name #ty_generics #where_clause {
+        impl #impl_generics #bevy_reflect_path::Reflect for #struct_name #ty_generics #where_clause {
             #[inline]
             fn type_name(&self) -> &str {
                 std::any::type_name::<Self>()
             }
 
+            #[inline]
+            fn type_id(&self) -> std::any::TypeId {
+                std::any::TypeId::of::<Self>()
+            }
+
             #[inline]
             fn get_type_info(&self) -> &'static #bevy_reflect_path::TypeInfo {
                 <Self as #bevy_reflect_path::Typed>::type_info()
             }
 
             #[inline]
-            fn any(&self) -> &dyn std::any::Any {
+            fn any(self: Box<Self>) -> Box<dyn std::any::Any> {
+                self
+            }
+
+            #[inline]
+            fn any_ref(&self) -> &dyn std::any::Any {
                 self
             }
+
             #[inline]
             fn any_mut(&mut self) -> &mut dyn std::any::Any {
                 self
@@ -279,22 +289,32 @@ pub(crate) fn impl_tuple_struct(derive_data: &ReflectDeriveData) -> TokenStream
             }
         }
 
-        // SAFE: any and any_mut both return self
-        unsafe impl #impl_generics #bevy_reflect_path::Reflect for #struct_name #ty_generics #where_clause {
+        impl #impl_generics #bevy_reflect_path::Reflect for #struct_name #ty_generics #where_clause {
             #[inline]
             fn type_name(&self) -> &str {
                 std::any::type_name::<Self>()
             }
 
+            #[inline]
+            fn type_id(&self) -> std::any::TypeId {
+                std::any::TypeId::of::<Self>()
+            }
+
             #[inline]
             fn get_type_info(&self) -> &'static #bevy_reflect_path::TypeInfo {
                 <Self as #bevy_reflect_path::Typed>::type_info()
             }
 
             #[inline]
-            fn any(&self) -> &dyn std::any::Any {
+            fn any(self: Box<Self>) -> Box<dyn std::any::Any> {
                 self
             }
+
+            #[inline]
+            fn any_ref(&self) -> &dyn std::any::Any {
+                self
+            }
+
             #[inline]
             fn any_mut(&mut self) -> &mut dyn std::any::Any {
                 self
@@ -379,20 +399,29 @@ pub(crate) fn impl_value(
 
         #typed_impl
 
-        // SAFE: any and any_mut both return self
-        unsafe impl #impl_generics #bevy_reflect_path::Reflect for #type_name #ty_generics #where_clause  {
+        impl #impl_generics #bevy_reflect_path::Reflect for #type_name #ty_generics #where_clause  {
             #[inline]
             fn type_name(&self) -> &str {
                 std::any::type_name::<Self>()
             }
 
+            #[inline]
+            fn type_id(&self) -> std::any::TypeId {
+                std::any::TypeId::of::<Self>()
+            }
+
             #[inline]
             fn get_type_info(&self) -> &'static #bevy_reflect_path::TypeInfo {
                 <Self as #bevy_reflect_path::Typed>::type_info()
             }
 
             #[inline]
-            fn any(&self) -> &dyn std::any::Any {
+            fn any(self: Box<Self>) -> Box<dyn std::any::Any> {
+                self
+            }
+
+            #[inline]
+            fn any_ref(&self) -> &dyn std::any::Any {
                 self
             }
 
@@ -418,7 +447,7 @@ pub(crate) fn impl_value(
 
             #[inline]
             fn apply(&mut self, value: &dyn #bevy_reflect_path::Reflect) {
-                let value = value.any();
+                let value = value.any_ref();
                 if let Some(value) = value.downcast_ref::<Self>() {
                     *self = value.clone();
                 } else {

crates/bevy_reflect/src/array.rs

@@ -152,20 +152,29 @@ impl DynamicArray {
     }
 }
 
-// SAFE: any and any_mut both return self
-unsafe impl Reflect for DynamicArray {
+impl Reflect for DynamicArray {
     #[inline]
     fn type_name(&self) -> &str {
         self.name.as_str()
     }
 
+    #[inline]
+    fn type_id(&self) -> TypeId {
+        TypeId::of::<Self>()
+    }
+
     #[inline]
     fn get_type_info(&self) -> &'static TypeInfo {
         <Self as Typed>::type_info()
     }
 
     #[inline]
-    fn any(&self) -> &dyn Any {
+    fn any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+
+    #[inline]
+    fn any_ref(&self) -> &dyn Any {
         self
     }
 

crates/bevy_reflect/src/impls/smallvec.rs

@@ -1,5 +1,5 @@
 use smallvec::SmallVec;
-use std::any::Any;
+use std::any::{Any, TypeId};
 
 use crate::utility::GenericTypeInfoCell;
 use crate::{
@@ -55,20 +55,27 @@ where
     }
 }
 
-// SAFE: any and any_mut both return self
-unsafe impl<T: smallvec::Array + Send + Sync + 'static> Reflect for SmallVec<T>
+impl<T: smallvec::Array + Send + Sync + 'static> Reflect for SmallVec<T>
 where
     T::Item: FromReflect + Clone,
 {
     fn type_name(&self) -> &str {
         std::any::type_name::<Self>()
     }
 
+    fn type_id(&self) -> TypeId {
+        TypeId::of::<Self>()
+    }
+
     fn get_type_info(&self) -> &'static TypeInfo {
         <Self as Typed>::type_info()
     }
 
-    fn any(&self) -> &dyn Any {
+    fn any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+
+    fn any_ref(&self) -> &dyn Any {
         self
     }
 

crates/bevy_reflect/src/impls/std.rs

@@ -10,7 +10,7 @@ use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_value};
 use bevy_utils::{Duration, HashMap, HashSet};
 use serde::{Deserialize, Serialize};
 use std::{
-    any::Any,
+    any::{Any, TypeId},
     borrow::Cow,
     hash::{Hash, Hasher},
     ops::Range,
@@ -106,16 +106,24 @@ impl<T: FromReflect> List for Vec<T> {
 }
 
 // SAFE: any and any_mut both return self
-unsafe impl<T: FromReflect> Reflect for Vec<T> {
+impl<T: FromReflect> Reflect for Vec<T> {
     fn type_name(&self) -> &str {
         std::any::type_name::<Self>()
     }
 
+    fn type_id(&self) -> TypeId {
+        TypeId::of::<Self>()
+    }
+
     fn get_type_info(&self) -> &'static TypeInfo {
         <Self as Typed>::type_info()
     }
 
-    fn any(&self) -> &dyn Any {
+    fn any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+
+    fn any_ref(&self) -> &dyn Any {
         self
     }
 
@@ -234,17 +242,24 @@ impl<K: Reflect + Eq + Hash, V: Reflect> Map for HashMap<K, V> {
     }
 }
 
-// SAFE: any and any_mut both return self
-unsafe impl<K: Reflect + Eq + Hash, V: Reflect> Reflect for HashMap<K, V> {
+impl<K: Reflect + Eq + Hash, V: Reflect> Reflect for HashMap<K, V> {
     fn type_name(&self) -> &str {
         std::any::type_name::<Self>()
     }
 
+    fn type_id(&self) -> TypeId {
+        TypeId::of::<Self>()
+    }
+
     fn get_type_info(&self) -> &'static TypeInfo {
         <Self as Typed>::type_info()
     }
 
-    fn any(&self) -> &dyn Any {
+    fn any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+
+    fn any_ref(&self) -> &dyn Any {
         self
     }
 
@@ -354,19 +369,28 @@ impl<T: Reflect, const N: usize> Array for [T; N] {
     }
 }
 
-// SAFE: any and any_mut both return self
-unsafe impl<T: Reflect, const N: usize> Reflect for [T; N] {
+impl<T: Reflect, const N: usize> Reflect for [T; N] {
     #[inline]
     fn type_name(&self) -> &str {
         std::any::type_name::<Self>()
     }
 
+    #[inline]
+    fn type_id(&self) -> TypeId {
+        TypeId::of::<Self>()
+    }
+
     fn get_type_info(&self) -> &'static TypeInfo {
         <Self as Typed>::type_info()
     }
 
     #[inline]
-    fn any(&self) -> &dyn Any {
+    fn any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+
+    #[inline]
+    fn any_ref(&self) -> &dyn Any {
         self
     }
 
@@ -474,17 +498,24 @@ impl_array_get_type_registration! {
     30 31 32
 }
 
-// SAFE: any and any_mut both return self
-unsafe impl Reflect for Cow<'static, str> {
+impl Reflect for Cow<'static, str> {
     fn type_name(&self) -> &str {
         std::any::type_name::<Self>()
     }
 
+    fn type_id(&self) -> TypeId {
+        TypeId::of::<Self>()
+    }
+
     fn get_type_info(&self) -> &'static TypeInfo {
         <Self as Typed>::type_info()
     }
 
-    fn any(&self) -> &dyn Any {
+    fn any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+
+    fn any_ref(&self) -> &dyn Any {
         self
     }
 
@@ -501,7 +532,7 @@ unsafe impl Reflect for Cow<'static, str> {
     }
 
     fn apply(&mut self, value: &dyn Reflect) {
-        let value = value.any();
+        let value = value.any_ref();
         if let Some(value) = value.downcast_ref::<Self>() {
             *self = value.clone();
         } else {
@@ -534,7 +565,7 @@ unsafe impl Reflect for Cow<'static, str> {
     }
 
     fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option<bool> {
-        let value = value.any();
+        let value = value.any_ref();
         if let Some(value) = value.downcast_ref::<Self>() {
             Some(std::cmp::PartialEq::eq(self, value))
         } else {
@@ -564,7 +595,12 @@ impl GetTypeRegistration for Cow<'static, str> {
 
 impl FromReflect for Cow<'static, str> {
     fn from_reflect(reflect: &dyn crate::Reflect) -> Option<Self> {
-        Some(reflect.any().downcast_ref::<Cow<'static, str>>()?.clone())
+        Some(
+            reflect
+                .any_ref()
+                .downcast_ref::<Cow<'static, str>>()?
+                .clone(),
+        )
     }
 }